New events & extensions

Modifier assignment priority 2

.github/workflows/main.yaml

@@ -6,11 +6,11 @@ jobs:
   build:
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
 
-      - uses: actions/cache@v3
+      - uses: actions/cache@v4
         with:
           path: |
             ~/.nuget/packages
@@ -20,7 +20,7 @@ jobs:
             ${{ runner.os }}-nuget-
 
       - name: Setup .NET
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
           dotnet-version: 8.0.x
 
@@ -29,17 +29,17 @@ jobs:
         with:
           verbosity: Diagnostic
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: MiraAPI.dll
           path: MiraAPI/bin/Release/net6.0/MiraAPI.dll
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: AllOfUs.MiraAPI.nupkg
           path: MiraAPI/bin/Release/AllOfUs.MiraAPI.*.nupkg
           
-      - uses: softprops/action-gh-release@v1
+      - uses: softprops/action-gh-release@v2
         if: github.ref_type == 'tag'
         with:
           draft: true

AmongUs.props

@@ -2,7 +2,7 @@
     <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.9.4" PrivateAssets="all" />
+        <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" />

Directory.Build.props

@@ -8,7 +8,7 @@
 
         <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
 
-        <VersionPrefix>0.1.6</VersionPrefix>
+        <VersionPrefix>0.1.9</VersionPrefix>
         <VersionSuffix>dev</VersionSuffix>
 
         <Authors>All Of Us, XtraCube, Angxl</Authors>

MiraAPI.Example/Buttons/Freezer/FreezeButton.cs

@@ -13,9 +13,11 @@ 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 float EffectDuration => 0f;
+
     public override int MaxUses => (int)OptionGroupSingleton<FreezerRoleSettings>.Instance.FreezeUses;
+
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
 
     protected override void OnClick()

MiraAPI.Example/Buttons/MeetingButton.cs

@@ -13,15 +13,13 @@ public class MeetingButton : CustomActionButton
 
     public override float Cooldown => 15;
 
-    public override float EffectDuration => 0;
-
     public override int MaxUses => 3;
 
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;
 
     public override bool Enabled(RoleBehaviour? role)
     {
-        return PlayerControl.LocalPlayer.HasModifier<CaptainModifier>();
+        return PlayerControl.LocalPlayer != null && PlayerControl.LocalPlayer.HasModifier<CaptainModifier>();
     }
 
     protected override void OnClick()

MiraAPI.Example/Buttons/Teleporter/TeleportButton.cs

@@ -8,6 +8,7 @@ using System.Collections;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons.Teleporter;
+
 [RegisterButton]
 public class TeleportButton : CustomActionButton
 {
@@ -17,15 +18,15 @@ public class TeleportButton : CustomActionButton
 
     public override float EffectDuration => OptionGroupSingleton<TeleporterOptions>.Instance.TeleportDuration;
 
-    public override int MaxUses => 0;
-
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.TeleportButton;
+
     public static bool IsZoom { get; private set; }
 
     public override bool Enabled(RoleBehaviour? role)
     {
         return role is TeleporterRole;
     }
+
     protected override void OnClick()
     {
         Coroutines.Start(ZoomOutCoroutine());

MiraAPI.Example/ExampleEventHandlers.cs

@@ -0,0 +1,59 @@
+using MiraAPI.Events;
+using MiraAPI.Events.Mira;
+using MiraAPI.Events.Vanilla.Gameplay;
+using MiraAPI.Events.Vanilla.Map;
+using MiraAPI.Events.Vanilla.Player;
+using MiraAPI.Example.Buttons.Freezer;
+using Reactor.Utilities;
+
+namespace MiraAPI.Example;
+
+public static class ExampleEventHandlers
+{
+    public static void Initialize()
+    {
+        // Register event handlers here
+        MiraEventManager.RegisterEventHandler<MiraButtonClickEvent<FreezeButton>>(FreezeButtonClickHandler, 1);
+        MiraEventManager.RegisterEventHandler<MiraButtonCancelledEvent<FreezeButton>>(FreezeButtonCancelledHandler);
+        MiraEventManager.RegisterEventHandler<UpdateSystemEvent>(UpdateSystemEventHandler);
+
+        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()}");
+        });
+    }
+
+    public static void UpdateSystemEventHandler(UpdateSystemEvent @event)
+    {
+        Logger<ExamplePlugin>.Error(@event.SystemType.ToString());
+    }
+
+    // Example event handler
+    public static void FreezeButtonClickHandler(MiraButtonClickEvent<FreezeButton> @event)
+    {
+        Logger<ExamplePlugin>.Warning("Freeze button clicked!");
+
+        if (PlayerControl.LocalPlayer.Data.PlayerName == "stupid")
+        {
+            @event.Cancel();
+            @event.Button.SetTimer(15f);
+        }
+    }
+
+    // Example event handler
+    public static void FreezeButtonCancelledHandler(MiraButtonCancelledEvent<FreezeButton> @event)
+    {
+        Logger<ExamplePlugin>.Warning("Freeze button cancelled!");
+        @event.Button.OverrideName("Freeze Canceled");
+    }
+}

MiraAPI.Example/ExamplePlugin.cs

@@ -21,6 +21,7 @@ public partial class ExamplePlugin : BasePlugin, IMiraPlugin
     public ConfigFile GetConfigFile() => Config;
     public override void Load()
     {
+        ExampleEventHandlers.Initialize();
         Harmony.PatchAll();
     }
 }

MiraAPI.Example/Modifiers/HighPriorityModifier.cs

@@ -0,0 +1,24 @@
+using MiraAPI.Modifiers;
+using MiraAPI.Modifiers.Types;
+
+namespace MiraAPI.Example.Modifiers;
+
+[RegisterModifier]
+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/ExampleOptions2.cs

@@ -14,16 +14,16 @@ public class ExampleOptions2 : AbstractOptionGroup
 
     public ModdedToggleOption ToggleOpt2 { get; } = new("Toggle Option 2", false)
     {
-        Visible = () => OptionGroupSingleton<ExampleOptions2>.Instance.ToggleOpt1.Value,
+        Visible = () => OptionGroupSingleton<ExampleOptions2>.Instance.ToggleOpt1, // implicit cast from ModdedToggleOption to bool
     };
 
-    public ModdedEnumOption EnumOpt { get; } = new("Enum Opt", 0, typeof(TestingData))
+    public ModdedEnumOption<TestingData> EnumOpt { get; } = new("Enum Opt", 0)
     {
         ChangedEvent = x => Logger<ExamplePlugin>.Info($"changed Enum Opt to {x}"),
     };
 }
 
-public enum TestingData
+public enum TestingData : ulong
 {
     Happy,
     Sad,

MiraAPI.Example/Roles/ChameleonRole.cs

@@ -1,5 +1,4 @@
 using MiraAPI.Roles;
-using MiraAPI.Utilities.Assets;
 using TMPro;
 using UnityEngine;
 
@@ -13,8 +12,11 @@ public class ChameloenRole : CrewmateRole, ICustomRole
     public string RoleDescription => RoleLongDescription;
     public Color RoleColor => Palette.AcceptedGreen;
     public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
-    public LoadableAsset<Sprite> OptionsScreenshot => ExampleAssets.Banner;
-    public int MaxPlayers => 2;
+
+    public CustomRoleConfiguration Configuration => new CustomRoleConfiguration(this)
+    {
+        OptionsScreenshot = ExampleAssets.Banner,
+    };
 
     public void PlayerControlFixedUpdate(PlayerControl playerControl)
     {

MiraAPI.Example/Roles/FreezerRole.cs

@@ -1,6 +1,4 @@
-using Il2CppInterop.Runtime.Attributes;
-using MiraAPI.Roles;
-using MiraAPI.Utilities.Assets;
+using MiraAPI.Roles;
 using UnityEngine;
 
 namespace MiraAPI.Example.Roles;
@@ -13,7 +11,10 @@ public class FreezerRole : ImpostorRole, ICustomRole
     public string RoleDescription => RoleLongDescription;
     public Color RoleColor => Palette.Blue;
     public ModdedRoleTeams Team => ModdedRoleTeams.Impostor;
-    [HideFromIl2Cpp]
-    public LoadableAsset<Sprite> OptionsScreenshot => ExampleAssets.Banner;
-    public int MaxPlayers => 2;
+
+    public CustomRoleConfiguration Configuration => new CustomRoleConfiguration(this)
+    {
+        OptionsScreenshot = ExampleAssets.Banner,
+        MaxRoleCount = 2,
+    };
 }

MiraAPI.Example/Roles/NeutralKillerRole.cs

@@ -11,9 +11,13 @@ public class NeutralKillerRole : ImpostorRole, ICustomRole
     public string RoleLongDescription => RoleDescription;
     public Color RoleColor => Color.magenta;
     public ModdedRoleTeams Team => ModdedRoleTeams.Neutral;
-    public bool UseVanillaKillButton => true;
-    public bool CanGetKilled => true;
-    public bool CanUseVent => true;
+
+    public CustomRoleConfiguration Configuration => new CustomRoleConfiguration(this)
+    {
+        UseVanillaKillButton = true,
+        CanGetKilled = true,
+        CanUseVent = true,
+    };
 
     public override void SpawnTaskHeader(PlayerControl playerControl)
     {

MiraAPI.Example/Roles/TeleporterRole.cs

@@ -1,6 +1,4 @@
-using Il2CppInterop.Runtime.Attributes;
-using MiraAPI.Roles;
-using MiraAPI.Utilities.Assets;
+using MiraAPI.Roles;
 using UnityEngine;
 
 namespace MiraAPI.Example.Roles;
@@ -13,6 +11,12 @@ public class TeleporterRole : CrewmateRole, ICustomRole
     public string RoleDescription => RoleLongDescription;
     public Color RoleColor => new Color32(221, 176, 152, 255);
     public ModdedRoleTeams Team => ModdedRoleTeams.Crewmate;
-    [HideFromIl2Cpp]
-    public LoadableAsset<Sprite> OptionsScreenshot => ExampleAssets.Banner;
+
+    public CustomRoleConfiguration Configuration => new CustomRoleConfiguration(this)
+    {
+        OptionsScreenshot = ExampleAssets.Banner,
+        CanModifyChance = false,
+        DefaultChance = 73,
+        DefaultRoleCount = 4,
+    };
 }

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,82 @@
+using System;
+using System.Collections.Generic;
+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="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/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/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,28 @@
+namespace MiraAPI.Events.Vanilla.Meeting;
+
+/// <summary>
+/// The event that is invoked when a player is ejected.
+/// </summary>
+public class EjectionEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the player that is being ejected.
+    /// </summary>
+    public PlayerControl? Player { get; }
+
+    /// <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="player">The player who is being ejected.</param>
+    /// <param name="controller">The exile controller.</param>
+    public EjectionEvent(PlayerControl player, ExileController controller)
+    {
+        Player = player;
+        ExileController = controller;
+    }
+}

MiraAPI/Events/Vanilla/Meeting/StartMeetingEvent.cs

@@ -0,0 +1,35 @@
+namespace MiraAPI.Events.Vanilla.Meeting;
+
+/// <summary>
+/// The event that is invoked when a meeting is called.
+/// </summary>
+public class StartMeetingEvent : MiraCancelableEvent
+{
+    /// <summary>
+    /// Gets the player that is calling the meeting.
+    /// </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="StartMeetingEvent"/> 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 StartMeetingEvent(PlayerControl reporter, NetworkedPlayerInfo? target, DeadBody? body)
+    {
+        Reporter = reporter;
+        Target = target;
+        Body = body;
+    }
+}

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;
+
+/// <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/GameOptions/Attributes/ModdedEnumOptionAttribute.cs

@@ -27,10 +27,8 @@ public class ModdedEnumOptionAttribute(string title, Type enumType, string[]? va
     /// <inheritdoc />
     public override object GetValue()
     {
-        if (HolderOption is ModdedEnumOption opt)
-        {
-            return Enum.ToObject(enumType, opt.Value);
-        }
-        throw new InvalidOperationException($"HolderOption for option \"{Title}\" with EnumType ${enumType.FullName} is not a ModdedEnumOption");
+        return HolderOption is ModdedEnumOption opt
+            ? Enum.ToObject(enumType, opt.Value)
+            : throw new InvalidOperationException($"HolderOption for option \"{Title}\" with EnumType ${enumType.FullName} is not a ModdedEnumOption");
     }
 }

MiraAPI/GameOptions/IModdedOption.cs

@@ -6,7 +6,7 @@ using UnityEngine;
 
 namespace MiraAPI.GameOptions;
 
-internal interface IModdedOption
+public interface IModdedOption
 {
     uint Id { get; }
     string Title { get; }

MiraAPI/GameOptions/ModdedOptionsManager.cs

@@ -31,7 +31,7 @@ public static class ModdedOptionsManager
     {
         if (Activator.CreateInstance(type) is not AbstractOptionGroup group)
         {
-            Logger<MiraApiPlugin>.Error($"Failed to create group from {type.Name}");
+            Logger<MiraApiPlugin>.Error($"Skipping option group {type.Name}. Does not inherit AbstractOptionGroup.");
             return false;
         }
 
@@ -45,6 +45,10 @@ public static class ModdedOptionsManager
         TypeToGroup.Add(type, group);
         pluginInfo.OptionGroups.Add(group);
 
+        typeof(OptionGroupSingleton<>).MakeGenericType(type)
+            .GetField("_instance", BindingFlags.Static | BindingFlags.NonPublic)!
+            .SetValue(null, group);
+
         return true;
     }
 

MiraAPI/GameOptions/OptionTypes/ModdedEnumOption.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Globalization;
 using System.Linq;
+using System.Text;
 using Il2CppInterop.Runtime.InteropTypes.Arrays;
 using MiraAPI.Networking;
 using Reactor.Localization.Utilities;
@@ -86,7 +88,7 @@ public class ModdedEnumOption : ModdedOption<int>
     /// <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;
@@ -98,3 +100,96 @@ public class ModdedEnumOption : ModdedOption<int>
         }
     }
 }
+
+
+/// <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="enumType">The Enum type.</param>
+    /// <param name="values">An option list of string values to use in place of the enum name.</param>
+    /// <param name="roleType">An optional role type to specify for a specific role.</param>
+    public ModdedEnumOption(string title, T defaultValue, string[]? values = null, Type? roleType = null) : base(title, defaultValue, roleType)
+    {
+        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);
+
+        OptionBehaviour = stringOption;
+
+        return stringOption;
+    }
+
+    /// <inheritdoc />
+    public override float GetFloatData()
+    {
+        return Convert.ToSingle(Value);
+    }
+
+    /// <inheritdoc />
+    public override NetData GetNetData()
+    {
+        return new NetData(Id, Encoding.Unicode.GetBytes(Convert.ToString(Value)));
+    }
+
+    /// <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());
+    }
+
+    /// <inheritdoc />
+    protected override void OnValueChanged(T newValue)
+    {
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(StringName, Data?.GetValueString(Convert.ToInt32(newValue)), false);
+        if (!OptionBehaviour)
+        {
+            return;
+        }
+
+        if (OptionBehaviour is StringOption opt)
+        {
+            opt.Value = Convert.ToInt32(newValue);
+        }
+    }
+}

MiraAPI/GameOptions/OptionTypes/ModdedNumberOption.cs

@@ -134,7 +134,7 @@ public class ModdedNumberOption : ModdedOption<float>
     protected override void OnValueChanged(float newValue)
     {
         Value = Mathf.Clamp(newValue, Min, Max);
-        DestroyableSingleton<HudManager>.Instance.Notifier.AddSettingsChangeMessage(
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(
             StringName,
             Data?.GetValueString(Value),
             false);
@@ -144,4 +144,14 @@ public class ModdedNumberOption : ModdedOption<float>
             opt.Value = Value;
         }
     }
+
+    /// <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

@@ -194,4 +194,14 @@ public abstract class ModdedOption<T> : IModdedOption
         NumberOption numberOpt,
         StringOption stringOpt,
         Transform container);
+
+    /// <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/ModdedToggleOption.cs

@@ -69,7 +69,7 @@ public class ModdedToggleOption : ModdedOption<bool>
     /// <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;

MiraAPI/Hud/CustomActionButton.cs

@@ -1,7 +1,12 @@
-using MiraAPI.Utilities.Assets;
+using MiraAPI.Events;
+using MiraAPI.Events.Mira;
+using MiraAPI.Patches;
+using MiraAPI.Utilities.Assets;
+using System;
 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.UI;
+using Object = UnityEngine.Object;
 
 namespace MiraAPI.Hud;
 
@@ -15,30 +20,35 @@ public abstract class CustomActionButton
     /// </summary>
     public abstract string Name { get; }
 
