remove unnecessary icustomrole methods

Voting API

.editorconfig

@@ -0,0 +1,2 @@
+[*.{cs,vb}]
+dotnet_diagnostic.CA1707.severity = none

.github/workflows/main.yaml

@@ -0,0 +1,51 @@
+name: CI
+
+on: ["workflow_dispatch", "push", "pull_request"]
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.nuget/packages
+            ~/.cache/bepinex
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-nuget-
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+
+      - name: Run the Cake script
+        uses: cake-build/cake-action@v2
+        with:
+          verbosity: Diagnostic
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: MiraAPI.dll
+          path: MiraAPI/bin/Release/net6.0/MiraAPI.dll
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: AllOfUs.MiraAPI.nupkg
+          path: MiraAPI/bin/Release/AllOfUs.MiraAPI.*.nupkg
+          
+      - uses: softprops/action-gh-release@v2
+        if: github.ref_type == 'tag'
+        with:
+          draft: true
+          files: MiraAPI/bin/Release/net6.0/MiraAPI.dll
+          
+      - name: Push NuGet package
+        if: github.ref_type == 'tag'
+        run: |
+          dotnet nuget push MiraAPI/bin/Release/AllOfUs.MiraAPI.*.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }}

.gitignore

@@ -4,4 +4,5 @@
 obj/
 bin/
 
-*.user
+*.user
+*.lock.json

AmongUs.props

@@ -0,0 +1,14 @@
+<Project>
+    <ItemGroup>
+        <PackageReference Include="Reactor" Version="2.3.1" />
+        <PackageReference Include="BepInEx.Unity.IL2CPP" Version="6.0.0-be.697" Private="false" ExcludeAssets="runtime;native" />
+        <PackageReference Include="AmongUs.GameLibs.Steam" Version="2024.10.29" PrivateAssets="all" />
+
+        <PackageReference Include="BepInEx.AutoPlugin" Version="1.1.0" PrivateAssets="all" />
+        <PackageReference Include="BepInEx.IL2CPP.MSBuild" Version="2.0.1" PrivateAssets="all" ExcludeAssets="runtime" />
+    </ItemGroup>
+
+    <Target Name="Copy" AfterTargets="Build" Condition="'$(AmongUs)' != ''">
+        <Copy SourceFiles="$(TargetPath)" DestinationFolder="$(AmongUs)/BepInEx/plugins/" UseSymboliclinksIfPossible="true" />
+    </Target>
+</Project>

Directory.Build.props

@@ -0,0 +1,45 @@
+<Project>
+    <PropertyGroup>
+        <TargetFramework>net6.0</TargetFramework>
+        <LangVersion>latest</LangVersion>
+        <DebugType>embedded</DebugType>
+        <Nullable>enable</Nullable>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+
+        <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+
+        <VersionPrefix>0.2.0</VersionPrefix>
+        <VersionSuffix>dev</VersionSuffix>
+
+        <Authors>All Of Us, XtraCube, Angxl</Authors>
+        <Company>All Of Us</Company>
+        <RepositoryType>git</RepositoryType>
+        <RepositoryUrl>https://github.com/All-Of-Us-Mods/MiraAPI</RepositoryUrl>
+        <PackageLicenseExpression>LGPL-2.1-or-later</PackageLicenseExpression>
+
+        <!-- SourceLink -->
+        <EmbedUntrackedSources>true</EmbedUntrackedSources>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <ContinuousIntegrationBuild Condition="'$(GITHUB_ACTIONS)' == 'true'">true</ContinuousIntegrationBuild>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <EnableNETAnalyzers>true</EnableNETAnalyzers>
+        <AnalysisLevel>latest</AnalysisLevel>
+        <AnalysisMode>recommended</AnalysisMode>
+        <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556" PrivateAssets="all" />
+        <AdditionalFiles Include="$(MSBuildThisFileDirectory)\stylecop.json" Link="stylecop.json" Visible="false" />
+
+        <PackageReference Include="SonarAnalyzer.CSharp" Version="9.32.0.97167">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+    <PropertyGroup>
+        <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)\stylecop.ruleset</CodeAnalysisRuleSet>
+    </PropertyGroup>
+</Project>

MiraAPI.Example/Buttons/ExampleButton.cs

@@ -1,26 +0,0 @@
-using MiraAPI.Hud;
-using MiraAPI.Utilities.Assets;
-using Reactor.Utilities;
-using UnityEngine;
-
-namespace MiraAPI.Example.Buttons;
-
-[RegisterButton]
-public class ExampleButton : CustomActionButton
-{
-    public override string Name => "Example Button";
-    public override float Cooldown => 5f;
-    public override float EffectDuration => 0f;
-    public override int MaxUses => 5;
-    public override LoadableAsset<Sprite> Sprite { get; } = ExampleAssets.ExampleButton;
-    
-    protected override void OnClick()
-    {
-        Logger<ExamplePlugin>.Info("Example button clicked!");
-    }
-
-    public override bool Enabled(RoleBehaviour role)
-    {
-        return true;
-    }
-}

MiraAPI.Example/Buttons/Freezer/FreezeButton.cs

@@ -0,0 +1,47 @@
+using MiraAPI.Example.Modifiers.Freezer;
+using MiraAPI.Example.Options.Roles;
+using MiraAPI.Example.Roles;
+using MiraAPI.GameOptions;
+using MiraAPI.Hud;
+using MiraAPI.Modifiers;
+using MiraAPI.Utilities;
+using MiraAPI.Utilities.Assets;
+using UnityEngine;
+
+namespace MiraAPI.Example.Buttons.Freezer;
+
+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 LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
+
+    protected override void OnClick()
+    {
+        Target?.RpcAddModifier<FreezeModifier>();
+    }
+
+    public override PlayerControl? GetTarget()
+    {
+        return PlayerControl.LocalPlayer.GetClosestPlayer(true, Distance);
+    }
+
+    public override void SetOutline(bool active)
+    {
+        Target?.cosmetics.SetOutline(active, new Il2CppSystem.Nullable<Color>(Palette.Blue));
+    }
+
+    public override bool IsTargetValid(PlayerControl? target)
+    {
+        return true;
+    }
+
+    public override bool Enabled(RoleBehaviour? role)
+    {
+        return role is FreezerRole;
+    }
+}

MiraAPI.Example/Buttons/MeetingButton.cs

@@ -0,0 +1,45 @@
+using MiraAPI.Example.Modifiers;
+using MiraAPI.Hud;
+using MiraAPI.Modifiers;
+using MiraAPI.Utilities.Assets;
+using UnityEngine;
+
+namespace MiraAPI.Example.Buttons;
+
+public class MeetingButton : CustomActionButton
+{
+    public override string Name => "Call Meeting";
+
+    public override float Cooldown => 15;
+
+    public override int MaxUses => 3;
+
+    public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
+
+    public override bool Enabled(RoleBehaviour? role)
+    {
+        return PlayerControl.LocalPlayer != null && PlayerControl.LocalPlayer.HasModifier<CaptainModifier>();
+    }
+
+    protected override void OnClick()
+    {
+        var bt = ShipStatus.Instance.EmergencyButton;
+
+        PlayerControl.LocalPlayer.NetTransform.Halt();
+        var minigame = Object.Instantiate(bt.MinigamePrefab, Camera.main!.transform, false);
+
+        var taskAdderGame = minigame as TaskAdderGame;
+        if (taskAdderGame != null)
+        {
+            taskAdderGame.SafePositionWorld = bt.SafePositionLocal + (Vector2)bt.transform.position;
+        }
+
+        minigame.transform.localPosition = new Vector3(0f, 0f, -50f);
+        minigame.Begin(null);
+
+        if (UsesLeft == 0 && PlayerControl.LocalPlayer.HasModifier<CaptainModifier>())
+        {
+            PlayerControl.LocalPlayer.RpcRemoveModifier<CaptainModifier>();
+        }
+    }
+}

MiraAPI.Example/Buttons/NeutralKillerButton.cs

@@ -0,0 +1,24 @@
+using MiraAPI.Example.GameOver;
+using MiraAPI.Example.Roles;
+using MiraAPI.GameEnd;
+using MiraAPI.Hud;
+using MiraAPI.Utilities.Assets;
+using UnityEngine;
+
+namespace MiraAPI.Example.Buttons;
+
+public class NeutralKillerButton : CustomActionButton
+{
+    public override string Name => "Win Game";
+    public override float Cooldown => 0f;
+    public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
+    protected override void OnClick()
+    {
+        CustomGameOver.Trigger<NeutralKillerGameOver>([PlayerControl.LocalPlayer.Data]);
+    }
+
+    public override bool Enabled(RoleBehaviour? role)
+    {
+        return role is NeutralKillerRole;
+    }
+}

MiraAPI.Example/Buttons/Teleporter/TeleportButton.cs

@@ -0,0 +1,87 @@
+using System.Collections;
+using MiraAPI.Example.Options.Roles;
+using MiraAPI.Example.Roles;
+using MiraAPI.GameOptions;
+using MiraAPI.Hud;
+using MiraAPI.Utilities.Assets;
+using Reactor.Utilities;
+using UnityEngine;
+
+namespace MiraAPI.Example.Buttons.Teleporter;
+
+public class TeleportButton : CustomActionButton
+{
+    public override string Name => "Teleport";
+
+    public override float Cooldown => OptionGroupSingleton<TeleporterOptions>.Instance.TeleportCooldown.Value;
+
+    public override float EffectDuration => OptionGroupSingleton<TeleporterOptions>.Instance.TeleportDuration;
+    public override int MaxUses => 2;
+
+    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 bool Enabled(RoleBehaviour? role)
+    {
+        return role is TeleporterRole;
+    }
+
+    protected override void OnClick()
+    {
+        Coroutines.Start(ZoomOutCoroutine());
+    }
+
+    public override void OnEffectEnd()
+    {
+        Coroutines.Start(ZoomInCoroutine());
+    }
+
+    protected override void FixedUpdate(PlayerControl playerControl)
+    {
+        base.FixedUpdate(playerControl);
+
+        if (!EffectActive) return;
+
+        if (Input.GetKey(KeyCode.Mouse0))
+        {
+            playerControl.NetTransform.RpcSnapTo(Camera.main.ScreenToWorldPoint(Input.mousePosition));
+            ResetCooldownAndOrEffect();
+        }
+    }
+
+    private static IEnumerator ZoomOutCoroutine()
+    {
+        HudManager.Instance.ShadowQuad.gameObject.SetActive(false);
+        IsZoom = true;
+        var zoomDistance = OptionGroupSingleton<TeleporterOptions>.Instance.ZoomDistance;
+        for (var ft = Camera.main!.orthographicSize; ft < zoomDistance; ft += 0.3f)
+        {
+            Camera.main.orthographicSize = MeetingHud.Instance ? 3f : ft;
+            ResolutionManager.ResolutionChanged.Invoke((float)Screen.width / Screen.height, Screen.width, Screen.height, Screen.fullScreen);
+            foreach (var cam in Camera.allCameras) cam.orthographicSize = Camera.main.orthographicSize;
+            yield return null;
+        }
+
+        foreach (var cam in Camera.allCameras) cam.orthographicSize = zoomDistance;
+        ResolutionManager.ResolutionChanged.Invoke((float)Screen.width / Screen.height, Screen.width, Screen.height, Screen.fullScreen);
+    }
+
+    private static IEnumerator ZoomInCoroutine()
+    {
+        for (var ft = Camera.main!.orthographicSize; ft > 3f; ft -= 0.3f)
+        {
+            Camera.main.orthographicSize = MeetingHud.Instance ? 3f : ft;
+            ResolutionManager.ResolutionChanged.Invoke((float)Screen.width / Screen.height, Screen.width, Screen.height, Screen.fullScreen);
+            foreach (var cam in Camera.allCameras) cam.orthographicSize = Camera.main.orthographicSize;
+
+            yield return null;
+        }
+
+        foreach (var cam in Camera.allCameras) cam.orthographicSize = 3f;
+        HudManager.Instance.ShadowQuad.gameObject.SetActive(true);
+        IsZoom = false;
+
+        ResolutionManager.ResolutionChanged.Invoke((float)Screen.width / Screen.height, Screen.width, Screen.height, Screen.fullScreen);
+    }
+}

MiraAPI.Example/ExampleAssets.cs

@@ -5,5 +5,8 @@ namespace MiraAPI.Example;
 public static class ExampleAssets
 {
     public static LoadableResourceAsset ExampleButton { get; } = new("MiraAPI.Example.Resources.ExampleButton.png");
+
+    // Credit to EpicHorrors for the teleport button asset.
+    public static LoadableResourceAsset TeleportButton { get; } = new("MiraAPI.Example.Resources.TeleportButton.png");
     public static LoadableResourceAsset Banner { get; } = new("MiraAPI.Example.Resources.FortniteBanner.jpeg");
-}
+}

MiraAPI.Example/ExampleColors.cs

@@ -0,0 +1,14 @@
+using MiraAPI.Colors;
+using UnityEngine;
+
+namespace MiraAPI.Example;
+
+[RegisterCustomColors]
+public static class ExampleColors
+{
+    public static CustomColor Cerulean { get; } = new("Cerulean", new Color(0.0f, 0.48f, 0.65f));
+
+    public static CustomColor Rose { get; } = new("Rose", new Color(0.98f, 0.26f, 0.62f));
+
+    public static CustomColor Gold { get; } = new("Gold", new Color(1.0f, 0.84f, 0.0f));
+}

MiraAPI.Example/ExampleEventHandlers.cs

@@ -0,0 +1,95 @@
+using System.Linq;
+using MiraAPI.Events;
+using MiraAPI.Events.Mira;
+using MiraAPI.Events.Vanilla.Gameplay;
+using MiraAPI.Events.Vanilla.Map;
+using MiraAPI.Events.Vanilla.Meeting;
+using MiraAPI.Events.Vanilla.Meeting.Voting;
+using MiraAPI.Events.Vanilla.Player;
+using MiraAPI.Example.Buttons.Freezer;
+using MiraAPI.Example.Roles;
+using MiraAPI.Utilities;
+using Reactor.Utilities;
+
+namespace MiraAPI.Example;
+
+public static class ExampleEventHandlers
+{
+    public static void Initialize()
+    {
+        // You can register event handlers with the MiraEventManager class.
+        MiraEventManager.RegisterEventHandler<BeforeMurderEvent>(@event =>
+        {
+            Logger<ExamplePlugin>.Info($"{@event.Source.Data.PlayerName} is about to kill {@event.Target.Data.PlayerName}");
+        });
+
+        MiraEventManager.RegisterEventHandler<AfterMurderEvent>(@event =>
+        {
+            Logger<ExamplePlugin>.Info($"{@event.Source.Data.PlayerName} has killed {@event.Target.Data.PlayerName}");
+        });
+
+        MiraEventManager.RegisterEventHandler<CompleteTaskEvent>(@event =>
+        {
+            Logger<ExamplePlugin>.Info($"{@event.Player.Data.PlayerName} completed {@event.Task.TaskType.ToString()}");
+        });
+    }
+
+    // If you want to add extra votes to a player, do something like this.
+    [RegisterEvent]
+    public static void StartMeetingEvent(StartMeetingEvent _)
+    {
+        foreach (var plr in PlayerControl.AllPlayerControls.ToArray().Where(player => player.Data.Role is MayorRole))
+        {
+            plr.GetVoteData().IncreaseRemainingVotes(1);
+        }
+    }
+
+    // Example of using the Voting API to make a role similar to the Prosecutor from Town of Us.
+    [RegisterEvent(15)]
+    public static void HandleVoteEvent(HandleVoteEvent @event)
+    {
+        if (@event.VoteData.Owner.Data.Role is not NeutralKillerRole) return;
+
+        @event.VoteData.SetRemainingVotes(0);
+
+        for (var i = 0; i < 5; i++)
+        {
+            @event.VoteData.VoteForPlayer(@event.TargetId);
+        }
+
+        foreach (var plr in PlayerControl.AllPlayerControls.ToArray().Where(player => player != @event.VoteData.Owner))
+        {
+            plr.GetVoteData().Votes.Clear();
+            plr.GetVoteData().VotesRemaining = 0;
+        }
+
+        @event.Cancel();
+    }
+
+    // Events can be registered using an attribute as well.
+    [RegisterEvent]
+    public static void UpdateSystemEventHandler(UpdateSystemEvent @event)
+    {
+        Logger<ExamplePlugin>.Error(@event.SystemType.ToString());
+    }
+
+    // Example event handler
+    [RegisterEvent(1)]
+    public static void FreezeButtonClickHandler(MiraButtonClickEvent<FreezeButton> @event)
+    {
+        Logger<ExamplePlugin>.Warning("Freeze button clicked!");
+
+        if (PlayerControl.LocalPlayer.Data.PlayerName != "stupid") return;
+
+        @event.Cancel();
+        @event.Button.SetTimer(15f);
+    }
+
+    // Example event handler
+    [RegisterEvent]
+    public static void FreezeButtonCancelledHandler(MiraButtonCancelledEvent<FreezeButton> @event)
+    {
+        Logger<ExamplePlugin>.Warning("Freeze button cancelled!");
+        @event.Button.OverrideName("Freeze Canceled");
+    }
+}

MiraAPI.Example/ExamplePlugin.cs

@@ -9,7 +9,7 @@ using Reactor.Networking.Attributes;
 
 namespace MiraAPI.Example;
 
-[BepInAutoPlugin("mira.example", "MiraAPIExample")]
+[BepInAutoPlugin("mira.example", "MiraExampleMod")]
 [BepInProcess("Among Us.exe")]
 [BepInDependency(ReactorPlugin.Id)]
 [BepInDependency(MiraApiPlugin.Id)]
@@ -17,9 +17,11 @@ namespace MiraAPI.Example;
 public partial class ExamplePlugin : BasePlugin, IMiraPlugin
 {
     public Harmony Harmony { get; } = new(Id);
+    public string OptionsTitleText => "Mira API\nExample Mod";
     public ConfigFile GetConfigFile() => Config;
     public override void Load()
     {
+        ExampleEventHandlers.Initialize();
         Harmony.PatchAll();
     }
-}
+}

MiraAPI.Example/GameOver/NeutralKillerGameOver.cs

@@ -0,0 +1,21 @@
+using MiraAPI.Example.Roles;
+using MiraAPI.GameEnd;
+using MiraAPI.Utilities;
+using UnityEngine;
+
+namespace MiraAPI.Example.GameOver;
+
+public class NeutralKillerGameOver : CustomGameOver
+{
+    public override bool VerifyCondition(PlayerControl playerControl, NetworkedPlayerInfo[] winners)
+    {
+        return winners is [{ Role: NeutralKillerRole }];
+    }
+
+    public override void AfterEndGameSetup(EndGameManager endGameManager)
+    {
+        endGameManager.WinText.text = "Outcast Killer Wins!";
+        endGameManager.WinText.color = Color.magenta;
+        endGameManager.BackgroundBar.material.SetColor(ShaderID.Color, Color.magenta);
+    }
+}

MiraAPI.Example/MiraAPI.Example.csproj

@@ -1,26 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+ <Project Sdk="Microsoft.NET.Sdk">
 	<PropertyGroup>
-		<TargetFramework>net6.0</TargetFramework>
+		<Version>1.0.0</Version>
-		<LangVersion>latest</LangVersion>
-		<DebugType>embedded</DebugType>
-
-		<VersionPrefix>1.0.0</VersionPrefix>
-		<VersionSuffix>dev</VersionSuffix>
 		<Description>Example mod for Mira API</Description>
 		<Authors>Angxl, XtraCube</Authors>
 	</PropertyGroup>
-	
-	<ItemGroup>
-		<PackageReference Include="Reactor" Version="2.3.0" />
-		<PackageReference Include="BepInEx.Unity.IL2CPP" Version="6.0.0-be.697" Private="false" ExcludeAssets="runtime;native" />
-		<PackageReference Include="Iced" Version="1.21.0" />
-		<PackageReference Include="AmongUs.GameLibs.Steam" Version="2024.8.13" PrivateAssets="all" />
-
-		<PackageReference Include="BepInEx.AutoPlugin" Version="1.1.0" PrivateAssets="all" />
-		<PackageReference Include="BepInEx.IL2CPP.MSBuild" Version="2.1.0-rc.1" PrivateAssets="all" ExcludeAssets="runtime">
-			<IncludeAssets>compile; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-		</PackageReference>
-	</ItemGroup>
 
 	<ItemGroup>
 		<ProjectReference Include="..\MiraAPI\MiraAPI.csproj" />
