copy new meeting event from voting branch

Optionable Types

.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.9</VersionPrefix>
+        <VersionPrefix>0.2.0</VersionPrefix>
         <VersionSuffix>dev</VersionSuffix>
 
         <Authors>All Of Us, XtraCube, Angxl</Authors>

MiraAPI.Example/Buttons/Freezer/FreezeButton.cs

@@ -3,19 +3,21 @@ using MiraAPI.Example.Options.Roles;
 using MiraAPI.Example.Roles;
 using MiraAPI.GameOptions;
 using MiraAPI.Hud;
+using MiraAPI.Modifiers;
 using MiraAPI.Utilities;
 using MiraAPI.Utilities.Assets;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons.Freezer;
 
-[RegisterButton]
 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

@@ -1,20 +1,17 @@
 using MiraAPI.Example.Modifiers;
 using MiraAPI.Hud;
-using MiraAPI.Utilities;
+using MiraAPI.Modifiers;
 using MiraAPI.Utilities.Assets;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons;
 
-[RegisterButton]
 public class MeetingButton : CustomActionButton
 {
     public override string Name => "Call Meeting";
 
     public override float Cooldown => 15;
 
-    public override float EffectDuration => 0;
-
     public override int MaxUses => 3;
 
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.ExampleButton;

MiraAPI.Example/Buttons/NeutralKillerButton.cs

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

MiraAPI.Example/Buttons/Teleporter/TeleportButton.cs

@@ -1,14 +1,14 @@
-using MiraAPI.Example.Options.Roles;
+using System.Collections;
+using MiraAPI.Example.Options.Roles;
 using MiraAPI.Example.Roles;
 using MiraAPI.GameOptions;
 using MiraAPI.Hud;
 using MiraAPI.Utilities.Assets;
 using Reactor.Utilities;
-using System.Collections;
 using UnityEngine;
 
 namespace MiraAPI.Example.Buttons.Teleporter;
-[RegisterButton]
+
 public class TeleportButton : CustomActionButton
 {
     public override string Name => "Teleport";
@@ -16,16 +16,17 @@ public class TeleportButton : CustomActionButton
     public override float Cooldown => OptionGroupSingleton<TeleporterOptions>.Instance.TeleportCooldown.Value;
 
     public override float EffectDuration => OptionGroupSingleton<TeleporterOptions>.Instance.TeleportDuration;
-
-    public override int MaxUses => 0;
+    public override int MaxUses => 2;
 
     public override LoadableAsset<Sprite> Sprite => ExampleAssets.TeleportButton;
+    public override Color TextOutlineColor => new Color32(221, 176, 152, 255);
     public static bool IsZoom { get; private set; }
 
     public override bool Enabled(RoleBehaviour? role)
     {
         return role is TeleporterRole;
     }
+
     protected override void OnClick()
     {
         Coroutines.Start(ZoomOutCoroutine());

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()
+    {
+        // You can register event handlers with the MiraEventManager class.
+        MiraEventManager.RegisterEventHandler<BeforeMurderEvent>(@event =>
+        {
+            Logger<ExamplePlugin>.Info($"{@event.Source.Data.PlayerName} is about to kill {@event.Target.Data.PlayerName}");
+        });
+
+        MiraEventManager.RegisterEventHandler<AfterMurderEvent>(@event =>
+        {
+            Logger<ExamplePlugin>.Info($"{@event.Source.Data.PlayerName} has killed {@event.Target.Data.PlayerName}");
+        });
+
+        MiraEventManager.RegisterEventHandler<CompleteTaskEvent>(@event =>
+        {
+            Logger<ExamplePlugin>.Info($"{@event.Player.Data.PlayerName} completed {@event.Task.TaskType.ToString()}");
+        });
+    }
+
+    // Events can be registered using an attribute as well.
+    [RegisterEvent]
+    public static void UpdateSystemEventHandler(UpdateSystemEvent @event)
+    {
+        Logger<ExamplePlugin>.Error(@event.SystemType.ToString());
+    }
+
+    // Example event handler
+    [RegisterEvent(1)]
+    public static void FreezeButtonClickHandler(MiraButtonClickEvent<FreezeButton> @event)
+    {
+        Logger<ExamplePlugin>.Warning("Freeze button clicked!");
+
+        if (PlayerControl.LocalPlayer.Data.PlayerName == "stupid")
+        {
+            @event.Cancel();
+            @event.Button.SetTimer(15f);
+        }
+    }
+
+    // Example event handler
+    [RegisterEvent]
+    public static void FreezeButtonCancelledHandler(MiraButtonCancelledEvent<FreezeButton> @event)
+    {
+        Logger<ExamplePlugin>.Warning("Freeze button cancelled!");
+        @event.Button.OverrideName("Freeze Canceled");
+    }
+}

MiraAPI.Example/ExamplePlugin.cs

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

MiraAPI.Example/GameOver/NeutralKillerGameOver.cs

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

MiraAPI.Example/Modifiers/CaptainModifier.cs

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

MiraAPI.Example/Modifiers/Freezer/FreezeModifier.cs

@@ -1,12 +1,10 @@
 using Il2CppSystem;
 using MiraAPI.Example.Roles;
-using MiraAPI.Modifiers;
 using MiraAPI.Modifiers.Types;
 using UnityEngine;
 
 namespace MiraAPI.Example.Modifiers.Freezer;
 
-[RegisterModifier]
 public class FreezeModifier : TimedModifier
 {
     public override string ModifierName => "Freezed";

MiraAPI.Example/Modifiers/HighPriorityModifier.cs

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

MiraAPI.Example/Options/ExampleOptions.cs

@@ -16,7 +16,7 @@ public class ExampleOptions : AbstractOptionGroup
     [ModdedToggleOption("Toggle Opt 2")]
     public bool ToggleOpt2 { get; set; } = true;
 
-    [ModdedNumberOption("Number Opt", min: 0, max: 10, suffixType: MiraNumberSuffixes.Percent)]
+    [ModdedNumberOption("Number Opt", min: 0, max: 10, increment: .25f, formatString: "0.00", suffixType: MiraNumberSuffixes.Percent)]
     public float NumberOpt { get; set; } = 4f;
 
     [ModdedEnumOption("Best API", typeof(BestApi), ["Mira API", "Mitochondria", "Reactor"])]

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/Options/Modifiers/CaptainModifierSettings.cs

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

MiraAPI.Example/Options/Modifiers/FreezeModifierSettings.cs

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

MiraAPI.Example/Options/Modifiers/GeneralModifierOptions.cs

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

MiraAPI.Example/Options/Roles/FreezerRoleSettings.cs

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

MiraAPI.Example/Options/Roles/TeleporterOptions.cs

@@ -1,5 +1,4 @@
-using System;
-using MiraAPI.Example.Roles;
+using MiraAPI.Example.Roles;
 using MiraAPI.GameOptions;
 using MiraAPI.GameOptions.Attributes;
 using MiraAPI.GameOptions.OptionTypes;
@@ -7,12 +6,10 @@ using MiraAPI.Utilities;
 
 namespace MiraAPI.Example.Options.Roles;
 
-public class TeleporterOptions : AbstractOptionGroup
+public class TeleporterOptions : AbstractOptionGroup<TeleporterRole>
 {
     public override string GroupName => "Teleporter";
 
-    public override Type AdvancedRole => typeof(TeleporterRole);
-
     public ModdedNumberOption TeleportCooldown { get; set; } = new("Teleport Cooldown", 10, 5, 60, 2.5f, MiraNumberSuffixes.Seconds);
 
     [ModdedNumberOption("Teleport Duration", 5, 25, 1, MiraNumberSuffixes.Seconds)]

MiraAPI.Example/Roles/ChameleonRole.cs

@@ -4,7 +4,6 @@ using UnityEngine;
 
 namespace MiraAPI.Example.Roles;
 
-[RegisterCustomRole]
 public class ChameloenRole : CrewmateRole, ICustomRole
 {
     public string RoleName => "Chamelon";

MiraAPI.Example/Roles/FreezerRole.cs

@@ -3,7 +3,6 @@ using UnityEngine;
 
 namespace MiraAPI.Example.Roles;
 
-[RegisterCustomRole]
 public class FreezerRole : ImpostorRole, ICustomRole
 {
     public string RoleName => "Freezer";

MiraAPI.Example/Roles/NeutralKillerRole.cs

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

MiraAPI.Example/Roles/TeleporterRole.cs

@@ -3,7 +3,6 @@ using UnityEngine;
 
 namespace MiraAPI.Example.Roles;
 
-[RegisterCustomRole]
 public class TeleporterRole : CrewmateRole, ICustomRole
 {
     public string RoleName => "Teleporter";
@@ -19,4 +18,9 @@ public class TeleporterRole : CrewmateRole, ICustomRole
         DefaultChance = 73,
         DefaultRoleCount = 4,
     };
+
+    public bool CanLocalPlayerSeeRole(PlayerControl player)
+    {
+        return true;
+    }
 }

MiraAPI/Events/Mira/MiraButtonCancelledEvent.cs

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

MiraAPI/Events/Mira/MiraButtonClickEvent.cs

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

MiraAPI/Events/MiraCancelableEvent.cs

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

MiraAPI/Events/MiraEvent.cs

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

MiraAPI/Events/MiraEventManager.cs

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

MiraAPI/Events/MiraEventWrapper.cs

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

MiraAPI/Events/RegisterEventAttribute.cs

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

MiraAPI/Events/Vanilla/Gameplay/AfterMurderEvent.cs

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

MiraAPI/Events/Vanilla/Gameplay/BeforeMurderEvent.cs

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

MiraAPI/Events/Vanilla/Gameplay/GameEndEvent.cs

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

MiraAPI/Events/Vanilla/Gameplay/IntroBeginEvent.cs

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

MiraAPI/Events/Vanilla/Gameplay/SetRoleEvent.cs

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

MiraAPI/Events/Vanilla/Map/CloseDoorsEvent.cs

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

MiraAPI/Events/Vanilla/Map/PlayerOpenSabotageEvent.cs

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

MiraAPI/Events/Vanilla/Map/UpdateSystemEvent.cs

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

MiraAPI/Events/Vanilla/Meeting/EjectionEvent.cs

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

MiraAPI/Events/Vanilla/Meeting/ReportBodyEvent.cs

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

MiraAPI/Events/Vanilla/Meeting/StartMeetingEvent.cs

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

MiraAPI/Events/Vanilla/Player/CompleteTaskEvent.cs

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

MiraAPI/Events/Vanilla/Player/PlayerDeathEvent.cs

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

MiraAPI/Events/Vanilla/Player/PlayerJoinEvent.cs

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

MiraAPI/Events/Vanilla/Player/PlayerLeaveEvent.cs

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

MiraAPI/Events/Vanilla/Usables/EnterVentEvent.cs

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

MiraAPI/Events/Vanilla/Usables/ExitVentEvent.cs

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

MiraAPI/Events/Vanilla/Usables/PlayerCanUseEvent.cs

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

MiraAPI/Events/Vanilla/Usables/PlayerUseEvent.cs

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

MiraAPI/GameEnd/CustomGameOver.cs

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

MiraAPI/GameEnd/GameOverData.cs

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

MiraAPI/GameEnd/GameOverManager.cs

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

MiraAPI/GameModes/CustomGameModeManager.cs

@@ -1,7 +1,7 @@
-using Reactor.Utilities;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using Reactor.Utilities;
 
 namespace MiraAPI.GameModes;
 

MiraAPI/GameModes/DefaultMode.cs

@@ -1,6 +1,5 @@
 namespace MiraAPI.GameModes;
 
-[RegisterGameMode]
 public class DefaultMode : CustomGameMode
 {
     public override string Name => "Default";

MiraAPI/GameModes/RegisterGameModeAttribute.cs

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

MiraAPI/GameOptions/AbstractOptionGroup.cs

@@ -16,6 +16,17 @@ public abstract class AbstractOptionGroup
     /// </summary>
     public abstract string GroupName { get; }
 
+    /// <summary>
+    /// Gets the Optionable type of the group.
+    /// </summary>
+    public virtual Type? OptionableType => null;
+
+    /// <summary>
+    /// Gets a value indicating whether the group should be shown in the modifiers menu.
+    /// </summary>
+    // TODO: make this not a boolean
+    public virtual bool ShowInModifiersMenu => false;
+
     /// <summary>
     /// Gets the function that determines whether the group should be visible or not.
     /// </summary>
@@ -32,12 +43,17 @@ public abstract class AbstractOptionGroup
     /// </summary>
     public virtual uint GroupPriority => uint.MaxValue;
 
-    /// <summary>
-    /// Gets the role the group is associated with. This is used for the advanced role options menu.
-    /// </summary>
-    public virtual Type? AdvancedRole => null;
-
     internal bool AllOptionsHidden { get; set; }
 
     internal CategoryHeaderMasked? Header { get; set; }
 }
+
+/// <summary>
+/// Base class for option groups. An option group is a collection of options that are displayed together in the options menu.
+/// </summary>
+/// <typeparam name="T">The type of the optionable that this group contains.</typeparam>
+public abstract class AbstractOptionGroup<T> : AbstractOptionGroup where T : IOptionable
+{
+    /// <inheritdoc />
+    public override Type OptionableType => typeof(T);
+}

MiraAPI/GameOptions/Attributes/ModdedEnumOptionAttribute.cs

@@ -1,6 +1,6 @@
-using MiraAPI.GameOptions.OptionTypes;
-using System;
+using System;
 using System.Reflection;
+using MiraAPI.GameOptions.OptionTypes;
 
 namespace MiraAPI.GameOptions.Attributes;
 
@@ -8,12 +8,12 @@ namespace MiraAPI.GameOptions.Attributes;
 /// Attribute for creating an enum option.
 /// </summary>
 [AttributeUsage(AttributeTargets.Property)]
-public class ModdedEnumOptionAttribute(string title, Type enumType, string[]? values = null, Type? roleType = null)
-    : ModdedOptionAttribute(title, roleType)
+public class ModdedEnumOptionAttribute(string title, Type enumType, string[]? values = null)
+    : ModdedOptionAttribute(title)
 {
     internal override IModdedOption CreateOption(object? value, PropertyInfo property)
     {
-        var opt = new ModdedEnumOption(Title, (int)(value ?? 0), enumType, values, RoleType);
+        var opt = new ModdedEnumOption(Title, (int)(value ?? 0), enumType, values);
         return opt;
     }
 
@@ -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/Attributes/ModdedNumberOptionAttribute.cs

@@ -1,7 +1,7 @@
-using MiraAPI.GameOptions.OptionTypes;
-using MiraAPI.Utilities;
-using System;
+using System;
 using System.Reflection;
+using MiraAPI.GameOptions.OptionTypes;
+using MiraAPI.Utilities;
 
 namespace MiraAPI.GameOptions.Attributes;
 
@@ -15,13 +15,13 @@ public class ModdedNumberOptionAttribute(
     float max,
     float increment = 1,
     MiraNumberSuffixes suffixType = MiraNumberSuffixes.None,
-    bool zeroInfinity = false,
-    Type? roleType = null)
-    : ModdedOptionAttribute(title, roleType)
+    string? formatString = null,
+    bool zeroInfinity = false)
+    : ModdedOptionAttribute(title)
 {
     internal override IModdedOption CreateOption(object? value, PropertyInfo property)
     {
-        return new ModdedNumberOption(Title, (float)(value ?? min+increment), min, max, increment, suffixType, zeroInfinity, RoleType);
+        return new ModdedNumberOption(Title, (float)(value ?? min+increment), min, max, increment, suffixType, formatString, zeroInfinity);
     }
 
     /// <inheritdoc />

MiraAPI/GameOptions/Attributes/ModdedToggleOptionAttribute.cs

@@ -1,6 +1,6 @@
-using MiraAPI.GameOptions.OptionTypes;
-using System;
+using System;
 using System.Reflection;
+using MiraAPI.GameOptions.OptionTypes;
 
 namespace MiraAPI.GameOptions.Attributes;
 
@@ -8,13 +8,12 @@ namespace MiraAPI.GameOptions.Attributes;
 /// Attribute for a toggle option.
 /// </summary>
 /// <param name="title">The option title.</param>
-/// <param name="roleType">An optional role type.</param>
 [AttributeUsage(AttributeTargets.Property)]
-public class ModdedToggleOptionAttribute(string title, Type? roleType = null) : ModdedOptionAttribute(title, roleType)
+public class ModdedToggleOptionAttribute(string title) : ModdedOptionAttribute(title)
 {
     internal override IModdedOption CreateOption(object? value, PropertyInfo property)
     {
-        var toggleOpt = new ModdedToggleOption(Title, (bool)(value ?? false), RoleType);
+        var toggleOpt = new ModdedToggleOption(Title, (bool)(value ?? false));
         return toggleOpt;
     }
 

MiraAPI/GameOptions/IModdedOption.cs

@@ -13,7 +13,6 @@ public interface IModdedOption
     StringNames StringName { get; }
     IMiraPlugin? ParentMod { get; set; }
     BaseGameSetting Data { get; }
-    Type? AdvancedRole { get; set; }
     OptionBehaviour? OptionBehaviour { get; }
     Func<bool> Visible { get; set; }
     ConfigDefinition? ConfigDefinition { get; set; }

MiraAPI/GameOptions/IOptionable.cs

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

MiraAPI/GameOptions/ModdedOptionsManager.cs

@@ -31,7 +31,6 @@ public static class ModdedOptionsManager
     {
         if (Activator.CreateInstance(type) is not AbstractOptionGroup group)
         {
-            Logger<MiraApiPlugin>.Error($"Failed to create group from {type.Name}");
             return false;
         }
 
@@ -109,7 +108,7 @@ public static class ModdedOptionsManager
         RegisterOption(option, group, property.Name, pluginInfo);
     }
 
-    private static void RegisterOption(
+    internal static void RegisterOption(
         IModdedOption option,
         AbstractOptionGroup group,
         string propertyName,
@@ -120,10 +119,7 @@ public static class ModdedOptionsManager
         option.ConfigDefinition = new ConfigDefinition(groupName, propertyName);
 
         option.ParentMod = pluginInfo.MiraPlugin;
-        option.AdvancedRole = group.AdvancedRole;
-
         pluginInfo.Options.Add(option);
-
         ModdedOptions.Add(option.Id, option);
         group.Options.Add(option);
     }

MiraAPI/GameOptions/ModifierOptionGroup.cs

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

MiraAPI/GameOptions/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;
@@ -25,8 +27,7 @@ public class ModdedEnumOption : ModdedOption<int>
     /// <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, int defaultValue, Type enumType, string[]? values = null, Type? roleType = null) : base(title, defaultValue, roleType)
+    public ModdedEnumOption(string title, int defaultValue, Type enumType, string[]? values = null) : base(title, defaultValue)
     {
         Values = values ?? Enum.GetNames(enumType);
         Data = ScriptableObject.CreateInstance<StringGameSetting>();
@@ -98,3 +99,93 @@ 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="values">An option list of string values to use in place of the enum name.</param>
+    public ModdedEnumOption(string title, T defaultValue, string[]? values = null) : base(title, defaultValue)
+    {
+        Values = values ?? Enum.GetNames(typeof(T));
+        Data = ScriptableObject.CreateInstance<StringGameSetting>();
+        var data = (StringGameSetting)Data;
+
+        data.Title = StringName;
+        data.Type = global::OptionTypes.String;
+        data.Values = values is null ?
+            Enum.GetNames(typeof(T)).Select(CustomStringName.CreateAndRegister).ToArray()
+            : values.Select(CustomStringName.CreateAndRegister).ToArray();
+
+        data.Index = Convert.ToInt32(Value);
+    }
+
+    /// <inheritdoc />
+    public override OptionBehaviour CreateOption(ToggleOption toggleOpt, NumberOption numberOpt, StringOption stringOpt, Transform container)
+    {
+        var stringOption = Object.Instantiate(stringOpt, container);
+
+        stringOption.SetUpFromData(Data, 20);
+        stringOption.OnValueChanged = (Il2CppSystem.Action<OptionBehaviour>)ValueChanged;
+
+        // SetUpFromData method doesnt work correctly so we must set the values manually
+        stringOption.Title = StringName;
+        stringOption.Values = (Data as StringGameSetting)?.Values ?? new Il2CppStructArray<StringNames>(0);
+        stringOption.Value = Convert.ToInt32(Value, NumberFormatInfo.InvariantInfo);
+
+        OptionBehaviour = stringOption;
+
+        return stringOption;
+    }
+
+    /// <inheritdoc />
+    public override float GetFloatData()
+    {
+        return Convert.ToSingle(Value, NumberFormatInfo.InvariantInfo);
+    }
+
+    /// <inheritdoc />
+    public override NetData GetNetData()
+    {
+        return new NetData(Id, Encoding.Unicode.GetBytes(Convert.ToString(Value, NumberFormatInfo.InvariantInfo)!));
+    }
+
+    /// <inheritdoc />
+    public override void HandleNetData(byte[] data)
+    {
+        SetValue((T)Enum.Parse(typeof(T), Encoding.Unicode.GetString(data)));
+    }
+
+    /// <inheritdoc />
+    public override T GetValueFromOptionBehaviour(OptionBehaviour optionBehaviour)
+    {
+        return (T)Enum.Parse(typeof(T), optionBehaviour.GetInt().ToString(NumberFormatInfo.InvariantInfo));
+    }
+
+    /// <inheritdoc />
+    protected override void OnValueChanged(T newValue)
+    {
+        HudManager.Instance.Notifier.AddSettingsChangeMessage(StringName, Data.GetValueString(Convert.ToInt32(newValue, NumberFormatInfo.InvariantInfo)), false);
+        if (!OptionBehaviour)
+        {
+            return;
+        }
+
+        if (OptionBehaviour is StringOption opt)
+        {
+            opt.Value = Convert.ToInt32(newValue, NumberFormatInfo.InvariantInfo);
+        }
+    }
+}

MiraAPI/GameOptions/OptionTypes/ModdedNumberOption.cs

@@ -1,7 +1,7 @@
-using AmongUs.GameOptions;
+using System;
+using AmongUs.GameOptions;
 using MiraAPI.Networking;
 using MiraAPI.Utilities;
-using System;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
@@ -46,8 +46,8 @@ public class ModdedNumberOption : ModdedOption<float>
     /// <param name="max">The maximum value.</param>
     /// <param name="increment">The increment.</param>
     /// <param name="suffixType">The suffix type.</param>
+    /// <param name="formatString">Optional format string for the option screen.</param>
     /// <param name="zeroInfinity">Whether zero is infinity or not.</param>
-    /// <param name="roleType">An optional role type.</param>
     public ModdedNumberOption(
         string title,
         float defaultValue,
@@ -55,8 +55,8 @@ public class ModdedNumberOption : ModdedOption<float>
         float max,
         float increment,
         MiraNumberSuffixes suffixType,
-        bool zeroInfinity = false,
-        Type? roleType = null) : base(title, defaultValue, roleType)
+        string? formatString = null,
+        bool zeroInfinity = false) : base(title, defaultValue)
     {
         Min = min;
         Max = max;
@@ -74,7 +74,13 @@ public class ModdedNumberOption : ModdedOption<float>
         data.Value = Value;
         data.Increment = Increment;
         data.ValidRange = new FloatRange(Min, Max);
-        data.FormatString = Increment % 1 == 0 && Value % 1 == 0 && Min % 1 == 0 && Max % 1 == 0 ? "0" : "0.0"; // not sure if the == checks will work since this is floats but we'll find out
+        data.FormatString = formatString ??
+                            (defaultValue.IsInteger() &&
+                             Increment.IsInteger() &&
+                             Value.IsInteger() &&
+                             Min.IsInteger() &&
+                             Max.IsInteger() ? "0" : "0.0");
+
         data.ZeroIsInfinity = ZeroInfinity;
         data.SuffixType = (NumberSuffixes)SuffixType;
         data.OptionName = FloatOptionNames.Invalid;
@@ -136,7 +142,7 @@ public class ModdedNumberOption : ModdedOption<float>
         Value = Mathf.Clamp(newValue, Min, Max);
         HudManager.Instance.Notifier.AddSettingsChangeMessage(
             StringName,
-            Data?.GetValueString(Value),
+            Data.GetValueString(Value),
             false);
 
         if (OptionBehaviour is NumberOption opt)
@@ -144,4 +150,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

@@ -1,10 +1,9 @@
-using BepInEx.Configuration;
+using System;
+using BepInEx.Configuration;
 using MiraAPI.Networking;
 using MiraAPI.PluginLoading;
-using MiraAPI.Roles;
 using Reactor.Localization.Utilities;
 using Reactor.Networking.Rpc;
-using System;
 using UnityEngine;
 
 namespace MiraAPI.GameOptions.OptionTypes;
@@ -72,11 +71,6 @@ public abstract class ModdedOption<T> : IModdedOption
     /// </summary>
     public Func<bool> Visible { get; set; }
 
-    /// <summary>
-    /// Gets or sets the advanced role of the option.
-    /// </summary>
-    public Type? AdvancedRole { get; set; }
-
     /// <summary>
     /// Gets or sets the option behaviour of the option.
     /// </summary>
@@ -102,8 +96,7 @@ public abstract class ModdedOption<T> : IModdedOption
     /// </summary>
     /// <param name="title">The option title.</param>
     /// <param name="defaultValue">The default value.</param>
-    /// <param name="roleType">The Role Type or null if it doesn't belong to a role.</param>
-    protected ModdedOption(string title, T defaultValue, Type? roleType)
+    protected ModdedOption(string title, T defaultValue)
     {
         Id = ModdedOptionsManager.NextId;
         Title = title;
@@ -111,11 +104,6 @@ public abstract class ModdedOption<T> : IModdedOption
         Value = defaultValue;
         StringName = CustomStringName.CreateAndRegister(Title);
         Visible = () => true;
-
-        if (roleType is not null && roleType.IsAssignableTo(typeof(ICustomRole)))
-        {
-            AdvancedRole = roleType;
-        }
     }
 
     internal void ValueChanged(OptionBehaviour optionBehaviour)
@@ -194,4 +182,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

@@ -1,5 +1,5 @@
-using MiraAPI.Networking;
-using System;
+using System;
+using MiraAPI.Networking;
 using UnityEngine;
 using Object = UnityEngine.Object;
 
@@ -15,8 +15,7 @@ public class ModdedToggleOption : ModdedOption<bool>
     /// </summary>
     /// <param name="title">The option title.</param>
     /// <param name="defaultValue">The default value.</param>
-    /// <param name="roleType">An optional role type.</param>
-    public ModdedToggleOption(string title, bool defaultValue, Type? roleType = null) : base(title, defaultValue, roleType)
+    public ModdedToggleOption(string title, bool defaultValue) : base(title, defaultValue)
     {
         Data = ScriptableObject.CreateInstance<CheckboxGameSetting>();
 

MiraAPI/Hud/CustomActionButton.cs

@@ -1,7 +1,13 @@
-using MiraAPI.Utilities.Assets;
+using System;
+using System.Globalization;
+using MiraAPI.Events;
+using MiraAPI.Events.Mira;
+using MiraAPI.Patches;
+using MiraAPI.Utilities.Assets;
 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.UI;
+using Object = UnityEngine.Object;
 
 namespace MiraAPI.Hud;
 
@@ -15,30 +21,40 @@ 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 button's text outline color.
+    /// </summary>
+    public virtual Color TextOutlineColor => Color.clear;
+
     /// <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.
@@ -55,6 +71,11 @@ public abstract class CustomActionButton
     /// </summary>
     public bool EffectActive { get; protected set; }
 
+    /// <summary>
+    /// Gets or sets a value indicating whether the timer is currently active.
+    /// </summary>
+    public bool TimerPaused { get; protected set; }
+
     /// <summary>
     /// Gets or sets the amount of uses left.
     /// </summary>
@@ -70,7 +91,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,8 +103,9 @@ public abstract class CustomActionButton
         }
 
         UsesLeft = MaxUses;
-        Timer = Cooldown;
+        Timer = AmongUsClient.Instance?.NetworkMode == NetworkModes.FreePlay ? 0 : InitialCooldown;
         EffectActive = false;
+        TimerPaused = false;
 
         Button = Object.Instantiate(HudManager.Instance.AbilityButton, parent);
         Button.name = Name + "Button";
@@ -93,15 +119,94 @@ public abstract class CustomActionButton
             Button.SetInfiniteUses();
         }
 
+        if (TextOutlineColor != Color.clear)
+        {
+            SetTextOutline(TextOutlineColor);
+        }
+
         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.InstanceExists || Button == null)
+        {
+            return;
+        }
+
+        this.Location = location;
+
+        if (!moveButton) return;
+
+        if (HudManagerPatches._bottomLeft == null || HudManagerPatches._bottomRight == null)
+        {
+            return;
+        }
+
+        switch (location)
+        {
+            case ButtonLocation.BottomLeft:
+                var gridArrange = HudManagerPatches._bottomLeft.GetComponent<GridArrange>();
+                var aspectPosition = HudManagerPatches._bottomLeft.GetComponent<AspectPosition>();
+
+                Button.transform.SetParent(HudManagerPatches._bottomLeft.transform);
+
+                gridArrange.Start();
+                gridArrange.ArrangeChilds();
+                aspectPosition.AdjustPosition();
+                break;
+            case ButtonLocation.BottomRight:
+                Button.transform.SetParent(HudManagerPatches._bottomRight);
+                break;
+        }
     }
 
     /// <summary>
     /// A utility function to reset the cooldown and/or effect of the button.
     /// </summary>
-    public void ResetCooldownAndOrEffect()
+    public virtual void ResetCooldownAndOrEffect()
     {
         Timer = Cooldown;
         if (EffectActive)
@@ -112,11 +217,21 @@ public abstract class CustomActionButton
         EffectActive = false;
     }
 
+    /// <summary>
+    /// A utility function to change the outline color of the button's text.
+    /// </summary>
+    /// <param name="color">The new color.</param>
+    /// <param name="thickness">The thickness of the outline. Set to 0 if you want to remove it.</param>
+    public virtual void SetTextOutline(Color color)
+    {
+        Button?.buttonLabelText.SetOutlineColor(color);
+    }
+
     /// <summary>
     /// A utility function to override the sprite of the button.
     /// </summary>
     /// <param name="sprite">The new sprite to override with.</param>
-    public void OverrideSprite(Sprite sprite)
+    public virtual void OverrideSprite(Sprite sprite)
     {
         if (Button != null)
         {
@@ -128,7 +243,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 +252,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 +261,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,26 +270,40 @@ 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);
     }
 
+    /// <summary>
+    /// Sets whether the timer is paused or not.
+    /// </summary>
+    /// <param name="val">Whether you want to pause/resume the timer.</param>
+    public virtual void SetTimerPaused(bool val)
+    {
+        TimerPaused = val;
+    }
+
     /// <summary>
     /// Set the amount of uses this button has left.
     /// </summary>
     /// <param name="amount">The amount you want to set to.</param>
-    public void SetUses(int amount)
+    public virtual void SetUses(int amount)
     {
         UsesLeft = Mathf.Clamp(amount, 0, int.MaxValue);
-        Button?.SetUsesRemaining(MaxUses);
+        Button?.SetUsesRemaining(UsesLeft);
+
+        if (Button != null)
+        {
+            Button.usesRemainingSprite.color = UsesLeft == 0 ? Color.red : Color.white;
+        }
     }
 
     /// <summary>
     /// Increase the amount of uses this button has left.
     /// </summary>
     /// <param name="amount">The amount you want to increase by. Default: 1.</param>
-    public void IncreaseUses(int amount = 1)
+    public virtual void IncreaseUses(int amount = 1)
     {
         SetUses(UsesLeft + amount);
     }
@@ -183,7 +312,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);
     }
@@ -218,14 +347,24 @@ public abstract class CustomActionButton
     }
 
     /// <summary>
-    /// When the button is enabled, this method is called to determine if the button can be used.
+    /// When the button is usable, this method is called to determine if the button can be clicked.
     /// By default, it takes into account the timer, effect, and uses.
     /// You can override it to change the behavior.
     /// </summary>
-    /// <returns>A value that represents whether the button can be used or not.</returns>
+    /// <returns>A value that represents whether the button can be clicked or not.</returns>
+    public virtual bool CanClick()
+    {
+        return Timer <= 0 && !EffectActive && CanUse();
+    }
+
+    /// <summary>
+    /// Whether the button should light up or not. This is also the base for CanClick.
+    /// You can override it to change the behaviour. Do not include timer in here, that is for CanClick.
+    /// </summary>
+    /// <returns>A value that represents whether the button should light up or not.</returns>
     public virtual bool CanUse()
     {
-        return Timer <= 0 && !EffectActive && (!LimitedUses || UsesLeft > 0);
+        return !LimitedUses || UsesLeft > 0;
     }
 
     /// <summary>
@@ -245,9 +384,9 @@ 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())
+        if (!CanClick())
         {
             return;
         }
@@ -259,7 +398,7 @@ public abstract class CustomActionButton
         }
 
         OnClick();