+    /// <summary>
+    /// 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>
-    /// Gets the button's effect duration in seconds. If the button has no effect, set to 0.
-    /// </summary>
-    public abstract float EffectDuration { get; }
-
-    /// <summary>
-    /// Gets the maximum amount of uses the button has. If the button has infinite uses, set to 0.
-    /// </summary>
-    public abstract int MaxUses { get; }
-
     /// <summary>
     /// Gets the sprite of the button. Use <see cref="LoadableResourceAsset"/> to load a sprite from a resource path. Use <see cref="LoadableBundleAsset{T}"/> to load a sprite from an asset bundle.
     /// </summary>
     public abstract LoadableAsset<Sprite> Sprite { get; }
 
+    /// <summary>
+    /// 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 location of the button on the screen.
     /// </summary>
-    public virtual ButtonLocation Location => ButtonLocation.BottomLeft;
+    public virtual ButtonLocation Location { get; private set; } = ButtonLocation.BottomLeft;
 
     /// <summary>
     /// Gets a value indicating whether the button has an effect ability.
@@ -70,7 +80,11 @@ public abstract class CustomActionButton
     /// </summary>
     protected ActionButton? Button { get; private set; }
 
-    internal void CreateButton(Transform parent)
+    /// <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)
         {
@@ -78,7 +92,7 @@ public abstract class CustomActionButton
         }
 
         UsesLeft = MaxUses;
-        Timer = Cooldown;
+        Timer = AmongUsClient.Instance?.NetworkMode == NetworkModes.FreePlay ? 0 : InitialCooldown;
         EffectActive = false;
 
         Button = Object.Instantiate(HudManager.Instance.AbilityButton, parent);
@@ -95,13 +109,87 @@ public abstract class CustomActionButton
 
         var pb = Button.GetComponent<PassiveButton>();
         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>
+    /// Allows you to change the button's location.
+    /// </summary>
+    /// <param name="location">The new location.</param>
+    /// <param name="moveButton">Whether the button's position should change ingame.</param>
+    public virtual void SetButtonLocation(ButtonLocation location, bool moveButton = true)
+    {
+        if (HudManager.Instance == null || 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 void ResetCooldownAndOrEffect()
+    public virtual void ResetCooldownAndOrEffect()
     {
         Timer = Cooldown;
         if (EffectActive)
@@ -116,7 +204,7 @@ public abstract class CustomActionButton
     /// A utility function to override the sprite of the button.
     /// </summary>
     /// <param name="sprite">The new sprite to override with.</param>
-    public void OverrideSprite(Sprite sprite)
+    public virtual void OverrideSprite(Sprite sprite)
     {
         if (Button != null)
         {
@@ -128,7 +216,7 @@ public abstract class CustomActionButton
     /// A utility function to override the name of the button.
     /// </summary>
     /// <param name="name">The new name to override with.</param>
-    public void OverrideName(string name)
+    public virtual void OverrideName(string name)
     {
         Button?.OverrideText(name);
     }
@@ -137,7 +225,7 @@ public abstract class CustomActionButton
     /// Set the button's timer.
     /// </summary>
     /// <param name="time">The time you want to set to.</param>
-    public void SetTimer(float time)
+    public virtual void SetTimer(float time)
     {
         Timer = Mathf.Clamp(time, -1, float.MaxValue);
     }
@@ -146,7 +234,7 @@ public abstract class CustomActionButton
     /// Increase the button's timer.
     /// </summary>
     /// <param name="amount">The amount you want to increase by.</param>
-    public void IncreaseTimer(float amount)
+    public virtual void IncreaseTimer(float amount)
     {
         SetTimer(Timer + amount);
     }
@@ -155,7 +243,7 @@ public abstract class CustomActionButton
     /// Decrease the button's timer.
     /// </summary>
     /// <param name="amount">The amount you want to decrease by.</param>
-    public void DecreaseTimer(float amount)
+    public virtual void DecreaseTimer(float amount)
     {
         SetTimer(Timer - amount);
     }
@@ -164,16 +252,17 @@ public abstract class CustomActionButton
     /// Set the amount of uses this button has left.
     /// </summary>
     /// <param name="amount">The amount you want to set to.</param>
-    public void SetUses(int amount)
+    public virtual void SetUses(int amount)
     {
         UsesLeft = Mathf.Clamp(amount, 0, int.MaxValue);
+        Button?.SetUsesRemaining(UsesLeft);
     }
 
     /// <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 void IncreaseUses(int amount = 1)
+    public virtual void IncreaseUses(int amount = 1)
     {
         SetUses(UsesLeft + amount);
     }
@@ -182,7 +271,7 @@ public abstract class CustomActionButton
     /// Decrease the amount of uses this button has left.
     /// </summary>
     /// <param name="amount">The amount you want to decrease by. Default: 1.</param>
-    public void DecreaseUses(int amount = 1)
+    public virtual void DecreaseUses(int amount = 1)
     {
         SetUses(UsesLeft - amount);
     }
@@ -244,7 +333,7 @@ public abstract class CustomActionButton
     /// This method takes into account cooldowns, effects, and uses, before calling the <see cref="OnClick"/> method.
     /// It can be overridden for custom behavior.
     /// </summary>
-    protected virtual void ClickHandler()
+    public virtual void ClickHandler()
     {
         if (!CanUse())
         {
@@ -327,7 +416,7 @@ public abstract class CustomActionButton<T> : CustomActionButton where T : MonoB
     /// <returns>True if the target object is valid, false otherwise.</returns>
     public virtual bool IsTargetValid(T? target)
     {
-        return target;
+        return target != null;
     }
 
     /// <summary>
@@ -354,6 +443,15 @@ public abstract class CustomActionButton<T> : CustomActionButton where T : MonoB
         Target = IsTargetValid(newTarget) ? newTarget : null;
         SetOutline(true);
 
-        return base.CanUse() && Target;
+        return base.CanUse() && 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,19 +1,26 @@
-using System;
+using MiraAPI.Events.Mira;
+using MiraAPI.PluginLoading;
+using Reactor.Utilities;
+using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Reactor.Utilities;
 
 namespace MiraAPI.Hud;
 
-internal static class CustomButtonManager
+/// <summary>
+/// Custom button manager for handling custom buttons.
+/// </summary>
+public static class CustomButtonManager
 {
     internal static readonly List<CustomActionButton> CustomButtons = [];
+    internal static readonly Dictionary<Type, Type> ButtonEventTypes = [];
+    internal static readonly Dictionary<Type, Type> ButtonCancelledEventTypes = [];
 
-    internal static void RegisterButton(Type buttonType)
+    internal static void RegisterButton(Type buttonType, MiraPluginInfo pluginInfo)
     {
         if (!typeof(CustomActionButton).IsAssignableFrom(buttonType))
         {
-            Logger<MiraApiPlugin>.Error($"{buttonType?.Name} does not inherit from CustomActionButton.");
+            Logger<MiraApiPlugin>.Error($"Skipping button {buttonType.Name}. Does not inherit CustomActionButton!");
             return;
         }
 
@@ -24,8 +31,12 @@ internal static class CustomButtonManager
         }
 
         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));
     }
 }

MiraAPI/Hud/CustomPlayerMenu.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AmongUs.GameOptions;
+using Il2CppInterop.Runtime.Attributes;
+using MiraAPI.Patches.Stubs;
+using Reactor.Utilities.Attributes;
+using Reactor.Utilities.Extensions;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace MiraAPI.Hud;
+
+/// <summary>
+/// Custom Player Menu using the ShapeshifterPanel as a base.
+/// </summary>
+/// <param name="il2CppPtr">Used by Il2Cpp. Do not use constructor, this is a MonoBehaviour.</param>
+[RegisterInIl2Cpp]
+public class CustomPlayerMenu(IntPtr il2CppPtr) : Minigame(il2CppPtr)
+{
+    public ShapeshifterPanel PanelPrefab;
+
+    public float XStart = -0.8f;
+
+    public float YStart = 2.15f;
+
+    public float XOffset = 1.95f;
+
+    public float YOffset = -0.65f;
+
+    public UiElement BackButton;
+
+    public UiElement DefaultButtonSelected;
+
+    public List<ShapeshifterPanel> potentialVictims;
+
+    /// <summary>
+    /// Creates a CustomPlayerMenu.
+    /// </summary>
+    /// <returns>New CustomPlayerMenu object.</returns>
+    public static CustomPlayerMenu Create()
+    {
+        var shapeShifterRole = RoleManager.Instance.GetRole(RoleTypes.Shapeshifter);
+
+        var ogMenu = shapeShifterRole.TryCast<ShapeshifterRole>().ShapeshifterMenu;
+        var newMenu = Instantiate(ogMenu);
+        var customMenu = newMenu.gameObject.AddComponent<CustomPlayerMenu>();
+
+        customMenu.PanelPrefab = newMenu.PanelPrefab;
+        customMenu.XStart = newMenu.XStart;
+        customMenu.YStart = newMenu.YStart;
+        customMenu.XOffset = newMenu.XOffset;
+        customMenu.YOffset = newMenu.YOffset;
+        customMenu.BackButton = newMenu.BackButton;
+        var back = customMenu.BackButton.GetComponent<PassiveButton>();
+        back.OnClick.RemoveAllListeners();
+        back.OnClick.AddListener((UnityAction)(() =>
+        {
+            Instance.Close();
+        }));
+
+        customMenu.CloseSound = newMenu.CloseSound;
+        customMenu.logger = newMenu.logger;
+        customMenu.OpenSound = newMenu.OpenSound;
+
+        newMenu.DestroyImmediate();
+
+        customMenu.transform.SetParent(Camera.main.transform, false);
+        customMenu.transform.localPosition = new Vector3(0f, 0f, -50f);
+        return customMenu;
+    }
+
+    private void OnDisable()
+    {
+        ControllerManager.Instance.CloseOverlayMenu(name);
+    }
+
+    public override void Begin(PlayerTask task)
+    {
+        throw new NotImplementedException("Use the other Begin method.");
+    }
+
+    /// <summary>
+    /// Begins/opens the custom player menu.
+    /// </summary>
+    /// <param name="playerMatch">Function to determine if player should show in the custom menu.</param>
+    /// <param name="onClick">Onclick action for player.</param>
+    [HideFromIl2Cpp]
+    public void Begin(Func<PlayerControl, bool> playerMatch, Action<PlayerControl> onClick)
+    {
+        MinigameStubs.Begin(this, null);
+
+        DestroyableSingleton<DebugAnalytics>.Instance.Analytics.MinigameOpened(PlayerControl.LocalPlayer.Data, TaskType);
+        var list = PlayerControl.AllPlayerControls.ToArray().Where(playerMatch).ToList();
+        potentialVictims = [];
+        var list2 = new Il2CppSystem.Collections.Generic.List<UiElement>();
+
+        for (var i = 0; i < list.Count; i++)
+        {
+            var player = list[i];
+            var num = i % 3;
+            var num2 = i / 3;
+            var flag = PlayerControl.LocalPlayer.Data.Role.NameColor == player.Data.Role.NameColor;
+            var shapeshifterPanel = Instantiate(PanelPrefab, transform);
+            shapeshifterPanel.transform.localPosition = new Vector3(XStart + num * XOffset, YStart + num2 * YOffset, -1f);
+            shapeshifterPanel.SetPlayer(i, player.Data, (Il2CppSystem.Action)(() => { onClick(player); }));
+            shapeshifterPanel.NameText.color = flag ? player.Data.Role.NameColor : Color.white;
+            potentialVictims.Add(shapeshifterPanel);
+            list2.Add(shapeshifterPanel.Button);
+        }
+        ControllerManager.Instance.OpenOverlayMenu(name, BackButton, DefaultButtonSelected, list2);
+    }
+}

MiraAPI/Modifiers/BaseModifier.cs

@@ -75,6 +75,6 @@ public abstract class BaseModifier
     /// <summary>
     /// Determines whether the player can vent.
     /// </summary>
-    /// <returns>True if the player can vent, false otherwise.</returns>
-    public virtual bool CanVent() => Player?.Data.Role.CanVent == true;
+    /// <returns>True if the player can vent, false otherwise. Null for no effect.</returns>
+    public virtual bool? CanVent() => null;
 }

MiraAPI/Modifiers/ModifierComponent.cs

@@ -39,11 +39,6 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
 
     internal void ClearModifiers()
     {
-        foreach (var modifier in Modifiers)
-        {
-            modifier.OnDeactivate();
-        }
-
         _toRemove.AddRange(Modifiers);
     }
 
@@ -74,7 +69,7 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
             Modifiers.Add(modifier);
             modifier.OnActivate();
 
-            if (_player?.AmOwner == true && modifier is TimedModifier { AutoStart: true } timer)
+            if (modifier is TimedModifier { AutoStart: true } timer)
             {
                 timer.StartTimer();
             }
@@ -84,7 +79,7 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
         {
             if (_player?.AmOwner == true)
             {
-                HudManager.Instance?.SetHudActive(true);
+                HudManager.Instance?.SetHudActive(_player, _player.Data.Role, HudManager.Instance.TaskPanel.isActiveAndEnabled);
             }
             _toAdd.Clear();
             _toRemove.Clear();
@@ -260,4 +255,24 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
     {
         return AddModifier(typeof(T)) as T;
     }
+
+    /// <summary>
+    /// Checks if a player has an active or queued modifier by its ID.
+    /// </summary>
+    /// <param name="id">The Modifier ID.</param>
+    /// <returns>True if the Modifier is present, false otherwise.</returns>
+    public bool HasModifier(uint id)
+    {
+        return ActiveModifiers.Exists(x => x.ModifierId == id) || _toAdd.Exists(x => x.ModifierId == id);
+    }
+
+    /// <summary>
+    /// Checks if a player has an active or queued modifier by its type.
+    /// </summary>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    /// <returns>True if the Modifier is present, false otherwise.</returns>
+    public bool HasModifier<T>()
+    {
+        return ActiveModifiers.Exists(x => x is T) || _toAdd.Exists(x => x is T);
+    }
 }

MiraAPI/Modifiers/ModifierManager.cs

@@ -19,6 +19,7 @@ public static class ModifierManager
 {
     private static readonly Dictionary<uint, Type> IdToTypeModifierMap = [];
     private static readonly Dictionary<Type, uint> TypeToIdModifierMap = [];
+    private static readonly Dictionary<int, List<uint>> PrioritiesToIdsMap = [];
 
     private static uint _nextId;
 
@@ -57,75 +58,90 @@ public static class ModifierManager
 
         IdToTypeModifierMap.Add(GetNextId(), modifierType);
         TypeToIdModifierMap.Add(modifierType, _nextId);
+
+        if (!typeof(GameModifier).IsAssignableFrom(modifierType))
+        {
+            return;
+        }
+
+        var mod = Activator.CreateInstance(modifierType) as GameModifier;
+        var priority = mod!.Priority();
+
+        if (!PrioritiesToIdsMap.TryGetValue(priority, out var list))
+        {
+            PrioritiesToIdsMap[priority] = list = [];
+        }
+
+        list.Add(_nextId);
     }
 
     internal static void AssignModifiers(List<PlayerControl> plrs)
     {
         var rand = new Random();
 
-        List<uint> filteredModifiers = [];
-
-        foreach (var modifier in IdToTypeModifierMap.Where(pair => pair.Value.IsAssignableTo(typeof(GameModifier))))
+        foreach (var priority in PrioritiesToIdsMap.Keys.OrderByDescending(x => x))
         {
-            if (Activator.CreateInstance(modifier.Value) is not GameModifier mod)
+            var filteredModifiers = new List<uint>();
+
+            foreach (var id in PrioritiesToIdsMap[priority])
             {
-                Logger<MiraApiPlugin>.Error($"Failed to create instance of {modifier.Value.Name}");
-                continue;
-            }
+                var mod = Activator.CreateInstance(IdToTypeModifierMap[id]) as GameModifier;
+                var chance = Math.Clamp(mod!.GetAssignmentChance(), 0, 100);
+                var count = mod.GetAmountPerGame();
 
-            if (!plrs.Exists(x => IsGameModifierValid(x, mod, modifier.Key)))
-            {
-                Logger<MiraApiPlugin>.Warning("No players are valid for modifier: " + mod.ModifierName);
-                continue;
-            }
-
-            var maxCount = plrs.Count(x => IsGameModifierValid(x, mod, modifier.Key));
-
-            var num = Math.Clamp(mod.GetAmountPerGame(), 0, maxCount);
-            var chance = mod.GetAssignmentChance();
-
-            for (var i = 0; i < num; i++)
-            {
-                var randomNum = rand.Next(100);
-
-                if (randomNum < Math.Clamp(chance, 0, 100))
+                if (chance == 0 || count == 0)
                 {
-                    filteredModifiers.Add(TypeToIdModifierMap[modifier.Value]);
+                    continue;
+                }
+
+                var maxCount = plrs.Count(x => IsGameModifierValid(x, mod, id));
+
+                if (maxCount == 0)
+                {
+                    Logger<MiraApiPlugin>.Warning($"No players are valid for {mod.ModifierName}");
+                    continue;
+                }
+
+                var num = Math.Clamp(count, 0, maxCount);
+
+                for (var i = 0; i < num; i++)
+                {
+                    var randomNum = rand.Next(100);
+
+                    if (randomNum < chance)
+                    {
+                        filteredModifiers.Add(id);
+                    }
                 }
             }
-        }
 
-        var shuffledModifiers = filteredModifiers.Randomize();
-        if (shuffledModifiers.Count > plrs.Count)
-        {
-            shuffledModifiers = shuffledModifiers.GetRange(0, plrs.Count);
-        }
-
-        while (shuffledModifiers.Count > 0)
-        {
-            var id = shuffledModifiers[0];
-
-            if (Activator.CreateInstance(IdToTypeModifierMap[id]) is not GameModifier mod)
+            if (filteredModifiers.Count == 0)
             {
-                Logger<MiraApiPlugin>.Error($"Failed to create instance of {IdToTypeModifierMap[id].Name}");
+                Logger<MiraApiPlugin>.Warning($"No filtered modifiers for priority {priority}");
                 continue;
             }
 
-            if (!plrs.Exists(x => IsGameModifierValid(x, mod, id)))
+            var shuffledList = filteredModifiers.Randomize();
+
+            if (shuffledList.Count > plrs.Count)
             {
-                shuffledModifiers.RemoveAt(0);
-                continue;
+                shuffledList = shuffledList.GetRange(0, plrs.Count);
             }
 
-            var plr = plrs.Random();
-
-            if (plr == null || !IsGameModifierValid(plr, mod, id))
+            foreach (var id in shuffledList)
             {
-                continue;
-            }
+                var mod = Activator.CreateInstance(IdToTypeModifierMap[id]) as GameModifier;
+                var plr = plrs.Where(x => IsGameModifierValid(x, mod!, id)).Random();
 
-            shuffledModifiers.RemoveAt(0);
-            plr.RpcAddModifier(id);
+                if (plr == null)
+                {
+                    Logger<MiraApiPlugin>.Warning($"Somehow valid players for modifier {mod!.ModifierName} disappeared");
+                }
+                else
+                {
+                    plr.RpcAddModifier(id);
+                }
+            }
         }
     }
 

MiraAPI/Modifiers/Types/GameModifier.cs

@@ -17,10 +17,23 @@ public abstract class GameModifier : BaseModifier
     /// <returns>An int value greater than or equal to zero.</returns>
     public abstract int GetAmountPerGame();
 
+    /// <summary>
+    /// Gets the priority at which the modifier will spawn. The higher the value, the higher up on the assignment list.
+    /// </summary>
+    /// <returns>An int value greater than or equal to -1.</returns>
+    public virtual int Priority() => -1;
+
     /// <summary>
     /// Determines whether the modifier is valid on a role.
     /// </summary>
     /// <param name="role">The role to be checked.</param>
     /// <returns>True if the modifier is valid on the role, otherwise false.</returns>
     public virtual bool IsModifierValidOn(RoleBehaviour role) => true;
+
+    /// <summary>
+    /// Determines whether the player won the game with this modifier.
+    /// </summary>
+    /// <param name="reason">The reason why the game ended.</param>
+    /// <returns>True if the player won, false if they lost. Return null to use the player's default win condition.</returns>
+    public virtual bool? DidWin(GameOverReason reason) => null;
 }

MiraAPI/Modifiers/Types/TimedModifier.cs

@@ -39,6 +39,9 @@ public abstract class TimedModifier : BaseModifier
     /// </summary>
     public float TimeRemaining { get; protected set; }
 
+    /// <inheritdoc />
+    public override bool HideOnUi => !TimerActive;
+
     /// <summary>
     /// Gets the HUD information for Timed Modifier, including the time remaining.
     /// </summary>
@@ -53,25 +56,18 @@ public abstract class TimedModifier : BaseModifier
     /// </summary>
     public override void FixedUpdate()
     {
-        if (Player?.AmOwner == false)
+        if (!TimerActive)
         {
             return;
         }
 
-        if (TimeRemaining > 0 && TimerActive)
+        if (TimeRemaining > 0)
         {
             TimeRemaining -= Time.fixedDeltaTime;
         }
         else
         {
-            TimerActive = false;
-            TimeRemaining = Duration;
-            OnTimerComplete();
-
-            if (RemoveOnComplete)
-            {
-                ModifierComponent?.RemoveModifier(ModifierId);
-            }
+            StopTimer();
         }
     }
 
@@ -86,7 +82,52 @@ public abstract class TimedModifier : BaseModifier
             return;
         }
 