@@ -29,9 +12,8 @@
 	<ItemGroup>
 		<EmbeddedResource Include="Resources\ExampleButton.png" />
 		<EmbeddedResource Include="Resources\FortniteBanner.jpeg" />
+		<EmbeddedResource Include="Resources\TeleportButton.png" />
 	</ItemGroup>
 
-	<Target Name="Copy" AfterTargets="Build" Condition="'$(AmongUs)' != ''">
+	<Import Project="..\AmongUs.props" />
-		<Copy SourceFiles="$(TargetPath)" DestinationFolder="$(AmongUs)/BepInEx/plugins/" UseSymboliclinksIfPossible="true" />
-	</Target>
 </Project>

MiraAPI.Example/MiraDebugWindow.cs

@@ -0,0 +1,27 @@
+using System;
+using Il2CppInterop.Runtime.Attributes;
+using Reactor.Utilities.Attributes;
+using Reactor.Utilities.ImGui;
+using UnityEngine;
+
+namespace MiraAPI.Example;
+
+[RegisterInIl2Cpp]
+public class MiraDebugWindow(IntPtr cppPtr) : MonoBehaviour(cppPtr)
+{
+    [HideFromIl2Cpp]
+    public DragWindow DebuggingWindow { get; } = new(
+        new Rect(10, 10, 0, 0),
+        "MIRA API DEBUGGING",
+        () =>
+        {
+        })
+    {
+        Enabled = true,
+    };
+
+    public void OnGUI()
+    {
+        DebuggingWindow.OnGUI();
+    }
+}

MiraAPI.Example/ModifierExample.cs

@@ -1,8 +0,0 @@
-namespace MiraAPI.Example;
-
-public class ModifierExample
-{
-    //name, role specific, etc
-
-    // mono behaviour stuff here (ModdedPlayerModifier inherits monobehaviour)
-}

MiraAPI.Example/Modifiers/CaptainModifier.cs

@@ -0,0 +1,20 @@
+using MiraAPI.Example.Options.Modifiers;
+using MiraAPI.GameOptions;
+using MiraAPI.Modifiers.Types;
+
+namespace MiraAPI.Example.Modifiers;
+
+public class CaptainModifier : GameModifier
+{
+    public override string ModifierName => "Captain";
+
+    public override int GetAssignmentChance()
+    {
+        return (int)OptionGroupSingleton<CaptainModifierSettings>.Instance.Chance;
+    }
+
+    public override int GetAmountPerGame()
+    {
+        return (int)OptionGroupSingleton<CaptainModifierSettings>.Instance.Amount;
+    }
+}

MiraAPI.Example/Modifiers/Freezer/FreezeModifier.cs

@@ -0,0 +1,41 @@
+using Il2CppSystem;
+using MiraAPI.Example.Roles;
+using MiraAPI.Modifiers.Types;
+using UnityEngine;
+
+namespace MiraAPI.Example.Modifiers.Freezer;
+
+public class FreezeModifier : TimedModifier
+{
+    public override string ModifierName => "Freezed";
+    public override bool HideOnUi => false;
+    public override float Duration => 15f;
+    public override bool AutoStart => true;
+    public override bool RemoveOnComplete => true;
+
+    public override void OnActivate()
+    {
+        if (Player.AmOwner)
+        {
+            Player.moveable = false;
+        }
+    }
+
+    public override void FixedUpdate()
+    {
+        base.FixedUpdate();
+
+        if (Player.AmOwner || PlayerControl.LocalPlayer.Data.Role is FreezerRole)
+        {
+            Player.cosmetics.SetOutline(true, new Nullable<Color>(Palette.LightBlue));
+        }
+    }
+
+    public override void OnTimerComplete()
+    {
+        if (Player.AmOwner)
+        {
+            Player.moveable = true;
+        }
+    }
+}

MiraAPI.Example/Modifiers/HighPriorityModifier.cs

@@ -0,0 +1,23 @@
+using MiraAPI.Modifiers.Types;
+
+namespace MiraAPI.Example.Modifiers;
+
+public class HighPriorityModifier : GameModifier
+{
+    public override string ModifierName => "High Priority";
+
+    public override int GetAssignmentChance()
+    {
+        return 100;
+    }
+
+    public override int GetAmountPerGame()
+    {
+        return 1;
+    }
+
+    public override int Priority()
+    {
+        return 100;
+    }
+}

MiraAPI.Example/Options/ExampleOptions.cs

@@ -1,33 +1,31 @@
 using MiraAPI.GameOptions;
 using MiraAPI.GameOptions.Attributes;
+using MiraAPI.Utilities;
 using UnityEngine;
 
 namespace MiraAPI.Example.Options;
 
 public class ExampleOptions : AbstractOptionGroup
 {
-    public override string GroupName => "General Group";
+    public override string GroupName => "Example Options 1";
-    public override Color GroupColor => Color.red;
+    public override Color GroupColor => Color.green;
 
-    [ModdedToggleOption("Use Thing")]
+    [ModdedToggleOption("Toggle Opt 1")]
-    public bool UseThing { get; set; } = false;
+    public bool ToggleOpt { get; set; } = false;
 
-    [ModdedToggleOption("Use another thing")]
+    [ModdedToggleOption("Toggle Opt 2")]
-    public bool UseAnotherThing { get; set; } = true;
+    public bool ToggleOpt2 { get; set; } = true;
 
-    [ModdedNumberOption("Sussy level", min: 0, max: 10)]
+    [ModdedNumberOption("Number Opt", min: 0, max: 10, increment: .25f, formatString: "0.00", suffixType: MiraNumberSuffixes.Percent)]
-    public float SussyLevel { get; set; } = 4f;
+    public float NumberOpt { get; set; } = 4f;
 
-    [ModdedStringOption("Sus choices", ["hello", "hello 2", "hello 3"])]
+    [ModdedEnumOption("Best API", typeof(BestApi), ["Mira API", "Mitochondria", "Reactor"])]
-    public int SusChoices { get; set; } = 2;
+    public BestApi Opt { get; set; } = BestApi.MiraAPI;
-
-    [ModdedEnumOption("Enum test", typeof(TestEnum))]
-    public TestEnum EnumTest { get; set; } = TestEnum.Bye;
 }
 
-public enum TestEnum
+public enum BestApi
 {
-    Hello,
+    MiraAPI,
-    Hi,
+    Mitochondria,
-    Bye
+    Reactor,
-}
+}

MiraAPI.Example/Options/ExampleOptions2.cs

@@ -1,27 +1,31 @@
 using MiraAPI.GameOptions;
 using MiraAPI.GameOptions.OptionTypes;
+using Reactor.Utilities;
 
 namespace MiraAPI.Example.Options;
 
 public class ExampleOptions2 : AbstractOptionGroup
 {
-    public override string GroupName => "Example 2";
+    public override string GroupName => "Example Options 2";
-    
+
-    public ModdedToggleOption UseThing { get; } = new("Use Thingy 5", false);
+    public override uint GroupPriority => 0; // This group will be displayed first. The default value is uint.MaxValue.
-    
+
-    public ModdedToggleOption UseThing2 { get; } = new("Use Thingy 6", false);
+    public ModdedToggleOption ToggleOpt1 { get; } = new("Toggle Option 1", false);
-    
+
-    public ModdedStringOption Sussy { get; } = new("Sussy", 0, ["Sussy 1", "Sussy 2", "Sussy 3"]);
+    public ModdedToggleOption ToggleOpt2 { get; } = new("Toggle Option 2", false)
-    
+    {
-    public ModdedEnumOption SussyEnum { get; } = new("Sussy Enum", 0, typeof(SussyEnum));
+        Visible = () => OptionGroupSingleton<ExampleOptions2>.Instance.ToggleOpt1, // implicit cast from ModdedToggleOption to bool
-    
+    };
-    public ModdedNumberOption YeezyLevel { get; } = new("Yeezy Level", 50, 0, 100, 25, NumberSuffixes.Multiplier);
+
+    public ModdedEnumOption<TestingData> EnumOpt { get; } = new("Enum Opt", 0)
+    {
+        ChangedEvent = x => Logger<ExamplePlugin>.Info($"changed Enum Opt to {x}"),
+    };
 }
 
-public enum SussyEnum
+public enum TestingData : ulong
 {
-    Sussy,
+    Happy,
-    Baka,
+    Sad,
-    Imposter,
+    Neutral,
-    Kanye
+}
-}

MiraAPI.Example/Options/Modifiers/CaptainModifierSettings.cs

@@ -0,0 +1,19 @@
+using MiraAPI.Example.Modifiers;
+using MiraAPI.GameOptions;
+using MiraAPI.GameOptions.Attributes;
+
+namespace MiraAPI.Example.Options.Modifiers;
+
+public class CaptainModifierSettings : AbstractOptionGroup<CaptainModifier>
+{
+    public override string GroupName => "Captain Settings";
+
+    [ModdedNumberOption("Amount", 0, 5)]
+    public float Amount { get; set; } = 1;
+
+    [ModdedNumberOption("Chance", 0, 100, 10)]
+    public float Chance { get; set; } = 50;
+
+    [ModdedNumberOption("Uses", 1, 5)]
+    public float NumUses { get; set; } = 3;
+}

MiraAPI.Example/Options/Modifiers/FreezeModifierSettings.cs

@@ -0,0 +1,13 @@
+using MiraAPI.Example.Modifiers.Freezer;
+using MiraAPI.GameOptions;
+using MiraAPI.GameOptions.Attributes;
+
+namespace MiraAPI.Example.Options.Modifiers;
+
+public class FreezeModifierSettings : AbstractOptionGroup<FreezeModifier>
+{
+    public override string GroupName => "Freeze";
+
+    [ModdedToggleOption("Use Color")]
+    public bool UseColor { get; set; } = true;
+}

MiraAPI.Example/Options/Modifiers/GeneralModifierOptions.cs

@@ -0,0 +1,19 @@
+using MiraAPI.GameOptions;
+using MiraAPI.GameOptions.Attributes;
+
+namespace MiraAPI.Example.Options.Modifiers;
+
+public class GeneralModifierOptions : AbstractOptionGroup
+{
+    public override string GroupName => "General";
+
+    public override uint GroupPriority => 0;
+
+    public override bool ShowInModifiersMenu => true;
+
+    [ModdedToggleOption("Some Boolean Option")]
+    public bool SomeBooleanOption { get; set; } = true;
+
+    [ModdedNumberOption("Number Option", 0, 10, 1)]
+    public float NumberOption { get; set; } = 5;
+}

MiraAPI.Example/Options/Roles/CustomRole2Settings.cs

@@ -1,16 +0,0 @@
-using System;
-using MiraAPI.Example.Roles;
-using MiraAPI.GameOptions;
-using MiraAPI.GameOptions.Attributes;
-
-namespace MiraAPI.Example.Options.Roles;
-
-public class CustomRole2Settings : AbstractOptionGroup
-{
-    public override string GroupName => "Custom Role";
-
-    public override Type AdvancedRole => typeof(CustomRole2);
-    
-    [ModdedToggleOption("Teleportation ability")] public bool Teleport { get; set; } = true;
-
-}

MiraAPI.Example/Options/Roles/CustomRoleSettings.cs

@@ -1,16 +0,0 @@
-using System;
-using MiraAPI.Example.Roles;
-using MiraAPI.GameOptions;
-using MiraAPI.GameOptions.Attributes;
-
-namespace MiraAPI.Example.Options.Roles;
-
-public class CustomRoleSettings : AbstractOptionGroup
-{
-    public override string GroupName => "Custom Role";
-
-    public override Type AdvancedRole => typeof(CustomRole);
-    
-    [ModdedNumberOption("Testing level", min: 3, max: 9)] public float TestingLevel { get; set; } = 4;
-
-}

MiraAPI.Example/Options/Roles/FreezerRoleSettings.cs

@@ -0,0 +1,17 @@
+using MiraAPI.Example.Roles;
+using MiraAPI.GameOptions;
+using MiraAPI.GameOptions.Attributes;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.Example.Options.Roles;
+
+public class FreezerRoleSettings : AbstractOptionGroup<FreezerRole>
+{
+    public override string GroupName => "Custom Role";
+
+    [ModdedNumberOption("Freeze Duration", 1, 15, 1, MiraNumberSuffixes.Seconds)]
+    public float FreezeDuration { get; set; } = 5;
+
+    [ModdedNumberOption("Freeze Uses", 1, 5)]
+    public float FreezeUses { get; set; } = 1;
+}

MiraAPI.Example/Options/Roles/TeleporterOptions.cs

@@ -0,0 +1,20 @@
+using MiraAPI.Example.Roles;
+using MiraAPI.GameOptions;
+using MiraAPI.GameOptions.Attributes;
+using MiraAPI.GameOptions.OptionTypes;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.Example.Options.Roles;
+
+public class TeleporterOptions : AbstractOptionGroup<TeleporterRole>
+{
+    public override string GroupName => "Teleporter";
+
+    public ModdedNumberOption TeleportCooldown { get; set; } = new("Teleport Cooldown", 10, 5, 60, 2.5f, MiraNumberSuffixes.Seconds);
+
+    [ModdedNumberOption("Teleport Duration", 5, 25, 1, MiraNumberSuffixes.Seconds)]
+    public float TeleportDuration { get; set; } = 10;
+
+    [ModdedNumberOption("Zoom Distance", 4, 15)]
+    public float ZoomDistance { get; set; } = 6;
+}

MiraAPI.Example/Roles/ChameleonRole.cs

@@ -0,0 +1,50 @@
+using AmongUs.GameOptions;
+using MiraAPI.Roles;
+using MiraAPI.Utilities;
+using TMPro;
+using UnityEngine;
+
+namespace MiraAPI.Example.Roles;
+
+public class ChameloenRole : CrewmateRole, ICustomRole
+{
+    public string RoleName => "Chamelon";
+    public string RoleLongDescription => "Stay invisible while not moving.";
+    public string RoleDescription => RoleLongDescription;
+    public Color RoleColor => Palette.AcceptedGreen;
+    public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
+
+    public CustomRoleConfiguration Configuration => new(this)
+    {
+        OptionsScreenshot = ExampleAssets.Banner,
+        IntroSound = CustomRoleUtils.GetIntroSound(RoleTypes.Shapeshifter),
+    };
+
+    public void PlayerControlFixedUpdate(PlayerControl playerControl)
+    {
+        if (playerControl.MyPhysics.Velocity.magnitude > 0)
+        {
+            SpriteRenderer rend = playerControl.cosmetics.currentBodySprite.BodySprite;
+            TextMeshPro tmp = playerControl.cosmetics.nameText;
+            tmp.color = Color.Lerp(tmp.color, new Color(tmp.color.r, tmp.color.g, tmp.color.b, 1), Time.deltaTime * 4f);
+            rend.color = Color.Lerp(rend.color, new Color(1, 1, 1, 1), Time.deltaTime * 4f);
+
+            foreach (var cosmetic in playerControl.cosmetics.transform.GetComponentsInChildren<SpriteRenderer>())
+            {
+                cosmetic.color = Color.Lerp(cosmetic.color, new Color(1, 1, 1, 1), Time.deltaTime * 4f);
+            }
+        }
+        else
+        {
+            SpriteRenderer rend = playerControl.cosmetics.currentBodySprite.BodySprite;
+            TextMeshPro tmp = playerControl.cosmetics.nameText;
+            tmp.color = Color.Lerp(tmp.color, new Color(tmp.color.r, tmp.color.g, tmp.color.b, playerControl.AmOwner ? 0.3f : 0), Time.deltaTime * 4f);
+            rend.color = Color.Lerp(rend.color, new Color(1, 1, 1, playerControl.AmOwner ? 0.3f : 0), Time.deltaTime * 4f);
+
+            foreach (var cosmetic in playerControl.cosmetics.transform.GetComponentsInChildren<SpriteRenderer>())
+            {
+                cosmetic.color = Color.Lerp(cosmetic.color, new Color(1, 1, 1, playerControl.AmOwner ? 0.3f : 0), Time.deltaTime * 4f);
+            }
+        }
+    }
+}

MiraAPI.Example/Roles/CustomRole.cs

@@ -1,17 +0,0 @@
-using MiraAPI.Roles;
-using MiraAPI.Utilities.Assets;
-using UnityEngine;
-
-namespace MiraAPI.Example.Roles;
-
-[RegisterCustomRole]
-public class CustomRole : ImpostorRole, ICustomRole
-{
-    public string RoleName => "fortnite killer";
-    public string RoleLongDescription => "ok so your objective is to eliminate everyone with your fortnite tactical shotgun, good luck";
-    public string RoleDescription => RoleLongDescription;
-    public Color RoleColor => Palette.Black;
-    public ModdedRoleTeams Team => ModdedRoleTeams.Impostor;
-    public LoadableAsset<Sprite> OptionsScreenshot => ExampleAssets.Banner;
-    
-}

MiraAPI.Example/Roles/CustomRole2.cs

@@ -1,17 +0,0 @@
-using MiraAPI.Roles;
-using MiraAPI.Utilities.Assets;
-using UnityEngine;
-
-namespace MiraAPI.Example.Roles;
-
-[RegisterCustomRole]
-public class CustomRole2 : CrewmateRole, ICustomRole
-{
-    public string RoleName => "fortnite defender";
-    public string RoleLongDescription => "ok so your objective is to save everyone from the fortnite killer";
-    public string RoleDescription => RoleLongDescription;
-    public Color RoleColor => Palette.AcceptedGreen;
-    public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
-    public LoadableAsset<Sprite> OptionsScreenshot => ExampleAssets.Banner;
-    
-}

MiraAPI.Example/Roles/CustomRole3.cs

@@ -1,17 +0,0 @@
-using MiraAPI.Roles;
-using MiraAPI.Utilities.Assets;
-using UnityEngine;
-
-namespace MiraAPI.Example.Roles;
-
-[RegisterCustomRole]
-public class CustomRole3 : CrewmateRole, ICustomRole
-{
-    public string RoleName => "fortnite helper";
-    public string RoleLongDescription => "ok so your objective is to help";
-    public string RoleDescription => RoleLongDescription;
-    public Color RoleColor => Palette.Brown;
-    public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
-    public LoadableAsset<Sprite> OptionsScreenshot => ExampleAssets.Banner;
-
-}

MiraAPI.Example/Roles/FreezerRole.cs

@@ -0,0 +1,19 @@
+using MiraAPI.Roles;
+using UnityEngine;
+
+namespace MiraAPI.Example.Roles;
+
+public class FreezerRole : ImpostorRole, ICustomRole
+{
+    public string RoleName => "Freezer";
+    public string RoleLongDescription => "Freeze another player for a duration of time.";
+    public string RoleDescription => RoleLongDescription;
+    public Color RoleColor => Palette.Blue;
+    public ModdedRoleTeams Team => ModdedRoleTeams.Impostor;
+
+    public CustomRoleConfiguration Configuration => new CustomRoleConfiguration(this)
+    {
+        OptionsScreenshot = ExampleAssets.Banner,
+        MaxRoleCount = 2,
+    };
+}

MiraAPI.Example/Roles/MayorRole.cs

@@ -0,0 +1,14 @@
+using MiraAPI.Roles;
+using UnityEngine;
+
+namespace MiraAPI.Example.Roles;
+
+public class MayorRole : CrewmateRole, ICustomRole
+{
+    public string RoleName => "Mayor";
+    public string RoleLongDescription => "You get extra votes!";
+    public string RoleDescription => RoleLongDescription;
+    public Color RoleColor => new Color32(221, 176, 152, 255);
+    public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
+    public CustomRoleConfiguration Configuration => new(this);
+}

MiraAPI.Example/Roles/NeutralKillerRole.cs