-        Button?.SetDisabled();
+
         if (HasEffect)
         {
             EffectActive = true;
@@ -279,7 +418,7 @@ public abstract class CustomActionButton
     /// <param name="playerControl">The local PlayerControl.</param>
     public virtual void FixedUpdateHandler(PlayerControl playerControl)
     {
-        if (Timer >= 0)
+        if (Timer >= 0 && !TimerPaused)
         {
             Timer -= Time.deltaTime;
         }
@@ -299,7 +438,17 @@ public abstract class CustomActionButton
             Button?.SetDisabled();
         }
 
-        Button?.SetCoolDown(Timer, EffectActive ? EffectDuration : Cooldown);
+        if (EffectActive)
+        {
+            Button?.SetFillUp(Timer, EffectDuration);
+
+            Button!.cooldownTimerText.text = Mathf.CeilToInt(Timer).ToString(NumberFormatInfo.InvariantInfo);
+            Button!.cooldownTimerText.gameObject.SetActive(true);
+        }
+        else
+        {
+            Button?.SetCoolDown(Timer, Cooldown);
+        }
 
         FixedUpdate(playerControl);
     }
@@ -357,4 +506,19 @@ public abstract class CustomActionButton<T> : CustomActionButton where T : MonoB
 
         return base.CanUse() && Target != null;
     }