+        TimeRemaining = Duration;
         TimerActive = true;
+    }
+
+    /// <summary>
+    /// Stops the timer and calls OnTimerComplete().
+    /// </summary>
+    public void StopTimer()
+    {
+        if (!TimerActive)
+        {
+            return;
+        }
+
+        TimerActive = false;
+        TimeRemaining = Duration;
+        OnTimerComplete();
+
+        if (RemoveOnComplete)
+        {
+            ModifierComponent?.RemoveModifier(ModifierId);
+        }
+    }
+
+    /// <summary>
+    /// Resets the timer. Does not call OnTimerComplete().
+    /// </summary>
+    public void ResetTimer()
+    {
+        TimerActive = false;
         TimeRemaining = Duration;
     }
+
+    /// <summary>
+    /// Pauses the timer.
+    /// </summary>
+    public void PauseTimer()
+    {
+        TimerActive = false;
+    }
+
+    /// <summary>
+    /// Pauses the timer.
+    /// </summary>
+    public void ResumeTimer()
+    {
+        TimerActive = true;
+    }
 }

MiraAPI/Networking/CustomMurderRpc.cs

@@ -1,11 +1,14 @@
-using System.Collections;
-using System.Linq;
-using AmongUs.GameOptions;
+using AmongUs.GameOptions;
 using Assets.CoreScripts;
 using BepInEx.Unity.IL2CPP.Utils;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Gameplay;
 using Reactor.Networking.Attributes;
+using Reactor.Networking.Rpc;
 using Reactor.Utilities;
 using Reactor.Utilities.Extensions;
+using System.Collections;
+using System.Linq;
 using UnityEngine;
 
 namespace MiraAPI.Networking;
@@ -26,7 +29,7 @@ public static class CustomMurderRpc
     /// <param name="teleportMurderer">Should the killer be snapped to the dead player.</param>
     /// <param name="showKillAnim">Should the kill animation be shown.</param>
     /// <param name="playKillSound">Should the kill sound be played.</param>
-    [MethodRpc((uint)MiraRpc.CustomMurder)]
+    [MethodRpc((uint)MiraRpc.CustomMurder, LocalHandling = RpcLocalHandling.Before, SendImmediately = true)]
     public static void RpcCustomMurder(
         this PlayerControl source,
         PlayerControl target,
@@ -38,6 +41,15 @@ public static class CustomMurderRpc
         bool playKillSound = true)
     {
         var murderResultFlags = didSucceed ? MurderResultFlags.Succeeded : MurderResultFlags.FailedError;
+
+        var beforeMurderEvent = new BeforeMurderEvent(source, target);
+        MiraEventManager.InvokeEvent(beforeMurderEvent);
+
+        if (beforeMurderEvent.IsCancelled)
+        {
+            murderResultFlags = MurderResultFlags.FailedError;
+        }
+
         var murderResultFlags2 = MurderResultFlags.DecisionByHost | murderResultFlags;
 
         source.CustomMurder(
@@ -72,7 +84,6 @@ public static class CustomMurderRpc
         bool playKillSound = true)
     {
         source.isKilling = false;
-        Logger<MiraApiPlugin>.Error($"{source.PlayerId} trying to murder {target.PlayerId}");
         var data = target.Data;
         if (resultFlags.HasFlag(MurderResultFlags.FailedError))
         {
@@ -87,7 +98,7 @@ public static class CustomMurderRpc
             if (flag && PlayerControl.LocalPlayer.Data.PlayerId == target.protectedByGuardianId)
             {
                 StatsManager.Instance.IncrementStat(StringNames.StatsGuardianAngelCrewmatesProtected);
-                DestroyableSingleton<AchievementManager>.Instance.OnProtectACrewmate();
+                AchievementManager.Instance.OnProtectACrewmate();
             }
 
             if (source.AmOwner || flag)
@@ -115,7 +126,7 @@ public static class CustomMurderRpc
             return;
         }
 
-        DestroyableSingleton<DebugAnalytics>.Instance.Analytics.Kill(target.Data, source.Data);
+        DebugAnalytics.Instance.Analytics.Kill(target.Data, source.Data);
         if (source.AmOwner)
         {
             StatsManager.Instance.IncrementStat(
@@ -139,7 +150,7 @@ public static class CustomMurderRpc
             }
         }
 
-        DestroyableSingleton<UnityTelemetry>.Instance.WriteMurder();
+        UnityTelemetry.Instance.WriteMurder();
         target.gameObject.layer = LayerMask.NameToLayer("Ghost");
         if (target.AmOwner)
         {
@@ -159,14 +170,14 @@ public static class CustomMurderRpc
 
             if (showKillAnim)
             {
-                DestroyableSingleton<HudManager>.Instance.KillOverlay.ShowKillAnimation(source.Data, data);
+                HudManager.Instance.KillOverlay.ShowKillAnimation(source.Data, data);
             }
 
             target.cosmetics.SetNameMask(false);
             target.RpcSetScanner(false);
         }
 
-        DestroyableSingleton<AchievementManager>.Instance.OnMurder(
+        AchievementManager.Instance.OnMurder(
             source.AmOwner,
             target.AmOwner,
             source.CurrentOutfitType == PlayerOutfitType.Shapeshifted,
@@ -267,5 +278,8 @@ public static class CustomMurderRpc
 
         PlayerControl.LocalPlayer.isKilling = false;
         source.isKilling = false;
+
+        var afterMurderEvent = new AfterMurderEvent(source, target);
+        MiraEventManager.InvokeEvent(afterMurderEvent);
     }
 }

MiraAPI/Patches/AmongUsClientSyncPatch.cs

@@ -1,5 +1,7 @@
 using HarmonyLib;
 using InnerNet;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Player;
 using MiraAPI.GameOptions;
 using MiraAPI.Modifiers;
 using MiraAPI.Roles;
@@ -9,11 +11,16 @@ namespace MiraAPI.Patches;
 /// <summary>
 /// Sync all options, role settings, and modifiers to the player when they join the game.
 /// </summary>
-[HarmonyPatch(typeof(AmongUsClient), nameof(AmongUsClient.CreatePlayer))]
+[HarmonyPatch(typeof(AmongUsClient))]
 public static class AmongUsClientSyncPatch
 {
-    public static void Postfix(ClientData clientData)
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(AmongUsClient), nameof(AmongUsClient.CreatePlayer))]
+    public static void CreatePlayerPatch(ClientData clientData)
     {
+        var joinEvent = new PlayerJoinEvent(clientData);
+        MiraEventManager.InvokeEvent(joinEvent);
+
         if (!AmongUsClient.Instance.AmHost)
         {
             return;
@@ -28,4 +35,12 @@ public static class AmongUsClientSyncPatch
         CustomRoleManager.SyncAllRoleSettings(clientData.Id);
         ModifierManager.SyncAllModifiers(clientData.Id);
     }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(AmongUsClient), nameof(AmongUsClient.OnPlayerLeft))]
+    public static void PlayerLeftPatch(ClientData data, DisconnectReasons reason)
+    {
+        var leftEvent = new PlayerLeaveEvent(data, reason);
+        MiraEventManager.InvokeEvent(leftEvent);
+    }
 }

MiraAPI/Patches/Events/CanUsePatches.cs

@@ -0,0 +1,36 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Usables;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace MiraAPI.Patches.Events;
+
+[HarmonyPatch]
+public static class CanUsePatches
+{
+    public static IEnumerable<MethodBase> TargetMethods()
+    {
+        yield return AccessTools.Method(typeof(Console), nameof(Console.CanUse));
+        yield return AccessTools.Method(typeof(MapConsole), nameof(MapConsole.CanUse));
+        yield return AccessTools.Method(typeof(SystemConsole), nameof(SystemConsole.CanUse));
+        yield return AccessTools.Method(typeof(Ladder), nameof(Ladder.CanUse));
+        yield return AccessTools.Method(typeof(PlatformConsole), nameof(PlatformConsole.CanUse));
+        yield return AccessTools.Method(typeof(OpenDoorConsole), nameof(OpenDoorConsole.CanUse));
+        yield return AccessTools.Method(typeof(DoorConsole), nameof(DoorConsole.CanUse));
+        yield return AccessTools.Method(typeof(OptionsConsole), nameof(OptionsConsole.CanUse));
+        yield return AccessTools.Method(typeof(ZiplineConsole), nameof(ZiplineConsole.CanUse));
+    }
+
+    [HarmonyPriority(Priority.Last)]
+    [HarmonyPrefix]
+    public static bool CanUsePatch(Il2CppSystem.Object __instance, [HarmonyArgument(0)] NetworkedPlayerInfo pc, [HarmonyArgument(1)] out bool canUse, [HarmonyArgument(2)] out bool couldUse)
+    {
+        var @event = new PlayerCanUseEvent(__instance.Cast<IUsable>());
+        MiraEventManager.InvokeEvent(@event);
+
+        canUse = couldUse = false;
+
+        return !@event.IsCancelled;
+    }
+}

MiraAPI/Patches/Events/EndGamePatches.cs

@@ -0,0 +1,20 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Gameplay;
+
+namespace MiraAPI.Patches.Events;
+
+/// <summary>
+/// Patch for trigging the GameEndEvent.
+/// </summary>
+[HarmonyPatch]
+public static class EndGamePatches
+{
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(EndGameManager), nameof(EndGameManager.SetEverythingUp))]
+    public static void SetEverythingUpPatch(EndGameManager __instance)
+    {
+        var @event = new GameEndEvent(__instance);
+        MiraEventManager.InvokeEvent(@event);
+    }
+}

MiraAPI/Patches/Events/KillAnimationPatches.cs

@@ -0,0 +1,25 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Gameplay;
+
+namespace MiraAPI.Patches;
+
+/// <summary>
+/// General patches for the KillAnimation class.
+/// </summary>
+[HarmonyPatch]
+public static class KillAnimationPatches
+{
+    /// <summary>
+    /// Used to trigger the <see cref="AfterMurderEvent"/>.
+    /// </summary>
+    /// <param name="source">The killer.</param>
+    /// <param name="target">The target.</param>
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(KillAnimation), nameof(KillAnimation.CoPerformKill))]
+    public static void KillAnimPostfix(PlayerControl source, PlayerControl target)
+    {
+        var afterMurderEvent = new AfterMurderEvent(source, target);
+        MiraEventManager.InvokeEvent(afterMurderEvent);
+    }
+}

MiraAPI/Patches/Events/MapBehaviourPatches.cs

@@ -0,0 +1,21 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Map;
+
+namespace MiraAPI.Patches.Events;
+
+/// <summary>
+/// Patch for map related MiraEvents.
+/// </summary>
+[HarmonyPatch]
+public static class MapBehaviourPatches
+{
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(MapBehaviour), nameof(MapBehaviour.ShowSabotageMap))]
+    public static bool MapShowSabotagePatch(MapBehaviour __instance)
+    {
+        var @event = new PlayerOpenSabotageEvent(__instance);
+        MiraEventManager.InvokeEvent(@event);
+        return !@event.IsCancelled;
+    }
+}

MiraAPI/Patches/Events/SabotageEventPatches.cs

@@ -0,0 +1,30 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Map;
+
+namespace MiraAPI.Patches.Events;
+
+/// <summary>
+/// Used for patching sabotage/system related MiraEvents.
+/// </summary>
+[HarmonyPatch]
+public static class SabotageEventPatches
+{
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(ShipStatus), nameof(ShipStatus.RpcUpdateSystem), typeof(SystemTypes), typeof(byte))]
+    public static bool ShipStatusUpdateSystemPrefix(ShipStatus __instance, SystemTypes systemType, byte amount)
+    {
+        var @event = new UpdateSystemEvent(systemType, PlayerControl.LocalPlayer, amount);
+        MiraEventManager.InvokeEvent(@event);
+        return !@event.IsCancelled;
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(ShipStatus), nameof(ShipStatus.RpcCloseDoorsOfType))]
+    public static bool ShipStatusCloseDoorsOfTypePrefix(ShipStatus __instance, SystemTypes type)
+    {
+        var @event = new CloseDoorsEvent(type);
+        MiraEventManager.InvokeEvent(@event);
+        return !@event.IsCancelled;
+    }
+}