@@ -0,0 +1,39 @@
+using MiraAPI.Example.GameOver;
+using MiraAPI.GameEnd;
+using MiraAPI.Roles;
+using UnityEngine;
+
+namespace MiraAPI.Example.Roles;
+
+public class NeutralKillerRole : ImpostorRole, ICustomRole
+{
+    public string RoleName => "Outcast Killer";
+    public string RoleDescription => "Outcast who can kill.";
+    public string RoleLongDescription => RoleDescription;
+    public Color RoleColor => Color.magenta;
+    public ModdedRoleTeams Team => ModdedRoleTeams.Custom;
+
+    public CustomRoleConfiguration Configuration => new(this)
+    {
+        UseVanillaKillButton = true,
+        CanGetKilled = true,
+        CanUseVent = true,
+    };
+
+    public RoleOptionsGroup RoleOptionsGroup { get; } = new("Outcast", Color.gray);
+
+    public TeamIntroConfiguration? IntroConfiguration { get; } = new(
+        Color.gray,
+        "OUTCAST",
+        "You are an Outcast. You do not have a team.");
+
+    public override void SpawnTaskHeader(PlayerControl playerControl)
+    {
+        // remove existing task header.
+    }
+
+    public override bool DidWin(GameOverReason gameOverReason)
+    {
+        return gameOverReason == CustomGameOver.GameOverReason<NeutralKillerGameOver>();
+    }
+}

MiraAPI.Example/Roles/TeleporterRole.cs

@@ -0,0 +1,26 @@
+using MiraAPI.Roles;
+using UnityEngine;
+
+namespace MiraAPI.Example.Roles;
+
+public class TeleporterRole : CrewmateRole, ICustomRole
+{
+    public string RoleName => "Teleporter";
+    public string RoleLongDescription => "Zoom out and teleport across the map!";
+    public string RoleDescription => RoleLongDescription;
+    public Color RoleColor => new Color32(221, 176, 152, 255);
+    public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
+
+    public CustomRoleConfiguration Configuration => new CustomRoleConfiguration(this)
+    {
+        OptionsScreenshot = ExampleAssets.Banner,
+        CanModifyChance = false,
+        DefaultChance = 73,
+        DefaultRoleCount = 4,
+    };
+
+    public bool CanLocalPlayerSeeRole(PlayerControl player)
+    {
+        return true;
+    }
+}

MiraAPI/Colors/CustomColor.cs

@@ -0,0 +1,44 @@
+using MiraAPI.Utilities;
+using Reactor.Localization.Utilities;
+using UnityEngine;
+
+namespace MiraAPI.Colors;
+
+/// <summary>
+/// Represents a custom color with a main color and a shadow color.
+/// </summary>
+/// <param name="name">The name of the option.</param>
+/// <param name="mainColor">The main color.</param>
+/// <param name="shadowColor">The shadow color.</param>
+public sealed class CustomColor(StringNames name, Color32 mainColor, Color32 shadowColor)
+{
+    /// <summary>
+    /// Gets the main color.
+    /// </summary>
+    public Color32 MainColor { get; } = mainColor;
+
+    /// <summary>
+    /// Gets the shadow color.
+    /// </summary>
+    public Color32 ShadowColor { get; } = shadowColor;
+
+    /// <summary>
+    /// Gets the name of the color.
+    /// </summary>
+    public StringNames Name { get; } = name;
+
+    /// <inheritdoc />
+    public CustomColor(StringNames name, Color32 mainColor) : this(name, mainColor, mainColor.GetShadowColor(60))
+    {
+    }
+
+    /// <inheritdoc />
+    public CustomColor(string name, Color32 mainColor) : this(name, mainColor, mainColor.GetShadowColor(60))
+    {
+    }
+
+    /// <inheritdoc />
+    public CustomColor(string name, Color32 mainColor, Color32 shadowColor) : this(CustomStringName.CreateAndRegister(name), mainColor, shadowColor)
+    {
+    }
+}

MiraAPI/Colors/PaletteManager.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Linq;
+using HarmonyLib;
+
+namespace MiraAPI.Colors;
+
+/// <summary>
+/// Used to register and track custom colors.
+/// </summary>
+public static class PaletteManager
+{
+    /// <summary>
+    /// Gets all registered custom colors.
+    /// </summary>
+    public static CustomColor[] RegisteredColors => [.. CustomColors];
+
+    internal static readonly List<CustomColor> CustomColors = [];
+
+    internal static void RegisterAllColors()
+    {
+        var colors = CustomColors.Select(x => x.MainColor).ToArray();
+        var shadowColors = CustomColors.Select(x => x.ShadowColor).ToArray();
+        var stringNames = CustomColors.Select(x => x.Name).ToArray();
+
+        Palette.PlayerColors = Palette.PlayerColors.ToArray().AddRangeToArray(colors);
+        Palette.ShadowColors = Palette.ShadowColors.ToArray().AddRangeToArray(shadowColors);
+        Palette.ColorNames = Palette.ColorNames.ToArray().AddRangeToArray(stringNames);
+
+        Palette.TextColors = Palette.TextColors.ToArray().AddRangeToArray(colors);
+        Palette.TextOutlineColors = Palette.TextOutlineColors.ToArray().AddRangeToArray(shadowColors);
+    }
+}

MiraAPI/Colors/RegisterCustomColorsAttribute.cs

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

MiraAPI/Events/Mira/MiraButtonCancelledEvent.cs

