Game modes

MiraAPI.Example/GameModes/ExampleMode.cs

@@ -0,0 +1,11 @@
+using MiraAPI.GameModes;
+using UnityEngine;
+
+namespace MiraAPI.Example.GameModes;
+
+public class ExampleMode : AbstractGameMode
+{
+    public override string Name => "Example Mode";
+    public override string Description => "An example gamemode.";
+    public override Color Color => Color.red;
+}

MiraAPI/Events/MiraCancelableEvent.cs

@@ -1,8 +1,11 @@
-namespace MiraAPI.Events;
+using MiraAPI.PluginLoading;
+
+namespace MiraAPI.Events;
 
 /// <summary>
 /// Abstract class for Mira Events that can be cancelled.
 /// </summary>
+[MiraIgnore]
 public abstract class MiraCancelableEvent : MiraEvent
 {
     /// <summary>

MiraAPI/Events/MiraEvent.cs

@@ -1,6 +1,9 @@
-namespace MiraAPI.Events;
+using MiraAPI.PluginLoading;
+
+namespace MiraAPI.Events;
 
 /// <summary>
 /// Abstract class for Mira Events.
 /// </summary>
+[MiraIgnore]
 public abstract class MiraEvent;

MiraAPI/GameModes/CustomGameMode.cs → MiraAPI/GameModes/AbstractGameMode.cs

@@ -1,11 +1,17 @@
-using System.Collections.Generic;
+using System.Collections;
+using System.Collections.Generic;
+using MiraAPI.GameOptions;
+using MiraAPI.PluginLoading;
+using Reactor.Utilities.Extensions;
+using UnityEngine;
 
 namespace MiraAPI.GameModes;
 
 /// <summary>
 /// Base class for custom gamemodes.
 /// </summary>
-public abstract class CustomGameMode
+[MiraIgnore]
+public abstract class AbstractGameMode : IOptionable
 {
     /// <summary>
     /// Gets the game mode name.
@@ -18,9 +24,57 @@ public abstract class CustomGameMode
     public abstract string Description { get; }
 
     /// <summary>
-    /// Gets the game mode ID.
+    /// Gets the game mode description.
     /// </summary>
-    public abstract int Id { get; }
+    public virtual Color Color { get; } = Color.white;
+
+    /// <summary>
+    /// Gets the colored game mode name, using the color and name properties.
+    /// </summary>
+    public string ColoredName => $"<color=#{Color.ToHtmlStringRGBA()}>{Name}</color>";
+
+    /// <summary>
+    /// Gets the game mode id.
+    /// </summary>
+    public uint ID { get; internal set; }
+
+    /// <summary>
+    /// Gets a value indicating whether a specific body type is used by the game mode.
+    /// </summary>
+    public virtual bool GameModeBodyTypeOverride => false;
+
+    /// <summary>
+    /// Gets a value indicating whether the gamemode is based on Hide n Seek.
+    /// </summary>
+    public virtual bool IsHideAndSeek => false;
+
+    /// <summary>
+    /// Gets a value indicating whether the gamemode removes the normal game settings.
+    /// </summary>
+    public virtual bool ShowNormalGameSettings => true;
+
+    /// <summary>
+    /// Called on GameManager.GetBodyType().
+    /// </summary>
+    /// <param name="player">Player to get body type from.</param>
+    /// <returns>Resulting body type.</returns>
+    public virtual PlayerBodyTypes GetBodyType(PlayerControl player)
+    {
+        if (AprilFoolsMode.ShouldHorseAround())
+        {
+            return PlayerBodyTypes.Horse;
+        }
+        if (AprilFoolsMode.ShouldLongAround())
+        {
+            return PlayerBodyTypes.Long;
+        }
+        return PlayerBodyTypes.Normal;
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether a custom intro sequence is implemented by the game mode.
+    /// </summary>
+    public virtual bool ShowGameModeIntroCutscene => false;
 
     /// <summary>
     /// Called when Intro Cutscene is destroyed.
@@ -49,8 +103,10 @@ public virtual void HudUpdate(HudManager instance)
     /// Called when a player is killed.
     /// </summary>
     /// <param name="player">PlayerControl that was killed.</param>
-    public virtual void OnDeath(PlayerControl player)
+    /// <param name="assignGhostRole">Determines whether to assign a ghost role on the player.</param>
+    public virtual void OnPlayerDeath(PlayerControl player, bool assignGhostRole)
     {
+        GameManager.Instance.LogicRoleSelection.OnPlayerDeath(player, assignGhostRole);
     }
 
     /// <summary>
@@ -85,29 +141,21 @@ public virtual void CanKill(out bool runOriginal, out bool result, PlayerControl
         runOriginal = true;
     }
 
-    /// <summary>
-    /// Should Roles Settings be available when this gamemode is selected.
-    /// </summary>
-    /// <returns>True if Role Settings are enabled in this game mode.</returns>
-    public virtual bool AreRoleSettingsEnabled() => true;
-
-    /// <summary>
-    /// Should Game Settings be available when this gamemode is selected.
-    /// </summary>
-    /// <returns>True if Game Settings are enabled in this mode.</returns>
-    public virtual bool AreGameSettingsEnabled() => true;
-
     /// <summary>
     /// Custom winner selection.
     /// </summary>
     /// <returns>List of winners or null.</returns>
     public virtual List<NetworkedPlayerInfo>? CalculateWinners() => null;
 
     /// <summary>
-    /// Show gamemode in Intro Cutscene.
+    /// The IEnumerator that plays the intro cutscene for this gamemode.
     /// </summary>
-    /// <returns>True if the game mode should be shown in the intro cutscene.</returns>
-    public virtual bool ShowGameModeIntroCutscene() => false;
+    /// <param name="__instance">An instance of IntroCutscene.</param>
+    /// <returns>An IEnumerator to run the intro cutscene instead of the base game one.</returns>
+    public virtual IEnumerator IntroCutscene(IntroCutscene __instance)
+    {
+        yield return new WaitForEndOfFrame();
+    }
 
     /// <summary>
     /// Can Admin be used in this gamemode.
@@ -151,4 +199,7 @@ public virtual void CanKill(out bool runOriginal, out bool result, PlayerControl
     /// <param name="playerInfo">Player attempting to vent.</param>
     /// <returns>True if venting is enabled in this mode.</returns>
     public virtual bool CanVent(Vent vent, NetworkedPlayerInfo playerInfo) => true;
+
+    /// <inheritdoc/>
+    public override string ToString() => Name;
 }

MiraAPI/GameModes/ClassicMode.cs

@@ -0,0 +1,16 @@
+using MiraAPI.PluginLoading;
+
+namespace MiraAPI.GameModes;
+
+/// <summary>
+/// The classic game mode.
+/// </summary>
+[MiraIgnore]
+public class ClassicMode : AbstractGameMode
+{
+    /// <inheritdoc/>
+    public override string Name => "Classic";
+
+    /// <inheritdoc/>
+    public override string Description => "The classic Among Us experience";
+}

MiraAPI/GameModes/CustomGameModeManager.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using MiraAPI.PluginLoading;
 using Reactor.Utilities;
 
 namespace MiraAPI.GameModes;
@@ -10,62 +10,109 @@
 /// </summary>
 public static class CustomGameModeManager
 {
-    /// <summary>
-    /// List of registered gamemodes.
-    /// </summary>
-    internal static readonly Dictionary<int, CustomGameMode> GameModes = [];
+    internal static readonly Dictionary<uint, AbstractGameMode> IdToModeMap = [];
 
-    public static bool IsDefault()
-    {
-        return ActiveMode?.Id == 0;
-    }
+    private static uint GetNextId() => ++LastId;
 
-    /// <summary>
-    /// Gets the current gamemode.
-    /// </summary>
-    public static CustomGameMode? ActiveMode { get; internal set; } = new DefaultMode();
+    private static uint LastId { get; set; }
 
     /// <summary>
-    /// Set current gamemode.
+    /// Register gamemode from type.
     /// </summary>
-    /// <param name="id">gamemode ID.</param>
-    public static void SetGameMode(int id)
+    /// <param name="gameModeType">Type of gamemode class, should inherit from <see cref="AbstractGameMode"/>.</param>
+    /// <param name="pluginInfo">The custom plugin info of the mod.</param>
+    internal static void RegisterGameMode(Type gameModeType, MiraPluginInfo pluginInfo)
     {
-        if (GameModes.TryGetValue(id, out var gameMode))
+        if (!typeof(AbstractGameMode).IsAssignableFrom(gameModeType))
         {
-            ActiveMode = gameMode;
+            Warning($"{gameModeType.Name} does not inherit CustomGameMode!");
             return;
         }
 
-        Error($"No gamemode with id {id} found!");
+        var instance = Activator.CreateInstance(gameModeType);
+
+        if (instance is not AbstractGameMode mode)
+        {
+            Error($"Failed to create instance of {gameModeType.Name}");
+            return;
+        }
+
+        IdToModeMap.Add(GetNextId(), mode);
+        pluginInfo.GameModes.Add(LastId, mode);
+        GameModeOption.AddOption(mode);
+        mode.ID = LastId;
     }
 
     /// <summary>
-    /// Register gamemode from type.
+    /// Checks to see if the classic game mode is on.
+    /// </summary>
+    /// <returns>True if the classic mode is the current one.</returns>
+    public static bool IsClassic() => IsActiveGameMode<ClassicMode>();
+
+    /// <summary>
+    /// Checks to see if the HNS game mode is on.
+    /// </summary>
+    /// <returns>True if the Hide & Seek mode is the current one.</returns>
+    public static bool IsHideNSeek() => IsActiveGameMode<HideAndSeekMode>();
+
+    /// <summary>
+    /// Checks if a provided GameMode is the current active one.
+    /// </summary>
+    /// <typeparam name="T">The AbstractGameMode subclass being checked.</typeparam>
+    /// <returns>Whether the provided mode is the current active one.</returns>
+    public static bool IsActiveGameMode<T>() where T : AbstractGameMode => ActiveMode is T;
+
+    /// <summary>
+    /// Gets the current gamemode.
     /// </summary>
-    /// <param name="gameModeType">Type of gamemode class, should inherit from <see cref="CustomGameMode"/>.</param>
-    internal static void RegisterGameMode(Type gameModeType)
+    public static AbstractGameMode? ActiveMode { get; internal set; }
+
+    /// <summary>
+    /// Gets a gamemode from an ID.
+    /// </summary>
+    /// <param name="id">The ID of the gamemode to fetch.</param>
+    /// <returns>The gamemode matching that ID.</returns>
+    public static AbstractGameMode GetMode(uint id) => IdToModeMap[id];
+
+    internal static void RegisterDefaultMode()
     {
-        if (!typeof(CustomGameMode).IsAssignableFrom(gameModeType))
+        var defaultMode = new ClassicMode();
+        IdToModeMap.Add(0, defaultMode);
+        // no need to add to game mode option as it already contains it
+        // because we cannot have the option be created with no values
+        defaultMode.ID = 0;
+        var hnsMode = new HideAndSeekMode();
+        IdToModeMap.Add(1, hnsMode);
+        hnsMode.ID = 1;
+        GameModeOption.AddOption(hnsMode);
+        LastId++;
+    }
+
+    internal static void SetGameMode(uint id)
+    {
+        if (IdToModeMap.TryGetValue(id, out var mode))
         {
-            Warning($"{gameModeType.Name} does not inherit CustomGameMode!");
-            return;
+            ActiveMode = mode;
         }
-
-        var modeObj = Activator.CreateInstance(gameModeType);
-
-        if (modeObj is not CustomGameMode gameMode)
+        else if (id != 0)
         {
-            Error($"Failed to create instance of {gameModeType.Name}");
-            return;
+            ActiveMode = IdToModeMap[0];
+            GameModeOption.Value = 0;
+            Logger<MiraApiPlugin>.Warning($"Unable to find game mode of id {id}!");
         }
+    }
+
+    internal static void GetAndSetGameMode()
+    {
+        var id = (uint)GameModeOption.Value;
 
-        if (GameModes.Any(x => x.Key == gameMode.Id))
+        if (IdToModeMap.TryGetValue(id, out var mode))
         {
-            Error($"ID for gamemode {gameMode.Name} already exists!");
+            ActiveMode = mode;
             return;
         }
 
-        GameModes.Add(gameMode.Id, gameMode);
+        ActiveMode = IdToModeMap[0];
+        Logger<MiraApiPlugin>.Warning($"Unable to find game mode of id {id}!");
     }
 }