MiraAPI/Patches/Events/StartMeetingEventPatch.cs

@@ -0,0 +1,21 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Meeting;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.Patches.Events;
+
+[HarmonyPatch]
+public static class StartMeetingEventPatch
+{
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(PlayerControl), nameof(PlayerControl.CmdReportDeadBody))]
+    public static bool PlayerControlCmdReportDeadBodyPrefix(PlayerControl __instance, NetworkedPlayerInfo? target)
+    {
+        var body = target != null ? Helpers.GetBodyById(target.PlayerId) : null;
+
+        var @event = new StartMeetingEvent(__instance, target, body);
+        MiraEventManager.InvokeEvent(@event);
+        return !@event.IsCancelled;
+    }
+}

MiraAPI/Patches/Events/UsePatches.cs

@@ -0,0 +1,35 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace MiraAPI.Patches.Events;
+
+[HarmonyPatch]
+public static class UsePatches
+{
+    public static IEnumerable<MethodBase> TargetMethods()
+    {
+        yield return AccessTools.Method(typeof(Console), nameof(Console.Use));
+        yield return AccessTools.Method(typeof(MapConsole), nameof(MapConsole.Use));
+        yield return AccessTools.Method(typeof(SystemConsole), nameof(SystemConsole.Use));
+        yield return AccessTools.Method(typeof(Vent), nameof(Vent.Use));
+        yield return AccessTools.Method(typeof(Ladder), nameof(Ladder.Use));
+        yield return AccessTools.Method(typeof(PlatformConsole), nameof(PlatformConsole.Use));
+        yield return AccessTools.Method(typeof(OpenDoorConsole), nameof(OpenDoorConsole.Use));
+        yield return AccessTools.Method(typeof(DoorConsole), nameof(DoorConsole.Use));
+        yield return AccessTools.Method(typeof(OptionsConsole), nameof(OptionsConsole.Use));
+        yield return AccessTools.Method(typeof(ZiplineConsole), nameof(ZiplineConsole.Use));
+    }
+
+    [HarmonyPriority(Priority.Last)]
+    [HarmonyPrefix]
+    public static bool UsePatch(Il2CppSystem.Object __instance)
+    {
+        var @event = new PlayerUseEvent(__instance.Cast<IUsable>());
+        MiraEventManager.InvokeEvent(@event);
+
+        return !@event.IsCancelled;
+    }
+}

MiraAPI/Patches/Events/VentEventPatches.cs

@@ -0,0 +1,57 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Usables;
+using System.Linq;
+
+namespace MiraAPI.Patches.Events;
+
+/// <summary>
+/// Patches to invoke vent related MiraEvents.
+/// </summary>
+[HarmonyPatch]
+public static class VentEventPatches
+{
+    // necessary because Vent.Use is inlined in il2cpp.
+    private static bool _showButtons;
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(VentButton), nameof(VentButton.DoClick))]
+    public static void VentUsePostfix(VentButton __instance)
+    {
+        __instance.currentTarget?.SetButtons(_showButtons);
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(PlayerPhysics), nameof(PlayerPhysics.RpcEnterVent))]
+    public static bool PlayerPhysicsRpcEnterVentPrefix(PlayerPhysics __instance, int id)
+    {
+        var pc = __instance.myPlayer;
+        var vent = ShipStatus.Instance.AllVents.FirstOrDefault(v => v.Id == id);
+
+        var @event = new EnterVentEvent(pc, vent);
+        MiraEventManager.InvokeEvent(@event);
+
+        if (pc.AmOwner)
+        {
+            _showButtons = !@event.IsCancelled;
+        }
+        return !@event.IsCancelled;
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(PlayerPhysics), nameof(PlayerPhysics.RpcExitVent))]
+    public static bool PlayerPhysicsRpcExitVentPrefix(PlayerPhysics __instance, int id)
+    {
+        var pc = __instance.myPlayer;
+        var vent = ShipStatus.Instance.AllVents.First(v => v.Id == id);
+
+        var @event = new ExitVentEvent(pc, vent);
+        MiraEventManager.InvokeEvent(@event);
+
+        if (pc.AmOwner)
+        {
+            _showButtons = @event.IsCancelled;
+        }
+        return !@event.IsCancelled;
+    }
+}

MiraAPI/Patches/HudManagerPatches.cs

@@ -1,6 +1,5 @@
 using HarmonyLib;
 using MiraAPI.Hud;
-using MiraAPI.Roles;
 using Reactor.Utilities.Extensions;
 using UnityEngine;
 using Object = UnityEngine.Object;
@@ -14,7 +13,9 @@ namespace MiraAPI.Patches;
 public static class HudManagerPatches
 {
     // Custom buttons parent.
-    private static GameObject? _bottomLeft;
+    internal static GameObject? _bottomLeft;
+    internal static Transform? _bottomRight;
+    internal static Transform? _buttons;
 
     /*
     /// <summary>
@@ -35,12 +36,19 @@ public static class HudManagerPatches
     [HarmonyPatch(nameof(HudManager.Start))]
     public static void StartPostfix(HudManager __instance)
     {
-        var buttons = __instance.transform.Find("Buttons");
-        var bottomRight = buttons.Find("BottomRight");
+        if (_buttons == null)
+        {
+            _buttons = __instance.transform.Find("Buttons");
+        }
+
+        if (_bottomRight == null)
+        {
+            _bottomRight = _buttons.Find("BottomRight");
+        }
 
         if (_bottomLeft == null)
         {
-            _bottomLeft = Object.Instantiate(bottomRight.gameObject, buttons);
+            _bottomLeft = Object.Instantiate(_bottomRight.gameObject, _buttons);
         }
 
         foreach (var t in _bottomLeft.GetComponentsInChildren<ActionButton>(true))
@@ -60,7 +68,7 @@ public static class HudManagerPatches
             var location = button.Location switch
             {
                 ButtonLocation.BottomLeft => _bottomLeft.transform,
-                ButtonLocation.BottomRight => bottomRight,
+                ButtonLocation.BottomRight => _bottomRight,
                 _ => null,
             };
 
@@ -89,7 +97,8 @@ public static class HudManagerPatches
     [HarmonyPatch(nameof(HudManager.SetHudActive), typeof(PlayerControl), typeof(RoleBehaviour), typeof(bool))]
     public static void SetHudActivePostfix(HudManager __instance, PlayerControl localPlayer, RoleBehaviour role, bool isActive)
     {
-        if (!localPlayer.Data)
+        __instance.AdminButton.ToggleVisible(isActive && role.IsImpostor && GameOptionsManager.Instance.CurrentGameOptions.GameMode == AmongUs.GameOptions.GameModes.HideNSeek);
+        if (localPlayer.Data == null)
         {
             return;
         }

MiraAPI/Patches/IntroCutscenePatches.cs

@@ -1,4 +1,6 @@
 using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Gameplay;
 using MiraAPI.Roles;
 using MiraAPI.Utilities;
 using UnityEngine;
@@ -20,6 +22,14 @@ public static class IntroCutscenePatches
         }
     }*/
 
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(IntroCutscene.CoBegin))]
+    public static void IntroBeginPatch(IntroCutscene __instance)
+    {
+        var @event = new IntroBeginEvent(__instance);
+        MiraEventManager.InvokeEvent(@event);
+    }
+
     [HarmonyPrefix]
     [HarmonyPatch(nameof(IntroCutscene.BeginCrewmate))]
     public static bool BeginCrewmatePatch(IntroCutscene __instance)

MiraAPI/Patches/Modifiers/EndGameDidWinPatch.cs

@@ -0,0 +1,40 @@
+using System.Linq;
+using HarmonyLib;
+using MiraAPI.Modifiers.Types;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.Patches.Modifiers;
+
+[HarmonyPatch(typeof(AmongUsClient), nameof(AmongUsClient.CoEndGame))]
+public static class EndGameDidWinPatch
+{
+    public static void Prefix()
+    {
+        var gameOverReason = EndGameResult.CachedGameOverReason;
+        EndGameResult.CachedWinners.Clear();
+
+        var players = GameData.Instance.AllPlayers.ToArray();
+        for (var i = 0; i < GameData.Instance.PlayerCount; i++)
+        {
+            var networkedPlayerInfo = players[i];
+            if (networkedPlayerInfo == null)
+            {
+                continue;
+            }
+
+            var didWin = networkedPlayerInfo.Role.DidWin(gameOverReason);
+
+            var modifierWin = networkedPlayerInfo.Object?.GetModifierComponent()?.ActiveModifiers.OfType<GameModifier>()
+                .FirstOrDefault(x => x.DidWin(gameOverReason) != null)?.DidWin(gameOverReason);
+            if (modifierWin != null)
+            {
+                didWin = modifierWin.Value;
+            }
+
+            if (didWin)
+            {
+                EndGameResult.CachedWinners.Add(new CachedPlayerData(networkedPlayerInfo));
+            }
+        }
+    }
+}

MiraAPI/Patches/Modifiers/VentPatches.cs

@@ -1,45 +0,0 @@
-using HarmonyLib;
-using MiraAPI.Utilities;
-using UnityEngine;
-
-namespace MiraAPI.Patches.Modifiers;
-
-[HarmonyPatch(typeof(Vent))]
-public static class VentPatches
-{
-    [HarmonyPostfix]
-    [HarmonyPatch(nameof(Vent.CanUse))]
-    public static void CanUseVentPatch(Vent __instance, ref float __result, [HarmonyArgument(0)] NetworkedPlayerInfo pc, [HarmonyArgument(1)] ref bool canUse, [HarmonyArgument(2)] ref bool couldUse)
-    {
-        var @object = pc.Object;
-        var role = @object.Data.Role;
-
-        var modifiers = @object.GetModifierComponent()?.ActiveModifiers;
-        if (modifiers is null || modifiers.Count <= 0)
-        {
-            return;
-        }
-
-        switch (role.CanVent)
-        {
-            case true when modifiers.Exists(x => !x.CanVent()):
-                couldUse = canUse = false;
-                return;
-            case false when modifiers.Exists(x => x.CanVent()):
-                couldUse = true;
-                break;
-        }
-
-        var num = float.MaxValue;
-
-        canUse = couldUse;
-        if (canUse)
-        {
-            var center = @object.Collider.bounds.center;
-            var position = __instance.transform.position;
-            num = Vector2.Distance(center, position);
-            canUse &= num <= __instance.UsableDistance && !PhysicsHelpers.AnythingBetween(@object.Collider, center, position, Constants.ShipOnlyMask, false);
-        }
-        __result = num;
-    }
-}

MiraAPI/Patches/Options/GameOptionsMenuPatch.cs

@@ -32,16 +32,25 @@ public static class GameOptionsMenuPatch
         var num = 2.1f;
         var filteredGroups =
             GameSettingMenuPatches.SelectedMod?.OptionGroups.Where(
-                x => x.GroupVisible.Invoke() && x.AdvancedRole is null) ?? [];
+                x => x.AdvancedRole is null) ?? [];
 
         foreach (var group in filteredGroups)
         {
-            var filteredOpts = group.Options.Where(x => x.Visible.Invoke()).ToList();
-            if (filteredOpts.Count == 0 || group.Header is null)
+            if (group.Options.Count == 0 || group.Header is null)
             {
                 continue;
             }
 
+            if (!group.GroupVisible.Invoke())
+            {
+                group.Header.gameObject.SetActive(false);
+                foreach (var option in group.Options)
+                {
+                    option.OptionBehaviour?.gameObject.SetActive(false);
+                }
+                continue;
+            }
+
             group.Header.gameObject.SetActive(true);
             group.Header.transform.localScale = Vector3.one * 0.63f;
             group.Header.transform.localPosition = new Vector3(-0.903f, num, -2f);

MiraAPI/Patches/Options/LobbyViewPanePatches.cs

@@ -1,12 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HarmonyLib;
+using HarmonyLib;
 using MiraAPI.PluginLoading;
 using MiraAPI.Roles;
 using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
-using Reactor.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.UI;
@@ -216,7 +215,7 @@ public static class LobbyViewPanePatches
         {
             var filteredRoles = SelectedMod.CustomRoles.Values
                 .OfType<ICustomRole>()
-                .Where(x => !x.HideSettings && x.Team == team).ToList();
+                .Where(x => !x.Configuration.HideSettings && x.Team == team).ToList();
 
             if (filteredRoles.Count == 0)
             {
@@ -285,7 +284,7 @@ public static class LobbyViewPanePatches
                     chancePerGame,
                     61,
                     customRole.RoleColor,
-                    customRole.Icon.LoadAsset(),
+                    customRole.Configuration.Icon.LoadAsset(),
                     true);
 
                 viewSettingsInfoPanelRoleVariant.titleText.color =
@@ -370,7 +369,7 @@ public static class LobbyViewPanePatches
             role.StringName,
             maskLayer,
             role.TeamType == RoleTeamTypes.Crewmate,
-            customRole.Icon.LoadAsset());
+            customRole.Configuration.Icon.LoadAsset());
         viewPanel.divider.material.SetInt(PlayerMaterial.MaskLayer, maskLayer);
 
         var num = viewPanel.yPosStart;
@@ -390,11 +389,6 @@ public static class LobbyViewPanePatches
 
             var value = option.GetFloatData();
 
-            if (baseGameSetting == null)
-            {
-                continue;
-            }
-
             if (baseGameSetting.Type == OptionTypes.Checkbox)
             {
                 viewSettingsInfoPanel.SetInfoCheckbox(baseGameSetting.Title, maskLayer, value > 0f);

MiraAPI/Patches/Options/NotificationPopperPatch.cs

@@ -27,12 +27,12 @@ public static class NotificationPopperPatch
             ? Palette.CrewmateSettingChangeText.ToTextColor()
             : Palette.ImpostorRed.ToTextColor();
 
-        var item = DestroyableSingleton<TranslationController>.Instance.GetString(
+        var item = TranslationController.Instance.GetString(
             StringNames.LobbyChangeSettingNotificationRole,
             string.Concat(
                 "<font=\"Barlow-Black SDF\" material=\"Barlow-Black Outline\">",
                 text,
-                DestroyableSingleton<TranslationController>.Instance.GetString(key, Array.Empty<Object>()),
+                TranslationController.Instance.GetString(key, Array.Empty<Object>()),
                 "</color></font>"
             ),
             "<font=\"Barlow-Black SDF\" material=\"Barlow-Black Outline\">" + roleCount + "</font>",

MiraAPI/Patches/Options/OptionsPatches.cs

@@ -17,7 +17,7 @@ public static class OptionsPatches
         }
 
         __instance.TitleText.text =
-            DestroyableSingleton<TranslationController>.Instance.GetString(__instance.Title, Array.Empty<Object>());
+            TranslationController.Instance.GetString(__instance.Title, Array.Empty<Object>());
 
         return false;
     }
@@ -39,7 +39,7 @@ public static class OptionsPatches
         }
 
         __instance.TitleText.text =
-            DestroyableSingleton<TranslationController>.Instance.GetString(__instance.Title, Array.Empty<Object>());
+            TranslationController.Instance.GetString(__instance.Title, Array.Empty<Object>());
 
         return false;
     }
@@ -61,8 +61,8 @@ public static class OptionsPatches
         }
 
         __instance.TitleText.text =