@@ -0,0 +1,44 @@
+using MiraAPI.Hud;
+
+namespace MiraAPI.Events.Mira;
+
+/// <summary>
+/// Invoked when a Mira Button click is cancelled. Do not use for vanilla buttons.
+/// </summary>
+/// <typeparam name="T">The Mira Button type.</typeparam>
+public sealed class MiraButtonCancelledEvent<T> : MiraEvent where T : CustomActionButton
+{
+    /// <summary>
+    /// Gets Mira Button whose click was cancelled.
+    /// </summary>
+    public T Button { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MiraButtonCancelledEvent{T}"/> class.
+    /// </summary>
+    /// <param name="button">The Mira Button whose click was cancelled.</param>
+    public MiraButtonCancelledEvent(T button)
+    {
+        Button = button;
+    }
+}
+
+/// <summary>
+/// Invoked when a Mira Button click is cancelled. Do not use for vanilla buttons.
+/// </summary>
+public sealed class MiraButtonCancelledEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets Mira Button whose click was cancelled.
+    /// </summary>
+    public CustomActionButton Button { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MiraButtonCancelledEvent"/> class.
+    /// </summary>
+    /// <param name="button">The Mira Button whose click was cancelled.</param>
+    public MiraButtonCancelledEvent(CustomActionButton button)
+    {
+        Button = button;
+    }
+}

MiraAPI/Events/Mira/MiraButtonClickEvent.cs

@@ -0,0 +1,51 @@
+using MiraAPI.Hud;
+
+namespace MiraAPI.Events.Mira;
+
+/// <summary>
+/// Button click event for Mira Buttons only. Do not use for vanilla buttons.
+/// </summary>
+/// <typeparam name="T">The Mira Button type.</typeparam>
+public sealed class MiraButtonClickEvent<T> : MiraCancelableEvent where T : CustomActionButton
+{
+    /// <summary>
+    /// Gets Mira Button that was clicked.
+    /// </summary>
+    public T Button { get; }
+
+    /// <summary>
+    /// Gets the generic click event that is invoked before this button-specific event.
+    /// </summary>
+    public MiraButtonClickEvent GenericClickEvent { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MiraButtonClickEvent{T}"/> class.
+    /// </summary>
+    /// <param name="button">The Mira Button that was clicked.</param>
+    /// <param name="genericClickEvent">The generic click event invoked before button-specific events.</param>
+    public MiraButtonClickEvent(T button, MiraButtonClickEvent genericClickEvent)
+    {
+        GenericClickEvent = genericClickEvent;
+        Button = button;
+    }
+}
+
+/// <summary>
+/// Button click event for Mira Buttons only. Do not use for vanilla buttons.
+/// </summary>
+public sealed class MiraButtonClickEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets Mira Button that was clicked.
+    /// </summary>
+    public CustomActionButton Button { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MiraButtonClickEvent"/> class.
+    /// </summary>
+    /// <param name="button">The Mira Button that was clicked.</param>
+    public MiraButtonClickEvent(CustomActionButton button)
+    {
+        Button = button;
+    }
+}

MiraAPI/Events/MiraCancelableEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events;
+
+/// <summary>
+/// Abstract class for Mira Events that can be cancelled.
+/// </summary>
+public abstract class MiraCancelableEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets a value indicating whether the event is cancelled.
+    /// </summary>
+    public bool IsCancelled { get; private set; }
+
+    /// <summary>
+    /// Cancels the event.
+    /// </summary>
+    public void Cancel()
+    {
+        IsCancelled = true;
+    }
+
+    /// <summary>
+    /// Uncancels the event.
+    /// </summary>
+    public void UnCancel()
+    {
+        IsCancelled = false;
+    }
+}

MiraAPI/Events/MiraEvent.cs

@@ -0,0 +1,6 @@
+namespace MiraAPI.Events;
+
+/// <summary>
+/// Abstract class for Mira Events.
+/// </summary>
+public abstract class MiraEvent;

MiraAPI/Events/MiraEventManager.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Reactor.Utilities;
+
+namespace MiraAPI.Events;
+
+/// <summary>
+/// Mira Event manager.
+/// </summary>
+public static class MiraEventManager
+{
+    private static readonly Dictionary<Type, List<MiraEventWrapper>> EventWrappers = [];
+
+    /// <summary>
+    /// Invoke an event.
+    /// </summary>
+    /// <param name="eventInstance">The event instance.</param>
+    /// <typeparam name="T">Type of Event.</typeparam>
+    /// <returns>If there was an event handler invoked for this event, return true. Otherwise, return false.</returns>
+    public static bool InvokeEvent<T>(T eventInstance) where T : MiraEvent
+    {
+        EventWrappers.TryGetValue(typeof(T), out var handlers);
+        if (handlers == null)
+        {
+            return false;
+        }
+
+        foreach (var handler in handlers)
+        {
+            ((Action<T>)handler.EventHandler).Invoke(eventInstance);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Invoke an event and use a specific type to find the handlers.
+    /// </summary>
+    /// <param name="eventInstance">The event instance.</param>
+    /// <param name="type">The type to use for handler lookup.</param>
+    /// <returns>If there was an event handler invoked for this event, return true. Otherwise, return false.</returns>
+    public static bool InvokeEvent(MiraEvent eventInstance, Type type)
+    {
+        EventWrappers.TryGetValue(type, out var handlers);
+        if (handlers == null)
+        {
+            return false;
+        }
+
+        foreach (var handler in handlers)
+        {
+            handler.EventHandler.DynamicInvoke(eventInstance);
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Register an event.
+    /// </summary>
+    /// <param name="type">The type of event.</param>
+    /// <param name="methodInfo">The MethodInfo of the event handler.</param>
+    /// <param name="priority">The priority of the event handler. Higher values are called first.</param>
+    public static void RegisterEventHandler(Type type, MethodInfo methodInfo, int priority = 0)
+    {
+        if (!type.IsSubclassOf(typeof(MiraEvent)))
+        {
+            Logger<MiraApiPlugin>.Error($"Type must be a subclass of MiraEvent: {nameof(type)}");
+            return;
+        }
+
+        if (!EventWrappers.TryGetValue(type, out var handlers))
+        {
+            handlers = [];
+            EventWrappers.Add(type, handlers);
+        }
+
+        var @delegate = Delegate.CreateDelegate(typeof(Action<>).MakeGenericType(type), methodInfo);
+        handlers.Add(new MiraEventWrapper(@delegate, priority));
+    }
+
+    /// <summary>
+    /// Register an event.
+    /// </summary>
+    /// <param name="handler">The callback method/handler for the event.</param>
+    /// <param name="priority">The priority of the event handler. Higher values are called first.</param>
+    /// <typeparam name="T">Type of event.</typeparam>
+    public static void RegisterEventHandler<T>(Action<T> handler, int priority = 0) where T : MiraEvent
+    {
+        if (!EventWrappers.ContainsKey(typeof(T)))
+        {
+            EventWrappers.Add(typeof(T), []);
+        }
+
+        var handlers = EventWrappers[typeof(T)];
+        handlers.Add(new MiraEventWrapper(handler, priority));
+    }
+
+    internal static void SortAllHandlers()
+    {
+        foreach (var handlers in EventWrappers.Values)
+        {
+            handlers.Sort((a, b) => a.Priority.CompareTo(b.Priority));
+        }
+    }
+}

MiraAPI/Events/MiraEventWrapper.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace MiraAPI.Events;
+
+/// <summary>
+/// Wrapper for event handlers.
+/// </summary>
+public class MiraEventWrapper
+{
+    /// <summary>
+    /// Gets the event handler delegate.
+    /// </summary>
+    public Delegate EventHandler { get; }
+
+    /// <summary>
+    /// Gets the priority of the handler. Higher values are called first.
+    /// </summary>
+    public int Priority { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MiraEventWrapper"/> class.
+    /// </summary>
+    /// <param name="eventHandler">The action for the event handler.</param>
+    /// <param name="priority">The priority of the handler.</param>
+    public MiraEventWrapper(Delegate eventHandler, int priority)
+    {
+        EventHandler = eventHandler;
+        Priority = priority;
+    }
+}

MiraAPI/Events/RegisterEventAttribute.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace MiraAPI.Events;
+
+/// <summary>
+/// Register an event.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method)]
+public class RegisterEventAttribute : Attribute
+{
+    /// <summary>
+    /// Gets the priority of the event.
+    /// </summary>
+    public int Priority { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RegisterEventAttribute"/> class.
+    /// </summary>
+    /// <param name="priority">The priority of the event.</param>
+    public RegisterEventAttribute(int priority = 0)
+    {
+        Priority = priority;
+    }
+}

MiraAPI/Events/Vanilla/Gameplay/AfterMurderEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events.Vanilla.Gameplay;
+
+/// <summary>
+/// Event that is invoked after a player is murdered. Only called after a successful murder. This event is not cancelable.
+/// </summary>
+public class AfterMurderEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the player that killed the target.
+    /// </summary>
+    public PlayerControl Source { get; }
+
+    /// <summary>
+    /// Gets the player that was killed.
+    /// </summary>
+    public PlayerControl Target { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AfterMurderEvent"/> class.
+    /// </summary>
+    /// <param name="source">The killer.</param>
+    /// <param name="target">The killed player.</param>
+    public AfterMurderEvent(PlayerControl source, PlayerControl target)
+    {
+        Source = source;
+        Target = target;
+    }
+}

MiraAPI/Events/Vanilla/Gameplay/BeforeMurderEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events.Vanilla.Gameplay;
+
+/// <summary>
+/// Event that is invoked before a player is murdered. This event is cancelable.
+/// </summary>
+public sealed class BeforeMurderEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the player that is killing the target.
+    /// </summary>
+    public PlayerControl Source { get; }
+
+    /// <summary>
+    /// Gets the player that is being killed.
+    /// </summary>
+    public PlayerControl Target { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="BeforeMurderEvent"/> class.
+    /// </summary>
+    /// <param name="source">The player that is killing the target.</param>
+    /// <param name="target">The player that is being killed.</param>
+    public BeforeMurderEvent(PlayerControl source, PlayerControl target)
+    {
+        Source = source;
+        Target = target;
+    }
+}

MiraAPI/Events/Vanilla/Gameplay/GameEndEvent.cs

@@ -0,0 +1,21 @@
+namespace MiraAPI.Events.Vanilla.Gameplay;
+
+/// <summary>
+/// The event that is invoked when the end game screen is shown. Non cancelable.
+/// </summary>
+public class GameEndEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the instance of the EndGameManager.
+    /// </summary>
+    public EndGameManager EndGameManager { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GameEndEvent"/> class.
+    /// </summary>
+    /// <param name="manager">The instance of the EndGameManager.</param>
+    public GameEndEvent(EndGameManager manager)
+    {
+        EndGameManager = manager;
+    }
+}

MiraAPI/Events/Vanilla/Gameplay/IntroBeginEvent.cs

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

MiraAPI/Events/Vanilla/Gameplay/SetRoleEvent.cs

@@ -0,0 +1,30 @@
+using AmongUs.GameOptions;
+
+namespace MiraAPI.Events.Vanilla.Gameplay;
+
+/// <summary>
+/// Event that is invoked after a player's role is set. This event is not cancelable.
+/// </summary>
+public class SetRoleEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the player whos role was changed.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the role that the player was set to.
+    /// </summary>
+    public RoleTypes Role { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SetRoleEvent"/> class.
+    /// </summary>
+    /// <param name="player">The player.</param>
+    /// <param name="role">The new role.</param>
+    public SetRoleEvent(PlayerControl player, RoleTypes role)
+    {
+        Player = player;
+        Role = role;
+    }
+}

MiraAPI/Events/Vanilla/Map/CloseDoorsEvent.cs

@@ -0,0 +1,21 @@
+namespace MiraAPI.Events.Vanilla.Map;
+
+/// <summary>
+/// Event fired when a player closes the doors in a room.
+/// </summary>
+public class CloseDoorsEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the room that the doors were closed in.
+    /// </summary>
+    public SystemTypes Room { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CloseDoorsEvent"/> class.
+    /// </summary>
+    /// <param name="room">The room that was closed.</param>
+    public CloseDoorsEvent(SystemTypes room)
+    {
+        Room = room;
+    }
+}

MiraAPI/Events/Vanilla/Map/PlayerOpenSabotageEvent.cs

@@ -0,0 +1,21 @@
+namespace MiraAPI.Events.Vanilla.Map;
+
+/// <summary>
+/// Sabotage from Vanilla Among Us.
+/// </summary>
+public class PlayerOpenSabotageEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the MapBehaviour.
+    /// </summary>
+    public MapBehaviour MapBehaviour { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlayerOpenSabotageEvent"/> class.
+    /// </summary>
+    /// <param name="mapBehaviour">The MapBehaviour.</param>
+    public PlayerOpenSabotageEvent(MapBehaviour mapBehaviour)
+    {
+        MapBehaviour = mapBehaviour;
+    }
+}

MiraAPI/Events/Vanilla/Map/UpdateSystemEvent.cs

@@ -0,0 +1,34 @@
+namespace MiraAPI.Events.Vanilla.Map;
+
+/// <summary>
+/// Cancelable event that is invoked before a system is updated. Usually used for sabotage events.
+/// </summary>
+public class UpdateSystemEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the type of system that will be updated.
+    /// </summary>
+    public SystemTypes SystemType { get; }
+
+    /// <summary>
+    /// Gets the player that is updating the system.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the byte amount the system is being updated by.
+    /// </summary>
+    public byte Amount { get; }
+
+    /// <summary>
+    ///  Initializes a new instance of the <see cref="UpdateSystemEvent"/> class.
+    /// </summary>
+    /// <param name="systemType">The SystemType being updated.</param>
+    /// <param name="amount">Amount to update System to.</param>
+    public UpdateSystemEvent(SystemTypes systemType, PlayerControl player, byte amount)
+    {
+        SystemType = systemType;
+        Player = player;
+        Amount = amount;
+    }
+}

MiraAPI/Events/Vanilla/Meeting/EjectionEvent.cs

@@ -0,0 +1,21 @@
+namespace MiraAPI.Events.Vanilla.Meeting;
+
+/// <summary>
+/// The event that is invoked when a player is ejected. Non-cancelable.
+/// </summary>
+public class EjectionEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the instance of the ExileController.
+    /// </summary>
+    public ExileController ExileController { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="EjectionEvent"/> class.
+    /// </summary>
+    /// <param name="controller">The exile controller.</param>
+    public EjectionEvent(ExileController controller)
+    {
+        ExileController = controller;
+    }
+}

MiraAPI/Events/Vanilla/Meeting/ReportBodyEvent.cs

@@ -0,0 +1,36 @@
+namespace MiraAPI.Events.Vanilla.Meeting;
+
+/// <summary>
+/// The event that is invoked when a body is reported.
+/// This is invoked in CmdReportBody.
+/// </summary>
+public class ReportBodyEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the player that is reporting the body.
+    /// </summary>
+    public PlayerControl Reporter { get; }
+
+    /// <summary>
+    /// Gets the player that is being reported. Will be null for emergency meeting.
+    /// </summary>
+    public NetworkedPlayerInfo? Target { get; }
+
+    /// <summary>
+    /// Gets the body that is being reported. Will be null for emergency meeting.
+    /// </summary>
+    public DeadBody? Body { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReportBodyEvent"/> class.
+    /// </summary>
+    /// <param name="reporter">The player who reported the body.</param>
+    /// <param name="target">The player being reported.</param>
+    /// <param name="body">The body being reported.</param>
+    public ReportBodyEvent(PlayerControl reporter, NetworkedPlayerInfo? target, DeadBody? body)
+    {
+        Reporter = reporter;
+        Target = target;
+        Body = body;
+    }
+}

MiraAPI/Events/Vanilla/Meeting/StartMeetingEvent.cs

@@ -0,0 +1,22 @@
+namespace MiraAPI.Events.Vanilla.Meeting;
+
+/// <summary>
+/// The event that is invoked when a meeting is called. This event is not cancelable.
+/// This event is called after Mira resets votes, so if you plan on adding votes to a specific player, do it with this event.
+/// </summary>
+public class StartMeetingEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the MeetingHud instance.
+    /// </summary>
+    public MeetingHud MeetingHud { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StartMeetingEvent"/> class.
+    /// </summary>
+    /// <param name="meetingHud">The MeetingHud instance.</param>
+    public StartMeetingEvent(MeetingHud meetingHud)
+    {
+        MeetingHud = meetingHud;
+    }
+}

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

@@ -0,0 +1,26 @@
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// Checks if voting is complete. If canceled, the default end voting logic will be skipped.
+/// </summary>
+public class CheckForEndVotingEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets a value indicating whether default voting logic determines that voting is complete.
+    /// </summary>
+    public bool IsVotingComplete { get; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the voting should be forced to end, regardless of the default logic.
+    /// </summary>
+    public bool ForceEndVoting { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CheckForEndVotingEvent"/> class.
+    /// </summary>
+    /// <param name="isVotingComplete">>True if voting is complete, false otherwise.</param>
+    public CheckForEndVotingEvent(bool isVotingComplete)
+    {
+        IsVotingComplete = isVotingComplete;
+    }
+}

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

@@ -0,0 +1,44 @@
+using MiraAPI.Voting;
+
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// The event that is invoked when Mira handles a vote. This is invoked before Mira's behaviour, so be cautious.
+/// If you intend on adding custom vote behaviour, cancel the event and do so.
+/// If you are NOT canceling the event, keep in mind that Mira automatically removes a vote and adds the suspect to the VotedPlayers list after this event is invoked.
+/// </summary>
+public class HandleVoteEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the instance of the voter's vote data.
+    /// </summary>
+    public PlayerVoteData VoteData { get; }
+
+    /// <summary>
+    /// Gets the player who voted.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the player id of the target.
+    /// </summary>
+    public byte TargetId { get; }
+
+    /// <summary>
+    /// Gets the player info of the target.
+    /// </summary>
+    public NetworkedPlayerInfo TargetPlayerInfo { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="HandleVoteEvent"/> class.
+    /// </summary>
+    /// <param name="playerVoteData">The voter's data.</param>
+    /// <param name="targetId">The target's playerId.</param>
+    public HandleVoteEvent(PlayerVoteData playerVoteData, byte targetId)
+    {
+        VoteData = playerVoteData;
+        Player = playerVoteData.Owner;
+        TargetId = targetId;
+        TargetPlayerInfo = GameData.Instance.GetPlayerById(targetId);
+    }
+}

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

@@ -0,0 +1,43 @@
+using MiraAPI.Voting;
+
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// The event that is invoked when the player tries to select another player to vote.
+/// </summary>
+public class MeetingSelectEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the instance of the voter's vote data.
+    /// </summary>
+    public PlayerVoteData VoteData { get; }
+
+    /// <summary>
+    /// Gets the player id of the target.
+    /// </summary>
+    public int TargetId { get; }
+
+    /// <summary>
+    /// Gets the player info of the target.
+    /// </summary>
+    public NetworkedPlayerInfo TargetPlayerInfo { get; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the player is allowed to select the target.
+    /// </summary>
+    public bool AllowSelect { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MeetingSelectEvent"/> class.
+    /// </summary>
+    /// <param name="playerVoteData">The voter's data.</param>
+    /// <param name="targetId">The target's playerId.</param>
+    /// <param name="allowSelect">>Whether the player is allowed to select the target.</param>
+    public MeetingSelectEvent(PlayerVoteData playerVoteData, int targetId, bool allowSelect)
+    {
+        VoteData = playerVoteData;
+        TargetId = targetId;
+        TargetPlayerInfo = GameData.Instance.GetPlayerById((byte)targetId);
+        AllowSelect = allowSelect;
+    }
+}

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

@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using MiraAPI.Voting;
+
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// Called in VotingUtils.HandlePopulateResults.
+/// Cancelling is NOT advised but if you do plan on cancelling, please ensure you account for displaying ALL player's votes.
+/// </summary>
+public class PopulateResultsEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets a list of networked votes.
+    /// </summary>
+    public List<CustomVote> Votes { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PopulateResultsEvent"/> class.
+    /// </summary>
+    /// <param name="votes">The list of votes.</param>
+    public PopulateResultsEvent(List<CustomVote> votes)
+    {
+        Votes = votes;
+    }
+}

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

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Linq;
+using MiraAPI.Voting;
+
+namespace MiraAPI.Events.Vanilla.Meeting.Voting;
+
+/// <summary>
+/// Ran after calculating votes and before displaying the results. Only ran on the host.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="ProcessVotesEvent"/> class.
+/// </remarks>
+/// <param name="votes">>The list of votes that are being processed.</param>
+/// <param name="exiledPlayer">The player to be exiled. Will be null if no player is to be exiled.</param>
+public class ProcessVotesEvent(List<CustomVote> votes, NetworkedPlayerInfo? exiledPlayer = null) : MiraEvent
+{
+    private readonly List<CustomVote> _originalVotes = [.. votes];
+
+    private NetworkedPlayerInfo? _exiledPlayer = exiledPlayer;
+
+    /// <summary>
+    /// Gets a value indicating whether the exiled player has been modified by the event.
+    /// </summary>
+    public bool ExiledPlayerModified { get; private set; }
+
+    /// <summary>
+    /// Gets a value indicating whether the votes have been modified by the event.
+    /// </summary>
+    public bool VotesModified => !Votes.SequenceEqual(_originalVotes);
+
+    /// <summary>
+    /// Gets the list of votes that are being processed.
+    /// </summary>
+    public List<CustomVote> Votes { get; } = votes;
+
+    /// <summary>
+    /// Gets or sets the player to be exiled. Will be null if no player is to be exiled.
+    /// </summary>
+    public NetworkedPlayerInfo? ExiledPlayer
+    {
+        get => _exiledPlayer;
+        set
+        {
+            _exiledPlayer = value;
+            ExiledPlayerModified = true;
+        }
+    }
+}

MiraAPI/Events/Vanilla/Player/CompleteTaskEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events.Vanilla.Player;
+
+/// <summary>
+/// The event that is invoked when a player completes a task. Non cancelable.
+/// </summary>
+public class CompleteTaskEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the instance of the <see cref="PlayerControl"/>.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the instance of the <see cref="PlayerTask"/> that the player completed.
+    /// </summary>
+    public PlayerTask Task { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CompleteTaskEvent"/> class.
+    /// </summary>
+    /// <param name="player">The player who completed the task.</param>
+    /// <param name="task">The task that the player completed.</param>
+    public CompleteTaskEvent(PlayerControl player, PlayerTask task)
+    {
+        Player = player;
+        Task = task;
+    }
+}

MiraAPI/Events/Vanilla/Player/PlayerDeathEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events.Vanilla.Player;
+
+/// <summary>
+/// Event that is invoked when a player dies. Non cancelable.
+/// </summary>
+public class PlayerDeathEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the player who died.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the reason the player died.
+    /// </summary>
+    public DeathReason DeathReason { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlayerDeathEvent"/> class.
+    /// </summary>
+    /// <param name="player">The player who died.</param>
+    /// <param name="reason">The reason the player died.</param>
+    public PlayerDeathEvent(PlayerControl player, DeathReason reason)
+    {
+        Player = player;
+        DeathReason = reason;
+    }
+}

MiraAPI/Events/Vanilla/Player/PlayerJoinEvent.cs

@@ -0,0 +1,23 @@
+using InnerNet;
+
+namespace MiraAPI.Events.Vanilla.Player;
+
+/// <summary>
+/// Event that is invoked when a player joins the lobby. Non cancelable.
+/// </summary>
+public class PlayerJoinEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the player who joined.
+    /// </summary>
+    public ClientData ClientData { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlayerJoinEvent"/> class.
+    /// </summary>
+    /// <param name="data">The data of the player who joined.</param>
+    public PlayerJoinEvent(ClientData data)
+    {
+        ClientData = data;
+    }
+}

MiraAPI/Events/Vanilla/Player/PlayerLeaveEvent.cs

@@ -0,0 +1,30 @@
+using InnerNet;
+
+namespace MiraAPI.Events.Vanilla.Player;
+
+/// <summary>
+/// Event that is invoked when a player leaves the game. Non cancelable.
+/// </summary>
+public class PlayerLeaveEvent : MiraEvent
+{
+    /// <summary>
+    /// Gets the player who left.
+    /// </summary>
+    public ClientData ClientData { get; }
+
+    /// <summary>
+    /// Gets the reason why the player left.
+    /// </summary>
+    public DisconnectReasons Reason { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlayerLeaveEvent"/> class.
+    /// </summary>
+    /// <param name="data">The data of the player who left.</param>
+    /// <param name="reason">The reason why the player left.</param>
+    public PlayerLeaveEvent(ClientData data, DisconnectReasons reason)
+    {
+        ClientData = data;
+        Reason = reason;
+    }
+}

MiraAPI/Events/Vanilla/Usables/EnterVentEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events.Vanilla.Usables;
+
+/// <summary>
+/// Event that is invoked when a player enters a vent. This event is cancelable.
+/// </summary>
+public class EnterVentEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the player that is entering the vent.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the vent that the player is entering.
+    /// </summary>
+    public Vent? Vent { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="EnterVentEvent"/> class.
+    /// </summary>
+    /// <param name="player">The player that is entering the vent.</param>
+    /// <param name="vent">The vent being entered.</param>
+    public EnterVentEvent(PlayerControl player, Vent? vent)
+    {
+        Player = player;
+        Vent = vent;
+    }
+}

MiraAPI/Events/Vanilla/Usables/ExitVentEvent.cs

@@ -0,0 +1,28 @@
+namespace MiraAPI.Events.Vanilla.Usables;
+
+/// <summary>
+/// Event that is invoked when a player exits a vent. This event is cancelable.
+/// </summary>
+public class ExitVentEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the player that is exiting the vent.
+    /// </summary>
+    public PlayerControl Player { get; }
+
+    /// <summary>
+    /// Gets the vent that the player is exiting.
+    /// </summary>
+    public Vent? Vent { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExitVentEvent"/> class.
+    /// </summary>
+    /// <param name="player">The player who is exiting the vent.</param>
+    /// <param name="vent">The vent being exited from.</param>
+    public ExitVentEvent(PlayerControl player, Vent? vent)
+    {
+        Player = player;
+        Vent = vent;
+    }
+}

MiraAPI/Events/Vanilla/Usables/PlayerCanUseEvent.cs

@@ -0,0 +1,15 @@
+namespace MiraAPI.Events.Vanilla.Usables;
+
+/// <summary>
+/// Event for if a <see cref="PlayerControl"/> can use an <see cref="IUsable"/> from Vanilla Among Us. Will always be ran locally.
+/// </summary>
+public class PlayerCanUseEvent : PlayerUseEvent
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlayerCanUseEvent"/> class.
+    /// </summary>
+    /// <param name="usable">The IUsable.</param>
+    public PlayerCanUseEvent(IUsable usable) : base(usable)
+    {
+    }
+}

MiraAPI/Events/Vanilla/Usables/PlayerUseEvent.cs

@@ -0,0 +1,34 @@
+namespace MiraAPI.Events.Vanilla.Usables;
+
+/// <summary>
+/// Event for <see cref="PlayerControl"/> using a <see cref="IUsable"/> from Vanilla Among Us. Will always be ran locally.
+/// </summary>
+public class PlayerUseEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the instance of <see cref="IUsable"/> that was used.
+    /// </summary>
+    public IUsable Usable { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the IUsable is a <see cref="Console"/>, <see cref="MapConsole"/>, or <see cref="SystemConsole"/>.
+    /// </summary>
+    public bool IsPrimaryConsole { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether the IUsable is a <see cref="Vent"/>.
+    /// </summary>
+    public bool IsVent { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PlayerUseEvent"/> class.
+    /// </summary>
+    /// <param name="usable">The IUsable.</param>
+    public PlayerUseEvent(IUsable usable)
+    {
+        Usable = usable;
+
+        IsPrimaryConsole = usable.TryCast<Console>() || usable.TryCast<SystemConsole>() || usable.TryCast<MapConsole>();
+        IsVent = usable.TryCast<Vent>();
+    }
+}

MiraAPI/GameEnd/CustomGameOver.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using MiraAPI.Networking;
+using Reactor.Networking.Rpc;
+
+namespace MiraAPI.GameEnd;
+
+/// <summary>
+/// Custom Game Over.
+/// </summary>
+public abstract class CustomGameOver
+{
+    /// <summary>
+    /// Gets the current CustomGameOver.
+    /// </summary>
+    public static CustomGameOver? Instance { get; internal set; }
+
+    /// <summary>
+    /// Verifies if the condition for this CustomGameOver is met.
+    /// </summary>
+    /// <param name="playerControl">The PlayerControl that requested the Game Over.</param>
+    /// <param name="winners">The collection of winners.</param>
+    /// <returns>True if the condition is met, otherwise false.</returns>
+    public virtual bool VerifyCondition(PlayerControl playerControl, NetworkedPlayerInfo[] winners)
+    {
+        return true;
+    }
+
+    /// <summary>
+    /// Runs before the base game calls EndGameManager.SetEverythingUp.
+    /// </summary>
+    /// <param name="endGameManager">The EndGameManager instance.</param>
+    /// <returns>Return True to use the run the original method, return False to skip it.</returns>
+    public virtual bool BeforeEndGameSetup(EndGameManager endGameManager)
+    {
+        return true;
+    }
+
+    /// <summary>
+    /// Runs after the base game calls EndGameManager.SetEverythingUp.
+    /// </summary>
+    /// <param name="endGameManager">The EndGameManager instance.</param>
+    public virtual void AfterEndGameSetup(EndGameManager endGameManager)
+    {
+    }
+
+    /// <summary>
+    /// Get the GameOverReason associated with this CustomGameOver.
+    /// </summary>
+    /// <typeparam name="T">Type of the custom game over.</typeparam>
+    /// <returns>The GameOverReason associated with the custom game over.</returns>
+    public static GameOverReason GameOverReason<T>() where T : CustomGameOver
+    {
+        return (GameOverReason)GameOverManager.GetGameOverId<T>();
+    }
+
+    /// <summary>
+    /// Send a custom game over.
+    /// </summary>
+    /// <param name="winners">A collection of winners.</param>
+    /// <typeparam name="T">Type of the custom game over.</typeparam>
+    public static void Trigger<T>(IEnumerable<NetworkedPlayerInfo> winners) where T : CustomGameOver
+    {
+        var reason = GameOverManager.GetGameOverId<T>();
+        var data = new GameOverData(reason, [.. winners]);
+
+        Rpc<CustomGameOverRpc>.Instance.Send(PlayerControl.LocalPlayer, data, true);
+    }
+
+    /// <summary>
+    /// Implicitly convert a CustomGameOver to a GameOverReason.
+    /// </summary>
+    /// <param name="gameOver">The CustomGameOver instance.</param>
+    /// <returns>The GameOverReason associated with the CustomGameOver.</returns>
+    public static implicit operator GameOverReason(CustomGameOver gameOver)
+    {
+        return (GameOverReason)GameOverManager.GetGameOverId(gameOver.GetType());
+    }
+}

MiraAPI/GameEnd/GameOverData.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace MiraAPI.GameEnd;
+
+/// <summary>
+/// Data for a game over.
+/// </summary>
+/// <param name="Reason">Reason for the game over.</param>
+/// <param name="Winners">A collection of winners.</param>
+public record struct GameOverData(int Reason, List<NetworkedPlayerInfo> Winners);

MiraAPI/GameEnd/GameOverManager.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Reactor.Utilities;
+
+namespace MiraAPI.GameEnd;
+
+/// <summary>
+/// Manage custom game overs.
+/// </summary>
+public static class GameOverManager
+{
+    private static readonly Dictionary<Type, int> GameOverIds = [];
+    private static readonly Dictionary<int, Type> GameOverTypes = [];
+
+    private static int _nextId = Enum.GetNames<GameOverReason>().Length;
+
+    /// <summary>
+    /// Register a custom game over.
+    /// </summary>
+    /// <param name="gameOverType">Type of the custom game over.</param>
+    /// <exception cref="ArgumentException">Thrown when the type is not a subclass of CustomGameOver, is abstract, or does not have a parameterless constructor.</exception>
+    /// <returns>>True if the game over was registered successfully, false otherwise.</returns>
+    public static bool RegisterGameOver(Type gameOverType)
+    {
+        if (!typeof(CustomGameOver).IsAssignableFrom(gameOverType))
+        {
+            return false;
+        }
+
+        if (gameOverType.IsAbstract)
+        {
+            Logger<MiraApiPlugin>.Error("The type must not be abstract.");
+            return false;
+        }
+
+        if (gameOverType.GetConstructor(Type.EmptyTypes) == null)
+        {
+            Logger<MiraApiPlugin>.Error("The type must have a parameterless constructor.");
+            return false;
+        }
+
+        GameOverIds.Add(gameOverType, _nextId);
+        GameOverTypes.Add(_nextId, gameOverType);
+        _nextId++;
+        return true;
+    }
+
+    /// <summary>
+    /// Create an instance of a custom game over.
+    /// </summary>
+    /// <param name="id">ID of the custom game over.</param>
+    /// <param name="customGameOver">The created instance of the custom game over.</param>
+    /// <returns>An instance of the custom game over.</returns>
+    public static bool TryGetGameOver(int id, [NotNullWhen(true)] out CustomGameOver? customGameOver)
+    {
+        if (GameOverTypes.TryGetValue(id, out var gameOverType))
+        {
+            customGameOver = Activator.CreateInstance(gameOverType) as CustomGameOver;
+            return customGameOver != null;
+        }
+
+        customGameOver = null;
+        return false;
+    }
+
+    /// <summary>
+    /// Get the ID of a custom game over.
+    /// </summary>
+    /// <typeparam name="T">Type of the custom game over.</typeparam>
+    /// <returns>The ID of the custom game over.</returns>
+    public static int GetGameOverId<T>() where T : CustomGameOver
+    {
+        return GetGameOverId(typeof(T));
+    }
+
+    /// <summary>
+    /// Get the ID of a custom game over.
+    /// </summary>
+    /// <param name="gameOverType">Type of the custom game over.</param>
+    /// <returns>The ID of the custom game over.</returns>
+    /// <exception cref="ArgumentException">Thrown when the type is not registered.</exception>
+    public static int GetGameOverId(Type gameOverType)
+    {
+        if (GameOverIds.TryGetValue(gameOverType, out var id))
+            return id;
+
+        throw new ArgumentException($"{gameOverType.FullName} is not a registered custom game over!");
+    }
+}

MiraAPI/GameModes/CustomGameMode.cs

@@ -3,74 +3,82 @@
 namespace MiraAPI.GameModes;
 
 /// <summary>
-/// Base class for custom gamemodes
+/// Base class for custom gamemodes.
 /// </summary>
 public abstract class CustomGameMode
 {
     /// <summary>
-    /// Game mode name
+    /// Gets the game mode name.
     /// </summary>
     public abstract string Name { get; }
 
     /// <summary>
-    /// Game mode description
+    /// Gets the game mode description.
     /// </summary>
     public abstract string Description { get; }
 
     /// <summary>
-    /// Game mode ID
+    /// Gets the game mode ID.
     /// </summary>
     public abstract int Id { get; }
 
     /// <summary>
-    /// Called when Intro Cutscene is destroyed
+    /// Called when Intro Cutscene is destroyed.
     /// </summary>
-    public virtual void Initialize() { }
+    public virtual void Initialize()
+    {
+    }
 
     /// <summary>
-    /// Called on HudManager.Start()
+    /// Called on HudManager.Start().
     /// </summary>
-    /// <param name="instance">Instance of HudManager</param>
+    /// <param name="instance">Instance of HudManager.</param>
-    public virtual void HudStart(HudManager instance) { }
+    public virtual void HudStart(HudManager instance)
+    {
+    }
 
     /// <summary>
-    /// Called every frame on HudManager.Update()
+    /// Called every frame on HudManager.Update().
     /// </summary>
-    /// <param name="instance">Instance of HudManager</param>
+    /// <param name="instance">Instance of HudManager.</param>
-    public virtual void HudUpdate(HudManager instance) { }
+    public virtual void HudUpdate(HudManager instance)
+    {
+    }
 
     /// <summary>
-    /// Called when a player is killed
+    /// Called when a player is killed.
     /// </summary>
-    /// <param name="player">PlayerControl that was killed</param>
+    /// <param name="player">PlayerControl that was killed.</param>
-    public virtual void OnDeath(PlayerControl player) { }
+    public virtual void OnDeath(PlayerControl player)
+    {
+    }
 
     /// <summary>
-    /// Calculate Game End logic
+    /// Calculate Game End logic.
     /// </summary>
-    /// <param name="runOriginal">Should original game end logic be used</param>
+    /// <param name="runOriginal">Should original game end logic be used.</param>
-    /// <param name="instance">Instance of LogicGameFlowNormal</param>
+    /// <param name="instance">Instance of LogicGameFlowNormal.</param>
     public virtual void CheckGameEnd(out bool runOriginal, LogicGameFlowNormal instance)
     {
         runOriginal = true;
     }
 
     /// <summary>
-    /// Custom role assignment
+    /// Custom role assignment.
     /// </summary>
-    /// <param name="runOriginal">Should original role assignment be used</param>
+    /// <param name="runOriginal">Should original role assignment be used.</param>
-    /// <param name="instance">Instance of LogicRoleSelection</param>
+    /// <param name="instance">Instance of LogicRoleSelection.</param>
     public virtual void AssignRoles(out bool runOriginal, LogicRoleSelectionNormal instance)
     {
         runOriginal = true;
     }
 
     /// <summary>
-    /// Custom murder logic
+    /// Custom murder logic.
     /// </summary>
-    /// <param name="runOriginal">Should original murder logic be used</param>
+    /// <param name="runOriginal">Should the original murder logic be used.</param>
-    /// <param name="result">Result of custom murder logic</param>
+    /// <param name="result">Result of custom murder logic.</param>
-    /// <param name="target">Target player for murder</param>
+    /// <param name="target">Target player for murder.</param>
     public virtual void CanKill(out bool runOriginal, out bool result, PlayerControl target)
     {
         result = false;
@@ -78,61 +86,69 @@ public abstract class CustomGameMode
     }
 
     /// <summary>
-    /// Should Roles Settings be available when this gamemode is selected?
+    /// Should Roles Settings be available when this gamemode is selected.
     /// </summary>
-    public virtual bool CanAccessRolesTab() => true;
+    /// <returns>True if Role Settings are enabled in this game mode.</returns>
+    public virtual bool AreRoleSettingsEnabled() => true;
 
     /// <summary>
-    /// Should Game Settings be available when this gamemode is selected?
+    /// Should Game Settings be available when this gamemode is selected.
     /// </summary>
-    public virtual bool CanAccessSettingsTab() => true;
+    /// <returns>True if Game Settings are enabled in this mode.</returns>
+    public virtual bool AreGameSettingsEnabled() => true;
 
     /// <summary>
-    /// Custom winner selection
+    /// Custom winner selection.
     /// </summary>
-    /// <returns>List of winners</returns>
+    /// <returns>List of winners or null.</returns>
-    public virtual List<NetworkedPlayerInfo> CalculateWinners() => null;
+    public virtual List<NetworkedPlayerInfo>? CalculateWinners() => null;
 
     /// <summary>
-    /// Show gamemode in Intro Cutscene
+    /// Show gamemode in Intro Cutscene.
     /// </summary>
-    public virtual bool ShowCustomRoleScreen() => false;
+    /// <returns>True if the game mode should be shown in the intro cutscene.</returns>
+    public virtual bool ShowGameModeIntroCutscene() => false;
 
     /// <summary>
-    /// Can Admin be used in this gamemode
+    /// Can Admin be used in this gamemode.
     /// </summary>
-    /// <param name="console">Admin Console</param>
+    /// <param name="console">Admin Console.</param>
+    /// <returns>True if Admin console is enabled.</returns>
     public virtual bool CanUseMapConsole(MapConsole console) => true;
 
     /// <summary>
-    /// Can a body be reported in this gamemode
+    /// Can a body be reported in this gamemode.
     /// </summary>
-    /// <param name="body">Target body for reporting</param>
+    /// <param name="body">Target body for reporting.</param>
+    /// <returns>True if dead bodies can be reported.</returns>
     public virtual bool CanReport(DeadBody body) => true;
 
     /// <summary>
-    /// Can system consoles be used in this gamemode
+    /// Can system consoles be used in this gamemode.
     /// </summary>
-    /// <param name="console">System Console</param>
+    /// <param name="console">System Console.</param>
+    /// <returns>True if system consoles are enabled in this mode.</returns>
     public virtual bool CanUseSystemConsole(SystemConsole console) => true;
 
     /// <summary>
-    /// Can tasks be interacted with in this gamemode
+    /// Can tasks be interacted with in this gamemode.
     /// </summary>
-    /// <param name="console">Task console</param>
+    /// <param name="console">Task console.</param>
-    public virtual bool CanUseConsole(Console console) => true;
+    /// <returns>True if tasks are enabled in this mode.</returns>
+    public virtual bool CanUseTasks(Console console) => true;
 
     /// <summary>
-    /// Should the sabotage map be used when attempting to open sabotage overlay
+    /// Should the sabotage map be used when attempting to open sabotage overlay.
     /// </summary>
-    /// <param name="map">MapBehaviour object</param>
+    /// <param name="map">MapBehaviour object.</param>
+    /// <returns>True if the sabotage map should be shown.</returns>
     public virtual bool ShouldShowSabotageMap(MapBehaviour map) => true;
 
     /// <summary>
-    /// Can a player vent in this gamemode
+    /// Can a player vent in this gamemode.
     /// </summary>
-    /// <param name="vent">Target vent</param>
+    /// <param name="vent">Target vent.</param>
-    /// <param name="playerInfo">Player attempting to vent</param>
+    /// <param name="playerInfo">Player attempting to vent.</param>
+    /// <returns>True if venting is enabled in this mode.</returns>
     public virtual bool CanVent(Vent vent, NetworkedPlayerInfo playerInfo) => true;
-
+}
-}

MiraAPI/GameModes/CustomGameModeManager.cs

@@ -1,20 +1,19 @@
-#nullable enable
+using System;
-using Reactor.Utilities;
-using System;
 using System.Collections.Generic;
 using System.Linq;
+using Reactor.Utilities;
 
 namespace MiraAPI.GameModes;
 
 /// <summary>
-/// Manages custom gamemodes
+/// Manages custom gamemodes.
 /// </summary>
 public static class CustomGameModeManager
 {
     /// <summary>
-    /// List of registered gamemodes
+    /// List of registered gamemodes.
     /// </summary>
-    public static readonly Dictionary<int, CustomGameMode> GameModes = [];
+    internal static readonly Dictionary<int, CustomGameMode> GameModes = [];
 
     public static bool IsDefault()
     {
@@ -22,14 +21,14 @@ public static class CustomGameModeManager
     }
 
     /// <summary>
-    /// Current gamemode
+    /// Current gamemode.
     /// </summary>
-    public static CustomGameMode? ActiveMode = new DefaultMode();
+    public static CustomGameMode? ActiveMode { get; internal set; } = new DefaultMode();
 
     /// <summary>
-    /// Set current gamemode
+    /// Set current gamemode.
     /// </summary>
-    /// <param name="id">gamemode ID</param>
+    /// <param name="id">gamemode ID.</param>
     public static void SetGameMode(int id)
     {
         if (GameModes.TryGetValue(id, out var gameMode))
@@ -42,9 +41,9 @@ public static class CustomGameModeManager
     }
 
     /// <summary>
-    /// Register gamemode from type 
+    /// Register gamemode from type.
     /// </summary>
-    /// <param name="gameModeType">Type of gamemode class, should inherit from <see cref="CustomGameMode"/></param>
+    /// <param name="gameModeType">Type of gamemode class, should inherit from <see cref="CustomGameMode"/>.</param>
     internal static void RegisterGameMode(Type gameModeType)
     {
         if (!typeof(CustomGameMode).IsAssignableFrom(gameModeType))
@@ -60,7 +59,7 @@ public static class CustomGameModeManager
             Logger<MiraApiPlugin>.Error($"Failed to create instance of {gameModeType.Name}");
             return;
         }
-        
+
         if (GameModes.Any(x => x.Key == gameMode.Id))
         {
             Logger<MiraApiPlugin>.Error($"ID for gamemode {gameMode.Name} already exists!");
@@ -69,4 +68,4 @@ public static class CustomGameModeManager
 
         GameModes.Add(gameMode.Id, gameMode);
     }
-}
+}

MiraAPI/GameModes/DefaultMode.cs

@@ -1,9 +1,8 @@
 namespace MiraAPI.GameModes;
 
-[RegisterGameMode]
 public class DefaultMode : CustomGameMode
 {
     public override string Name => "Default";
     public override string Description => "Default Among Us GameMode";
     public override int Id => 0;
-}
+}

MiraAPI/GameModes/RegisterGameModeAttribute.cs

@@ -1,28 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-
-namespace MiraAPI.GameModes;
-
-[AttributeUsage(AttributeTargets.Class)]
-public class RegisterGameModeAttribute : Attribute
-{
-    private static readonly HashSet<Assembly> RegisteredAssemblies = [];
-
-    internal static void Register(Assembly assembly)
-    {
-        if (!RegisteredAssemblies.Add(assembly))
-        {
-            return;
-        }
-
-        foreach (var type in assembly.GetTypes())
-        {
-            var attribute = type.GetCustomAttribute<RegisterGameModeAttribute>();
-            if (attribute != null)
-            {
-                CustomGameModeManager.RegisterGameMode(type);
-            }
-        }
-    }
-}

MiraAPI/GameOptions/AbstractOptionGroup.cs

@@ -4,27 +4,56 @@ using UnityEngine;
 
 namespace MiraAPI.GameOptions;
 
+/// <summary>
+/// Base class for option groups. An option group is a collection of options that are displayed together in the options menu.
+/// </summary>
 public abstract class AbstractOptionGroup
 {
-    public List<IModdedOption> Options { get; } = [];
+    internal List<IModdedOption> Options { get; } = [];
-    
+
     /// <summary>
-    /// The name of the group. Visible in options menu.
+    /// Gets the name of the group. Visible in options menu.
     /// </summary>
     public abstract string GroupName { get; }
-    
+
     /// <summary>
-    /// A function that returns whether the group should be visible or not.
+    /// Gets the Optionable type of the group.
+    /// </summary>
+    public virtual Type? OptionableType => null;
+
+    /// <summary>
+    /// Gets a value indicating whether the group should be shown in the modifiers menu.
+    /// </summary>
+    // TODO: make this not a boolean
+    public virtual bool ShowInModifiersMenu => false;
+
+    /// <summary>
+    /// Gets the function that determines whether the group should be visible or not.
     /// </summary>
     public virtual Func<bool> GroupVisible => () => true;
-    
+
     /// <summary>
-    /// The group color. This is used to color the group in the options menu.
+    /// Gets the group color. This is used to color the group in the options menu.
     /// </summary>
-    public virtual Color GroupColor => Color.clear;
+    public virtual Color GroupColor => MiraApiPlugin.DefaultHeaderColor;
-    
+
     /// <summary>
-    /// The role the group is associated with. This is used for the advanced role options menu.
+    /// Gets the group priority. This is used to determine the order in which groups are displayed in the options menu.
+    /// Zero is the highest priority, and the default value is the max uint value.
     /// </summary>
-    public virtual Type AdvancedRole => null;
+    public virtual uint GroupPriority => uint.MaxValue;
-}
+
+    internal bool AllOptionsHidden { get; set; }
+
+    internal CategoryHeaderMasked? Header { get; set; }
+}
+
+/// <summary>
+/// Base class for option groups. An option group is a collection of options that are displayed together in the options menu.
+/// </summary>
+/// <typeparam name="T">The type of the optionable that this group contains.</typeparam>
+public abstract class AbstractOptionGroup<T> : AbstractOptionGroup where T : IOptionable
+{
+    /// <inheritdoc />
+    public override Type OptionableType => typeof(T);
+}

MiraAPI/GameOptions/Attributes/ModdedEnumOptionAttribute.cs

@@ -1,27 +1,34 @@
-using MiraAPI.GameOptions.OptionTypes;
+using System;
-using System;
 using System.Reflection;
+using MiraAPI.GameOptions.OptionTypes;
 
 namespace MiraAPI.GameOptions.Attributes;
 
-public class ModdedEnumOptionAttribute(string title, Type enumType, Type roleType = null)
+/// <summary>
-    : ModdedOptionAttribute(title, roleType)
+/// Attribute for creating an enum option.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property)]
+public class ModdedEnumOptionAttribute(string title, Type enumType, string[]? values = null)
+    : ModdedOptionAttribute(title)
 {
-    internal override IModdedOption CreateOption(object value, PropertyInfo property)
+    internal override IModdedOption CreateOption(object? value, PropertyInfo property)
     {
-        var opt = new ModdedEnumOption(Title, (int)value, enumType, RoleType);
+        var opt = new ModdedEnumOption(Title, (int)(value ?? 0), enumType, values);
         return opt;
     }
 
+    /// <inheritdoc />
     public override void SetValue(object value)
     {
-        ModdedEnumOption opt = HolderOption as ModdedEnumOption;
+        var opt = HolderOption as ModdedEnumOption;
-        opt.SetValue((int)value);
+        opt?.SetValue((int)value);
     }
 
+    /// <inheritdoc />
     public override object GetValue()
     {
-        ModdedEnumOption opt = HolderOption as ModdedEnumOption;
+        return HolderOption is ModdedEnumOption opt
-        return Enum.ToObject(enumType, opt.Value);
+            ? Enum.ToObject(enumType, opt.Value)
+            : throw new InvalidOperationException($"HolderOption for option \"{Title}\" with EnumType ${enumType.FullName} is not a ModdedEnumOption");
     }
-}
+}

MiraAPI/GameOptions/Attributes/ModdedNumberOptionAttribute.cs

@@ -1,34 +1,43 @@
-using MiraAPI.GameOptions.OptionTypes;
+using System;
-using System;
 using System.Reflection;
+using MiraAPI.GameOptions.OptionTypes;
+using MiraAPI.Utilities;
 
 namespace MiraAPI.GameOptions.Attributes;
 
+/// <summary>
+/// A number option attribute for the modded options system.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property)]
 public class ModdedNumberOptionAttribute(
     string title,
     float min,
     float max,
     float increment = 1,
-    NumberSuffixes suffixType = NumberSuffixes.None,
+    MiraNumberSuffixes suffixType = MiraNumberSuffixes.None,
-    bool zeroInfinity = false,
+    string? formatString = null,
-    Type roleType = null)
+    bool zeroInfinity = false)
-    : ModdedOptionAttribute(title, roleType)
+    : ModdedOptionAttribute(title)
 {
-    internal override IModdedOption CreateOption(object value, PropertyInfo property)
+    internal override IModdedOption CreateOption(object? value, PropertyInfo property)
     {
-        var toggleOpt = new ModdedNumberOption(Title, (float)value, min, max, increment, suffixType, zeroInfinity, RoleType);
+        return new ModdedNumberOption(Title, (float)(value ?? min+increment), min, max, increment, suffixType, formatString, zeroInfinity);
-        return toggleOpt;
     }
 
+    /// <inheritdoc />
     public override void SetValue(object value)
     {
-        ModdedNumberOption toggleOpt = HolderOption as ModdedNumberOption;
+        var opt = HolderOption as ModdedNumberOption;
-        toggleOpt.SetValue((float)value);
+        opt?.SetValue((float)value);
     }
 
+    /// <inheritdoc />
     public override object GetValue()
     {
-        ModdedNumberOption toggleOpt = HolderOption as ModdedNumberOption;
+        if (HolderOption is ModdedNumberOption opt)
-        return toggleOpt.Value;
+        {
+            return opt.Value;
+        }
+        throw new InvalidOperationException($"HolderOption for option \"{Title}\" is not a ModdedNumberOption");
     }
-}
+}

MiraAPI/GameOptions/Attributes/ModdedOptionAttribute.cs

@@ -3,18 +3,37 @@ using System.Reflection;
 
 namespace MiraAPI.GameOptions.Attributes;
 
+/// <summary>
+/// Represents an attribute that is used to define a modded option.
+/// </summary>
+/// <param name="title">The option title.</param>
+/// <param name="roleType">Optional parameter to specify a role Type.</param>
 [AttributeUsage(AttributeTargets.Property)]
-public abstract class ModdedOptionAttribute(string title, Type roleType = null) : Attribute
+public abstract class ModdedOptionAttribute(string title, Type? roleType = null) : Attribute
 {
-    public IModdedOption HolderOption { get; set; }
+    internal IModdedOption? HolderOption { get; set; }
-    
-    public string Title { get; private set; } = title;
-    
-    protected Type RoleType { get; private set; } = roleType;
 
-    public abstract void SetValue(object val);
+    /// <summary>
-    
+    /// Gets the title of the option.
+    /// </summary>
+    public string Title { get; private set; } = title;
+
+    /// <summary>
+    /// Gets the role type of the option.
+    /// </summary>
+    protected Type? RoleType { get; private set; } = roleType;
+
+    /// <summary>
+    /// Sets the value of the option.
+    /// </summary>
+    /// <param name="value">The new value as an object.</param>
+    public abstract void SetValue(object value);
+
+    /// <summary>
+    /// Gets the value of the option.
+    /// </summary>
+    /// <returns>The value of the option as an object.</returns>
     public abstract object GetValue();
 
-    internal abstract IModdedOption CreateOption(object value, PropertyInfo property);
+    internal abstract IModdedOption? CreateOption(object? value, PropertyInfo property);
-}
+}

MiraAPI/GameOptions/Attributes/ModdedStringOptionAttribute.cs

@@ -1,27 +0,0 @@
-using MiraAPI.GameOptions.OptionTypes;
-using System;
-using System.Reflection;
-
-namespace MiraAPI.GameOptions.Attributes;
-
-public class ModdedStringOptionAttribute(string title, string[] values, Type roleType = null)
-    : ModdedOptionAttribute(title, roleType)
-{
-    internal override IModdedOption CreateOption(object value, PropertyInfo property)
-    {
-        var opt = new ModdedStringOption(Title, (int)value, values, RoleType);
-        return opt;
-    }
-
-    public override void SetValue(object value)
-    {
-        ModdedStringOption opt = HolderOption as ModdedStringOption;
-        opt.SetValue((int)value);
-    }
-
-    public override object GetValue()
-    {
-        ModdedStringOption opt = HolderOption as ModdedStringOption;
-        return opt.Value;
-    }
-}

MiraAPI/GameOptions/Attributes/ModdedToggleOptionAttribute.cs

@@ -1,26 +1,36 @@
-using MiraAPI.GameOptions.OptionTypes;
+using System;
-using System;
 using System.Reflection;
+using MiraAPI.GameOptions.OptionTypes;
 
 namespace MiraAPI.GameOptions.Attributes;
 
-public class ModdedToggleOptionAttribute(string title, Type roleType = null) : ModdedOptionAttribute(title, roleType)
+/// <summary>
+/// Attribute for a toggle option.
+/// </summary>
+/// <param name="title">The option title.</param>
+[AttributeUsage(AttributeTargets.Property)]
+public class ModdedToggleOptionAttribute(string title) : ModdedOptionAttribute(title)
 {
-    internal override IModdedOption CreateOption(object value, PropertyInfo property)
+    internal override IModdedOption CreateOption(object? value, PropertyInfo property)
     {
-        var toggleOpt = new ModdedToggleOption(Title, (bool)value, RoleType);
+        var toggleOpt = new ModdedToggleOption(Title, (bool)(value ?? false));
         return toggleOpt;
     }
 
+    /// <inheritdoc />
     public override void SetValue(object value)
     {
-        ModdedToggleOption toggleOpt = HolderOption as ModdedToggleOption;
+        var opt = HolderOption as ModdedToggleOption;
-        toggleOpt.SetValue((bool)value);
+        opt?.SetValue((bool)value);
     }
 
+    /// <inheritdoc />
     public override object GetValue()
     {
-        ModdedToggleOption toggleOpt = HolderOption as ModdedToggleOption;
+        if (HolderOption is ModdedToggleOption opt)
-        return toggleOpt.Value;
+        {
+            return opt.Value;
+        }
+        throw new InvalidOperationException($"Holder option for {Title} is not a ModdedToggleOption.");
     }
-}
+}

MiraAPI/GameOptions/IModdedOption.cs

@@ -1,24 +1,23 @@
-using MiraAPI.PluginLoading;
+using System;
-using System;
 using BepInEx.Configuration;
 using MiraAPI.Networking;
+using MiraAPI.PluginLoading;
 using UnityEngine;
 
 namespace MiraAPI.GameOptions;
 
 public interface IModdedOption
 {
-    public uint Id { get; }
+    uint Id { get; }
-    public BaseGameSetting Data { get; }
+    string Title { get; }
-    public IMiraPlugin ParentMod { get; set; }
+    StringNames StringName { get; }
-    public Type AdvancedRole { get; set; }
+    IMiraPlugin? ParentMod { get; set; }
-    public OptionBehaviour OptionBehaviour { get; protected set; }
+    BaseGameSetting Data { get; }
-    public string Title { get; }
+    OptionBehaviour? OptionBehaviour { get; }
-    public StringNames StringName { get; }
+    Func<bool> Visible { get; set; }
-    public Func<bool> Visible { get; set; }
+    ConfigDefinition? ConfigDefinition { get; set; }
-    public ConfigDefinition ConfigDefinition { get; }
+    OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container);
-    public void ValueChanged(OptionBehaviour optionBehaviour);
+    float GetFloatData();
-    public OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container);
+    NetData GetNetData();
-    public NetData GetNetData();
+    void HandleNetData(byte[] data);
-    public void HandleNetData(byte[] data);
+}
-}