+
+    /// <inheritdoc />
+    public override bool CanClick()
+    {
+        return base.CanClick() && Target != null;
+    }
+
+    /// <summary>
+    /// Use this to reset the button's target after used.
+    /// </summary>
+    public virtual void ResetTarget()
+    {
+        Target = null;
+        SetOutline(false);
+    }
 }

MiraAPI/Hud/CustomButtonManager.cs

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

MiraAPI/Hud/CustomPlayerMenu.cs

@@ -2,6 +2,7 @@
 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;
@@ -84,10 +85,17 @@ public class CustomPlayerMenu(IntPtr il2CppPtr) : Minigame(il2CppPtr)
     /// </summary>
     /// <param name="playerMatch">Function to determine if player should show in the custom menu.</param>
     /// <param name="onClick">Onclick action for player.</param>
-    public void Begin(Func<PlayerControl, bool> playerMatch, Action<PlayerControl> onClick)
+    [HideFromIl2Cpp]
+    public void Begin(Func<PlayerControl, bool> playerMatch, Action<PlayerControl?> onClick)
     {
         MinigameStubs.Begin(this, null);
 
+        var back = BackButton.GetComponent<PassiveButton>();
+        back.OnClick.AddListener((UnityAction)(() =>
+        {
+            onClick(null);
+        }));
+
         DestroyableSingleton<DebugAnalytics>.Instance.Analytics.MinigameOpened(PlayerControl.LocalPlayer.Data, TaskType);
         var list = PlayerControl.AllPlayerControls.ToArray().Where(playerMatch).ToList();
         potentialVictims = [];

MiraAPI/Hud/RegisterButtonAttribute.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace MiraAPI.Hud;
-
-/// <summary>
-/// Attribute to register a button in the HUD. Necessary for the button to be recognized by Mira.
-/// </summary>
-[AttributeUsage(AttributeTargets.Class)]
-public class RegisterButtonAttribute : Attribute;

MiraAPI/MiraApiPlugin.cs

@@ -10,17 +10,20 @@ using UnityEngine;
 
 namespace MiraAPI;
 
+/// <summary>
+/// The main plugin class for Mira API.
+/// </summary>
 [BepInAutoPlugin("mira.api", "MiraAPI")]
 [BepInProcess("Among Us.exe")]
 [BepInDependency(ReactorPlugin.Id)]
 [ReactorModFlags(ModFlags.RequireOnAllClients)]
 public partial class MiraApiPlugin : BasePlugin
 {
-    private static MiraPluginManager? PluginManager { get; set; }
-
-    public Harmony Harmony { get; } = new(Id);
     public static Color MiraColor { get; } = new Color32(238, 154, 112, 255);
+    private static MiraPluginManager? PluginManager { get; set; }
+    internal Harmony Harmony { get; } = new(Id);
 
+    /// <inheritdoc />
     public override void Load()
     {
         Harmony.PatchAll();

MiraAPI/Modifiers/AssignmentConfiguration.cs

@@ -0,0 +1,10 @@
+namespace MiraAPI.Modifiers;
+
+/// <summary>
+/// Represents the assignment configuration for a game modifier.
+/// </summary>
+/// <param name="DefaultAmount">The default amount of players that can have this modifier in a game.</param>
+/// <param name="DefaultChance">The default chance of the modifier being assigned to a player.</param>
+/// <param name="CreateAmountOption">Whether Mira should create an amount option for the modifier.</param>
+/// <param name="CreateChanceOption">Whether Mira should create a chance option for the modifier.</param>
+public record struct AssignmentConfiguration(int DefaultAmount, int DefaultChance, bool CreateAmountOption, bool CreateChanceOption);

MiraAPI/Modifiers/BaseModifier.cs

@@ -1,9 +1,13 @@
-namespace MiraAPI.Modifiers;
+using System;
+using MiraAPI.GameOptions;
+using MiraAPI.PluginLoading;
+
+namespace MiraAPI.Modifiers;
 
 /// <summary>
 /// Base class for all modifiers.
 /// </summary>
-public abstract class BaseModifier
+public abstract class BaseModifier : IOptionable
 {
     /// <summary>
     /// Gets the player that the modifier is attached to.
@@ -16,9 +20,27 @@ public abstract class BaseModifier
     public ModifierComponent? ModifierComponent { get; internal set; }
 
     /// <summary>
-    /// Gets the modifier id.
+    /// Gets a value indicating whether the modifier has been initialized.
     /// </summary>
-    public uint ModifierId { get; internal set; }
+    public bool Initialized { get; internal set; }
+
+    /// <summary>
+    /// Gets the unique ID of the modifier.
+    /// </summary>
+    public Guid UniqueId { get; internal set; } = Guid.Empty;
+
+    /// <summary>
+    /// Gets the type ID of the modifier.
+    /// </summary>
+    public uint TypeId => ModifierManager.GetModifierTypeId(GetType()) ?? throw new InvalidOperationException("Modifier is not registered.");
+
+    /// <summary>
+    /// Gets the parent mod of the modifier.
+    /// </summary>
+    public MiraPluginInfo ParentMod => Array.Find(
+        MiraPluginManager.Instance.RegisteredPlugins(),
+        x => x.Modifiers.Exists(y => y.TypeId == TypeId)
+        ) ?? throw new InvalidOperationException("Modifier is not registered.");
 
     /// <summary>
     /// Gets the modifier name.
@@ -30,6 +52,16 @@ public abstract class BaseModifier
     /// </summary>
     public virtual bool HideOnUi => false;
 
+    /// <summary>
+    /// Gets a value indicating whether the modifier is shown in the freeplay menu.
+    /// </summary>
+    public virtual bool ShowInFreeplay => false;
+
+    /// <summary>
+    /// Gets a value indicating whether the modifier is unique. If true, the player can only have one instance of this modifier.
+    /// </summary>
+    public virtual bool Unique => true;
+
     /// <summary>
     /// Gets the HUD information for this modifier. Defaults to the modifier name. Does nothing if <see cref="HideOnUi"/> is true.
     /// </summary>

MiraAPI/Modifiers/ModifierComponent.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Text;
@@ -67,6 +68,7 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
         foreach (var modifier in _toAdd)
         {
             Modifiers.Add(modifier);
+            modifier.Initialized = true;
             modifier.OnActivate();
 
             if (modifier is TimedModifier { AutoStart: true } timer)
@@ -79,7 +81,7 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
         {
             if (_player?.AmOwner == true)
             {
-                HudManager.Instance?.SetHudActive(HudManager.Instance.TaskPanel.isActiveAndEnabled);
+                HudManager.Instance?.SetHudActive(_player, _player.Data.Role, HudManager.Instance.TaskPanel.isActiveAndEnabled);
             }
             _toAdd.Clear();
             _toRemove.Clear();
@@ -103,14 +105,12 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
             return;
         }
 
-        var filteredModifiers = Modifiers.Where(mod => !mod.HideOnUi);
+        var filteredModifiers = Modifiers.Where(mod => !mod.HideOnUi).ToArray();
 
-        var baseModifiers = filteredModifiers as BaseModifier[] ?? filteredModifiers.ToArray();
-
-        if (baseModifiers.Length != 0)
+        if (filteredModifiers.Length != 0 && !MeetingHud.Instance)
         {
             var stringBuild = new StringBuilder();
-            foreach (var mod in baseModifiers)
+            foreach (var mod in filteredModifiers)
             {
                 stringBuild.Append(CultureInfo.InvariantCulture, $"\n{mod.GetHudString()}");
             }
@@ -123,45 +123,178 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
     }
 
     /// <summary>
-    /// Removes a modifier from the player.
+    /// Gets a collection of modifiers by type.
+    /// </summary>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    /// <returns>A collection of modifiers.</returns>
+    [HideFromIl2Cpp]
+    public IEnumerable<T> GetModifiers<T>(Func<T, bool>? predicate=null) where T : BaseModifier
+    {
+        return Modifiers.OfType<T>().Where(x => predicate == null || predicate(x));
+    }
+
+    /// <summary>
+    /// Gets a collection of modifiers by type.
     /// </summary>
     /// <param name="type">The modifier type.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>A collection of modifiers.</returns>
     [HideFromIl2Cpp]
-    public void RemoveModifier(Type type)
+    public IEnumerable<BaseModifier> GetModifiers(Type type, Func<BaseModifier, bool>? predicate=null)
     {
-        var modifier = Modifiers.Find(x => x.GetType() == type);
+        return Modifiers.Where(x => x.GetType() == type && (predicate == null || predicate(x)));
+    }
 
-        if (modifier is null)
-        {
-            Logger<MiraApiPlugin>.Error($"Cannot remove modifier {type.Name} because it is not active.");
-            return;
-        }
+    /// <summary>
+    /// Gets a collection of modifiers by type ID.
+    /// </summary>
+    /// <param name="id">The modifier's type ID.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>A collection of modifiers.</returns>
+    [HideFromIl2Cpp]
+    public IEnumerable<BaseModifier> GetModifiers(uint id, Func<BaseModifier, bool>? predicate=null)
+    {
+        var type = ModifierManager.GetModifierType(id) ?? throw new InvalidOperationException(
+            $"Cannot get modifier with id {id} because it is not registered.");
 
-        RemoveModifier(modifier);
+        return GetModifiers(type, predicate);
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its type.
+    /// </summary>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool TryGetModifier<T>([NotNullWhen(true)] out T? modifier, Func<T, bool>? predicate = null) where T : BaseModifier
+    {
+        modifier = GetModifier(predicate);
+        return modifier != null;
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its type.
+    /// </summary>
+    /// <param name="type">The modifier type.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool TryGetModifier(Type type, [NotNullWhen(true)] out BaseModifier? modifier, Func<BaseModifier, bool>? predicate = null)
+    {
+        modifier = GetModifier(type, predicate);
+        return modifier != null;
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its type ID.
+    /// </summary>
+    /// <param name="id">The modifier type ID.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool TryGetModifier(uint id, [NotNullWhen(true)] out BaseModifier? modifier, Func<BaseModifier, bool>? predicate = null)
+    {
+        modifier = GetModifier(id, predicate);
+        return modifier != null;
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its unique ID.
+    /// </summary>
+    /// <param name="modifierGuid">The modifier unique ID.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool TryGetModifier(Guid modifierGuid, [NotNullWhen(true)] out BaseModifier? modifier)
+    {
+        modifier = GetModifier(modifierGuid);
+        return modifier != null;
+    }
+
+    /// <summary>
+    /// Gets a modifier by its type.
+    /// </summary>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    /// <returns>The Modifier if it is found, null otherwise.</returns>
+    [HideFromIl2Cpp]
+    public T? GetModifier<T>(Func<T, bool>? predicate = null) where T : BaseModifier
+    {
+        return GetModifiers(predicate).FirstOrDefault();
+    }
+
+    /// <summary>
+    /// Gets a modifier by its type.
+    /// </summary>
+    /// <param name="type">The modifier type.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>The Modifier if it is found, null otherwise.</returns>
+    [HideFromIl2Cpp]
+    public BaseModifier? GetModifier(Type type, Func<BaseModifier, bool>? predicate = null)
+    {
+        return GetModifiers(type).FirstOrDefault(predicate ?? (_ => true));
+    }
+
+    /// <summary>
+    /// Gets a modifier by its type ID.
+    /// </summary>
+    /// <param name="id">The modifier ID.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>The Modifier if it is found, null otherwise.</returns>
+    [HideFromIl2Cpp]
+    public BaseModifier? GetModifier(uint id, Func<BaseModifier, bool>? predicate = null)
+    {
+        var type = ModifierManager.GetModifierType(id) ?? throw new InvalidOperationException(
+            $"Cannot get modifier with id {id} because it is not registered.");
+
+        return GetModifier(type, predicate);
+    }
+
+    /// <summary>
+    /// Gets a modifier by unique ID.
+    /// </summary>
+    /// <param name="modifierGuid">The modifier's unique ID.</param>
+    /// <returns>The modifier if it is found, or null.</returns>
+    [HideFromIl2Cpp]
+    public BaseModifier? GetModifier(Guid modifierGuid)
+    {
+        return Modifiers.Find(x => x.UniqueId == modifierGuid);
     }
 
     /// <summary>
     /// Removes a modifier from the player.
     /// </summary>
     /// <typeparam name="T">The modifier type.</typeparam>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
     [HideFromIl2Cpp]
-    public void RemoveModifier<T>() where T : BaseModifier
+    public void RemoveModifier<T>(Func<T, bool>? predicate = null) where T : BaseModifier
     {
-        RemoveModifier(typeof(T));
+        RemoveModifier(typeof(T), x => predicate == null || predicate((T)x));
     }
 
     /// <summary>
     /// Removes a modifier from the player.
     /// </summary>
-    /// <param name="modifierId">The modifier ID.</param>
+    /// <param name="type">The modifier type.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
     [HideFromIl2Cpp]
-    public void RemoveModifier(uint modifierId)
+    public void RemoveModifier(Type type, Func<BaseModifier, bool>? predicate = null)
     {
-        var modifier = Modifiers.Find(x => x.ModifierId == modifierId);
+        var modifiers = Modifiers.Where(x => x.GetType() == type && (predicate == null || predicate(x))).ToList();
+        if (modifiers.Count > 1)
+        {
+            throw new InvalidOperationException($"Cannot remove modifier {type.Name} because there are multiple instances of that modifier.");
+        }
 
+        var modifier = modifiers.FirstOrDefault();
         if (modifier is null)
         {
-            Logger<MiraApiPlugin>.Error($"Cannot remove modifier with id {modifierId} because it is not active.");
+            Logger<MiraApiPlugin>.Error($"Cannot remove modifier {type.Name} because it is not active.");
             return;
         }
 
@@ -184,6 +317,48 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
         _toRemove.Add(modifier);
     }
 
+    /// <summary>
+    /// Removes a modifier from the player.
+    /// </summary>
+    /// <param name="typeId">The modifier's type ID.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    [HideFromIl2Cpp]
+    public void RemoveModifier(uint typeId, Func<BaseModifier, bool>? predicate = null)
+    {
+        var type = ModifierManager.GetModifierType(typeId) ?? throw new InvalidOperationException(
+            $"Cannot remove modifier with id {typeId} because it is not registered.");
+        RemoveModifier(type, predicate);
+    }
+
+    /// <summary>
+    /// Removes a modifier from the player.
+    /// </summary>
+    /// <param name="uniqueId">The modifier's unique ID.</param>
+    [HideFromIl2Cpp]
+    public void RemoveModifier(Guid uniqueId)
+    {
+        var modifier = GetModifier(uniqueId);
+        if (modifier == null)
+        {
+            Logger<MiraApiPlugin>.Error($"Cannot remove modifier with unique id {uniqueId} because it is not active.");
+            return;
+        }
+
+        RemoveModifier(modifier);
+    }
+
+    /// <summary>
+    /// Adds a modifier to the player.
+    /// </summary>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    /// <typeparam name="T">The Type of the modifier.</typeparam>
+    /// <returns>The new modifier.</returns>
+    [HideFromIl2Cpp]
+    public T? AddModifier<T>(params object[] args) where T : BaseModifier
+    {
+        return AddModifier(typeof(T), args) as T;
+    }
+
     /// <summary>
     /// Adds a modifier to the player.
     /// </summary>
@@ -192,24 +367,32 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
     [HideFromIl2Cpp]
     public BaseModifier? AddModifier(BaseModifier modifier)
     {
-        if (Modifiers.Contains(modifier))
+        // TODO: Make a proper synchronization system.
+        if (LobbyBehaviour.Instance)
         {
-            Logger<MiraApiPlugin>.Error($"Player already has modifier with id {modifier.ModifierId}!");
+            Logger<MiraApiPlugin>.Warning($"Modifiers added in the lobby won't sync to new players!");
+        }
+
+        var id = modifier.TypeId;
+        if (modifier.Unique && Modifiers.Find(x => x.TypeId == id) != null)
+        {
+            Logger<MiraApiPlugin>.Error($"Player already has modifier with id {id}!");
             return null;
         }
 
-        var modifierId = ModifierManager.GetModifierId(modifier.GetType());
-
-        if (modifierId == null)
+        if (Modifiers.Contains(modifier))
         {
-            Logger<MiraApiPlugin>.Error($"Cannot add modifier {modifier.GetType().Name} because it has no ID!");
+            Logger<MiraApiPlugin>.Error($"Player already has this modifier!");
             return null;
         }
 
         _toAdd.Add(modifier);
         modifier.Player = _player;
         modifier.ModifierComponent = this;
-        modifier.ModifierId = modifierId.Value;
+        if (modifier.UniqueId == Guid.Empty)
+        {
+            modifier.UniqueId = Guid.NewGuid();
+        }
         return modifier;
     }
 
@@ -217,42 +400,90 @@ public class ModifierComponent(IntPtr cppPtr) : MonoBehaviour(cppPtr)
     /// Adds a modifier to the player.
     /// </summary>
     /// <param name="type">The modifier type.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
     /// <returns>The modifier that was added.</returns>
     [HideFromIl2Cpp]
-    public BaseModifier? AddModifier(Type type)
+    public BaseModifier? AddModifier(Type type, params object[] args)
     {
-        var modifierId = ModifierManager.GetModifierId(type);
-        if (modifierId == null)
+        BaseModifier? modifier;
+        if (args.Length > 0)
         {
-            Logger<MiraApiPlugin>.Error($"Cannot add modifier {type.Name} because it is not registered.");
-            return null;
+            modifier = ModifierFactory.CreateInstance(type, args);
+        }
+        else
+        {
+            modifier = Activator.CreateInstance(type) as BaseModifier;
+            if (modifier == null)
+            {
+                throw new InvalidOperationException($"Cannot add modifier {type.Name} because it is not a valid modifier.");
+            }
         }
 
-        if (Modifiers.Find(x => x.ModifierId == modifierId) != null)
-        {
-            Logger<MiraApiPlugin>.Error($"Player already has modifier with id {modifierId}!");
-            return null;
-        }
-
-        if (Activator.CreateInstance(type) is not BaseModifier modifier)
-        {
-            Logger<MiraApiPlugin>.Error($"Cannot add modifier {type.Name} because it is null.");
-            return null;
-        }
-
-        AddModifier(modifier);
-
-        return modifier;
+        return AddModifier(modifier);
     }
 
     /// <summary>
     /// Adds a modifier to the player.
     /// </summary>
-    /// <typeparam name="T">The Type of the modifier.</typeparam>
-    /// <returns>The new modifier.</returns>
+    /// <param name="id">The ID of the modifier.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    /// <returns>The modifier if it was created, or null if it failed.</returns>
     [HideFromIl2Cpp]
-    public T? AddModifier<T>() where T : BaseModifier
+    public BaseModifier? AddModifier(uint id, params object[] args)
     {
-        return AddModifier(typeof(T)) as T;
+        var type = ModifierManager.GetModifierType(id) ?? throw new InvalidOperationException(
+            $"Cannot add modifier with id {id} because it is not registered.");
+
+        return AddModifier(type, args);
+    }
+
+    /// <summary>
+    /// Checks if a player has an active modifier by its type.
+    /// </summary>
+    /// <param name="predicate">The predicate to check the modifier.</param>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    /// <returns>True if the Modifier is present, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool HasModifier<T>(Func<T, bool>? predicate=null) where T : BaseModifier
+    {
+        return Modifiers.Exists(x => x is T modifier && (predicate == null || predicate(modifier)));
+    }
+
+    /// <summary>
+    /// Checks if a player has an active modifier by its type.
+    /// </summary>
+    /// <param name="type">The modifier type.</param>
+    /// <param name="predicate">The predicate to check the modifier.</param>
+    /// <returns>True if the Modifier is present, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool HasModifier(Type type, Func<BaseModifier, bool>? predicate=null)
+    {
+        return Modifiers.Exists(x => x.GetType() == type && (predicate == null || predicate(x)));
+    }
+
+    /// <summary>
+    /// Checks if a player has an active modifier by its type ID.
+    /// </summary>
+    /// <param name="id">The modifier's type ID.</param>
+    /// <param name="predicate">The predicate to check the modifier.</param>
+    /// <returns>True if the modifier is present, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool HasModifier(uint id, Func<BaseModifier, bool>? predicate=null)
+    {
+        var type = ModifierManager.GetModifierType(id) ?? throw new InvalidOperationException(
+            $"Cannot get modifier with id {id} because it is not registered.");
+
+        return HasModifier(type, predicate);
+    }
+
+    /// <summary>
+    /// Checks if a player has an active modifier by its unique ID.
+    /// </summary>
+    /// <param name="id">The modifier's guid.</param>
+    /// <returns>True if the modifier is present, false otherwise.</returns>
+    [HideFromIl2Cpp]
+    public bool HasModifier(Guid id)
+    {
+        return Modifiers.Exists(x => x.UniqueId == id);
     }
 }

MiraAPI/Modifiers/ModifierExtensions.cs

@@ -0,0 +1,448 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using MiraAPI.Networking;
+using MiraAPI.Networking.Modifiers;
+using Reactor.Networking.Attributes;
+using Reactor.Networking.Rpc;
+using Reactor.Utilities;
+
+namespace MiraAPI.Modifiers;
+
+/// <summary>
+/// Extensions for modifiers.
+/// </summary>
+public static class ModifierExtensions
+{
+    /// <summary>
+    /// Gets the dictionary to cache ModifierComponents.
+    /// </summary>
+    public static Dictionary<PlayerControl, ModifierComponent> ModifierComponents { get; } = [];
+
+    /// <summary>
+    /// Remote Procedure Call to add a modifier to a player.
+    /// </summary>
+    /// <param name="target">The player to add the modifier to.</param>
+    /// <param name="typeId">The modifier type ID.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    public static void RpcAddModifier(this PlayerControl target, uint typeId, params object[] args)
+    {
+        _ = ModifierManager.GetModifierType(typeId) ?? throw new InvalidOperationException(
+            $"Modifier with ID {typeId} is not registered.");
+
+        Rpc<AddModifierRpc>.Instance.Send(target, new ModifierData(typeId, Guid.NewGuid(), args));
+    }
+
+    /// <summary>
+    /// Remote Procedure Call to add a modifier to a player.
+    /// </summary>
+    /// <param name="player">The player to add the modifier to.</param>
+    /// <param name="type">The type of the modifier.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    public static void RpcAddModifier(this PlayerControl player, Type type, params object[] args)
+    {
+        var id = ModifierManager.GetModifierTypeId(type) ?? throw new InvalidOperationException(
+            $"Modifier {type.Name} is not registered.");
+
+        player.RpcAddModifier(id, args);
+    }
+
+    /// <summary>
+    /// Remote Procedure Call to add a modifier to a player.
+    /// </summary>
+    /// <param name="player">The player to add the modifier to.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    /// <typeparam name="T">The modifier Type.</typeparam>
+    public static void RpcAddModifier<T>(this PlayerControl player, params object[] args) where T : BaseModifier
+    {
+        player.RpcAddModifier(typeof(T), args);
+    }
+
+    /// <summary>
+    /// Remote Procedure Call to remove a modifier from a player.
+    /// </summary>
+    /// <param name="target">The player to remove the modifier from.</param>
+    /// <param name="uniqueId">The unique ID of the modifier.</param>
+    [MethodRpc((uint)MiraRpc.RemoveModifier)]
+    public static void RpcRemoveModifier(this PlayerControl target, Guid uniqueId)
+    {
+        target.RemoveModifier(uniqueId);
+    }
+
+    /// <summary>
+    /// Remote Procedure Call to remove a modifier from a player by type ID.
+    /// </summary>
+    /// <param name="target">The player to remove the modifier from.</param>
+    /// <param name="typeId">The type ID of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    public static void RpcRemoveModifier(
+        this PlayerControl target,
+        uint typeId,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        var modifier = target.GetModifier(typeId, predicate);
+        if (modifier is null)
+        {
+            Logger<MiraApiPlugin>.Error($"Player {target.PlayerId} does not have modifier with type ID {typeId}.");
+            return;
+        }
+
+        target.RpcRemoveModifier(modifier.UniqueId);
+    }
+
+    /// <summary>
+    /// Remote Procedure Call to remove a modifier from a player.
+    /// </summary>
+    /// <param name="player">The player to remove the modifier from.</param>
+    /// <param name="type">The type of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    public static void RpcRemoveModifier(
+        this PlayerControl player,
+        Type type,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        var id = ModifierManager.GetModifierTypeId(type) ?? throw new InvalidOperationException(
+            $"Modifier {type.Name} is not registered.");
+
+        player.RpcRemoveModifier(id, predicate);
+    }
+
+    /// <summary>
+    /// Remote Procedure Call to remove a modifier from a player.
+    /// </summary>
+    /// <param name="player">The player to remove the modifier from.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    public static void RpcRemoveModifier<T>(this PlayerControl player, Func<BaseModifier, bool>? predicate = null)
+        where T : BaseModifier
+    {
+        player.RpcRemoveModifier(typeof(T), predicate);
+    }
+
+    /// <summary>
+    /// Gets the ModifierComponent for a player.
+    /// </summary>
+    /// <param name="player">The PlayerControl object.</param>
+    /// <returns>A ModifierComponent if there is one, null otherwise.</returns>
+    public static ModifierComponent GetModifierComponent(this PlayerControl player)
+    {
+        if (ModifierComponents.TryGetValue(player, out var component))
+        {
+            return component;
+        }
+
+        component = player.GetComponent<ModifierComponent>();
+        if (!component)
+        {
+            throw new InvalidOperationException("ModifierComponent is not attached to the player.");
+        }
+
+        ModifierComponents[player] = component;
+        return component;
+    }
+
+    /// <summary>
+    /// Checks if the player has a specific modifier.
+    /// </summary>
+    /// <typeparam name="T">The type of the modifier.</typeparam>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>True if the player has the modifier, false otherwise.</returns>
+    public static bool HasModifier<T>(this PlayerControl player, Func<T, bool>? predicate = null) where T : BaseModifier
+    {
+        return player.GetModifierComponent().HasModifier(predicate);
+    }
+
+    /// <summary>
+    /// Checks if the player has a specific modifier by type.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="type">The type of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>True if the player has the modifier, false otherwise.</returns>
+    public static bool HasModifier(this PlayerControl player, Type type, Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().HasModifier(type, predicate);
+    }
+
+    /// <summary>
+    /// Checks if the player has a specific modifier by type ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="typeId">The type ID of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>True if the player has the modifier, false otherwise.</returns>
+    public static bool HasModifier(
+        this PlayerControl player,
+        uint typeId,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().HasModifier(typeId, predicate);
+    }
+
+    /// <summary>
+    /// Checks if the player has a specific modifier by its GUID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="uniqueId">The unique ID of the modifier.</param>
+    /// <returns>True if the player has the modifier, false otherwise.</returns>
+    public static bool HasModifier(this PlayerControl player, Guid uniqueId)
+    {
+        return player.GetModifierComponent().HasModifier(uniqueId);
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its type.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <typeparam name="T">The Type of the Modifier.</typeparam>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    public static bool TryGetModifier<T>(this PlayerControl player, [NotNullWhen(true)] out T? modifier, Func<T, bool>? predicate = null) where T : BaseModifier
+    {
+        return player.GetModifierComponent().TryGetModifier(out modifier, predicate);
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its type.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="type">The modifier type.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    public static bool TryGetModifier(this PlayerControl player, Type type, [NotNullWhen(true)] out BaseModifier? modifier, Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().TryGetModifier(type, out modifier, predicate);
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its type ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="id">The modifier type ID.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <param name="predicate">The predicate to check the modifier by.</param>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    public static bool TryGetModifier(this PlayerControl player, uint id, [NotNullWhen(true)] out BaseModifier? modifier, Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().TryGetModifier(id, out modifier, predicate);
+    }
+
+    /// <summary>
+    /// Tries to get a modifier by its unique ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="modifierGuid">The modifier unique ID.</param>
+    /// <param name="modifier">The modifier or null.</param>
+    /// <returns>True if the modifier was found, false otherwise.</returns>
+    public static bool TryGetModifier(this PlayerControl player, Guid modifierGuid, [NotNullWhen(true)] out BaseModifier? modifier)
+    {
+        return player.GetModifierComponent().TryGetModifier(modifierGuid, out modifier);
+    }
+
+    /// <summary>
+    /// Gets a specific modifier from the player.
+    /// </summary>
+    /// <typeparam name="T">The type of the modifier.</typeparam>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>The modifier if found, null otherwise.</returns>
+    public static T? GetModifier<T>(this PlayerControl player, Func<T, bool>? predicate = null) where T : BaseModifier
+    {
+        return player.GetModifierComponent().GetModifier(predicate);
+    }
+
+    /// <summary>
+    /// Gets a specific modifier from the player by type.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="type">The type of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>The modifier if found, null otherwise.</returns>
+    public static BaseModifier? GetModifier(
+        this PlayerControl player,
+        Type type,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().GetModifier(type, predicate);
+    }
+
+    /// <summary>
+    /// Gets a specific modifier from the player by its type ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="typeId">The type ID of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>The modifier if found, null otherwise.</returns>
+    public static BaseModifier? GetModifier(
+        this PlayerControl player,
+        uint typeId,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().GetModifier(typeId, predicate);
+    }
+
+    /// <summary>
+    /// Gets a specific modifier from the player by its GUID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="uniqueId">The GUID of the modifier.</param>
+    /// <returns>The modifier if found, null otherwise.</returns>
+    public static BaseModifier? GetModifier(
+        this PlayerControl player,
+        Guid uniqueId)
+    {
+        return player.GetModifierComponent().GetModifier(uniqueId);
+    }
+
+    /// <summary>
+    /// Gets all modifiers of a specific type from the player.
+    /// </summary>
+    /// <typeparam name="T">The type of the modifiers.</typeparam>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>A collection of modifiers.</returns>
+    public static IEnumerable<T> GetModifiers<T>(this PlayerControl player, Func<T, bool>? predicate = null)
+        where T : BaseModifier
+    {
+        return player.GetModifierComponent().GetModifiers(predicate);
+    }
+
+    /// <summary>
+    /// Gets all modifiers of a specific type from the player.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="type">The type of the modifiers.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>A collection of modifiers.</returns>
+    public static IEnumerable<BaseModifier> GetModifiers(
+        this PlayerControl player,
+        Type type,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().GetModifiers(type, predicate);
+    }
+
+    /// <summary>
+    /// Gets all modifiers of a specific type from the player by type ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="typeId">The type ID of the modifiers.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    /// <returns>A collection of modifiers.</returns>
+    public static IEnumerable<BaseModifier> GetModifiers(
+        this PlayerControl player,
+        uint typeId,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        return player.GetModifierComponent().GetModifiers(typeId, predicate);
+    }
+
+    /// <summary>
+    /// Removes a specific modifier from the player.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="modifier">The modifier to remove.</param>
+    public static void RemoveModifier(this PlayerControl player, BaseModifier modifier)
+    {
+        player.GetModifierComponent().RemoveModifier(modifier);
+    }
+
+    /// <summary>
+    /// Removes a specific modifier from the player.
+    /// </summary>
+    /// <typeparam name="T">The type of the modifier.</typeparam>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    public static void RemoveModifier<T>(this PlayerControl player, Func<T, bool>? predicate = null)
+        where T : BaseModifier
+    {
+        player.GetModifierComponent().RemoveModifier(predicate);
+    }
+
+    /// <summary>
+    /// Removes a specific modifier from the player by type.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="type">The type of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    public static void RemoveModifier(this PlayerControl player, Type type, Func<BaseModifier, bool>? predicate = null)
+    {
+        player.GetModifierComponent().RemoveModifier(type, predicate);
+    }
+
+    /// <summary>
+    /// Removes a specific modifier from the player by its type ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="typeId">The type ID of the modifier.</param>
+    /// <param name="predicate">Optional predicate to filter the modifiers.</param>
+    public static void RemoveModifier(
+        this PlayerControl player,
+        uint typeId,
+        Func<BaseModifier, bool>? predicate = null)
+    {
+        player.GetModifierComponent().RemoveModifier(typeId, predicate);
+    }
+
+    /// <summary>
+    /// Removes a specific modifier from the player by its GUID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="uniqueId">The GUID of the modifier.</param>
+    public static void RemoveModifier(
+        this PlayerControl player,
+        Guid uniqueId)
+    {
+        player.GetModifierComponent().RemoveModifier(uniqueId);
+    }
+
+    /// <summary>
+    /// Adds a specific modifier to the player.
+    /// </summary>
+    /// <typeparam name="T">The type of the modifier.</typeparam>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    /// <returns>The added modifier.</returns>
+    public static T? AddModifier<T>(this PlayerControl player, params object[] args) where T : BaseModifier
+    {
+        return player.GetModifierComponent().AddModifier<T>(args);
+    }
+
+    /// <summary>
+    /// Adds a specific modifier to the player.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="modifier">The modifier to add.</param>
+    /// <returns>The added modifier.</returns>
+    public static BaseModifier? AddModifier(this PlayerControl player, BaseModifier modifier)
+    {
+        return player.GetModifierComponent().AddModifier(modifier);
+    }
+
+    /// <summary>
+    /// Adds a specific modifier to the player by type.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="type">The type of the modifier.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    /// <returns>The added modifier.</returns>
+    public static BaseModifier? AddModifier(this PlayerControl player, Type type, params object[] args)
+    {
+        return player.GetModifierComponent().AddModifier(type, args);
+    }
+
+    /// <summary>
+    /// Adds a specific modifier to the player by type ID.
+    /// </summary>
+    /// <param name="player">The PlayerControl instance.</param>
+    /// <param name="typeId">The type ID of the modifier.</param>
+    /// <param name="args">The arguments to initialize the modifier constructor with.</param>
+    /// <returns>The added modifier.</returns>
+    public static BaseModifier? AddModifier(this PlayerControl player, uint typeId, params object[] args)
+    {
+        return player.GetModifierComponent().AddModifier(typeId, args);
+    }
+}

MiraAPI/Modifiers/ModifierFactory.cs

@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.Modifiers;
+
+/// <summary>
+/// Factory for creating instances of a modifier. More efficient than using reflection.
+/// </summary>
+public static class ModifierFactory
+{
+    private static readonly Dictionary<(Type, Type[]), Func<object[], BaseModifier>> _constructorCache = [];
+
+    private static Func<object[], BaseModifier> CreateConstructor(Type type, params object[] args)
+    {
+        var constructorInfo = type.GetBestConstructor(args) ?? throw new InvalidOperationException(
+            $"Could not find a constructor for type {type} with the specified arguments.");
+
+        var parameters = constructorInfo.GetParameters();
+
+        var argsParam = Expression.Parameter(typeof(object[]), "args");
+        var constructorParams = new Expression[parameters.Length];
+
+        for (var i = 0; i < parameters.Length; i++)
+        {
+            var paramType = parameters[i].ParameterType;
+            var paramAccess = Expression.ArrayIndex(argsParam, Expression.Constant(i));
+            var convertedParam = Expression.Convert(paramAccess, paramType);
+            constructorParams[i] = convertedParam;
+        }
+
+        var newExpr = Expression.New(constructorInfo, constructorParams);
+        var lambda = Expression.Lambda<Func<object[], BaseModifier>>(newExpr, argsParam);
+
+        return lambda.Compile();
+    }
+
+    /// <summary>
+    /// Creates a modifier with the specified type and arguments.
+    /// </summary>
+    /// <param name="type">Modifier type.</param>
+    /// <param name="args">Arguments.</param>
+    /// <returns>An instance of the modifier.</returns>
+    public static BaseModifier CreateInstance(Type type, params object[] args)
+    {
+        var argTypes = args.Select(arg => arg?.GetType() ?? typeof(object)).ToArray();
+        var key = (type, argTypes);
+
+        if (!_constructorCache.TryGetValue(key, out var constructor))
+        {
+            constructor = CreateConstructor(type, args);
+            _constructorCache[key] = constructor;
+        }
+
+        return constructor(args);
+    }
+}
+
+/// <summary>
+/// Factory for creating instances of a modifier. More efficient than using reflection.
+/// </summary>
+/// <typeparam name="T">The modifier type.</typeparam>
+public static class ModifierFactory<T> where T : BaseModifier
+{
+    private static readonly Func<object[], T> Constructor = CreateConstructor();
+
+    private static Func<object[], T> CreateConstructor(params object[] args)
+    {
+        var constructorInfo = typeof(T).GetBestConstructor(args) ?? throw new InvalidOperationException(
+            $"Could not find a constructor for type {typeof(T)} with the specified arguments.");
+
+        var parameters = constructorInfo.GetParameters();
+
+        var argsParam = Expression.Parameter(typeof(object[]), "args");
+        var constructorParams = new Expression[parameters.Length];
+
+        for (var i = 0; i < parameters.Length; i++)
+        {
+            var paramType = parameters[i].ParameterType;
+            var paramAccess = Expression.ArrayIndex(argsParam, Expression.Constant(i));
+            var convertedParam = Expression.Convert(paramAccess, paramType);
+            constructorParams[i] = convertedParam;
+        }
+
+        var newExpr = Expression.New(constructorInfo, constructorParams);
+        var lambda = Expression.Lambda<Func<object[], T>>(newExpr, argsParam);
+
+        return lambda.Compile();
+    }
+
+    /// <summary>
+    /// Creates an instance of the modifier.
+    /// </summary>
+    /// <param name="args">Parameters for the constructor.</param>
+    /// <returns>An instance of the modifier.</returns>
+    public static T CreateInstance(params object[] args)
+    {
+        return Constructor(args);
+    }
+}

MiraAPI/Modifiers/ModifierManager.cs

@@ -1,12 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Serialization;
 using MiraAPI.Modifiers.Types;
-using MiraAPI.Networking;
 using MiraAPI.PluginLoading;
 using MiraAPI.Roles;
 using MiraAPI.Utilities;
-using Reactor.Networking.Rpc;
 using Reactor.Utilities;
 using Reactor.Utilities.Extensions;
 using Random = System.Random;
@@ -20,17 +19,18 @@ 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;
+    private static uint _nextTypeId;
 
-    private static uint GetNextId()
+    private static uint GetNextTypeId()
     {
-        _nextId++;
-        return _nextId;
+        _nextTypeId++;
+        return _nextTypeId;
     }
 
     /// <summary>
-    /// Gets the modifier type from the id.
+    /// Gets the modifier type from the type id.
     /// </summary>
     /// <param name="id">The ID.</param>
     /// <returns>The Type of the modifier.</returns>
@@ -44,160 +44,134 @@ public static class ModifierManager
     /// </summary>
     /// <param name="type">The Type.</param>
     /// <returns>The ID of the modifier.</returns>
-    public static uint? GetModifierId(Type type)
+    public static uint? GetModifierTypeId(Type type)
     {
-        return TypeToIdModifierMap.GetValueOrDefault(type);
+        if (!TypeToIdModifierMap.TryGetValue(type, out var id))
+        {
+            return null;
+        }
+
+        return id;
     }
 
-    internal static void RegisterModifier(Type modifierType)
+    internal static bool RegisterModifier(Type modifierType, MiraPluginInfo info)
     {
         if (!typeof(BaseModifier).IsAssignableFrom(modifierType))
         {
-            return;
+            return false;
         }
 
-        IdToTypeModifierMap.Add(GetNextId(), modifierType);
-        TypeToIdModifierMap.Add(modifierType, _nextId);
+        IdToTypeModifierMap.Add(GetNextTypeId(), modifierType);
+        TypeToIdModifierMap.Add(modifierType, _nextTypeId);
+
+        BaseModifier modifier;
+        if (modifierType.GetConstructor(Type.EmptyTypes) != null)
+        {
+            modifier = (BaseModifier)Activator.CreateInstance(modifierType)!;
+        }
+        else
+        {
+            // this is probably terrible but its good enough for now.
+            modifier = (BaseModifier)FormatterServices.GetUninitializedObject(modifierType);
+        }
+
+        info.Modifiers.Add(modifier);
+
+        if (modifier is not GameModifier gameModifier)
+        {
+            return true;
+        }
+
+        if (modifierType.GetConstructor(Type.EmptyTypes) == null)
+        {
+            Logger<MiraApiPlugin>.Error($"Game Modifier {modifierType.FullName} does not have a parameterless constructor!");
+            return false;
+        }
+
+        var priority = gameModifier.Priority();
+
+        if (!PrioritiesToIdsMap.TryGetValue(priority, out var list))
+        {
+            PrioritiesToIdsMap[priority] = list = [];
+        }
+
+        list.Add(_nextTypeId);
+        return true;
     }
 
     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 || plr == null)
+                {
+                    Logger<MiraApiPlugin>.Warning($"Somehow valid players for modifier {mod!.ModifierName} disappeared");
+                }
+                else
+                {
+                    plr.RpcAddModifier(id);
+                }
+            }
         }
     }
 
     private static bool IsGameModifierValid(PlayerControl player, GameModifier modifier, uint modifierId)
     {
         return (player.Data.Role is not ICustomRole role || role.IsModifierApplicable(modifier)) &&
-               modifier.IsModifierValidOn(player.Data.Role) &&
-               !player.HasModifier(modifierId);
-    }
-
-    internal static void SyncAllModifiers(int targetId = -1)
-    {
-        var data = new List<NetData>();
-
-        foreach (var player in PlayerControl.AllPlayerControls)
-        {
-            data.Add(GetPlayerModifiers(player));
-        }
-
-        Rpc<SyncModifiersRpc>.Instance.SendTo(PlayerControl.LocalPlayer, targetId, [.. data]);
-    }
-
-    internal static void HandleSyncModifiers(NetData[] data)
-    {
-        foreach (var netData in data)
-        {
-            var ids = new uint[netData.Data.Length / 4];
-            Buffer.BlockCopy(netData.Data, 0, ids, 0, netData.Data.Length);
-
-            var plr = GameData.Instance.GetPlayerById((byte)netData.Id).Object;
-            var modifierComponent = plr.GetComponent<ModifierComponent>();
-
-            if (!modifierComponent)
-            {
-                continue;
-            }
-
-            modifierComponent.ClearModifiers();
-
-            foreach (var id in ids)
-            {
-                if (!IdToTypeModifierMap.TryGetValue(id, out var type))
-                {
-                    Logger<MiraApiPlugin>.Error($"Cannot add modifier with id {id} because it is not registered.");
-                    continue;
-                }
-
-                modifierComponent.AddModifier(type);
-            }
-        }
-    }
-
-    private static NetData GetPlayerModifiers(PlayerControl? player)
-    {
-        if (player == null || !player)
-        {
-            return new NetData(0, []);
-        }
-
-        List<byte> bytes = [];
-        var modifierComponent = player.GetComponent<ModifierComponent>();
-        if (modifierComponent == null || !modifierComponent)
-        {
-            return new NetData(player.PlayerId, []);
-        }
-
-        foreach (var modifier in modifierComponent.ActiveModifiers)
-        {
-            bytes.AddRange(BitConverter.GetBytes(TypeToIdModifierMap[modifier.GetType()]));
-        }
-
-        return new NetData(player.PlayerId, [.. bytes]);
+               modifier.IsModifierValidOn(player.Data.Role) && !player.HasModifier(modifierId);
     }
 }

MiraAPI/Modifiers/RegisterModifierAttribute.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace MiraAPI.Modifiers;
-
-/// <summary>
-/// Marks a class as a modifier that can be registered with the <see cref="ModifierManager"/>.
-/// </summary>
-[AttributeUsage(AttributeTargets.Class)]
-public class RegisterModifierAttribute : Attribute;

MiraAPI/Modifiers/Types/GameModifier.cs

@@ -5,6 +5,9 @@
 /// </summary>
 public abstract class GameModifier : BaseModifier
 {
+    /// <inheritdoc />
+    public override bool ShowInFreeplay => true;
+
     /// <summary>
     /// Gets the chance of the modifier being assigned to a player.
     /// </summary>
@@ -17,6 +20,12 @@ 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>
@@ -27,6 +36,7 @@ public abstract class GameModifier : BaseModifier
     /// <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

@@ -17,7 +17,7 @@ public abstract class TimedModifier : BaseModifier
     /// <summary>
     /// Gets a value indicating whether the timer should start automatically when added.
     /// </summary>
-    public virtual bool AutoStart => false;
+    public virtual bool AutoStart => true;
 
     /// <summary>
     /// Gets a value indicating whether the modifier should be removed when the timer completes.
@@ -27,7 +27,9 @@ public abstract class TimedModifier : BaseModifier
     /// <summary>
     /// Called when the timer completes.
     /// </summary>
-    public abstract void OnTimerComplete();
+    public virtual void OnTimerComplete()
+    {
+    }
 
     /// <summary>
     /// Gets or sets a value indicating whether the timer is active.
@@ -102,7 +104,7 @@ public abstract class TimedModifier : BaseModifier
 
         if (RemoveOnComplete)
         {
-            ModifierComponent?.RemoveModifier(ModifierId);
+            ModifierComponent?.RemoveModifier(this);
         }
     }
 

MiraAPI/Networking/CustomGameOverRpc.cs

@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using Hazel;
+using InnerNet;
+using MiraAPI.GameEnd;
+using Reactor.Networking.Attributes;
+using Reactor.Networking.Rpc;
+using Reactor.Utilities;
+
+namespace MiraAPI.Networking;
+
+/// <summary>
+/// Custom Game Over RPC.
+/// </summary>
+/// <inheritdoc />
+[RegisterCustomRpc((uint)MiraRpc.CustomGameOver)]
+public class CustomGameOverRpc(MiraApiPlugin plugin, uint id) : PlayerCustomRpc<MiraApiPlugin, GameOverData>(plugin, id)
+{
+    /// <inheritdoc />
+    public override RpcLocalHandling LocalHandling => RpcLocalHandling.After;
+
+    /// <inheritdoc />
+    public override void Write(MessageWriter writer, GameOverData data)
+    {
+        writer.WritePacked(data.Reason);
+        writer.WritePacked(data.Winners.Count);
+        foreach (var player in data.Winners)
+        {
+            writer.WriteNetObject(player);
+        }
+    }
+
+    /// <inheritdoc />
+    public override GameOverData Read(MessageReader reader)
+    {
+        var reason = reader.ReadPackedInt32();
+        var count = reader.ReadPackedInt32();
+        var data = new List<NetworkedPlayerInfo>(count);
+        for (var i = 0; i < count; i++)
+        {
+            data.Add(reader.ReadNetObject<NetworkedPlayerInfo>());
+        }
+
+        return new GameOverData(reason, data);
+    }
+
+    /// <inheritdoc />
+    public override void Handle(PlayerControl innerNetObject, GameOverData data)
+    {
+        if (GameOverManager.TryGetGameOver(data.Reason, out var gameOver))
+        {
+            if (!gameOver.VerifyCondition(innerNetObject, [.. data.Winners]))
+            {
+                Logger<MiraApiPlugin>.Info($"Game over condition not met for {gameOver.GetType().Name}");
+                return;
+            }
+
+            CustomGameOver.Instance = gameOver;
+
+            if (AmongUsClient.Instance.AmHost)
+            {
+                GameManager.Instance.RpcEndGame(gameOver, false);
+            }
+        }
+        else
+        {
+            CustomGameOver.Instance = null;
+            Logger<MiraApiPlugin>.Error($"Unknown game over reason: {data.Reason}");
+        }
+    }
+}

MiraAPI/Networking/CustomMurderRpc.cs

@@ -3,9 +3,10 @@ using System.Linq;
 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 UnityEngine;
 
@@ -39,6 +40,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(
@@ -73,7 +83,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))
         {
@@ -106,7 +115,6 @@ public static class CustomMurderRpc
                 target.RemoveProtection();
             }
 
-            Logger<MiraApiPlugin>.Error($"{source.PlayerId} failed to murder {target.PlayerId} due to guardian angel protection");
             return;
         }
 
@@ -174,7 +182,6 @@ public static class CustomMurderRpc
             source.shapeshiftTargetPlayerId,
             target.PlayerId);
         source.MyPhysics.StartCoroutine(source.KillAnimations.Random()?.CoPerformCustomKill(source, target, createDeadBody, teleportMurderer));
-        Logger<MiraApiPlugin>.Error($"{source.PlayerId} succeeded in murdering {target.PlayerId}");
     }
 
     /// <summary>