-            DestroyableSingleton<TranslationController>.Instance.GetString(__instance.Title, Array.Empty<Object>());
-        __instance.ValueText.text = DestroyableSingleton<TranslationController>.Instance.GetString(
+            TranslationController.Instance.GetString(__instance.Title, Array.Empty<Object>());
+        __instance.ValueText.text = TranslationController.Instance.GetString(
             __instance.Values[__instance.Value],
             Array.Empty<Object>());
 

MiraAPI/Patches/Options/RoleSettingMenuPatches.cs

@@ -56,7 +56,7 @@ public static class RoleSettingMenuPatches
 
         var crewRoles = GameSettingMenuPatches.SelectedMod?.CustomRoles.Values
             .OfType<ICustomRole>()
-            .Where(role => role is { Team: ModdedRoleTeams.Crewmate, HideSettings: false })
+            .Where(role => role is { Team: ModdedRoleTeams.Crewmate, Configuration.HideSettings: false })
             .ToList() ?? [];
 
         if (crewRoles is { Count: > 0 })
@@ -82,7 +82,7 @@ public static class RoleSettingMenuPatches
 
         var impRoles = GameSettingMenuPatches.SelectedMod?.CustomRoles.Values
             .OfType<ICustomRole>()
-            .Where(role => role is { Team: ModdedRoleTeams.Impostor, HideSettings: false })
+            .Where(role => role is { Team: ModdedRoleTeams.Impostor, Configuration.HideSettings: false })
             .ToList() ?? [];
 
         if (impRoles is { Count: > 0 })
@@ -109,7 +109,7 @@ public static class RoleSettingMenuPatches
 
         var neutRoles = GameSettingMenuPatches.SelectedMod?.CustomRoles.Values
             .OfType<ICustomRole>()
-            .Where(role => role is { Team: ModdedRoleTeams.Neutral, HideSettings: false })
+            .Where(role => role is { Team: ModdedRoleTeams.Neutral, Configuration.HideSettings: false })
             .ToList() ?? [];
 
         if (neutRoles is { Count: > 0 })
@@ -159,18 +159,22 @@ public static class RoleSettingMenuPatches
     {
         var roleSetting = obj.Cast<RoleOptionSetting>();
         var role = roleSetting.Role as ICustomRole;
-        if (role is null or { HideSettings: true })
+        if (role is null or { Configuration.HideSettings: true })
         {
             return;
         }
 
         try
         {
-            role.ParentMod.PluginConfig.TryGetEntry<int>(role.NumConfigDefinition, out var numEntry);
-            numEntry.Value = roleSetting.RoleMaxCount;
+            if (role.Configuration.MaxRoleCount != 0)
+            {
+                role.SetCount(roleSetting.RoleMaxCount);
+            }
 
-            role.ParentMod.PluginConfig.TryGetEntry<int>(role.ChanceConfigDefinition, out var chanceEntry);
-            chanceEntry.Value = roleSetting.RoleChance;
+            if (role.Configuration.CanModifyChance)
+            {
+                role.SetChance(roleSetting.RoleChance);
+            }
         }
         catch (Exception e)
         {
@@ -178,7 +182,7 @@ public static class RoleSettingMenuPatches
         }
 
         roleSetting.UpdateValuesAndText(GameOptionsManager.Instance.CurrentGameOptions.RoleOptions);
-        DestroyableSingleton<HudManager>.Instance.Notifier.AddRoleSettingsChangeMessage(
+        HudManager.Instance.Notifier.AddRoleSettingsChangeMessage(
             roleSetting.Role.StringName,
             roleSetting.RoleMaxCount,
             roleSetting.RoleChance,
@@ -228,7 +232,7 @@ public static class RoleSettingMenuPatches
                 renderer.material.SetInt(PlayerMaterial.MaskLayer, 20);
             }
 
-            foreach (var fontMat in newOpt.GetComponentsInChildren<TextMeshPro>(true).Select(x=>x.fontMaterial))
+            foreach (var fontMat in newOpt.GetComponentsInChildren<TextMeshPro>(true).Select(x => x.fontMaterial))
             {
                 fontMat.SetFloat(ShaderID.StencilComp, 3f);
                 fontMat.SetFloat(ShaderID.Stencil, 20);
@@ -254,11 +258,11 @@ public static class RoleSettingMenuPatches
         }
 
         __instance.roleDescriptionText.text = customRole.RoleLongDescription;
-        __instance.roleTitleText.text = DestroyableSingleton<TranslationController>.Instance.GetString(
+        __instance.roleTitleText.text = TranslationController.Instance.GetString(
             role.StringName,
             new Il2CppReferenceArray<Il2CppSystem.Object>(0));
         __instance.roleScreenshot.sprite = Sprite.Create(
-            customRole.OptionsScreenshot.LoadAsset().texture,
+            customRole.Configuration.OptionsScreenshot.LoadAsset().texture,
             new Rect(0, 0, 370, 230),
             Vector2.one / 2,
             100);
@@ -305,6 +309,7 @@ public static class RoleSettingMenuPatches
             Quaternion.identity,
             __instance.RoleChancesSettings.transform);
         roleOptionSetting.transform.localPosition = new Vector3(-0.15f, yPos, -2f);
+
         roleOptionSetting.SetRole(GameOptionsManager.Instance.CurrentGameOptions.RoleOptions, role, 20);
         roleOptionSetting.labelSprite.color = customRole.RoleColor;
         roleOptionSetting.OnValueChanged = new Action<OptionBehaviour>(ValueChanged);
@@ -336,6 +341,18 @@ public static class RoleSettingMenuPatches
             passiveButton.OnClick.AddListener((UnityAction)(() => { ChangeTab(role, __instance); }));
         }
 
+        if (customRole.Configuration is { MaxRoleCount: 0 })
+        {
+            roleOptionSetting.CountMinusBtn.gameObject.SetActive(false);
+            roleOptionSetting.CountPlusBtn.gameObject.SetActive(false);
+        }
+
+        if (!customRole.Configuration.CanModifyChance)
+        {
+            roleOptionSetting.ChanceMinusBtn.gameObject.SetActive(false);
+            roleOptionSetting.ChancePlusBtn.gameObject.SetActive(false);
+        }
+
         if (index < GameSettingMenuPatches.SelectedMod?.CustomRoles.Count - 1)
         {
             yPos += -0.43f;

MiraAPI/Patches/Options/SettingPatches.cs

@@ -39,7 +39,7 @@ public static class SettingPatches
                 MiraNumberSuffixes.None => value.ToString(__instance.FormatString, NumberFormatInfo.InvariantInfo),
                 MiraNumberSuffixes.Multiplier => value.ToString(__instance.FormatString, NumberFormatInfo.InvariantInfo) + "x",
                 MiraNumberSuffixes.Percent => value.ToString(__instance.FormatString, NumberFormatInfo.InvariantInfo) + "%",
-                _ => DestroyableSingleton<TranslationController>.Instance.GetString(
+                _ => TranslationController.Instance.GetString(
                     StringNames.GameSecondsAbbrev,
                     (Il2CppSystem.Object[])[value.ToString(__instance.FormatString, CultureInfo.InvariantCulture)]),
             };

MiraAPI/Patches/PlayerControlPatches.cs

@@ -1,8 +1,12 @@
 using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Gameplay;
+using MiraAPI.Events.Vanilla.Player;
 using MiraAPI.Hud;
 using MiraAPI.Modifiers;
 using MiraAPI.Roles;
 using Reactor.Utilities.Extensions;
+using System.Linq;
 
 namespace MiraAPI.Patches;
 
@@ -15,7 +19,8 @@ public static class PlayerControlPatches
     /// <summary>
     /// Adds the modifier component to the player on start.
     /// </summary>
-    [HarmonyPrefix]
+    /// <param name="__instance">PlayerControl instance.</param>
+    [HarmonyPostfix]
     [HarmonyPatch(nameof(PlayerControl.Start))]
     public static void PlayerControlStartPostfix(PlayerControl __instance)
     {
@@ -30,21 +35,59 @@ public static class PlayerControlPatches
     /// <summary>
     /// Calls the OnDeath method for all active modifiers.
     /// </summary>
+    /// <param name="__instance">PlayerControl instance.</param>
     [HarmonyPostfix]
     [HarmonyPatch(nameof(PlayerControl.Die))]
     public static void PlayerControlDiePostfix(PlayerControl __instance, DeathReason reason)
     {
+        var deathEvent = new PlayerDeathEvent(__instance, reason);
+        MiraEventManager.InvokeEvent(deathEvent);
+
         var modifiersComponent = __instance.GetComponent<ModifierComponent>();
 
         if (modifiersComponent)
         {
-            modifiersComponent.ActiveModifiers.ForEach(x=>x.OnDeath(reason));
+            modifiersComponent.ActiveModifiers.ForEach(x => x.OnDeath(reason));
         }
     }
 
+    /// <summary>
+    /// Used to trigger the <see cref="CompleteTaskEvent"/>.
+    /// </summary>
+    /// <param name="__instance">PlayerControl instance.</param>
+    /// <param name="idx">The task id.</param>
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(PlayerControl.CompleteTask))]
+    public static void PlayerCompleteTaskPostfix(PlayerControl __instance, uint idx)
+    {
+        var playerTask = __instance.myTasks.ToArray().First(playerTask => playerTask.Id == idx);
+        if (playerTask != null)
+        {
+            var completeTaskEvent = new CompleteTaskEvent(__instance, playerTask);
+            MiraEventManager.InvokeEvent(completeTaskEvent);
+        }
+    }
+
+    /// <summary>
+    /// Used to trigger the <see cref="BeforeMurderEvent"/>.
+    /// </summary>
+    /// <param name="__instance">The source player.</param>
+    /// <param name="target">The target.</param>
+    /// <param name="didSucceed">Whether the kill succeeded.</param>
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(PlayerControl.RpcMurderPlayer))]
+    public static void PlayerControlMurderPrefix(PlayerControl __instance, PlayerControl target, ref bool didSucceed)
+    {
+        var beforeMurderEvent = new BeforeMurderEvent(__instance, target);
+        MiraEventManager.InvokeEvent(beforeMurderEvent);
+
+        didSucceed = beforeMurderEvent.IsCancelled;
+    }
+
     /// <summary>
     /// FixedUpdate handler for custom roles and custom buttons.
     /// </summary>
+    /// <param name="__instance">PlayerControl instance.</param>
     [HarmonyPostfix]
     [HarmonyPatch(nameof(PlayerControl.FixedUpdate))]
     public static void PlayerControlFixedUpdatePostfix(PlayerControl __instance)
@@ -74,4 +117,15 @@ public static class PlayerControlPatches
             button.FixedUpdateHandler(__instance);
         }
     }
+
+    /// <summary>
+    /// Clear from modifier component cache.
+    /// </summary>
+    /// <param name="__instance">PlayerControl instance.</param>
+    [HarmonyPrefix]
+    [HarmonyPatch(nameof(PlayerControl.OnDestroy))]
+    public static void PlayerControlOnDestroyPrefix(PlayerControl __instance)
+    {
+        Utilities.Extensions.ModifierComponents.Remove(__instance);
+    }
 }

MiraAPI/Patches/Roles/EjectionPatches.cs

@@ -1,4 +1,6 @@
 using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Meeting;
 using MiraAPI.Roles;
 
 namespace MiraAPI.Patches.Roles;