MiraAPI/GameOptions/IOptionable.cs

@@ -0,0 +1,6 @@
+namespace MiraAPI.GameOptions;
+
+/// <summary>
+/// Interface for classes that can be used for option groups.
+/// </summary>
+public interface IOptionable;

MiraAPI/GameOptions/ModdedOptionsManager.cs

@@ -1,32 +1,36 @@
-using HarmonyLib;
+using System;
-using MiraAPI.GameOptions.Attributes;
-using Reactor.Utilities;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using BepInEx.Configuration;
+using HarmonyLib;
+using MiraAPI.GameOptions.Attributes;
 using MiraAPI.Networking;
 using MiraAPI.PluginLoading;
+using MiraAPI.Utilities;
 using Reactor.Networking.Rpc;
+using Reactor.Utilities;
 
 namespace MiraAPI.GameOptions;
 
-public class ModdedOptionsManager
+/// <summary>
+/// Handles modded options.
+/// </summary>
+public static class ModdedOptionsManager
 {
-    private static readonly Dictionary<PropertyInfo, ModdedOptionAttribute> OptionAttributes = new();
+    private static readonly Dictionary<PropertyInfo, ModdedOptionAttribute> OptionAttributes = [];
-    private static readonly Dictionary<Type, AbstractOptionGroup> TypeToGroup = new();
+    private static readonly Dictionary<Type, AbstractOptionGroup> TypeToGroup = [];
 
-    public static readonly Dictionary<uint, IModdedOption> ModdedOptions = new();
+    internal static readonly Dictionary<uint, IModdedOption> ModdedOptions = [];
-    public static readonly List<AbstractOptionGroup> Groups = [];
+    internal static readonly List<AbstractOptionGroup> Groups = [];
-    
+
-    public static uint NextId => _nextId++;
+    internal static uint NextId => _nextId++;
     private static uint _nextId = 1;
-    
+
     internal static bool RegisterGroup(Type type, MiraPluginInfo pluginInfo)
     {
         if (Activator.CreateInstance(type) is not AbstractOptionGroup group)
         {
-            Logger<MiraApiPlugin>.Error($"Failed to create group from {type.Name}");
             return false;
         }
 
@@ -39,10 +43,14 @@ public class ModdedOptionsManager
         Groups.Add(group);
         TypeToGroup.Add(type, group);
         pluginInfo.OptionGroups.Add(group);
-        
+
+        typeof(OptionGroupSingleton<>).MakeGenericType(type)
+            .GetField("_instance", BindingFlags.Static | BindingFlags.NonPublic)!
+            .SetValue(null, group);
+
         return true;
     }
-    
+
     internal static void RegisterPropertyOption(Type type, PropertyInfo property, MiraPluginInfo pluginInfo)
     {
         if (!TypeToGroup.TryGetValue(type, out var group))
@@ -56,11 +64,15 @@ public class ModdedOptionsManager
             Logger<MiraApiPlugin>.Error($"Failed to get option for {property.Name}");
             return;
         }
-        
+
-        RegisterOption(option, group, pluginInfo);
+        RegisterOption(option, group, property.Name, pluginInfo);
     }