@@ -240,11 +247,11 @@ public static class CustomMurderRpc
         }
 
         target.Die(DeathReason.Kill, true);
-        yield return source.MyPhysics.Animations.CoPlayCustomAnimation(anim.BlurAnim);
-        sourcePhys.Animations.PlayIdleAnimation();
 
         if (teleportMurderer)
         {
+            yield return source.MyPhysics.Animations.CoPlayCustomAnimation(anim.BlurAnim);
+            sourcePhys.Animations.PlayIdleAnimation();
             source.NetTransform.SnapTo(target.transform.position);
             KillAnimation.SetMovement(source, true);
         }
@@ -256,6 +263,9 @@ public static class CustomMurderRpc
             deadBody.enabled = true;
         }
 
+        var afterMurderEvent = new AfterMurderEvent(source, target);
+        MiraEventManager.InvokeEvent(afterMurderEvent);
+
         if (!isParticipant)
         {
             yield break;

MiraAPI/Networking/GuidConverter.cs

@@ -0,0 +1,32 @@
+using System;
+using Hazel;
+using Reactor.Networking.Attributes;
+using Reactor.Networking.Serialization;
+
+namespace MiraAPI.Networking;
+
+/// <summary>
+/// Converter for <see cref="Guid"/>.
+/// </summary>
+[MessageConverter]
+public class GuidConverter : MessageConverter<Guid>
+{
+    /// <summary>
+    /// Writes a <see cref="Guid"/> to the writer.
+    /// </summary>
+    /// <inheritdoc />
+    public override void Write(MessageWriter writer, Guid value)
+    {
+        writer.WriteBytesAndSize(value.ToByteArray());
+    }
+
+    /// <summary>
+    /// Reads a <see cref="Guid"/> from the reader.
+    /// </summary>
+    /// <inheritdoc />
+    /// <returns>A GUID object.</returns>
+    public override Guid Read(MessageReader reader, Type objectType)
+    {
+        return new Guid(reader.ReadBytesAndSize());
+    }
+}

MiraAPI/Networking/MiraRpc.cs

@@ -34,4 +34,9 @@ public enum MiraRpc : uint
     /// Custom Murder RPC.
     /// </summary>
     CustomMurder,
+
+    /// <summary>
+    /// Custom Game Over RPC.
+    /// </summary>
+    CustomGameOver,
 }