@@ -13,6 +15,13 @@ public static class EjectionPatches
     [HarmonyPatch(nameof(ExileController.Begin))]
     public static void BeginPostfix(ExileController __instance)
     {
+        var @event = new EjectionEvent(__instance.initData.networkedPlayer.Object, __instance);
+        MiraEventManager.InvokeEvent(@event);
+
+        if (@event.IsCancelled)
+        {
+            return;
+        }
         if (!__instance.initData.networkedPlayer || !__instance.initData.networkedPlayer.Role ||
             __instance.initData.networkedPlayer.Role is not ICustomRole role)
         {

MiraAPI/Patches/Roles/HudManagerPatches.cs

@@ -17,6 +17,10 @@ public static class HudManagerPatches
     /// <summary>
     /// Fixes Kill Button not showing for Neutral killing role.
     /// </summary>
+    /// <param name="__instance">HudManager instance.</param>
+    /// <param name="localPlayer">The local PlayerControl.</param>
+    /// <param name="role">The player's RoleBehaviour.</param>
+    /// <param name="isActive">Whether the Hud should be set active or not.</param>
     [HarmonyPostfix]
     [HarmonyPatch(nameof(HudManager.SetHudActive), typeof(PlayerControl), typeof(RoleBehaviour), typeof(bool))]
     public static void SetHudActivePostfix(
@@ -29,9 +33,9 @@ public static class HudManagerPatches
 
         if (role is ICustomRole customRole)
         {
-            __instance.KillButton.ToggleVisible(isActive && role.CanUseKillButton && !flag);
-            __instance.ImpostorVentButton.ToggleVisible(isActive && role.CanVent && !flag);
-            __instance.SabotageButton.gameObject.SetActive(isActive && customRole.CanUseSabotage);
+            __instance.KillButton.ToggleVisible(isActive && customRole.Configuration.UseVanillaKillButton && !flag);
+            __instance.ImpostorVentButton.ToggleVisible(isActive && customRole.Configuration.CanUseVent && !flag);
+            __instance.SabotageButton.gameObject.SetActive(isActive && customRole.Configuration.CanUseSabotage);
         }
 
         if (_roleTab)
@@ -56,7 +60,7 @@ public static class HudManagerPatches
 
         var role = local?.Data?.Role;
 
-        if (role is ICustomRole { RoleHintType: RoleHintType.RoleTab } customRole)
+        if (role is ICustomRole { Configuration.RoleHintType: RoleHintType.RoleTab } customRole)
         {
             customRole.HudUpdate(__instance);
 

MiraAPI/Patches/Roles/KillButtonPatches.cs

@@ -36,7 +36,7 @@ public static class KillButtonPatches
         __instance.currentTarget = target;
         if (__instance.currentTarget)
         {
-            __instance.currentTarget.cosmetics.SetOutline(true, new Nullable<Color>(customRole.KillButtonOutlineColor));
+            __instance.currentTarget.cosmetics.SetOutline(true, new Nullable<Color>(customRole.Configuration.KillButtonOutlineColor));
             __instance.SetEnabled();
             return false;
         }
@@ -52,11 +52,6 @@ public static class KillButtonPatches
     [HarmonyPatch(nameof(KillButton.DoClick))]
     public static bool DoClickPrefix(KillButton __instance)
     {
-        if (PlayerControl.LocalPlayer.Data.Role is not ICustomRole)
-        {
-            return true;
-        }
-
         if (!__instance.isActiveAndEnabled || !__instance.currentTarget || __instance.isCoolingDown ||
             PlayerControl.LocalPlayer.Data.IsDead || !PlayerControl.LocalPlayer.CanMove)
         {

MiraAPI/Patches/Roles/RoleManagerPatches.cs

@@ -37,12 +37,12 @@ public static class RoleManagerPatches
             return true;
         }
 
-        if (role.GhostRole is RoleTypes.CrewmateGhost or RoleTypes.ImpostorGhost)
+        if (role.Configuration.GhostRole is RoleTypes.CrewmateGhost or RoleTypes.ImpostorGhost)
         {
             return true;
         }
 
-        plr.RpcSetRole(role.GhostRole);
+        plr.RpcSetRole(role.Configuration.GhostRole);
         return false;
     }
 }

MiraAPI/Patches/Roles/RoleOptionsCollectionPatch.cs

@@ -1,55 +1,73 @@
 using AmongUs.GameOptions;
 using HarmonyLib;
 using MiraAPI.Roles;
+using Reactor.Utilities;
 
 namespace MiraAPI.Patches.Roles;
 
+/// <summary>
+/// Patches to return the correct role counts.
+/// </summary>
 [HarmonyPatch(typeof(RoleOptionsCollectionV08))]
 public static class RoleOptionsCollectionPatch
 {
     /// <summary>
     /// Set the role chance for custom Launchpad roles based on config
     /// </summary>
+    /// <returns>Return false to skip original method, true to not.</returns>
     [HarmonyPrefix]
     [HarmonyPatch(nameof(RoleOptionsCollectionV08.GetChancePerGame))]
-    public static bool GetChancePrefix([HarmonyArgument(0)] RoleTypes roleType, ref int __result)
+    public static bool GetChancePrefix(RoleTypes role, ref int __result)
     {
-        if (!CustomRoleManager.GetCustomRoleBehaviour(roleType, out var customRole) || customRole == null)
+        if (!CustomRoleManager.GetCustomRoleBehaviour(role, out var customRole) || customRole == null)
         {
             return true;
         }
 
-        if (customRole.HideSettings)
+        if (customRole.Configuration.HideSettings)
         {
             __result = 0;
             return false;
         }
 
-        customRole.ParentMod.PluginConfig.TryGetEntry<int>(customRole.ChanceConfigDefinition, out var entry);
-        __result = entry.Value;
+        var chance = customRole.GetChance();
+        if (chance == null)
+        {
+            Logger<MiraApiPlugin>.Error($"Chance is null, defaulting to zero.");
+            chance = 0;
+        }
+
+        __result = chance.Value;
         return false;
     }
 
     /// <summary>
     /// Set the amount for custom Launchpad roles based on config
     /// </summary>
+    /// <returns>Return false to skip original method, true to not.</returns>
     [HarmonyPrefix]
     [HarmonyPatch(nameof(RoleOptionsCollectionV08.GetNumPerGame))]
-    public static bool GetNumPrefix([HarmonyArgument(0)] RoleTypes roleType, ref int __result)
+    public static bool GetNumPrefix(RoleTypes role, ref int __result)
     {
-        if (!CustomRoleManager.GetCustomRoleBehaviour(roleType, out var customRole) || customRole == null)
+        if (!CustomRoleManager.GetCustomRoleBehaviour(role, out var customRole) || customRole == null)
         {
             return true;
         }
 
-        if (customRole.HideSettings)
+        if (customRole.Configuration.HideSettings)
         {
             __result = 0;
             return false;
         }
 
-        customRole.ParentMod.PluginConfig.TryGetEntry<int>(customRole.NumConfigDefinition, out var entry);
-        __result = entry.Value;
+        var count = customRole.GetCount();
+        if (count == null)
+        {
+            Logger<MiraApiPlugin>.Error($"Count is null, defaulting to zero.");
+            count = 0;
+        }
+
+        __result = count.Value;
         return false;
     }
 }

MiraAPI/Patches/Roles/SabotageButtonPatch.cs

@@ -20,12 +20,12 @@ public class SabotageButtonPatch
             return true;
         }
 
-        if (!customRole.CanUseSabotage || PlayerControl.LocalPlayer.inVent || !GameManager.Instance.SabotagesEnabled())
+        if (!customRole.Configuration.CanUseSabotage || PlayerControl.LocalPlayer.inVent || !GameManager.Instance.SabotagesEnabled())
         {
             return false;
         }
 
-        DestroyableSingleton<HudManager>.Instance.ToggleMapVisible(
+        HudManager.Instance.ToggleMapVisible(
             new MapOptions
             {
                 Mode = MapOptions.Modes.Sabotage,
@@ -52,7 +52,7 @@ public class SabotageButtonPatch
 
         if (player.inVent || !GameManager.Instance.SabotagesEnabled() || player.petting)
         {
-            __instance.ToggleVisible(customRole.CanUseSabotage && GameManager.Instance.SabotagesEnabled());
+            __instance.ToggleVisible(customRole.Configuration.CanUseSabotage && GameManager.Instance.SabotagesEnabled());
             __instance.SetDisabled();
             return false;
         }

MiraAPI/Patches/Roles/TaskAdderPatch.cs

@@ -1,7 +1,7 @@
 using AmongUs.GameOptions;
 using HarmonyLib;
-using Il2CppSystem;
-using Il2CppSystem.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using MiraAPI.PluginLoading;
 using MiraAPI.Roles;
 using MiraAPI.Utilities.Assets;
@@ -12,10 +12,13 @@ using Object = UnityEngine.Object;
 
 namespace MiraAPI.Patches.Roles;
 
+/// <summary>
+/// Patch TaskAdder for organizing Roles and adding scroller.
+/// </summary>
 [HarmonyPatch]
 public static class TaskAdderPatch
 {
-    private static readonly System.Collections.Generic.Dictionary<string, string> ModsFolders = [];
+    private static readonly Dictionary<string, string> ModsFolders = [];
     private static Scroller? _scroller;
 
     [HarmonyPostfix]
@@ -167,19 +170,14 @@ public static class TaskAdderPatch
 
             ControllerManager.Instance.AddSelectableUiElement(taskFolder2.Button);
             if (!string.IsNullOrEmpty(__instance.restorePreviousSelectionByFolderName) &&
-                taskFolder2.FolderName.Equals(__instance.restorePreviousSelectionByFolderName, System.StringComparison.Ordinal))
+                taskFolder2.FolderName.Equals(__instance.restorePreviousSelectionByFolderName, StringComparison.Ordinal))
             {
                 __instance.restorePreviousSelectionFound = taskFolder2.Button;
             }
         }
 
         var flag = false;
-        var list = new List<PlayerTask>();
-
-        foreach (var item in taskFolder.Children)
-        {
-            list.Add(item);
-        }
+        var list = taskFolder.Children.ToArray().OrderBy(t => t.TaskType).ToList();
 
         for (var l = 0; l < list.Count; l++)
         {
@@ -190,26 +188,24 @@ public static class TaskAdderPatch
                 case TaskTypes.DivertPower:
                 {
                     var targetSystem = taskAddButton.MyTask.Cast<DivertPowerTask>().TargetSystem;
-                    taskAddButton.Text.text = DestroyableSingleton<TranslationController>.Instance.GetString(
+                    taskAddButton.Text.text = TranslationController.Instance.GetString(
                         StringNames.DivertPowerTo,
-                        DestroyableSingleton<TranslationController>.Instance.GetString(targetSystem));
+                        TranslationController.Instance.GetString(targetSystem));
                     break;
                 }
                 case TaskTypes.FixWeatherNode:
                 {
-                    var nodeId = ((WeatherNodeTask)taskAddButton.MyTask).NodeId;
+                    var nodeId = taskAddButton.MyTask.Cast<WeatherNodeTask>().NodeId;
                     taskAddButton.Text.text =
-                        DestroyableSingleton<TranslationController>.Instance.GetString(
-                            StringNames.FixWeatherNode,
-                            Array.Empty<Il2CppSystem.Object>()) + " " +
-                        DestroyableSingleton<TranslationController>.Instance.GetString(
-                            WeatherSwitchGame.ControlNames[nodeId],
-                            Array.Empty<Il2CppSystem.Object>());
+                        TranslationController.Instance.GetString(
+                            StringNames.FixWeatherNode) + " " +
+                        TranslationController.Instance.GetString(
+                            WeatherSwitchGame.ControlNames[nodeId]);
                     break;
                 }
                 default:
                     taskAddButton.Text.text =
-                        DestroyableSingleton<TranslationController>.Instance.GetString(taskAddButton.MyTask.TaskType);
+                        TranslationController.Instance.GetString(taskAddButton.MyTask.TaskType);
                     break;
             }
 
@@ -238,9 +234,9 @@ public static class TaskAdderPatch
 
         if (taskFolder.FolderName == "Roles")
         {
-            for (var m = 0; m < DestroyableSingleton<RoleManager>.Instance.AllRoles.Length; m++)
+            for (var m = 0; m < RoleManager.Instance.AllRoles.Length; m++)
             {
-                var roleBehaviour = DestroyableSingleton<RoleManager>.Instance.AllRoles[m];
+                var roleBehaviour = RoleManager.Instance.AllRoles[m];
                 if (roleBehaviour.Role == RoleTypes.ImpostorGhost || roleBehaviour.Role == RoleTypes.CrewmateGhost ||
                     CustomRoleManager.CustomRoles.ContainsKey((ushort)roleBehaviour.Role))
                 {
@@ -275,7 +271,7 @@ public static class TaskAdderPatch
 
         if (ModsFolders.TryGetValue(taskFolder.FolderName, out var guid))
         {
-            var plugin = MiraPluginManager.Instance.GetPluginByGuid(guid);
+            var plugin = MiraPluginManager.GetPluginByGuid(guid);
             for (var m = 0; m < plugin.CustomRoles.Count; m++)
             {
                 var roleBehaviour = plugin.CustomRoles.ElementAt(m).Value;

MiraAPI/Patches/Roles/VentPatches.cs

@@ -6,12 +6,17 @@ using UnityEngine;
 namespace MiraAPI.Patches.Roles;
 
 /// <summary>
-/// Set vent outline color based on the player's role.
+/// Vent patches for Roles.
 /// </summary>
-[HarmonyPatch(typeof(Vent), nameof(Vent.SetOutline))]
-public static class VentOutlinePatch
+[HarmonyPatch(typeof(Vent))]
+public static class VentPatches
 {
-    public static void Postfix(Vent __instance, bool on, bool mainTarget)
+    /// <summary>
+    /// Set outline to player's custom role color.
+    /// </summary>
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(Vent.SetOutline))]
+    public static void SetOutlinePostfix(Vent __instance, bool on, bool mainTarget)
     {
         if (PlayerControl.LocalPlayer.Data.Role is not ICustomRole customRole)
         {

MiraAPI/Patches/Stubs/MinigameStubs.cs

@@ -0,0 +1,24 @@
+using System.Runtime.CompilerServices;
+using HarmonyLib;
+
+namespace MiraAPI.Patches.Stubs;
+
+/// <summary>
+/// Reverse patches for Minigames.
+/// </summary>
+[HarmonyPatch]
+public static class MinigameStubs
+{
+    /// <summary>
+    /// Reverse patch for Minigame.Begin.
+    /// </summary>
+    /// <param name="instance">The Minigame instance.</param>
+    /// <param name="task">Associated PlayerTask.</param>
+    [HarmonyReversePatch]
+    [HarmonyPatch(typeof(Minigame), nameof(Minigame.Begin))]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void Begin(Minigame instance, PlayerTask? task)
+    {
+        // nothing needed
+    }
+}

MiraAPI/Patches/VentPatches.cs

@@ -0,0 +1,65 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Usables;
+using MiraAPI.Roles;
+using MiraAPI.Utilities;
+using UnityEngine;
+
+namespace MiraAPI.Patches;
+
+/// <summary>
+/// Vent patches to make sure the player is able to use the vent.
+/// </summary>
+[HarmonyPatch(typeof(Vent))]
+public static class VentPatches
+{
+    /// <summary>
+    /// CanUse patch.
+    /// </summary>
+    [HarmonyPostfix]
+    [HarmonyPatch(nameof(Vent.CanUse))]
+    public static void VentCanUsePostfix(Vent __instance, ref float __result, [HarmonyArgument(0)] NetworkedPlayerInfo pc, [HarmonyArgument(1)] ref bool canUse, [HarmonyArgument(2)] ref bool couldUse)
+    {
+        var @event = new PlayerCanUseEvent(__instance.Cast<IUsable>());
+        MiraEventManager.InvokeEvent(@event);
+
+        if (@event.IsCancelled)
+        {
+            canUse = couldUse = false;
+            return;
+        }
+
+        var @object = pc.Object;
+        var role = @object.Data.Role;
+
+        var canVent = role is ICustomRole customRole ? customRole.Configuration.CanUseVent : role.CanVent;
+        couldUse = canVent;
+
+        var modifiers = @object.GetModifierComponent()?.ActiveModifiers;
+        if (modifiers is { Count: > 0 })
+        {
+            switch (canVent)
+            {
+                case true when modifiers.Exists(x => x.CanVent().HasValue && x.CanVent() == false):
+                    couldUse = canUse = false;
+                    return;
+                case false when modifiers.Exists(x => x.CanVent().HasValue && x.CanVent() == true):
+                    couldUse = true;
+                    break;
+            }
+        }
+
+        var num = float.MaxValue;
+
+        canUse = couldUse;
+        if (canUse)
+        {
+            var center = @object.Collider.bounds.center;
+            var position = __instance.transform.position;
+            num = Vector2.Distance(center, position);
+            canUse &= num <= __instance.UsableDistance && !PhysicsHelpers.AnythingBetween(@object.Collider, center, position, Constants.ShipOnlyMask, false);
+        }
+
+        __result = num;
+    }
+}

MiraAPI/PluginLoading/MiraPluginInfo.cs

@@ -3,6 +3,8 @@ using BepInEx.Configuration;
 using MiraAPI.GameModes;
 using MiraAPI.GameOptions;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using MiraAPI.Hud;
 
 namespace MiraAPI.PluginLoading;
 
@@ -19,6 +21,42 @@ public class MiraPluginInfo
         PluginId = info.Metadata.GUID;
     }
 
+    /// <summary>
+    /// Get a read only collection of this plugin's Option Groups.
+    /// </summary>
+    /// <returns>Readonly collection of option groups.</returns>
+    public IReadOnlyCollection<AbstractOptionGroup> GetOptionGroups()
+    {
+        return OptionGroups.AsReadOnly();
+    }
+
+    /// <summary>
+    /// Gets a read only collection of this plugin's options.
+    /// </summary>
+    /// <returns>Read only collection of options.</returns>
+    public IReadOnlyCollection<IModdedOption> GetOptions()
+    {
+        return Options.AsReadOnly();
+    }
+
+    /// <summary>
+    /// Gets a read only dictionary of Role IDs and the RoleBehaviour object they are associated with.
+    /// </summary>
+    /// <returns>Read only dictionary of IDs and Roles.</returns>
+    public ReadOnlyDictionary<ushort, RoleBehaviour> GetRoles()
+    {
+        return new ReadOnlyDictionary<ushort, RoleBehaviour>(CustomRoles);
+    }
+
+    /// <summary>
+    /// Gets a read only collection of this plugin's custom buttons.
+    /// </summary>
+    /// <returns>Read only collection of buttons.</returns>
+    public IReadOnlyCollection<CustomActionButton> GetButtons()
+    {
+        return Buttons.AsReadOnly();
+    }
+
     internal List<AbstractOptionGroup> OptionGroups { get; } = [];
 
     internal List<IModdedOption> Options { get; } = [];
@@ -27,6 +65,8 @@ public class MiraPluginInfo
 
     internal Dictionary<int, CustomGameMode> GameModes { get; } = [];
 
+    internal List<CustomActionButton> Buttons { get; } = [];
+
     /// <summary>
     /// Gets the plugin's ID, as defined in the plugin's BepInEx metadata.
     /// </summary>

MiraAPI/PluginLoading/MiraPluginManager.cs

@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using BepInEx.Unity.IL2CPP;
+using BepInEx.Unity.IL2CPP;
 using MiraAPI.Colors;
+using MiraAPI.Events;
 using MiraAPI.GameOptions;
 using MiraAPI.GameOptions.Attributes;
 using MiraAPI.Hud;
@@ -12,16 +9,23 @@ using MiraAPI.Roles;
 using MiraAPI.Utilities;
 using Reactor.Networking;
 using Reactor.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 
 namespace MiraAPI.PluginLoading;
 
-internal sealed class MiraPluginManager
+/// <summary>
+/// Mira Plugin manager.
+/// </summary>
+public sealed class MiraPluginManager
 {
     private readonly Dictionary<Assembly, MiraPluginInfo> _registeredPlugins = [];
 
     internal MiraPluginInfo[] RegisteredPlugins() => [.. _registeredPlugins.Values];
 
-    public static MiraPluginManager Instance { get; private set; } = new();
+    internal static MiraPluginManager Instance { get; private set; } = new();
 
     internal void Initialize()
     {
@@ -39,7 +43,7 @@ internal sealed class MiraPluginManager
             RegisterAllOptions(assembly, info);
 
             RegisterRoleAttribute(assembly, info);
-            RegisterButtonAttribute(assembly);
+            RegisterButtonAttribute(assembly, info);
 
             RegisterColorClasses(assembly);
 
@@ -48,11 +52,17 @@ internal sealed class MiraPluginManager
             Logger<MiraApiPlugin>.Info($"Registering mod {pluginInfo.Metadata.GUID} with Mira API.");
         };
         IL2CPPChainloader.Instance.Finished += PaletteManager.RegisterAllColors;
+        IL2CPPChainloader.Instance.Finished += MiraEventManager.SortAllHandlers;
     }
 
-    public MiraPluginInfo GetPluginByGuid(string guid)
+    /// <summary>
+    /// Get a mira plugin by its GUID.
+    /// </summary>
+    /// <param name="guid">The plugin GUID.</param>
+    /// <returns>A MiraPluginInfo.</returns>
+    public static MiraPluginInfo GetPluginByGuid(string guid)
     {
-        return _registeredPlugins.Values.First(plugin => plugin.PluginId == guid);
+        return Instance._registeredPlugins.Values.First(plugin => plugin.PluginId == guid);
     }
 
     private static void RegisterAllOptions(Assembly assembly, MiraPluginInfo pluginInfo)
@@ -161,14 +171,14 @@ internal sealed class MiraPluginManager
         }
     }
 
-    private static void RegisterButtonAttribute(Assembly assembly)
+    private static void RegisterButtonAttribute(Assembly assembly, MiraPluginInfo pluginInfo)
     {
         foreach (var type in assembly.GetTypes())
         {
             var attribute = type.GetCustomAttribute<RegisterButtonAttribute>();
             if (attribute != null)
             {
-                CustomButtonManager.RegisterButton(type);
+                CustomButtonManager.RegisterButton(type, pluginInfo);
             }
         }
     }

MiraAPI/Roles/CustomRoleConfiguration.cs

@@ -0,0 +1,122 @@
+using AmongUs.GameOptions;
+using MiraAPI.Utilities.Assets;
+using UnityEngine;
+
+namespace MiraAPI.Roles;
+
+/// <summary>
+/// Used to configure the specific settings of a role.
+/// </summary>
+public struct CustomRoleConfiguration
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CustomRoleConfiguration"/> struct.
+    /// </summary>
+    /// <param name="role">The role in which you are configuring.</param>
+    public CustomRoleConfiguration(ICustomRole role)
+    {
+        var roleBehaviour = role as RoleBehaviour;
+
+        MaxRoleCount = 15;
+        DefaultRoleCount = 0;
+        DefaultChance = 0;
+
+        OptionsScreenshot = Icon = MiraAssets.Empty;
+        AffectedByLightOnAirship = role.Team == ModdedRoleTeams.Crewmate;
+        KillButtonOutlineColor = role.Team switch
+        {
+            ModdedRoleTeams.Impostor => Palette.ImpostorRed,
+            ModdedRoleTeams.Crewmate => Palette.CrewmateBlue,
+            _ => role.RoleColor,
+        };
+        RoleHintType = RoleHintType.RoleTab;
+        GhostRole = role.Team is ModdedRoleTeams.Impostor ? RoleTypes.ImpostorGhost : RoleTypes.CrewmateGhost;
+        CanGetKilled = roleBehaviour?.IsDead == false && role.Team is not ModdedRoleTeams.Impostor;
+        UseVanillaKillButton = role.Team is ModdedRoleTeams.Impostor;
+        CanUseVent = role.Team is ModdedRoleTeams.Impostor;
+        CanUseSabotage = role.Team is ModdedRoleTeams.Impostor;
+        TasksCountForProgress = role.Team is ModdedRoleTeams.Crewmate;
+        HideSettings = roleBehaviour?.IsDead == true;
+        CanModifyChance = true;
+    }
+
+    /// <summary>
+    /// Gets the hard limit of players that can have this role. This property is used to set a limit in the Role Options menu. If set to 0, the role will not be assigned at start.
+    /// </summary>
+    public int MaxRoleCount;
+
+    /// <summary>
+    /// Gets the default role count.
+    /// </summary>
+    public int DefaultRoleCount;
+
+    /// <summary>
+    /// Gets the default role chance.
+    /// </summary>
+    public int DefaultChance;
+
+    /// <summary>
+    /// Whether the chance option can be changed or not.
+    /// </summary>
+    public bool CanModifyChance;
+
+    /// <summary>
+    /// Gets the Sprite used for the Role Options menu screenshot.
+    /// </summary>
+    public LoadableAsset<Sprite> OptionsScreenshot;
+
+    /// <summary>
+    /// Gets the Sprite used for the Role Icon.
+    /// </summary>
+    public LoadableAsset<Sprite> Icon;
+
+    /// <summary>
+    /// Gets a value indicating whether the role is affected by light affectors on Airship.
+    /// </summary>
+    public bool AffectedByLightOnAirship;
+
+    /// <summary>
+    /// Gets a value indicating whether the role can be killed by vanilla murder system.
+    /// </summary>
+    public bool CanGetKilled;
+
+    /// <summary>
+    /// Gets a value indicating whether the role should use the vanilla kill button.
+    /// </summary>
+    public bool UseVanillaKillButton;
+
+    /// <summary>
+    /// Gets a value indicating whether the role can use vents.
+    /// </summary>
+    public bool CanUseVent;
+
+    /// <summary>
+    /// Gets a value indicating whether the role can use the sabotage button.
+    /// </summary>
+    public bool CanUseSabotage;
+
+    /// <summary>
+    /// Gets a value indicating whether the role's tasks count towards task progress.
+    /// </summary>
+    public bool TasksCountForProgress;
+
+    /// <summary>
+    /// Gets a value indicating whether the role should show up in the Role Options menu.
+    /// </summary>
+    public bool HideSettings;
+
+    /// <summary>
+    /// Gets the outline color for the KillButton if <see cref="UseVanillaKillButton"/> is true.
+    /// </summary>
+    public Color KillButtonOutlineColor;
+
+    /// <summary>
+    /// Gets the role hint style. See <see cref="RoleHintType"/> enum for all options.
+    /// </summary>
+    public RoleHintType RoleHintType;
+
+    /// <summary>
+    /// Gets the Ghost role that is applied when the player is killed.
+    /// </summary>
+    public RoleTypes GhostRole;
+}

MiraAPI/Roles/CustomRoleManager.cs

@@ -36,7 +36,7 @@ public static class CustomRoleManager
     {
         RoleManager.Instance.AllRoles = RoleManager.Instance.AllRoles.Concat(CustomRoles.Values).ToArray();
 
-        foreach (var role in CustomRoles.Values.Where(x=>x.IsDead))
+        foreach (var role in CustomRoles.Values.Where(x => x.IsDead))
         {
             RoleManager.GhostRoles.Add(role.Role);
         }
@@ -84,21 +84,21 @@ public static class CustomRoleManager
         roleBehaviour.StringName = CustomStringName.CreateAndRegister(customRole.RoleName);
         roleBehaviour.BlurbName = CustomStringName.CreateAndRegister(customRole.RoleDescription);
         roleBehaviour.BlurbNameLong = CustomStringName.CreateAndRegister(customRole.RoleLongDescription);
-        roleBehaviour.AffectedByLightAffectors = customRole.AffectedByLightOnAirship;
-        roleBehaviour.CanBeKilled = customRole.CanGetKilled;
-        roleBehaviour.CanUseKillButton = customRole.UseVanillaKillButton;
-        roleBehaviour.TasksCountTowardProgress = customRole.TasksCountForProgress;
-        roleBehaviour.CanVent = customRole.CanUseVent;
-        roleBehaviour.DefaultGhostRole = customRole.GhostRole;
-        roleBehaviour.MaxCount = customRole.MaxPlayers;
-        roleBehaviour.RoleScreenshot = customRole.OptionsScreenshot.LoadAsset();
+        roleBehaviour.AffectedByLightAffectors = customRole.Configuration.AffectedByLightOnAirship;
+        roleBehaviour.CanBeKilled = customRole.Configuration.CanGetKilled;
+        roleBehaviour.CanUseKillButton = customRole.Configuration.UseVanillaKillButton;
+        roleBehaviour.TasksCountTowardProgress = customRole.Configuration.TasksCountForProgress;
+        roleBehaviour.CanVent = customRole.Configuration.CanUseVent;
+        roleBehaviour.DefaultGhostRole = customRole.Configuration.GhostRole;
+        roleBehaviour.MaxCount = customRole.Configuration.MaxRoleCount;
+        roleBehaviour.RoleScreenshot = customRole.Configuration.OptionsScreenshot.LoadAsset();
 
-        if (customRole.IsGhostRole)
+        if (roleBehaviour.IsDead)
         {
             RoleManager.GhostRoles.Add(roleBehaviour.Role);
         }
 
-        var useTaskHint = customRole.RoleHintType is RoleHintType.TaskHint;
+        var useTaskHint = customRole.Configuration.RoleHintType is RoleHintType.TaskHint;
         var overridesTaskText = customRole.GetType().GetMethod("SpawnTaskHeader")?.DeclaringType == customRole.GetType();
 
         if (useTaskHint && !overridesTaskText)
@@ -108,14 +108,14 @@ public static class CustomRoleManager
 
         CustomRoles.Add(roleId, roleBehaviour);
 
-        if (customRole.HideSettings)
+        if (customRole.Configuration.HideSettings)
         {
             return roleBehaviour;
         }
 
         var config = parentMod.PluginConfig;
-        config.Bind(customRole.NumConfigDefinition, 1);
-        config.Bind(customRole.ChanceConfigDefinition, 100);
+        config.Bind(customRole.NumConfigDefinition, Mathf.Clamp(customRole.Configuration.DefaultRoleCount, 0, customRole.Configuration.MaxRoleCount));
+        config.Bind(customRole.ChanceConfigDefinition, Mathf.Clamp(customRole.Configuration.DefaultChance, 0, 100));
 
         return roleBehaviour;
     }
@@ -186,7 +186,7 @@ public static class CustomRoleManager
     internal static void SyncAllRoleSettings(int targetId = -1)
     {
         var data = CustomRoles.Values
-            .Where(x => x is ICustomRole { HideSettings: false })
+            .Where(x => x is ICustomRole { Configuration.HideSettings: false })
             .Select(x => ((ICustomRole)x).GetNetData())
             .ChunkNetData(1000);
 
@@ -216,7 +216,7 @@ public static class CustomRoleManager
             }
 
             var customRole = role as ICustomRole;
-            if (customRole is null or { HideSettings: true })
+            if (customRole is null or { Configuration.HideSettings: true })
             {
                 continue;
             }
@@ -224,19 +224,12 @@ public static class CustomRoleManager
             var num = BitConverter.ToInt32(netData.Data, 0);
             var chance = BitConverter.ToInt32(netData.Data, 4);
 
-            DestroyableSingleton<HudManager>.Instance.Notifier.AddRoleSettingsChangeMessage(role.StringName, num, chance, role.TeamType, false);
+            HudManager.Instance.Notifier.AddRoleSettingsChangeMessage(role.StringName, num, chance, role.TeamType, false);
 
             try
             {
-                customRole.ParentMod.PluginConfig.TryGetEntry<int>(
-                    customRole.NumConfigDefinition,
-                    out var numEntry);
-                customRole.ParentMod.PluginConfig.TryGetEntry<int>(
-                    customRole.ChanceConfigDefinition,
-                    out var chanceEntry);
-
-                numEntry.Value = num;
-                chanceEntry.Value = chance;
+                customRole.SetCount(num);
+                customRole.SetChance(chance);
             }
             catch (Exception e)
             {

MiraAPI/Roles/CustomRoleSingleton.cs

@@ -0,0 +1,19 @@
+using System.Linq;
+
+namespace MiraAPI.Roles;
+
+/// <summary>
+/// A utility class to get the instance of a custom role.
+/// </summary>
+/// <typeparam name="T">The role you are trying to access.</typeparam>
+public static class CustomRoleSingleton<T> where T : ICustomRole
+{
+    private static ICustomRole? _instance;
+
+    /// <summary>
+    /// Gets the instance of the role.
+    /// </summary>
+#pragma warning disable CA1000
+    public static ICustomRole Instance => _instance ??= CustomRoleManager.CustomRoles.Values.OfType<T>().Single();
+#pragma warning restore CA1000
+}

MiraAPI/Roles/ICustomRole.cs

@@ -1,11 +1,9 @@
-using System.Text;
-using AmongUs.GameOptions;
-using BepInEx.Configuration;
-using Il2CppInterop.Runtime.Attributes;
+using BepInEx.Configuration;
 using MiraAPI.Modifiers;
 using MiraAPI.PluginLoading;
 using MiraAPI.Utilities;
-using MiraAPI.Utilities.Assets;
+using Reactor.Utilities;
+using System.Text;
 using UnityEngine;
 
 namespace MiraAPI.Roles;
@@ -41,91 +39,9 @@ public interface ICustomRole
     ModdedRoleTeams Team { get; }
 
     /// <summary>
-    /// Gets the hard limit of players that can have this role. This property is used to set a limit in the Role Options menu.
+    /// Gets advanced settings of the role.
     /// </summary>
-    int MaxPlayers => 15;
-
-    /// <summary>
-    /// Gets the Sprite used for the Role Options menu screenshot.
-    /// </summary>
-    [HideFromIl2Cpp]
-    LoadableAsset<Sprite> OptionsScreenshot => MiraAssets.Empty;
-
-    /// <summary>
-    /// Gets the Sprite used for the Role Icon.
-    /// </summary>
-    [HideFromIl2Cpp]
-    LoadableAsset<Sprite> Icon => MiraAssets.Empty;
-
-    /// <summary>
-    /// Gets a value indicating whether the role is affected by light affectors on Airship.
-    /// </summary>
-    bool AffectedByLightOnAirship => Team == ModdedRoleTeams.Crewmate;
-
-    /// <summary>
-    /// Gets a value indicating whether the role can be killed by vanilla murder system.
-    /// </summary>
-    bool CanGetKilled => Team == ModdedRoleTeams.Crewmate;
-
-    /// <summary>
-    /// Gets a value indicating whether the role should use the vanilla kill button.
-    /// </summary>
-    bool UseVanillaKillButton => Team == ModdedRoleTeams.Impostor;
-
-    /// <summary>
-    /// Gets a value indicating whether the role can use vents.
-    /// </summary>
-    bool CanUseVent => Team == ModdedRoleTeams.Impostor;
-
-    /// <summary>
-    /// Gets a value indicating whether the role can use the sabotage button.
-    /// </summary>
-    bool CanUseSabotage => Team == ModdedRoleTeams.Impostor;
-
-    /// <summary>
-    /// Gets a value indicating whether the role's tasks count towards task progress.
-    /// </summary>
-    bool TasksCountForProgress => Team == ModdedRoleTeams.Crewmate;
-
-    /// <summary>
-    /// Gets a value indicating whether the role is a Ghost.
-    /// </summary>
-    bool IsGhostRole => false;
-
-    /// <summary>
-    /// Gets a value indicating whether the role should show up in the Role Options menu.
-    /// </summary>
-    bool HideSettings => IsGhostRole;
-
-    /// <summary>
-    /// Gets the outline color for the KillButton if <see cref="UseVanillaKillButton"/> is true.
-    /// </summary>
-    Color KillButtonOutlineColor => Team switch
-    {
-        ModdedRoleTeams.Impostor => Palette.ImpostorRed,
-        ModdedRoleTeams.Crewmate => Palette.CrewmateBlue,
-        _ => RoleColor,
-    };
-
-    /// <summary>
-    /// Gets the role hint style. See <see cref="RoleHintType"/> enum for all options.
-    /// </summary>
-    RoleHintType RoleHintType => RoleHintType.RoleTab;
-
-    /// <summary>
-    /// Gets the Ghost role that is applied when the player is killed.
-    /// </summary>
-    RoleTypes GhostRole => Team == ModdedRoleTeams.Impostor ? RoleTypes.ImpostorGhost : RoleTypes.CrewmateGhost;
-
-    /// <summary>
-    /// Gets the BepInEx ConfigDefinition for the amount of players that can have this role.
-    /// </summary>
-    ConfigDefinition NumConfigDefinition => new("Roles", $"Num {GetType().FullName}");
-
-    /// <summary>
-    /// Gets the BepInEx ConfigDefinition for the chance of this role being selected.
-    /// </summary>
-    ConfigDefinition ChanceConfigDefinition => new("Roles", $"Chance {GetType().FullName}");
+    CustomRoleConfiguration Configuration { get; }
 
     /// <summary>
     /// Gets the parent mod of this role.
@@ -140,6 +56,78 @@ public interface ICustomRole
     {
     }
 
+    internal ConfigDefinition NumConfigDefinition => new("Roles", $"Num {GetType().FullName}");
+    internal ConfigDefinition ChanceConfigDefinition => new("Roles", $"Chance {GetType().FullName}");
+
+    /// <summary>
+    /// Gets the role chance option.
+    /// </summary>
+    /// <returns>The role chance option.</returns>
+    public virtual int? GetChance()
+    {
+        if (!Configuration.CanModifyChance)
+        {
+            return Configuration.DefaultChance;
+        }
+
+        if (ParentMod.PluginConfig.TryGetEntry(ChanceConfigDefinition, out ConfigEntry<int> entry))
+        {
+            return Mathf.Clamp(entry.Value, 0, 100);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Gets the role count option.
+    /// </summary>
+    /// <returns>The role count option.</returns>
+    public virtual int? GetCount()
+    {
+        if (ParentMod.PluginConfig.TryGetEntry(NumConfigDefinition, out ConfigEntry<int> entry))
+        {
+            return Mathf.Clamp(entry.Value, 0, Configuration.MaxRoleCount);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Sets the role chance option.
+    /// </summary>
+    /// <param name="chance">The chance between 0 and 100.</param>
+    public virtual void SetChance(int chance)
+    {
+        if (!Configuration.CanModifyChance)
+        {
+            Logger<MiraApiPlugin>.Error($"Cannot modify chance for role: {RoleName}");
+            return;
+        }
+
+        if (ParentMod.PluginConfig.TryGetEntry(ChanceConfigDefinition, out ConfigEntry<int> entry))
+        {
+            entry.Value = Mathf.Clamp(chance, 0, 100);
+            return;
+        }
+
+        Logger<MiraApiPlugin>.Error($"Error getting chance configuration for role: {RoleName}");
+    }
+
+    /// <summary>
+    /// Sets the role count option.
+    /// </summary>
+    /// <param name="count">The amount of this role between zero and its MaxRoleCount in the Configuration.</param>
+    public virtual void SetCount(int count)
+    {
+        if (ParentMod.PluginConfig.TryGetEntry(NumConfigDefinition, out ConfigEntry<int> entry))
+        {
+            entry.Value = Mathf.Clamp(count, 0, Configuration.MaxRoleCount);
+            return;
+        }
+
+        Logger<MiraApiPlugin>.Error($"Error getting count configuration for role: {RoleName}");
+    }
+
     /// <summary>
     /// This method runs on the HudManager.Update method ONLY when the LOCAL player has this role.
     /// </summary>

MiraAPI/Roles/RoleHintType.cs

@@ -16,7 +16,7 @@ public enum RoleHintType
     TaskHint,
 
     /// <summary>
-    /// Use custom role tab.
+    /// Use Mira's custom role tab.
     /// </summary>
     RoleTab,
 }

MiraAPI/Utilities/Assets/LoadableResourceAsset.cs

@@ -7,7 +7,7 @@ namespace MiraAPI.Utilities.Assets;
 /// A utility class for loading assets from embedded resources.
 /// </summary>
 /// <param name="path">The path to the embedded resource.</param>
-public class LoadableResourceAsset(string path) : LoadableAsset<Sprite>
+public class LoadableResourceAsset(string path, float pixelsPerUnit=100f) : LoadableAsset<Sprite>
 {
     private readonly Assembly _assembly = Assembly.GetCallingAssembly();
 
@@ -19,6 +19,6 @@ public class LoadableResourceAsset(string path) : LoadableAsset<Sprite>
             return LoadedAsset;
         }
 
-        return LoadedAsset = SpriteTools.LoadSpriteFromPath(path, _assembly);
+        return LoadedAsset = SpriteTools.LoadSpriteFromPath(path, _assembly, pixelsPerUnit);
     }
 }

MiraAPI/Utilities/Assets/SpriteTools.cs

@@ -1,8 +1,5 @@
 using System;
 using System.Reflection;
-using Il2CppInterop.Runtime;
-using Il2CppInterop.Runtime.InteropTypes.Arrays;
-using Reactor.Utilities;
 using Reactor.Utilities.Extensions;
 using UnityEngine;
 
@@ -13,46 +10,26 @@ namespace MiraAPI.Utilities.Assets;
 /// </summary>
 public static class SpriteTools
 {
-    private delegate bool DLoadImage(IntPtr tex, IntPtr data, bool markNonReadable);
-
-    private static DLoadImage? _iCallLoadImage;
-
-    /// <summary>
-    /// Load an image into a texture.
-    /// </summary>
-    /// <param name="tex">The texture.</param>
-    /// <param name="data">Byte data of image.</param>
-    /// <param name="markNonReadable">Mark nonreadable.</param>
-    /// <returns>True if succeeded.</returns>
-    public static bool LoadImage(Texture2D tex, byte[] data, bool markNonReadable)
-    {
-        _iCallLoadImage ??= IL2CPP.ResolveICall<DLoadImage>("UnityEngine.ImageConversion::LoadImage");
-
-        var il2CPPArray = (Il2CppStructArray<byte>)data;
-
-        return _iCallLoadImage.Invoke(tex.Pointer, il2CPPArray.Pointer, markNonReadable);
-    }
-
     /// <summary>
     /// Load a sprite from a resource path.
     /// </summary>
     /// <param name="resourcePath">The path to the resource.</param>
     /// <returns>A sprite made from the resource.</returns>
     /// <exception cref="Exception">The resource cannot be found.</exception>
-    public static Sprite LoadSpriteFromPath(string resourcePath, Assembly assembly)
+    public static Sprite LoadSpriteFromPath(string resourcePath, Assembly assembly, float pixelsPerUnit)
     {
         var tex = new Texture2D(1, 1, TextureFormat.ARGB32, false);
         var myStream = assembly.GetManifestResourceStream(resourcePath);
         if (myStream != null)
         {
             var buttonTexture = myStream.ReadFully();
-            LoadImage(tex, buttonTexture, false);
+            tex.LoadImage(buttonTexture, false);
         }
         else
         {
-            Logger<MiraApiPlugin>.Error($"Resource not found: {resourcePath}\nReturning empty sprite!");
+            throw new ArgumentException($"Resource not found: {resourcePath}");
         }
 
-        return Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f));
+        return Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f), pixelsPerUnit);
     }
 }

MiraAPI/Utilities/Extensions.cs

@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using HarmonyLib;
 using MiraAPI.GameOptions;
 using MiraAPI.Modifiers;
@@ -8,6 +5,10 @@ using MiraAPI.Networking;
 using MiraAPI.Roles;
 using Reactor.Networking.Attributes;
 using Reactor.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using UnityEngine;
 
 namespace MiraAPI.Utilities;
@@ -17,12 +18,42 @@ namespace MiraAPI.Utilities;
 /// </summary>
 public static class Extensions
 {
+    public static IEnumerable<Type> GetTypesSafe(this Assembly assembly)
+    {
+        try
+        {
+            return assembly.GetTypes();
+        }
+        catch (ReflectionTypeLoadException ex)
+        {
+            return ex.Types.Where(t => t != null);
+        }
+        catch
+        {
+            return Enumerable.Empty<Type>();
+        }
+    }
+
     internal static NetData GetNetData(this ICustomRole role)
     {
-        role.ParentMod.PluginConfig.TryGetEntry<int>(role.NumConfigDefinition, out var numEntry);
-        role.ParentMod.PluginConfig.TryGetEntry<int>(role.ChanceConfigDefinition, out var chanceEntry);
+        var count = role.GetCount();
+        var chance = role.GetChance();
 
-        return new NetData(RoleId.Get(role.GetType()), BitConverter.GetBytes(numEntry.Value).AddRangeToArray(BitConverter.GetBytes(chanceEntry.Value)));
+        if (count == null)
+        {
+            Logger<MiraApiPlugin>.Error("Couldn't get role count for NetData, defaulting to zero.");
+            count = 0;
+        }
+
+        if (chance == null)
+        {
+            Logger<MiraApiPlugin>.Error("Couldn't get role chance for NetData, defaulting to zero.");
+            chance = 0;
+        }
+
+        return new NetData(
+            RoleId.Get(role.GetType()),
+            BitConverter.GetBytes(count.Value).AddRangeToArray(BitConverter.GetBytes(chance.Value)));
     }
 
     /// <summary>
@@ -83,7 +114,7 @@ public static class Extensions
 
             if (length > chunkSize)
             {
-                Logger<MiraApiPlugin>.Error($"NetData length is greater than chunk size: {length} > {chunkSize}");
+                Logger<MiraApiPlugin>.Info($"NetData length is greater than chunk size: {length} > {chunkSize}");
                 continue;
             }
 
@@ -112,10 +143,11 @@ public static class Extensions
     /// <returns>True if the OptionBehaviour is for a custom options, false otherwise.</returns>
     public static bool IsCustom(this OptionBehaviour optionBehaviour)
     {
-        return ModdedOptionsManager.ModdedOptions.Values.Any(opt => opt.OptionBehaviour && opt.OptionBehaviour == optionBehaviour);
+        return ModdedOptionsManager.ModdedOptions.Values.Any(
+            opt => opt.OptionBehaviour && opt.OptionBehaviour == optionBehaviour);
     }
 
-    private static readonly Dictionary<PlayerControl, ModifierComponent> ModifierComponents = [];
+    internal static Dictionary<PlayerControl, ModifierComponent> ModifierComponents { get; } = [];
 
     /// <summary>
     /// Gets the ModifierComponent for a player.
@@ -130,11 +162,12 @@ public static class Extensions
         }
 
         component = player.GetComponent<ModifierComponent>();
-        if (component)
+        if (component == null)
         {
-            ModifierComponents[player] = component;
+            return null;
         }
 
+        ModifierComponents[player] = component;
         return component;
     }
 
@@ -154,6 +187,7 @@ public static class Extensions
             randomizedList.Add(list[index]);
             list.RemoveAt(index);
         }
+
         return randomizedList;
     }
 
@@ -176,7 +210,8 @@ public static class Extensions
     /// <returns>True if the Modifier is present, false otherwise.</returns>
     public static bool HasModifier<T>(this PlayerControl? player) where T : BaseModifier
     {
-        return player?.GetModifierComponent() != null && player.GetModifierComponent()!.ActiveModifiers.Exists(x => x is T);
+        return player?.GetModifierComponent() != null &&
+               player.GetModifierComponent()!.HasModifier<T>();
     }
 
     /// <summary>
@@ -187,7 +222,8 @@ public static class Extensions
     /// <returns>True if the Modifier is present, false otherwise.</returns>
     public static bool HasModifier(this PlayerControl? player, uint id)
     {
-        return player?.GetModifierComponent() != null && player.GetModifierComponent()!.ActiveModifiers.Exists(x => x.ModifierId == id);
+        return player?.GetModifierComponent() != null &&
+               player.GetModifierComponent()!.HasModifier(id);
     }
 
     /// <summary>
@@ -233,6 +269,7 @@ public static class Extensions
             Logger<MiraApiPlugin>.Error($"Cannot add modifier with id {modifierId} because it is not registered.");
             return;
         }