-    
+
-    internal static void RegisterAttributeOption(Type type, ModdedOptionAttribute attribute, PropertyInfo property, MiraPluginInfo pluginInfo)
+    internal static void RegisterAttributeOption(
+        Type type,
+        ModdedOptionAttribute attribute,
+        PropertyInfo property,
+        MiraPluginInfo pluginInfo)
     {
         if (OptionAttributes.ContainsKey(property))
         {
@@ -75,13 +87,13 @@ public class ModdedOptionsManager
         }
 
         var option = attribute.CreateOption(property.GetValue(group), property);
-        
+
         if (option == null)
         {
             Logger<MiraApiPlugin>.Error($"Failed to get option for {property.Name}");
             return;
         }
-        
+
         var setterOriginal = property.GetSetMethod();
         var setterPatch = typeof(ModdedOptionsManager).GetMethod(nameof(PropertySetterPatch));
         PluginSingleton<MiraApiPlugin>.Instance.Harmony.Patch(setterOriginal, postfix: new HarmonyMethod(setterPatch));
@@ -92,80 +104,91 @@ public class ModdedOptionsManager
 
         OptionAttributes.Add(property, attribute);
         attribute.HolderOption = option;
-        
+
-        RegisterOption(option, group, pluginInfo);
+        RegisterOption(option, group, property.Name, pluginInfo);
     }
 
-    private static void RegisterOption(IModdedOption option, AbstractOptionGroup group, MiraPluginInfo pluginInfo)
+    internal static void RegisterOption(
+        IModdedOption option,
+        AbstractOptionGroup group,
+        string propertyName,
+        MiraPluginInfo pluginInfo)
     {
+        var groupName = group.GetType().FullName;
+
+        option.ConfigDefinition = new ConfigDefinition(groupName, propertyName);
+
         option.ParentMod = pluginInfo.MiraPlugin;
-        option.AdvancedRole = group.AdvancedRole;
-        
         pluginInfo.Options.Add(option);
-        
         ModdedOptions.Add(option.Id, option);
         group.Options.Add(option);
     }
-    
-    internal static void SyncAllOptions(int targetId=-1)
-    {
-        List<NetData> data = [];
-        
-        var count = 0;
-        foreach (var netData in ModdedOptions.Values.Select(option => option.GetNetData()))
-        {
-            data.Add(netData);
-            count += netData.GetLength();
 
-            if (count <= 1000)
+    internal static void SyncAllOptions(int targetId = -1)
-            {
+    {
-                continue;
+        var chunks = ModdedOptions.Values.Select(option => option.GetNetData()).ChunkNetData(1000);
-            }
+
-            
+        while (chunks.Count > 0)
-            Rpc<SyncOptionsRpc>.Instance.SendTo(PlayerControl.LocalPlayer, targetId, data.ToArray());
-            data.Clear();
-            count = 0;
-        }
-        
-        if (data.Count > 0)
         {
-            Rpc<SyncOptionsRpc>.Instance.SendTo(PlayerControl.LocalPlayer, targetId, data.ToArray());
+            Rpc<SyncOptionsRpc>.Instance.SendTo(PlayerControl.LocalPlayer, targetId, chunks.Dequeue());
         }
     }
 
-
     internal static void HandleSyncOptions(NetData[] data)
     {
+        // necessary to disable then re-enable this setting
+        // we dont know how other plugins handle their configs
+        // this way, all the options are saved at once, instead of one by one
+        var oldConfigSetting = new Dictionary<MiraPluginInfo, bool>();
+        foreach (var plugin in MiraPluginManager.Instance.RegisteredPlugins())
+        {
+            oldConfigSetting.Add(plugin, plugin.PluginConfig.SaveOnConfigSet);
+            plugin.PluginConfig.SaveOnConfigSet = false;
+        }
+
         foreach (var netData in data)
         {
             if (!ModdedOptions.TryGetValue(netData.Id, out var option))
             {
                 continue;
             }
-            
+
-            Logger<MiraApiPlugin>.Error("Handling option " + option.Title);
             option.HandleNetData(netData.Data);
         }
+
+        foreach (var plugin in MiraPluginManager.Instance.RegisteredPlugins())
+        {
+            plugin.PluginConfig.Save();
+            plugin.PluginConfig.SaveOnConfigSet = oldConfigSetting[plugin];
+        }
+
+        if (LobbyInfoPane.Instance)
+        {
+            LobbyInfoPane.Instance.RefreshPane();
+        }
     }
-        
+
-        
+    /// <summary>
+    /// Patches the setter of a property to update the value of the option.
+    /// </summary>
+    /// <param name="__originalMethod">The original setter method.</param>
+    /// <param name="value">The new object value.</param>
     public static void PropertySetterPatch(MethodBase __originalMethod, object value)
     {
-        ModdedOptionAttribute attribute = OptionAttributes.First(pair => pair.Key.GetSetMethod().Equals(__originalMethod)).Value;
+        var attribute = OptionAttributes.First(pair => pair.Key.GetSetMethod() == __originalMethod).Value;
-
+        attribute.SetValue(value);
-        attribute?.SetValue(value);
     }
 
+    /// <summary>
+    /// Patches the getter of a property to return the value of the option.
+    /// </summary>
+    /// <param name="__originalMethod">The original getter method.</param>
+    /// <param name="__result">The result of the property getter.</param>
+    /// <returns>False so the original getter gets skipped.</returns>
     public static bool PropertyGetterPatch(MethodBase __originalMethod, ref object __result)
     {
-        ModdedOptionAttribute attribute = OptionAttributes.First(pair => pair.Key.GetGetMethod().Equals(__originalMethod)).Value;
+        var attribute = OptionAttributes.First(pair => pair.Key.GetGetMethod() == __originalMethod).Value;
-
-        if (attribute == null)
-        {
-            return true;
-        }
-        
         __result = attribute.GetValue();
         return false;
     }
-}
+}

MiraAPI/GameOptions/ModifierOptionGroup.cs

@@ -0,0 +1,15 @@
+using System.Linq;
+
+namespace MiraAPI.GameOptions;
+
+internal class ModifierOptionGroup : AbstractOptionGroup
+{
+    public override string GroupName { get; }
+
+    public ModifierOptionGroup(string name, IModdedOption[] options, params AbstractOptionGroup[] groups)
+    {
+        GroupName = name;
+        Options.AddRange(options);
+        Options.AddRange(groups.SelectMany(x=>x.Options));
+    }
+}

MiraAPI/GameOptions/OptionGroupSingleton.cs

@@ -1,23 +1,19 @@
-using System;
+using System.Linq;
-using System.Linq;
 
 namespace MiraAPI.GameOptions;
 
-public class OptionGroupSingleton<T> where T : AbstractOptionGroup
+/// <summary>
+/// Singleton for option groups.
+/// </summary>
+/// <typeparam name="T">The option group type.</typeparam>
+public static class OptionGroupSingleton<T> where T : AbstractOptionGroup
 {
-    private static T _instance;
+    private static T? _instance;
 
-    public static T Instance
+    /// <summary>
-    {
+    /// Gets the instance of the option group.
-        get => _instance ??= ModdedOptionsManager.Groups.OfType<T>().Single();
+    /// </summary>
-        set
+#pragma warning disable CA1000
-        {
+    public static T Instance => _instance ??= ModdedOptionsManager.Groups.OfType<T>().Single();
-            if (_instance != null)
+#pragma warning restore CA1000
-            {
+}
-                throw new InvalidOperationException($"Instance for {typeof(T)} is already set");
-            }
-
-            _instance = value;
-        }
-    }
-}

MiraAPI/GameOptions/OptionTypes/ModdedEnumOption.cs

@@ -1,77 +1,191 @@
-using Reactor.Localization.Utilities;
+using System;
-using System;
+using System.Globalization;
 using System.Linq;
+using System.Text;
+using Il2CppInterop.Runtime.InteropTypes.Arrays;
 using MiraAPI.Networking;
+using Reactor.Localization.Utilities;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
 namespace MiraAPI.GameOptions.OptionTypes;
 
+/// <summary>
+/// An option for selecting an enum value.
+/// </summary>
 public class ModdedEnumOption : ModdedOption<int>
 {
-    public string[] Values { get; }
+    /// <summary>
+    /// Gets the string values of the enum.
+    /// </summary>
+    public string[]? Values { get; }
 
-    public ModdedEnumOption(string title, int defaultValue, Type enumType, Type roleType=null) : base(title, defaultValue, roleType)
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ModdedEnumOption"/> class.
+    /// </summary>
+    /// <param name="title">The title of the option.</param>
+    /// <param name="defaultValue">The default value as an int.</param>
+    /// <param name="enumType">The Enum type.</param>
+    /// <param name="values">An option list of string values to use in place of the enum name.</param>
+    public ModdedEnumOption(string title, int defaultValue, Type enumType, string[]? values = null) : base(title, defaultValue)
     {
-        Values = Enum.GetNames(enumType);
+        Values = values ?? Enum.GetNames(enumType);
         Data = ScriptableObject.CreateInstance<StringGameSetting>();
         var data = (StringGameSetting)Data;
-            
+
         data.Title = StringName;
         data.Type = global::OptionTypes.String;
-        data.Values = Values.Select(CustomStringName.CreateAndRegister).ToArray();
+        data.Values = values is null ?
+            Enum.GetNames(enumType).Select(CustomStringName.CreateAndRegister).ToArray()
+            : values.Select(CustomStringName.CreateAndRegister).ToArray();
+
         data.Index = Value;
     }
 
+    /// <inheritdoc />
     public override OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container)
     {
         var stringOption = Object.Instantiate(stringOpt, container);
 
         stringOption.SetUpFromData(Data, 20);
         stringOption.OnValueChanged = (Il2CppSystem.Action<OptionBehaviour>)ValueChanged;
-            
+
         // SetUpFromData method doesnt work correctly so we must set the values manually
         stringOption.Title = StringName;
-        stringOption.Values = ((StringGameSetting)Data).Values;
+        stringOption.Values = (Data as StringGameSetting)?.Values ?? new Il2CppStructArray<StringNames>(0);
         stringOption.Value = Value;
 
         OptionBehaviour = stringOption;
 
         return stringOption;
     }
-        
+
+    /// <inheritdoc />
+    public override float GetFloatData()
+    {
+        return Value;
+    }
+
+    /// <inheritdoc />
     public override NetData GetNetData()
     {
         return new NetData(Id, BitConverter.GetBytes(Value));
     }
 
+    /// <inheritdoc />
     public override void HandleNetData(byte[] data)
     {
         SetValue(BitConverter.ToInt32(data));
     }
 
-    public override string GetHudStringText()
+    /// <inheritdoc />
-    {
-        return Title + ": " + Values[Value];
-    }
-
     public override int GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour)
     {
         return optionBehaviour.GetInt();
     }
 
-    public override void OnValueChanged(int newValue)
+    /// <inheritdoc />
+    protected override void OnValueChanged(int newValue)
     {
-        DestroyableSingleton<HudManager>.Instance.Notifier.AddSettingsChangeMessage(StringName, Data.GetValueString(newValue), false);
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(StringName, Data?.GetValueString(newValue), false);
         if (!OptionBehaviour)
         {
             return;
         }
 
-        var opt = OptionBehaviour as StringOption;
+        if (OptionBehaviour is StringOption opt)
-        if (opt)
         {
             opt.Value = newValue;
         }
     }
-}
+}
+
+/// <summary>
+/// An option for selecting an enum value.
+/// </summary>
+/// <typeparam name="T">The enum type.</typeparam>
+public class ModdedEnumOption<T> : ModdedOption<T> where T : Enum
+{
+    /// <summary>
+    /// Gets the string values of the enum.
+    /// </summary>
+    public string[]? Values { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ModdedEnumOption{T}"/> class.
+    /// </summary>
+    /// <param name="title">The title of the option.</param>
+    /// <param name="defaultValue">The default value as an int.</param>
+    /// <param name="values">An option list of string values to use in place of the enum name.</param>
+    public ModdedEnumOption(string title, T defaultValue, string[]? values = null) : base(title, defaultValue)
+    {
+        Values = values ?? Enum.GetNames(typeof(T));
+        Data = ScriptableObject.CreateInstance<StringGameSetting>();
+        var data = (StringGameSetting)Data;
+
+        data.Title = StringName;
+        data.Type = global::OptionTypes.String;
+        data.Values = values is null ?
+            Enum.GetNames(typeof(T)).Select(CustomStringName.CreateAndRegister).ToArray()
+            : values.Select(CustomStringName.CreateAndRegister).ToArray();
+
+        data.Index = Convert.ToInt32(Value);
+    }
+
+    /// <inheritdoc />
+    public override OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container)
+    {
+        var stringOption = Object.Instantiate(stringOpt, container);
+
+        stringOption.SetUpFromData(Data, 20);
+        stringOption.OnValueChanged = (Il2CppSystem.Action<OptionBehaviour>)ValueChanged;
+
+        // SetUpFromData method doesnt work correctly so we must set the values manually
+        stringOption.Title = StringName;
+        stringOption.Values = (Data as StringGameSetting)?.Values ?? new Il2CppStructArray<StringNames>(0);
+        stringOption.Value = Convert.ToInt32(Value, NumberFormatInfo.InvariantInfo);
+
+        OptionBehaviour = stringOption;
+
+        return stringOption;
+    }
+
+    /// <inheritdoc />
+    public override float GetFloatData()
+    {
+        return Convert.ToSingle(Value, NumberFormatInfo.InvariantInfo);
+    }
+
+    /// <inheritdoc />
+    public override NetData GetNetData()
+    {
+        return new NetData(Id, Encoding.Unicode.GetBytes(Convert.ToString(Value, NumberFormatInfo.InvariantInfo)!));
+    }
+
+    /// <inheritdoc />
+    public override void HandleNetData(byte[] data)
+    {
+        SetValue((T)Enum.Parse(typeof(T), Encoding.Unicode.GetString(data)));
+    }
+
+    /// <inheritdoc />
+    public override T GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour)
+    {
+        return (T)Enum.Parse(typeof(T), optionBehaviour.GetInt().ToString(NumberFormatInfo.InvariantInfo));
+    }
+
+    /// <inheritdoc />
+    protected override void OnValueChanged(T newValue)
+    {
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(StringName, Data.GetValueString(Convert.ToInt32(newValue, NumberFormatInfo.InvariantInfo)), false);
+        if (!OptionBehaviour)
+        {
+            return;
+        }
+
+        if (OptionBehaviour is StringOption opt)
+        {
+            opt.Value = Convert.ToInt32(newValue, NumberFormatInfo.InvariantInfo);
+        }
+    }
+}