MiraAPI/Networking/Modifiers/AddModifierRpc.cs

@@ -0,0 +1,76 @@
+using System;
+using Hazel;
+using MiraAPI.Modifiers;
+using Reactor.Networking.Attributes;
+using Reactor.Networking.Rpc;
+using Reactor.Networking.Serialization;
+
+namespace MiraAPI.Networking.Modifiers;
+
+/// <summary>
+/// Remote procedure call for adding a modifier.
+/// </summary>
+/// <param name="plugin">Mira plugin.</param>
+/// <param name="id">RPC ID.</param>
+[RegisterCustomRpc((uint)MiraRpc.AddModifier)]
+public class AddModifierRpc(MiraApiPlugin plugin, uint id) : PlayerCustomRpc<MiraApiPlugin, ModifierData>(plugin, id)
+{
+    /// <inheritdoc />
+    public override RpcLocalHandling LocalHandling => RpcLocalHandling.Before;
+
+    /// <inheritdoc />
+    public override void Write(MessageWriter writer, ModifierData data)
+    {
+        writer.WritePacked(data.TypeId);
+        writer.WriteBytesAndSize(data.UniqueId.ToByteArray());
+        writer.WritePacked(data.Args.Length);
+        foreach (var arg in data.Args)
+        {
+            writer.Write(arg.GetType().AssemblyQualifiedName);
+            writer.Serialize(arg);
+        }
+    }
+
+    /// <inheritdoc />
+    public override ModifierData Read(MessageReader reader)
+    {
+        var modId = reader.ReadPackedUInt32();
+        var guid = new Guid(reader.ReadBytesAndSize());
+        var argCount = reader.ReadPackedUInt32();
+        var objects = new object[argCount];
+
+        if (argCount > 0)
+        {
+            var types = new Type[argCount];
+            for (var i = 0; i < argCount; i++)
+            {
+                var name = reader.ReadString();
+                types[i] = Type.GetType(name) ?? throw new InvalidOperationException($"Type not found: {name}");
+                objects[i] = reader.Deserialize(types[i]);
+            }
+        }
+
+        return new ModifierData(modId, guid, objects);
+    }
+
+    /// <inheritdoc />
+    public override void Handle(PlayerControl player, ModifierData data)
+    {
+        var type = ModifierManager.GetModifierType(data.TypeId) ?? throw new InvalidOperationException($"Modifier type not found for ID {data.TypeId}.");
+        BaseModifier? modifier;
+        if (data.Args.Length > 0)
+        {
+            modifier = ModifierFactory.CreateInstance(type, data.Args);
+        }
+        else
+        {
+            modifier = Activator.CreateInstance(type) as BaseModifier;
+            if (modifier == null)
+            {
+                throw new InvalidOperationException($"Cannot add modifier {type.Name} because it is not a valid modifier.");
+            }
+        }
+        modifier.UniqueId = data.UniqueId;
+        player.AddModifier(modifier);
+    }
+}