+
         target.GetModifierComponent()?.AddModifier(type);
     }
 
@@ -304,37 +341,82 @@ public static class Extensions
     /// <returns>The dead body if it is found, or null there is none within the radius.</returns>
     public static DeadBody? GetNearestDeadBody(this PlayerControl playerControl, float radius)
     {
-        return Helpers.GetNearestDeadBodies(playerControl.GetTruePosition(), radius).Find(component => component && !component.Reported);
+        return Helpers
+            .GetNearestDeadBodies(playerControl.GetTruePosition(), radius, Helpers.CreateFilter(Constants.NotShipMask))
+            .Find(component => component && !component.Reported);
     }
 
+    /// <summary>
+    /// Get all living players.
+    /// </summary>
+    /// <returns>A list of alive players.</returns>
+    public static List<PlayerControl> GetAlivePlayers()
+    {
+        return PlayerControl.AllPlayerControls.ToArray().Where(x => !x.Data.IsDead).ToList();
+    }
+
+
     /// <summary>
     /// Finds the nearest object of a specified type to a player. It will only work if the object has a collider.
     /// </summary>
     /// <param name="playerControl">The player object.</param>
     /// <param name="radius">The radius to search within.</param>
+    /// <param name="filter">The contact filter.</param>
     /// <param name="colliderTag">An optional collider tag.</param>
     /// <param name="predicate">Optional predicate to test if the object is valid.</param>
     /// <typeparam name="T">The type of the object.</typeparam>
     /// <returns>The object if it was found, or null if there is none within the radius.</returns>