MiraAPI/GameOptions/OptionTypes/ModdedNumberOption.cs

@@ -7,19 +7,56 @@ using Object = UnityEngine.Object;
 
 namespace MiraAPI.GameOptions.OptionTypes;
 
+/// <summary>
+/// Represents a modded number option.
+/// </summary>
 public class ModdedNumberOption : ModdedOption<float>
 {
-    public float Min { get;}
+    /// <summary>
-    
+    /// Gets the minimum value of the option.
+    /// </summary>
+    public float Min { get; }
+
+    /// <summary>
+    /// Gets the maximum value of the option.
+    /// </summary>
     public float Max { get; }
-    
+
+    /// <summary>
+    /// Gets the increment value of the option.
+    /// </summary>
     public float Increment { get; }
-    
+
-    public NumberSuffixes SuffixType { get; }
+    /// <summary>
-    
+    /// Gets the suffix type of the option.
+    /// </summary>
+    public MiraNumberSuffixes SuffixType { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether zero is infinity.
+    /// </summary>
     public bool ZeroInfinity { get; }
-    
+
-    public ModdedNumberOption(string title, float defaultValue, float min, float max, float increment, NumberSuffixes suffixType, bool zeroInfinity=false, Type roleType=null) : base(title, defaultValue, roleType)
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ModdedNumberOption"/> class.
+    /// </summary>
+    /// <param name="title">The title of the option.</param>
+    /// <param name="defaultValue">The default value as a float.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <param name="increment">The increment.</param>
+    /// <param name="suffixType">The suffix type.</param>
+    /// <param name="formatString">Optional format string for the option screen.</param>
+    /// <param name="zeroInfinity">Whether zero is infinity or not.</param>
+    public ModdedNumberOption(
+        string title,
+        float defaultValue,
+        float min,
+        float max,
+        float increment,
+        MiraNumberSuffixes suffixType,
+        string? formatString = null,
+        bool zeroInfinity = false) : base(title, defaultValue)
     {
         Min = min;
         Max = max;
@@ -28,77 +65,99 @@ public class ModdedNumberOption : ModdedOption<float>
         ZeroInfinity = zeroInfinity;
 
         Value = Mathf.Clamp(defaultValue, min, max);
-            
+
         Data = ScriptableObject.CreateInstance<FloatGameSetting>();
-            
+
         var data = (FloatGameSetting)Data;
         data.Type = global::OptionTypes.Float;
         data.Title = StringName;
         data.Value = Value;
         data.Increment = Increment;
         data.ValidRange = new FloatRange(Min, Max);
-        data.FormatString = Increment % 1 == 0 && Value % 1 == 0  && Min % 1 == 0  && Max % 1 == 0 ? "0" : "0.0";
+        data.FormatString = formatString ??
+                            (defaultValue.IsInteger() &&
+                             Increment.IsInteger() &&
+                             Value.IsInteger() &&
+                             Min.IsInteger() &&
+                             Max.IsInteger() ? "0" : "0.0");
+
         data.ZeroIsInfinity = ZeroInfinity;
-        data.SuffixType = SuffixType;
+        data.SuffixType = (NumberSuffixes)SuffixType;
         data.OptionName = FloatOptionNames.Invalid;
     }
 
-    public override OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container)
+    /// <inheritdoc />
+    public override OptionBehaviour CreateOption(
+        ToggleOption toggleOpt,
+        NumberOption numberOpt,
+        StringOption stringOpt,
+        Transform container)
     {
         var numberOption = Object.Instantiate(numberOpt, Vector3.zero, Quaternion.identity, container);
 
         numberOption.SetUpFromData(Data, 20);
         numberOption.OnValueChanged = (Il2CppSystem.Action<OptionBehaviour>)ValueChanged;
-            
+
         numberOption.Title = StringName;
         numberOption.Value = Value;
         numberOption.Increment = Increment;
         numberOption.ValidRange = new FloatRange(Min, Max);
-        numberOption.FormatString = ((FloatGameSetting)Data).FormatString;
+        numberOption.FormatString = (Data as FloatGameSetting)?.FormatString ?? "0.0";
         numberOption.ZeroIsInfinity = ZeroInfinity;
-        numberOption.SuffixType = SuffixType;
+        numberOption.SuffixType = (NumberSuffixes)SuffixType;
         numberOption.floatOptionName = FloatOptionNames.Invalid;
-            
+
-            
         OptionBehaviour = numberOption;
 
         return numberOption;
     }
 
+    /// <inheritdoc />
+    public override float GetFloatData()
+    {
+        return Value;
+    }
+
+    /// <inheritdoc />
     public override NetData GetNetData()
     {
         return new NetData(Id, BitConverter.GetBytes(Value));
     }
 
+    /// <inheritdoc />
     public override void HandleNetData(byte[] data)
     {
         SetValue(BitConverter.ToSingle(data));
     }
 
-    public override string GetHudStringText()
+    /// <inheritdoc />
-    {
-        return Title + ": " + Value + Helpers.GetSuffix(SuffixType);
-    }
-
     public override float GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour)
     {
         return Mathf.Clamp(optionBehaviour.GetFloat(), Min, Max);
     }
 
-    public override void OnValueChanged(float newValue)
+    /// <inheritdoc />
+    protected override void OnValueChanged(float newValue)
     {
         Value = Mathf.Clamp(newValue, Min, Max);
-        DestroyableSingleton<HudManager>.Instance.Notifier.AddSettingsChangeMessage(StringName, Data.GetValueString(Value), false);
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(
+            StringName,
+            Data.GetValueString(Value),
+            false);
 
-        if (!OptionBehaviour)
+        if (OptionBehaviour is NumberOption opt)
         {
-            return;
+            opt.Value = Value;
-        }
-
-        var opt = OptionBehaviour as NumberOption;
-        if (opt)
-        {
-            opt.Value = newValue;
         }
     }
-}
+
+    /// <summary>
+    /// Implicitly converts the option to an int.
+    /// </summary>
+    /// <param name="option">The option.</param>
+    /// <returns>Integer value.</returns>
+    public static implicit operator int(ModdedNumberOption option)
+    {
+        return (int)option.Value;
+    }
+}

MiraAPI/GameOptions/OptionTypes/ModdedOption.cs

@@ -1,41 +1,92 @@
-using MiraAPI.PluginLoading;
+using System;
-using MiraAPI.Roles;
-using Reactor.Localization.Utilities;
-using System;
 using BepInEx.Configuration;
 using MiraAPI.Networking;
+using MiraAPI.PluginLoading;
+using Reactor.Localization.Utilities;
 using Reactor.Networking.Rpc;
 using UnityEngine;
 
 namespace MiraAPI.GameOptions.OptionTypes;
 
+/// <summary>
+/// Represents a modded option.
+/// </summary>
+/// <typeparam name="T">The value type.</typeparam>
 public abstract class ModdedOption<T> : IModdedOption
 {
-    private IMiraPlugin _parentMod;
+    private IMiraPlugin? _parentMod;
-    
+
+    /// <summary>
+    /// Gets the unique identifier of the option.
+    /// </summary>
     public uint Id { get; }
+
+    /// <summary>
+    /// Gets the title of the option.
+    /// </summary>
+    public string Title { get; }
+
+    /// <summary>
+    /// Gets the StringName object of the option.
+    /// </summary>
+    public StringNames StringName { get; }
+
+    /// <summary>
+    /// Gets the BaseGameSetting data of the option.
+    /// </summary>
     public BaseGameSetting Data { get; protected init; }
-    public IMiraPlugin ParentMod
+
+    /// <summary>
+    /// Gets or sets the parent mod of the option.
+    /// </summary>
+    public IMiraPlugin? ParentMod
     {
         get => _parentMod;
         set
         {
+            if (_parentMod != null || value == null) return;
             _parentMod = value;
             var entry = _parentMod.GetConfigFile().Bind(ConfigDefinition, DefaultValue);
             Value = entry.Value;
         }
     }
-    public T Value { get; protected set; }
-    public T DefaultValue { get; init; }
-    public Action<T> ChangedEvent { get; set; }
-    public string Title { get; }
-    public StringNames StringName { get; }
-    public Func<bool> Visible { get; set; }
-    public Type AdvancedRole { get; set; }
-    public OptionBehaviour OptionBehaviour { get; set; }
-    public ConfigDefinition ConfigDefinition => new ("Options", Title);
 
-    protected ModdedOption(string title, T defaultValue, Type roleType)
+    /// <summary>
+    /// Gets or sets the value of the option.
+    /// </summary>
+    public T Value { get; protected set; }
+
+    /// <summary>
+    /// Gets the default value of the option.
+    /// </summary>
+    public T DefaultValue { get; }
+
+    /// <summary>
+    /// Gets or sets the event that is invoked when the value of the option changes.
+    /// </summary>
+    public Action<T>? ChangedEvent { get; set; }
+
+    /// <summary>
+    /// Gets or sets the visibility of the option.
+    /// </summary>
+    public Func<bool> Visible { get; set; }
+
+    /// <summary>
+    /// Gets or sets the option behaviour of the option.
+    /// </summary>
+    public OptionBehaviour? OptionBehaviour { get; protected set; }
+
+    /// <summary>
+    /// Gets or sets the config definition of the option.
+    /// </summary>
+    public ConfigDefinition? ConfigDefinition { get; set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ModdedOption{T}"/> class.
+    /// </summary>
+    /// <param name="title">The option title.</param>
+    /// <param name="defaultValue">The default value.</param>
+    protected ModdedOption(string title, T defaultValue)
     {
         Id = ModdedOptionsManager.NextId;
         Title = title;
@@ -43,50 +94,92 @@ public abstract class ModdedOption<T> : IModdedOption
         Value = defaultValue;
         StringName = CustomStringName.CreateAndRegister(Title);
         Visible = () => true;
-
-        if (roleType is not null && roleType.IsAssignableTo(typeof(ICustomRole)))
-        {
-            AdvancedRole = roleType;
-        }
     }
 
-    public void ValueChanged(OptionBehaviour optionBehaviour)
+    internal void ValueChanged(OptionBehaviour optionBehaviour)
     {
         SetValue(GetValueFromOptionBehaviour(optionBehaviour));
     }
 
+    /// <summary>
+    /// Sets the value of the option.
+    /// </summary>
+    /// <param name="newValue">The new value.</param>
     public void SetValue(T newValue)
     {
         var oldVal = Value;
         Value = newValue;
-        if (!Value.Equals(oldVal) && ChangedEvent != null)
+
+        if (Value?.Equals(oldVal) == false)
         {
-            ChangedEvent.Invoke(Value);
+            ChangedEvent?.Invoke(Value);
         }
 
         if (AmongUsClient.Instance.AmHost)
         {
+            if (ParentMod?.GetConfigFile().TryGetEntry<T>(ConfigDefinition, out var entry) == true)
+            {
+                entry.Value = Value;
+            }
+
             Rpc<SyncOptionsRpc>.Instance.Send(PlayerControl.LocalPlayer, [GetNetData()], true);
         }
-        
+
-        if (ParentMod is not null &&
-            ParentMod.GetConfigFile().TryGetEntry<T>(ConfigDefinition, out var entry))
-        {
-            entry.Value = Value;
-        }
-        
         OnValueChanged(newValue);
     }
 
+    /// <summary>
+    /// Gets the float data of the option.
+    /// </summary>
+    /// <returns>A float object representing the option's value.</returns>
+    public abstract float GetFloatData();
+
+    /// <summary>
+    /// Gets the net data of the option.
+    /// </summary>
+    /// <returns>A NetData object representing this option's data.</returns>
     public abstract NetData GetNetData();
-        
+
+    /// <summary>
+    /// Handles incoming net data.
+    /// </summary>
+    /// <param name="data">The NetData's byte array.</param>
     public abstract void HandleNetData(byte[] data);
 
-    public abstract void OnValueChanged(T newValue);
+    /// <summary>
+    /// Handles the value changed event.
+    /// </summary>
+    /// <param name="newValue">The new value.</param>
+    protected abstract void OnValueChanged(T newValue);
 
+    /// <summary>
+    /// Gets the value from the option behaviour.
+    /// </summary>
+    /// <param name="optionBehaviour">The OptionBehaviour.</param>
+    /// <returns>The value.</returns>
     public abstract T GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour);
 
-    public abstract OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container);
+    /// <summary>
+    /// Creates the option behaviour.
+    /// </summary>
+    /// <param name="toggleOpt">The ToggleOption prefab.</param>
+    /// <param name="numberOpt">The NumberOption prefab.</param>
+    /// <param name="stringOpt">The StringOption prefab.</param>
+    /// <param name="container">The options container.</param>
+    /// <returns>A new OptionBehaviour for this modded option.</returns>
+    public abstract OptionBehaviour CreateOption(
+        ToggleOption toggleOpt,
+        NumberOption numberOpt,
+        StringOption stringOpt,
+        Transform container);
 
-    public abstract string GetHudStringText();
+    /// <summary>
-}
+    /// Implicitly converts the option to type of <typeparamref name="T"/>.
+    /// </summary>
+    /// <param name="option">The option.</param>
+    /// <returns>Value of type <typeparamref name="T"/>.</returns>
+    public static implicit operator T(ModdedOption<T> option)
+    {
+        return option.Value;
+    }
+}

MiraAPI/GameOptions/OptionTypes/ModdedStringOption.cs

@@ -1,77 +0,0 @@
-using Reactor.Localization.Utilities;
-using System;
-using System.Linq;
-using MiraAPI.Networking;
-using UnityEngine;
-using Object = UnityEngine.Object;
-
-namespace MiraAPI.GameOptions.OptionTypes;
-
-public class ModdedStringOption : ModdedOption<int>
-{
-    public string[] Values { get; }
-    
-    public ModdedStringOption(string title, int defaultValue, string[] values, Type roleType=null) : base(title, defaultValue, roleType)
-    {
-        Values = values;
-        Data = ScriptableObject.CreateInstance<StringGameSetting>();
-        var data = (StringGameSetting)Data;
-            
-        data.Title = StringName;
-        data.Type = global::OptionTypes.String;
-        data.Values = Values.Select(CustomStringName.CreateAndRegister).ToArray();
-        data.Index = Value;
-    }
-
-    public override OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container)
-    {
-        var stringOption = Object.Instantiate(stringOpt, container);
-
-        stringOption.SetUpFromData(Data, 20);
-        stringOption.OnValueChanged = (Il2CppSystem.Action<OptionBehaviour>)ValueChanged;
-
-        // SetUpFromData method doesnt work correctly so we must set the values manually
-        stringOption.Title = StringName;
-        stringOption.Values = ((StringGameSetting)Data).Values;
-        stringOption.Value = Value;
-            
-        OptionBehaviour = stringOption;
-            
-        return stringOption;
-    }
-
-    public override NetData GetNetData()
-    {
-        return new NetData(Id, BitConverter.GetBytes(Value));
-    }
-
-    public override void HandleNetData(byte[] data)
-    {
-        SetValue(BitConverter.ToInt32(data));
-    }
-
-    public override string GetHudStringText()
-    {
-        return Title + ": " + Values[Value];
-    }
-
-    public override int GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour)
-    {
-        return optionBehaviour.GetInt();
-    }
-
-    public override void OnValueChanged(int newValue)
-    {
-        DestroyableSingleton<HudManager>.Instance.Notifier.AddSettingsChangeMessage(StringName, Data.GetValueString(newValue), false);
-        if (!OptionBehaviour)
-        {
-            return;
-        }
-
-        var opt = OptionBehaviour as StringOption;
-        if (opt)
-        {
-            opt.Value = newValue;
-        }
-    }
-}

MiraAPI/GameOptions/OptionTypes/ModdedToggleOption.cs

@@ -1,13 +1,21 @@
-using MiraAPI.Networking;
+using System;
-using System;
+using MiraAPI.Networking;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
 namespace MiraAPI.GameOptions.OptionTypes;
 
+/// <summary>
+/// A modded toggle option.
+/// </summary>
 public class ModdedToggleOption : ModdedOption<bool>
 {
-    public ModdedToggleOption(string title, bool defaultValue, Type roleType = null) : base(title, defaultValue, roleType)
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ModdedToggleOption"/> class.
+    /// </summary>
+    /// <param name="title">The option title.</param>
+    /// <param name="defaultValue">The default value.</param>
+    public ModdedToggleOption(string title, bool defaultValue) : base(title, defaultValue)
     {
         Data = ScriptableObject.CreateInstance<CheckboxGameSetting>();
 
@@ -16,6 +24,7 @@ public class ModdedToggleOption : ModdedOption<bool>
         data.Type = global::OptionTypes.Checkbox;
     }
 
+    /// <inheritdoc />
     public override OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container)
     {
         var toggleOption = Object.Instantiate(toggleOpt, Vector3.zero, Quaternion.identity, container);
@@ -32,38 +41,42 @@ public class ModdedToggleOption : ModdedOption<bool>
         return toggleOption;
     }
 
+    /// <inheritdoc />
+    public override float GetFloatData()
+    {
+        return Value ? 1 : 0;
+    }
+
+    /// <inheritdoc />
     public override NetData GetNetData()
     {
         return new NetData(Id, BitConverter.GetBytes(Value));
     }
 
+    /// <inheritdoc />
     public override void HandleNetData(byte[] data)
     {
         SetValue(BitConverter.ToBoolean(data));
     }
 
-    public override string GetHudStringText()
+    /// <inheritdoc />
-    {
-        return Title + ": " + (Value ? "On" : "Off");
-    }
-
     public override bool GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour)
     {
         return optionBehaviour.GetBool();
     }
 
-    public override void OnValueChanged(bool newValue)
+    /// <inheritdoc />
+    protected override void OnValueChanged(bool newValue)
     {
-        DestroyableSingleton<HudManager>.Instance.Notifier.AddSettingsChangeMessage(StringName, newValue ? "On" : "Off", false);
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(StringName, newValue ? "On" : "Off", false);
         if (!OptionBehaviour)
         {
             return;
         }
 
-        var toggleOpt = OptionBehaviour as ToggleOption;
+        if (OptionBehaviour is ToggleOption toggleOpt)
-        if (toggleOpt)
         {
             toggleOpt.CheckMark.enabled = newValue;
         }
     }
-}
+}

MiraAPI/Hud/ButtonLocation.cs

@@ -0,0 +1,17 @@
+namespace MiraAPI.Hud;
+
+/// <summary>
+/// The location of the custom button on the screen.
+/// </summary>
+public enum ButtonLocation
+{
+    /// <summary>
+    /// Placed in the bottom left.
+    /// </summary>
+    BottomLeft,
+
+    /// <summary>
+    /// Placed in the bottom right.
+    /// </summary>
+    BottomRight,
+}

MiraAPI/Hud/CustomActionButton.cs

@@ -1,67 +1,101 @@
-using MiraAPI.Utilities.Assets;
+using System;
+using System.Globalization;
+using MiraAPI.Events;
+using MiraAPI.Events.Mira;
+using MiraAPI.Patches;
+using MiraAPI.Utilities.Assets;
 using UnityEngine;
 using UnityEngine.Events;
+using UnityEngine.UI;
+using Object = UnityEngine.Object;
 
 namespace MiraAPI.Hud;
 