MiraAPI/Networking/Modifiers/ModifierConverter.cs

@@ -0,0 +1,40 @@
+using System;
+using Hazel;
+using InnerNet;
+using MiraAPI.Modifiers;
+using Reactor.Networking.Attributes;
+using Reactor.Networking.Serialization;
+
+namespace MiraAPI.Networking.Modifiers;
+
+/// <summary>
+/// Converter for serializing and deserializing <see cref="BaseModifier"/> objects.
+/// </summary>
+[MessageConverter]
+public class ModifierConverter : MessageConverter<BaseModifier>
+{
+    /// <summary>
+    /// Writes a <see cref="BaseModifier"/> to the writer.
+    /// </summary>
+    /// <param name="writer">The writer to write to.</param>
+    /// <param name="value">The <see cref="BaseModifier"/> to write.</param>
+    public override void Write(MessageWriter writer, BaseModifier value)
+    {
+        writer.WriteNetObject(value.Player);
+        writer.WriteBytesAndSize(value.UniqueId.ToByteArray());
+    }
+
+    /// <summary>
+    /// Reads a <see cref="BaseModifier"/> from the reader.
+    /// </summary>
+    /// <param name="reader">The reader to read from.</param>
+    /// <param name="objectType">The type of the object to read.</param>
+    /// <returns>The <see cref="BaseModifier"/> that was read.</returns>
+    /// <exception cref="InvalidOperationException">Thrown if the modifier is not found.</exception>
+    public override BaseModifier Read(MessageReader reader, Type objectType)
+    {
+        var player = reader.ReadNetObject<PlayerControl>();
+        var guid = new Guid(reader.ReadBytesAndSize());
+        return player.GetModifier(guid) ?? throw new InvalidOperationException($"Modifier with GUID {guid} not found for player with ID: {player.PlayerId}");
+    }
+}