-    public static T? GetNearestObjectOfType<T>(this PlayerControl playerControl, float radius, string? colliderTag = null, Predicate<T>? predicate = null) where T : Component
+    public static T? GetNearestObjectOfType<T>(
+        this PlayerControl playerControl,
+        float radius,
+        ContactFilter2D filter,
+        string? colliderTag = null,
+        Predicate<T>? predicate = null) where T : Component
     {
-        return Helpers.GetNearestObjectsOfType<T>(playerControl.GetTruePosition(), radius, colliderTag).Find(predicate ?? (component => component));
+        return Helpers.GetNearestObjectsOfType<T>(playerControl.GetTruePosition(), radius, filter, colliderTag)
+            .Find(predicate ?? (component => component));
     }
 
     /// <summary>
-    /// Gets the nearest player to a player.
+    /// Gets the closest player that matches the given criteria.
     /// </summary>
     /// <param name="playerControl">The player object.</param>
     /// <param name="includeImpostors">Whether impostors should be included in the search.</param>
     /// <param name="distance">The radius to search within.</param>
     /// <param name="ignoreColliders">Whether colliders should be ignored when searching.</param>
+    /// <param name="predicate">Optional predicate to test if the object is valid.</param>
     /// <returns>The closest player if there is one, false otherwise.</returns>
-    public static PlayerControl? GetClosestPlayer(this PlayerControl playerControl, bool includeImpostors, float distance, bool ignoreColliders = false)
+    public static PlayerControl? GetClosestPlayer(
+        this PlayerControl playerControl,
+        bool includeImpostors,
+        float distance,
+        bool ignoreColliders = false,
+        Predicate<PlayerControl>? predicate = null)
     {
         var filteredPlayers = Helpers.GetClosestPlayers(playerControl, distance, ignoreColliders)
-            .Where(playerInfo => !playerInfo.Data.Disconnected && playerInfo.PlayerId != playerControl.PlayerId && !playerInfo.Data.IsDead &&
-                                 (includeImpostors || !playerInfo.Data.Role.IsImpostor));
+            .Where(
+                playerInfo => !playerInfo.Data.Disconnected &&
+                              playerInfo.PlayerId != playerControl.PlayerId &&
+                              !playerInfo.Data.IsDead &&
+                              (includeImpostors || !playerInfo.Data.Role.IsImpostor))
+            .ToList();
 
-        return filteredPlayers.FirstOrDefault();
+        return predicate != null ? filteredPlayers.Find(predicate) : filteredPlayers.FirstOrDefault();
+    }
+
+    private static readonly int _outline = Shader.PropertyToID("_Outline");
+    private static readonly int _outlineColor = Shader.PropertyToID("_OutlineColor");
+    private static readonly int _addColor = Shader.PropertyToID("_AddColor");
+
+    /// <summary>
+    /// Fixed version of Reactor's SetOutline.
+    /// </summary>
+    /// <param name="renderer">The renderer you want to update the outline for.</param>
+    /// <param name="color">The outline color.</param>
+    public static void UpdateOutline(this Renderer renderer, Color? color)
+    {
+        renderer.material.SetFloat(_outline, color.HasValue ? 1 : 0);
+        renderer.material.SetColor(_outlineColor, color.HasValue ? color.Value : Color.clear);
+        renderer.material.SetColor(_addColor, color.HasValue ? color.Value : Color.clear);
     }
 }

MiraAPI/Utilities/Helpers.cs

@@ -1,4 +1,5 @@
-using MiraAPI.Roles;
+using System.Collections;
+using MiraAPI.Roles;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -15,12 +16,23 @@ namespace MiraAPI.Utilities;
 public static class Helpers
 {
     /// <summary>
-    /// NotShipMask filter for collisions.
+    /// Returns an empty coroutine.
     /// </summary>
-    public static readonly ContactFilter2D Filter = ContactFilter2D.CreateLegacyFilter(
-        Constants.NotShipMask,
-        float.MinValue,
-        float.MaxValue);
+    /// <returns>Empty coroutine.</returns>
+    public static IEnumerator EmptyCoroutine()
+    {
+        yield break;
+    }
+
+    /// <summary>
+    /// Creates a ContactFilter2D from a layer mask.
+    /// </summary>
+    /// <param name="layerMask">The layer mask.</param>
+    /// <returns>A new ContactFilter2D that represents the layer mask.</returns>
+    public static ContactFilter2D CreateFilter(int layerMask)
+    {
+        return ContactFilter2D.CreateLegacyFilter(layerMask, float.MinValue, float.MaxValue);
+    }
 
     /// <summary>
     /// Get the room at a specific position.
@@ -29,7 +41,7 @@ public static class Helpers
     /// <returns>The ship room if its found.</returns>
     public static PlainShipRoom? GetRoom(Vector3 pos)
     {
-        return ShipStatus.Instance.AllRooms.ToList().Find(room => room.roomArea.OverlapPoint(pos));
+        return ShipStatus.Instance.AllRooms.FirstOrDefault(room => room.roomArea.OverlapPoint(pos));
     }
 
     /// <summary>
@@ -37,11 +49,12 @@ public static class Helpers
     /// </summary>
     /// <param name="source">The source location.</param>
     /// <param name="radius">The radius to search in.</param>
+    /// <param name="filter">The contact filter.</param>
     /// <returns>A list of dead bodies.</returns>
-    public static List<DeadBody> GetNearestDeadBodies(Vector2 source, float radius)
+    public static List<DeadBody> GetNearestDeadBodies(Vector2 source, float radius, ContactFilter2D filter)
     {
         var results = new Il2CppSystem.Collections.Generic.List<Collider2D>();
-        Physics2D.OverlapCircle(source, radius, Filter, results);
+        Physics2D.OverlapCircle(source, radius, filter, results);
         return results.ToArray()
             .Where(collider2D => collider2D.CompareTag("DeadBody"))
             .Select(collider2D => collider2D.GetComponent<DeadBody>()).ToList();
@@ -52,14 +65,15 @@ public static class Helpers
     /// </summary>
     /// <param name="source">The source point.</param>
     /// <param name="radius">The radius to search in.</param>
+    /// <param name="filter">The contact filter.</param>
     /// <param name="colliderTag">An optional collider tag.</param>
     /// <typeparam name="T">The type of the object.</typeparam>
     /// <returns>A list of objects of type T.</returns>
-    public static List<T> GetNearestObjectsOfType<T>(Vector2 source, float radius, string? colliderTag = null)
+    public static List<T> GetNearestObjectsOfType<T>(Vector2 source, float radius, ContactFilter2D filter, string? colliderTag = null)
         where T : Component
     {
         var results = new Il2CppSystem.Collections.Generic.List<Collider2D>();
-        Physics2D.OverlapCircle(source, radius, Filter, results);
+        Physics2D.OverlapCircle(source, radius, filter, results);
         return results.ToArray()
             .Where(collider2D => colliderTag == null || collider2D.CompareTag(colliderTag))
             .Select(collider2D => collider2D.GetComponent<T>()).ToList();
@@ -77,7 +91,7 @@ public static class Helpers
         float radius,
         bool ignoreColliders = true)
     {
-        var newList = GetNearestObjectsOfType<PlayerControl>(source, radius);
+        var newList = GetNearestObjectsOfType<PlayerControl>(source, radius, CreateFilter(Constants.NotShipMask));
 
         if (!ignoreColliders)
         {