+/// <summary>
+/// Class for making custom action buttons. More customizable than the default Action/Ability buttons in the base game.
+/// </summary>
 public abstract class CustomActionButton
 {
     /// <summary>
-    /// The name and text of the button.
+    /// Gets the name and text of the button.
     /// </summary>
     public abstract string Name { get; }
 
     /// <summary>
-    /// How long the button takes to cooldown.
+    /// Gets the initial cooldown duration in seconds.
+    /// </summary>
+    public virtual float InitialCooldown => Cooldown;
+
+    /// <summary>
+    /// Gets the button's cooldown duration in seconds.
     /// </summary>
     public abstract float Cooldown { get; }
 
     /// <summary>
-    /// If the button has an effect ability, how long the effect should last. To disable effects, set to 0.
+    /// 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>
-    public abstract float EffectDuration { get; }
-
-    /// <summary>
-    /// If the button has limited uses, how many uses it has. To make the button infinite, set to 0.
-    /// </summary>
-    public abstract int MaxUses { get; }
-
-    /// <summary>
-    /// 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>
     public abstract LoadableAsset<Sprite> Sprite { get; }
 
     /// <summary>
-    /// Returns true if the button has an effect ability.
+    /// Gets the button's effect duration in seconds. If the button has no effect, set to 0.
+    /// </summary>
+    public virtual float EffectDuration => 0;
+
+    /// <summary>
+    /// Gets the maximum amount of uses the button has. If the button has infinite uses, set to 0.
+    /// </summary>
+    public virtual int MaxUses => 0;
+
+    /// <summary>
+    /// Gets the button's text outline color.
+    /// </summary>
+    public virtual Color TextOutlineColor => Color.clear;
+
+    /// <summary>
+    /// Gets or sets the location of the button on the screen.
+    /// </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>
-    /// Returns true if the button has limited uses.
+    /// Gets a value indicating whether the button has limited uses.
     /// </summary>
     public bool LimitedUses => MaxUses > 0;
 
     /// <summary>
-    /// Returns true if the effect is currently active.
+    /// Gets or sets a value indicating whether the effect is currently active, if there is one.
     /// </summary>
-    protected bool EffectActive;
+    public bool EffectActive { get; set; }
 
     /// <summary>
-    /// A timer variable to measure cooldowns and effects.
+    /// Gets or sets a value indicating whether the timer is currently active.
     /// </summary>
-    protected float Timer;
+    public bool TimerPaused { get; set; }
 
     /// <summary>
-    /// Returns the amount of uses left.
+    /// Gets or sets the amount of uses left.
     /// </summary>
-    protected int UsesLeft;
+    public int UsesLeft { get; set; }
 
     /// <summary>
-    /// The button object in game. This is created by Mira API automatically.
+    /// Gets or sets the timer variable to measure cooldowns and effects.
     /// </summary>
-    protected ActionButton Button { get; private set; }
+    public float Timer { get; set; }
-    
+
-    internal void CreateButton(Transform parent)
+    /// <summary>
+    /// Gets or sets the button object in game. This is created by Mira API automatically.
+    /// </summary>
+    public ActionButton? Button { get; set; }
+
+    /// <summary>
+    /// The method used to create the button.
+    /// </summary>
+    /// <param name="parent">The parent of the button.</param>
+    public virtual void CreateButton(Transform parent)
     {
         if (Button)
         {
@@ -69,12 +103,13 @@ public abstract class CustomActionButton
         }
 
         UsesLeft = MaxUses;
-        Timer = Cooldown;
+        Timer = AmongUsClient.Instance?.NetworkMode == NetworkModes.FreePlay ? 0 : InitialCooldown;
         EffectActive = false;
+        TimerPaused = false;
 
         Button = Object.Instantiate(HudManager.Instance.AbilityButton, parent);
         Button.name = Name + "Button";
-        Button.OverrideText(Name.ToUpper());
+        Button.OverrideText(Name.ToUpperInvariant());
 
         Button.graphic.sprite = Sprite.LoadAsset();
 
@@ -84,51 +119,213 @@ public abstract class CustomActionButton
             Button.SetInfiniteUses();
         }
 
+        if (TextOutlineColor != Color.clear)
+        {
+            SetTextOutline(TextOutlineColor);
+        }
+
         var pb = Button.GetComponent<PassiveButton>();
-        pb.OnClick.RemoveAllListeners();
+        pb.OnClick = new Button.ButtonClickedEvent();
-        pb.OnClick.AddListener((UnityAction)ClickHandler);
+        pb.OnClick.AddListener((UnityAction)(() =>
+        {
+            // Invoke the generic button click event.
+            var genericEvent = new MiraButtonClickEvent(this);
+            MiraEventManager.InvokeEvent(genericEvent);
+            if (genericEvent.IsCancelled)
+            {
+                MiraEventManager.InvokeEvent(new MiraButtonCancelledEvent(this));
+            }
+
+            // Invoke the button click event for specific button.
+            var eventType = CustomButtonManager.ButtonEventTypes[GetType()];
+            var @event = (MiraCancelableEvent)Activator.CreateInstance(eventType, this, genericEvent)!;
+            var specificInvoked = MiraEventManager.InvokeEvent(@event, eventType);
+            if (@event.IsCancelled)
+            {
+                var cancelEventType = CustomButtonManager.ButtonCancelledEventTypes[GetType()];
+                var cancelEvent = (MiraEvent)Activator.CreateInstance(cancelEventType, this)!;
+                MiraEventManager.InvokeEvent(cancelEvent, cancelEventType);
+            }
+
+            if (specificInvoked)
+            {
+                if (!@event.IsCancelled)
+                {
+                    ClickHandler();
+                }
+            }
+            else
+            {
+                if (!genericEvent.IsCancelled)
+                {
+                    ClickHandler();
+                }
+            }
+        }));
     }
 
     /// <summary>
-    /// A utility function to reset the cooldown of the button.
+    /// Allows you to change the button's location.
     /// </summary>
-    public void ResetCooldown()
+    /// <param name="location">The new location.</param>
+    /// <param name="moveButton">Whether the button's position should change in-game.</param>
+    public virtual void SetButtonLocation(ButtonLocation location, bool moveButton = true)
+    {
+        if (!HudManager.InstanceExists || Button == null)
+        {
+            return;
+        }
+
+        this.Location = location;
+
+        if (!moveButton) return;
+
+        if (HudManagerPatches._bottomLeft == null || HudManagerPatches._bottomRight == null)
+        {
+            return;
+        }
+
+        switch (location)
+        {
+            case ButtonLocation.BottomLeft:
+                var gridArrange = HudManagerPatches._bottomLeft.GetComponent<GridArrange>();
+                var aspectPosition = HudManagerPatches._bottomLeft.GetComponent<AspectPosition>();
+
+                Button.transform.SetParent(HudManagerPatches._bottomLeft.transform);
+
+                gridArrange.Start();
+                gridArrange.ArrangeChilds();
+                aspectPosition.AdjustPosition();
+                break;
+            case ButtonLocation.BottomRight:
+                Button.transform.SetParent(HudManagerPatches._bottomRight);
+                break;
+        }
+    }
+
+    /// <summary>
+    /// A utility function to reset the cooldown and/or effect of the button.
+    /// </summary>
+    public virtual void ResetCooldownAndOrEffect()
     {
         Timer = Cooldown;
         if (EffectActive)
         {
             OnEffectEnd();
         }
-        
+
         EffectActive = false;
     }
-    
+
+    /// <summary>
+    /// A utility function to change the outline color of the button's text.
+    /// </summary>
+    /// <param name="color">The new color.</param>
+    public virtual void SetTextOutline(Color color)
+    {
+        Button?.buttonLabelText.SetOutlineColor(color);
+    }
+
     /// <summary>
     /// A utility function to override the sprite of the button.
     /// </summary>
-    /// <param name="sprite">The new sprite to override with</param>
+    /// <param name="sprite">The new sprite to override with.</param>
-    public void OverrideSprite(Sprite sprite)
+    public virtual void OverrideSprite(Sprite sprite)
     {
-        Button.graphic.sprite = sprite;
+        if (Button != null)
+        {
+            Button.graphic.sprite = sprite;
+        }
     }
 
     /// <summary>
     /// A utility function to override the name of the button.
     /// </summary>
-    /// <param name="name">The new name to override with</param>
+    /// <param name="name">The new name to override with.</param>
-    public void OverrideName(string name)
+    public virtual void OverrideName(string name)
     {
-        Button.OverrideText(name);
+        Button?.OverrideText(name);
     }
 
     /// <summary>
-    /// A utility function that runs with the local PlayerControl's FixedUpdate.
+    /// Set the button's timer.
     /// </summary>
-    /// <param name="playerControl">the local PlayerControl</param>
+    /// <param name="time">The time you want to set to.</param>
-    protected virtual void FixedUpdate(PlayerControl playerControl) { }
+    public virtual void SetTimer(float time)
+    {
+        Timer = Mathf.Clamp(time, -1, float.MaxValue);
+    }
 
     /// <summary>
-    /// Runs when the button is clicked.
+    /// Increase the button's timer.
+    /// </summary>
+    /// <param name="amount">The amount you want to increase by.</param>
+    public virtual void IncreaseTimer(float amount)
+    {
+        SetTimer(Timer + amount);
+    }
+
+    /// <summary>
+    /// Decrease the button's timer.
+    /// </summary>
+    /// <param name="amount">The amount you want to decrease by.</param>
+    public virtual void DecreaseTimer(float amount)
+    {
+        SetTimer(Timer - amount);
+    }
+
+    /// <summary>
+    /// Sets whether the timer is paused or not.
+    /// </summary>
+    /// <param name="val">Whether you want to pause/resume the timer.</param>
+    public virtual void SetTimerPaused(bool val)
+    {
+        TimerPaused = val;
+    }
+
+    /// <summary>
+    /// Set the amount of uses this button has left.
+    /// </summary>
+    /// <param name="amount">The amount you want to set to.</param>
+    public virtual void SetUses(int amount)
+    {
+        UsesLeft = Mathf.Clamp(amount, 0, int.MaxValue);
+        Button?.SetUsesRemaining(UsesLeft);
+
+        if (Button != null)
+        {
+            Button.usesRemainingSprite.color = UsesLeft == 0 ? Color.red : Color.white;
+        }
+    }
+
+    /// <summary>
+    /// Increase the amount of uses this button has left.
+    /// </summary>
+    /// <param name="amount">The amount you want to increase by. Default: 1.</param>
+    public virtual void IncreaseUses(int amount = 1)
+    {
+        SetUses(UsesLeft + amount);
+    }
+
+    /// <summary>
+    /// Decrease the amount of uses this button has left.
+    /// </summary>
+    /// <param name="amount">The amount you want to decrease by. Default: 1.</param>
+    public virtual void DecreaseUses(int amount = 1)
+    {
+        SetUses(UsesLeft - amount);
+    }
+
+    /// <summary>
+    /// A utility function that runs with the local PlayerControl's FixedUpdate if the button is enabled.
+    /// </summary>
+    /// <param name="playerControl">the local PlayerControl.</param>
+    protected virtual void FixedUpdate(PlayerControl playerControl)
+    {
+    }
+
+    /// <summary>
+    /// Callback method for the button click event.
     /// </summary>
     protected abstract void OnClick();
 
@@ -137,22 +334,36 @@ public abstract class CustomActionButton
     /// True means the button is active, false means the button is disabled.
     /// </summary>
     /// <param name="role">The role of the local player.</param>
-    public abstract bool Enabled(RoleBehaviour role);
+    /// <returns>True if the button is enabled, false otherwise.</returns>
+    public abstract bool Enabled(RoleBehaviour? role);
 
     /// <summary>
-    /// Given that there is an effect, this method that runs when the effect ends.
+    /// Given that there is an effect, this method runs when the effect ends.
+    /// <br /> <br /> THIS IS A CALLBACK METHOD! Use <see cref="ResetCooldownAndOrEffect" /> if you want to end the effect.
     /// </summary>
-    public virtual void OnEffectEnd() { }
+    public virtual void OnEffectEnd()
+    {
+    }
 
     /// <summary>
-    /// When the button is enabled, this method is called to determine if the button can be used.
+    /// 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.
     /// You can override it to change the behavior.
     /// </summary>
-    /// <returns>A value that represents whether the button can be used or not.</returns>
+    /// <returns>A value that represents whether the button can be clicked or not.</returns>
+    public virtual bool CanClick()
+    {
+        return Timer <= 0 && !EffectActive && CanUse();
+    }
+
+    /// <summary>
+    /// Whether the button should light up or not. This is also the base for CanClick.
+    /// You can override it to change the behaviour. Do not include timer in here, that is for CanClick.
+    /// </summary>
+    /// <returns>A value that represents whether the button should light up or not.</returns>
     public virtual bool CanUse()
     {
-        return Timer <= 0 && !EffectActive && (!LimitedUses || UsesLeft > 0);
+        return PlayerControl.LocalPlayer.moveable && (!LimitedUses || UsesLeft > 0);
     }
 
     /// <summary>
@@ -160,11 +371,11 @@ public abstract class CustomActionButton
     /// The default behavior is to show the button if the <paramref name="visible"/> parameter and the <see cref="Enabled"/> method return true.
     /// It can be overridden for custom behavior.
     /// </summary>
-    /// <param name="visible">Passed in from HudManager.SetHudActive, should hud be active?</param>
+    /// <param name="visible">Passed in from HudManager.SetHudActive, should hud be active.</param>
     /// <param name="role">Passed in from HudManager.SetHudActive, the current role of the player.</param>
     public virtual void SetActive(bool visible, RoleBehaviour role)
     {
-        Button.ToggleVisible(visible && Enabled(role));
+        Button?.ToggleVisible(visible && Enabled(role));
     }
 
     /// <summary>
@@ -174,7 +385,7 @@ public abstract class CustomActionButton
     /// </summary>
     public virtual void ClickHandler()
     {
-        if (!CanUse())
+        if (!CanClick())
         {
             return;
         }
@@ -182,11 +393,11 @@ public abstract class CustomActionButton
         if (LimitedUses)
         {
             UsesLeft--;
-            Button.SetUsesRemaining(UsesLeft);
+            Button?.SetUsesRemaining(UsesLeft);
         }
 
         OnClick();
-        Button.SetDisabled();
+
         if (HasEffect)
         {
             EffectActive = true;
@@ -203,10 +414,10 @@ public abstract class CustomActionButton
     /// By default, it handles the cooldown and effect timers, and sets the button to enabled or disabled.
     /// It can be overridden for custom behavior.
     /// </summary>
-    /// <param name="playerControl">The local PlayerControl</param>
+    /// <param name="playerControl">The local PlayerControl.</param>
     public virtual void FixedUpdateHandler(PlayerControl playerControl)
     {
-        if (Timer >= 0)
+        if (Timer >= 0 && !TimerPaused)
         {
             Timer -= Time.deltaTime;
         }
@@ -219,15 +430,94 @@ public abstract class CustomActionButton
 
         if (CanUse())
         {
-            Button.SetEnabled();
+            Button?.SetEnabled();
         }
         else
         {
-            Button.SetDisabled();
+            Button?.SetDisabled();
+        }
+
+        if (EffectActive)
+        {
+            Button?.SetFillUp(Timer, EffectDuration);
+
+            Button!.cooldownTimerText.text = Mathf.CeilToInt(Timer).ToString(NumberFormatInfo.InvariantInfo);
+            Button!.cooldownTimerText.gameObject.SetActive(true);
+        }
+        else
+        {
+            Button?.SetCoolDown(Timer, Cooldown);
         }
-        
-        Button.SetCoolDown(Timer, EffectActive ? EffectDuration : Cooldown);
 
         FixedUpdate(playerControl);
     }
-}
+}
+
+/// <summary>
+/// Custom action button that has a target object.
+/// </summary>
+/// <typeparam name="T">The type of the target object.</typeparam>
+public abstract class CustomActionButton<T> : CustomActionButton where T : MonoBehaviour
+{
+    /// <summary>
+    /// Gets or sets the target object of the button.
+    /// </summary>
+    public T? Target { get; set; }
+
+    /// <summary>
+    /// Gets the distance the player must be from the target object to use the button.
+    /// </summary>
+    public virtual float Distance => PlayerControl.LocalPlayer.Data.Role.GetAbilityDistance();
+
+    /// <summary>
+    /// Determines if the target object is valid.
+    /// </summary>
+    /// <param name="target">The target object being checked.</param>
+    /// <returns>True if the target object is valid, false otherwise.</returns>
+    public virtual bool IsTargetValid(T? target)
+    {
+        return target != null;
+    }
+
+    /// <summary>
+    /// The method used to get the target object.
+    /// </summary>
+    /// <returns>The target object or null if it isn't found.</returns>
+    public abstract T? GetTarget();
+
+    /// <summary>
+    /// Sets the outline of the target object.
+    /// </summary>
+    /// <param name="active">Should the outline be active.</param>
+    public abstract void SetOutline(bool active);
+
+    /// <inheritdoc />
+    public override bool CanUse()
+    {
+        var newTarget = GetTarget();
+        if (newTarget != Target)
+        {
+            SetOutline(false);
+        }
+
+        Target = IsTargetValid(newTarget) ? newTarget : null;
+        SetOutline(true);
+
+        return base.CanUse() && Target != null;
+    }
+
+    /// <inheritdoc />
+    public override bool CanClick()
+    {
+        return base.CanClick() && Target != null;
+    }
+
+    /// <summary>
+    /// Use this to reset the button's target after used.
+    /// </summary>
+    public virtual void ResetTarget()
+    {
+        Target = null;
+        SetOutline(false);
+    }
+}

MiraAPI/Hud/CustomButtonManager.cs

@@ -1,31 +1,42 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Reflection;
-using Reactor.Utilities;
+using MiraAPI.Events.Mira;
+using MiraAPI.PluginLoading;
 
 namespace MiraAPI.Hud;
 
+/// <summary>
+/// Custom button manager for handling custom buttons.
+/// </summary>
 public static class CustomButtonManager
 {
-    public static readonly List<CustomActionButton> CustomButtons = [];
+    /// <summary>
+    /// Gets a list of all registered custom buttons.
+    /// </summary>
+    public static ReadOnlyCollection<CustomActionButton> Buttons { get; internal set; } = new([]);
 
-    internal static void RegisterButton(Type buttonType)
+    internal static readonly List<CustomActionButton> CustomButtons = [];
+    internal static readonly Dictionary<Type, Type> ButtonEventTypes = [];
+    internal static readonly Dictionary<Type, Type> ButtonCancelledEventTypes = [];
+
+    internal static bool RegisterButton(Type buttonType, MiraPluginInfo pluginInfo)
     {
-        if (!typeof(CustomActionButton).IsAssignableFrom(buttonType))
+        if (!buttonType.IsAssignableTo(typeof(CustomActionButton)) || Activator.CreateInstance(buttonType) is not CustomActionButton button)
         {
-            Logger<MiraApiPlugin>.Error($"{buttonType?.Name} does not inherit from CustomActionButton.");
+            return false;
-            return;
         }
 
-        if (Activator.CreateInstance(buttonType) is not CustomActionButton button)
-        {
-            Logger<MiraApiPlugin>.Error($"Failed to create button from {buttonType.Name}");
-            return;
-        }
-        
         CustomButtons.Add(button);
+        pluginInfo.Buttons.Add(button);
         typeof(CustomButtonSingleton<>).MakeGenericType(buttonType)
             .GetField("_instance", BindingFlags.Static | BindingFlags.NonPublic)!
             .SetValue(null, button);
+
+        ButtonEventTypes.Add(buttonType, typeof(MiraButtonClickEvent<>).MakeGenericType(buttonType));
+        ButtonCancelledEventTypes.Add(buttonType, typeof(MiraButtonCancelledEvent<>).MakeGenericType(buttonType));
+
+        return true;
     }
-}
+}

MiraAPI/Hud/CustomButtonSingleton.cs

@@ -1,6 +1,4 @@
-#nullable enable
+using System.Linq;
-using System;
-using System.Linq;
 
 namespace MiraAPI.Hud;
 
@@ -8,26 +6,14 @@ namespace MiraAPI.Hud;
 /// A utility class to get the instance of a custom action button.
 /// </summary>
 /// <typeparam name="T">The type of the button you are trying to access.</typeparam>
-public class CustomButtonSingleton<T> where T : CustomActionButton
+public static class CustomButtonSingleton<T> where T : CustomActionButton
 {
     private static T? _instance;
 
-    public static T Instance
+    /// <summary>
-    {
+    /// Gets the instance of the button.
-        get => _instance ??= CustomButtonManager.CustomButtons.OfType<T>().Single();
+    /// </summary>
-        set
+#pragma warning disable CA1000
-        {
+    public static T Instance => _instance ??= CustomButtonManager.CustomButtons.OfType<T>().Single();
-            if (_instance == value)
+#pragma warning restore CA1000
-            {
+}
-                return;
-            }
-
-            if (_instance != null)
-            {
-                throw new InvalidOperationException($"Instance for {typeof(T)} is already set");
-            }
-
-            _instance = value;
-        }
-    }
-}