MiraAPI/Networking/Modifiers/ModifierData.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace MiraAPI.Networking.Modifiers;
+
+/// <summary>
+/// Modifier data for networking.
+/// </summary>
+/// <param name="TypeId">The ID of the modifier.</param>
+/// <param name="UniqueId">The unique ID of the modifier.</param>
+/// <param name="Args">Parameters for constructor.</param>
+public record struct ModifierData(uint TypeId, Guid UniqueId, object[] Args);

MiraAPI/Networking/SyncModifiersRpc.cs

@@ -1,52 +0,0 @@
-using Hazel;
-using MiraAPI.Modifiers;
-using Reactor.Networking.Attributes;
-using Reactor.Networking.Rpc;
-
-namespace MiraAPI.Networking;
-
-[RegisterCustomRpc((uint)MiraRpc.SyncModifiers)]
-internal sealed class SyncModifiersRpc(MiraApiPlugin plugin, uint id) : PlayerCustomRpc<MiraApiPlugin, NetData[]>(plugin, id)
-{
-    public override RpcLocalHandling LocalHandling => RpcLocalHandling.None;
-
-    public override void Write(MessageWriter writer, NetData[]? data)
-    {
-        if (data == null)
-        {
-            writer.WritePacked(0U);
-            return;
-        }
-
-        writer.WritePacked((uint)data.Length);
-        foreach (var netData in data)
-        {
-            writer.WritePacked(netData.Id);
-            writer.WriteBytesAndSize(netData.Data);
-        }
-    }
-
-    public override NetData[] Read(MessageReader reader)
-    {
-        var length = reader.ReadPackedUInt32();
-        var data = new NetData[length];
-        for (var i = 0; i < length; i++)
-        {
-            var dataId = reader.ReadPackedUInt32();
-            var bytes = reader.ReadBytesAndSize();
-            data[i] = new NetData(dataId, bytes);
-        }
-
-        return data;
-    }
-
-    public override void Handle(PlayerControl playerControl, NetData[]? data)
-    {
-        if (AmongUsClient.Instance.HostId != playerControl.OwnerId)
-        {
-            return;
-        }
-
-        ModifierManager.HandleSyncModifiers(data ?? []);
-    }
-}

MiraAPI/Patches/AmongUsClientSyncPatch.cs

@@ -1,19 +1,25 @@
 using HarmonyLib;
 using InnerNet;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Player;
 using MiraAPI.GameOptions;
-using MiraAPI.Modifiers;
 using MiraAPI.Roles;
 
 namespace MiraAPI.Patches;
 
 /// <summary>
-/// Sync all options, role settings, and modifiers to the player when they join the game.
+/// Sync all settings to the player when they join the game.
 /// </summary>
-[HarmonyPatch(typeof(AmongUsClient), nameof(AmongUsClient.CreatePlayer))]
-public static class AmongUsClientSyncPatch
+[HarmonyPatch(typeof(AmongUsClient))]
+internal 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;
@@ -26,6 +32,13 @@ public static class AmongUsClientSyncPatch
 
         ModdedOptionsManager.SyncAllOptions(clientData.Id);
         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/Colors/ScrollingColorsPatch.cs

@@ -4,17 +4,19 @@ using UnityEngine;
 
 namespace MiraAPI.Patches.Colors;
 
-[HarmonyPatch(typeof(PlayerTab))]
+/// <summary>
+/// This patch adds scrolling to the colors tab in the player customization menu.
+/// </summary>
+[HarmonyPatch(typeof(PlayerTab), nameof(PlayerTab.OnEnable))]
 public static class ScrollingColorsPatch
 {
     // Collider
     private static BoxCollider2D? _collider;
 
     /// <summary>
-    /// Add scrolling to the colors tab
+    /// Add scrolling to the colors tab.
     /// </summary>
-    [HarmonyPostfix, HarmonyPatch("OnEnable")]
-    public static void AddScrollingToColorsTabPatch(PlayerTab __instance)
+    public static void Postfix(PlayerTab __instance)
     {
         if (!PlayerCustomizationMenu.Instance)
         {

MiraAPI/Patches/Events/CanUsePatches.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Reflection;
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Usables;
+
+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)
+    {
+        canUse = couldUse = false;
+
+        IUsable usable = __instance.Cast<IUsable>();
+        if (usable != null)
+        {
+            var @event = new PlayerCanUseEvent(__instance.Cast<IUsable>());
+            MiraEventManager.InvokeEvent(@event);
+
+            return !@event.IsCancelled;
+        }
+
+        return true;
+    }
+}

MiraAPI/Patches/Events/EndGamePatches.cs

@@ -0,0 +1,33 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Gameplay;
+using MiraAPI.GameEnd;
+
+namespace MiraAPI.Patches.Events;
+
+[HarmonyPatch(typeof(EndGameManager), nameof(EndGameManager.SetEverythingUp))]
+internal static class EndGamePatches
+{
+    public static bool Prefix(EndGameManager __instance)
+    {
+        if (CustomGameOver.Instance is not { } gameOver)
+        {
+            return true;
+        }
+
+        var result = gameOver.BeforeEndGameSetup(__instance);
+        return result;
+    }
+
+    public static void Postfix(EndGameManager __instance)
+    {
+        if (CustomGameOver.Instance is { } gameOver)
+        {
+            gameOver.AfterEndGameSetup(__instance);
+            CustomGameOver.Instance = null;
+        }
+
+        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.Events;
+
+/// <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/ReportBodyEventPatch.cs

@@ -0,0 +1,19 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Meeting;
+using MiraAPI.Utilities;
+
+namespace MiraAPI.Patches.Events;
+
+[HarmonyPatch(typeof(PlayerControl), nameof(PlayerControl.CmdReportDeadBody))]
+public static class ReportBodyEventPatch
+{
+    public static bool Prefix(PlayerControl __instance, NetworkedPlayerInfo? target)
+    {
+        var body = target != null ? Helpers.GetBodyById(target.PlayerId) : null;
+
+        var @event = new ReportBodyEvent(__instance, target, body);
+        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,15 @@
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Meeting;
+
+namespace MiraAPI.Patches.Events;
+
+[HarmonyPatch(typeof(MeetingHud), nameof(MeetingHud.Start))]
+public static class StartMeetingEventPatch
+{
+    public static void Postfix(MeetingHud __instance)
+    {
+        var @event = new StartMeetingEvent(__instance);
+        MiraEventManager.InvokeEvent(@event);
+    }
+}

MiraAPI/Patches/Events/UsePatches.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using System.Reflection;
+using HarmonyLib;
+using MiraAPI.Events;
+using MiraAPI.Events.Vanilla.Usables;
+
+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;
+    }
+}