isaacscript-common 14.2.0 → 15.0.0

package/src/classes/features/callbackLogic/CustomGridEntities.ts

@@ -7,6 +7,7 @@ import {
   UseFlag,
 } from "isaac-typescript-definitions";
 import { game } from "../../../core/cachedClasses";
+import { Exported } from "../../../decorators";
 import { ISCFeature } from "../../../enums/ISCFeature";
 import {
   removeGridEntity,
@@ -22,6 +23,7 @@ import { Feature } from "../../private/Feature";
 import { RunInNFrames } from "../other/RunInNFrames";
 
 export class CustomGridEntities extends Feature {
+  /** @internal */
   public override v = {
     level: {
       /** Indexed by room list index and grid index. */
@@ -38,6 +40,7 @@ export class CustomGridEntities extends Feature {
 
   private runInNFrames: RunInNFrames;
 
+  /** @internal */
   constructor(runInNFrames: RunInNFrames) {
     super();
 
@@ -158,7 +161,8 @@ export class CustomGridEntities extends Feature {
    * dime when destroyed:
    *
    * ```ts
-   * // This is local to the mod and can safely overlap with the values of `GridEntityType`.
+   * // This is local to the mod and can safely overlap with the values of `GridEntityType` (or
+   * // values chosen by other mods).
    * const GridEntityTypeCustom = {
    *   SILVER_ROCK: 0 as GridEntityType,
    * } as const;
@@ -212,6 +216,7 @@ export class CustomGridEntities extends Feature {
    * @param baseGridEntityVariant Optional. The variant of the grid entity to use as a "base" for
    *                              this custom grid entity. Default is 0.
    */
+  @Exported
   public spawnCustomGridEntity(
     gridEntityTypeCustom: GridEntityType,
     gridIndexOrPosition: int | Vector,
@@ -281,6 +286,7 @@ export class CustomGridEntities extends Feature {
    * @returns The grid entity that was removed. Returns undefined if no grid entity was found at the
    *          given location or if the given grid entity was not a custom grid entity.
    */
+  @Exported
   public removeCustomGridEntity(
     gridIndexOrPositionOrGridEntity: int | Vector | GridEntity,
     updateRoom = true,
@@ -327,6 +333,7 @@ export class CustomGridEntities extends Feature {
    * Helper function to get the custom grid entities in the current room. Returns an array of tuples
    * containing the raw decoration grid entity and the associated entity data.
    */
+  @Exported
   public getCustomGridEntities(): Array<
     [gridEntity: GridEntity, data: GridEntityCustomData]
   > {
@@ -354,6 +361,7 @@ export class CustomGridEntities extends Feature {
    * undefined if the provided `GridEntity` is not a custom grid entity, or if there was not a grid
    * entity on the provided grid index.
    */
+  @Exported
   public getCustomGridEntityType(
     gridEntityOrGridIndex: GridEntity | int,
   ): GridEntityType | undefined {
@@ -385,6 +393,7 @@ export class CustomGridEntities extends Feature {
    * Helper function to check if a `GridEntity` is a custom grid entity or if a grid index has a
    * custom grid entity.
    */
+  @Exported
   public isCustomGridEntity(gridEntityOrGridIndex: GridEntity | int): boolean {
     const gridEntityTypeCustom = this.getCustomGridEntityType(
       gridEntityOrGridIndex,

package/src/classes/features/callbackLogic/CustomRevive.ts

@@ -6,8 +6,8 @@ import {
   SoundEffect,
 } from "isaac-typescript-definitions";
 import { sfxManager } from "../../../core/cachedClasses";
-import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
-import { runNextGameFrame } from "../../../features/runInNFrames";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
 import { removeCollectibleFromItemTracker } from "../../../functions/collectibles";
 import { removeAllFamiliars } from "../../../functions/entitiesSpecific";
 import { log } from "../../../functions/log";
@@ -21,6 +21,7 @@ import { PlayerIndex } from "../../../types/PlayerIndex";
 import { PostCustomRevive } from "../../callbacks/PostCustomRevive";
 import { PreCustomRevive } from "../../callbacks/PreCustomRevive";
 import { Feature } from "../../private/Feature";
+import { RunInNFrames } from "../other/RunInNFrames";
 
 const DEBUG = false as boolean;
 
@@ -47,13 +48,17 @@ export class CustomRevive extends Feature {
 
   private preCustomRevive: PreCustomRevive;
   private postCustomRevive: PostCustomRevive;
+  private runInNFrames: RunInNFrames;
 
   constructor(
     preCustomRevive: PreCustomRevive,
     postCustomRevive: PostCustomRevive,
+    runInNFrames: RunInNFrames,
   ) {
     super();
 
+    this.featuresUsed = [ISCFeature.RUN_IN_N_FRAMES];
+
     this.callbacksUsed = [
       [ModCallback.POST_RENDER, [this.postRender]], // 2
       [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
@@ -62,14 +67,15 @@ export class CustomRevive extends Feature {
 
     this.customCallbacksUsed = [
       [
-        ModCallbackCustom2.POST_PLAYER_FATAL_DAMAGE,
+        ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE,
         [this.postPlayerFatalDamage],
       ],
-      [ModCallbackCustom2.PRE_BERSERK_DEATH, [this.preBerserkDeath]],
+      [ModCallbackCustom.PRE_BERSERK_DEATH, [this.preBerserkDeath]],
     ];
 
     this.preCustomRevive = preCustomRevive;
     this.postCustomRevive = postCustomRevive;
+    this.runInNFrames = runInNFrames;
   }
 
   // ModCallback.POST_RENDER (2)
@@ -178,7 +184,7 @@ export class CustomRevive extends Feature {
     // wrong, probably with the `isDamageToPlayerFatal` function. Since end-user code is already
     // assuming that a custom revive is occurring, explicitly kill the player.
     const playerIndex = getPlayerIndex(player);
-    runNextGameFrame(() => {
+    this.runInNFrames.runNextGameFrame(() => {
       const futurePlayer = getPlayerFromIndex(playerIndex);
       if (futurePlayer === undefined) {
         return;

package/src/classes/features/callbackLogic/GameReorderedCallbacks.ts

@@ -32,6 +32,7 @@ export class GameReorderedCallbacks extends Feature {
   private postNewRoomReordered: PostNewRoomReordered;
   private postGameStartedReorderedLast: PostGameStartedReorderedLast;
 
+  /** @internal */
   constructor(
     postGameStartedReordered: PostGameStartedReordered,
     postNewLevelReordered: PostNewLevelReordered,
@@ -133,10 +134,6 @@ export class GameReorderedCallbacks extends Feature {
     this.currentStageType = stageType;
   }
 
-  // --------------
-  // Public methods
-  // --------------
-
   @Exported
   public forceNewLevelCallback(): void {
     this.forceNewLevel = true;

package/src/classes/features/callbackLogic/PlayerCollectibleDetection.ts

@@ -6,6 +6,7 @@ import {
   ModCallback,
   PlayerType,
 } from "isaac-typescript-definitions";
+import { ISCFeature } from "../../../enums/ISCFeature";
 import { arrayEquals } from "../../../functions/array";
 import { getEnumValues } from "../../../functions/enums";
 import { hasFlag } from "../../../functions/flag";
@@ -13,16 +14,14 @@ import {
   defaultMapGetPlayer,
   mapSetPlayer,
 } from "../../../functions/playerDataStructures";
-import {
-  getPlayerCollectibleMap,
-  getPlayerFromPtr,
-} from "../../../functions/players";
+import { getPlayerFromPtr } from "../../../functions/players";
 import { repeat } from "../../../functions/utils";
 import { PlayerIndex } from "../../../types/PlayerIndex";
 import { PostPlayerCollectibleAdded } from "../../callbacks/PostPlayerCollectibleAdded";
 import { PostPlayerCollectibleRemoved } from "../../callbacks/PostPlayerCollectibleRemoved";
 import { DefaultMap } from "../../DefaultMap";
 import { Feature } from "../../private/Feature";
+import { ModdedElementSets } from "../other/ModdedElementSets";
 import { RunInNFrames } from "../other/RunInNFrames";
 
 export class PlayerCollectibleDetection extends Feature {
@@ -42,15 +41,22 @@ export class PlayerCollectibleDetection extends Feature {
 
   private postPlayerCollectibleAdded: PostPlayerCollectibleAdded;
   private postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved;
+  private moddedElementSets: ModdedElementSets;
   private runInNFrames: RunInNFrames;
 
   constructor(
     postPlayerCollectibleAdded: PostPlayerCollectibleAdded,
     postPlayerCollectibleRemoved: PostPlayerCollectibleRemoved,
+    moddedElementSets: ModdedElementSets,
     runInNFrames: RunInNFrames,
   ) {
     super();
 
+    this.featuresUsed = [
+      ISCFeature.MODDED_ELEMENT_SETS,
+      ISCFeature.RUN_IN_N_FRAMES,
+    ];
+
     this.callbacksUsed = [
       [ModCallback.POST_USE_ITEM, [this.useItemD4, CollectibleType.D4]], // 3
       [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
@@ -62,6 +68,7 @@ export class PlayerCollectibleDetection extends Feature {
 
     this.postPlayerCollectibleAdded = postPlayerCollectibleAdded;
     this.postPlayerCollectibleRemoved = postPlayerCollectibleRemoved;
+    this.moddedElementSets = moddedElementSets;
     this.runInNFrames = runInNFrames;
   }
 
@@ -85,7 +92,8 @@ export class PlayerCollectibleDetection extends Feature {
       this.v.run.playersCollectibleMap,
       player,
     );
-    const newCollectibleMap = getPlayerCollectibleMap(player);
+    const newCollectibleMap =
+      this.moddedElementSets.getPlayerCollectibleMap(player);
     mapSetPlayer(this.v.run.playersCollectibleMap, player, newCollectibleMap);
 
     const collectibleTypesSet = new Set<CollectibleType>([

package/src/classes/features/callbackLogic/PlayerReorderedCallbacks.ts

@@ -4,7 +4,7 @@
 // - POST_PLAYER_UPDATE_REORDERED
 
 import { ModCallback } from "isaac-typescript-definitions";
-import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
 import { emptyArray } from "../../../functions/array";
 import {
   getPlayerFromIndex,
@@ -46,7 +46,7 @@ export class PlayerReorderedCallbacks extends Feature {
 
     this.customCallbacksUsed = [
       [
-        ModCallbackCustom2.POST_GAME_STARTED_REORDERED_LAST,
+        ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST,
         [this.postGameStartedReorderedLast],
       ], // 19
     ];

package/src/classes/features/callbackLogic/SlotUpdateDetection.ts

@@ -1,5 +1,5 @@
 import { ModCallback } from "isaac-typescript-definitions";
-import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
 import { getSlots } from "../../../functions/entitiesSpecific";
 import { PostSlotInit } from "../../callbacks/PostSlotInit";
 import { PostSlotUpdate } from "../../callbacks/PostSlotUpdate";
@@ -25,7 +25,7 @@ export class SlotUpdateDetection extends Feature {
     this.customCallbacksUsed = [
       // This has to be the reordered callback because we don't want the `POST_SLOT_INIT` callback
       // firing on the first room of a floor before the `POST_NEW_LEVEL` callback.
-      [ModCallbackCustom2.POST_NEW_ROOM_REORDERED, [this.postNewRoomReordered]],
+      [ModCallbackCustom.POST_NEW_ROOM_REORDERED, [this.postNewRoomReordered]],
     ];
 
     this.postSlotInit = postSlotInit;

package/src/classes/features/other/CharacterHealthConversion.ts

@@ -0,0 +1,132 @@
+import {
+  HeartSubType,
+  ModCallback,
+  PickupVariant,
+  PlayerType,
+} from "isaac-typescript-definitions";
+import { Exported } from "../../../decorators";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
+import { isRedHeart } from "../../../functions/pickups";
+import { ConversionHeartSubType } from "../../../types/ConversionHeartSubType";
+import { Feature } from "../../private/Feature";
+
+export class CharacterHealthConversion extends Feature {
+  private characterHealthReplacementMap = new Map<
+    PlayerType,
+    ConversionHeartSubType
+  >();
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.PRE_PICKUP_COLLISION,
+        [this.prePickupCollisionHeart, PickupVariant.HEART],
+      ], // 38
+    ];
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        [this.postPEffectUpdateReordered],
+      ],
+    ];
+  }
+
+  // ModCallback.PRE_PICKUP_COLLISION (38)
+  // PickupVariant.HEART (10)
+  private prePickupCollisionHeart = (
+    pickup: EntityPickup,
+    collider: Entity,
+  ) => {
+    if (!isRedHeart(pickup)) {
+      return undefined;
+    }
+
+    const player = collider.ToPlayer();
+    if (player === undefined) {
+      return undefined;
+    }
+
+    const character = player.GetPlayerType();
+    const conversionHeartSubType =
+      this.characterHealthReplacementMap.get(character);
+    if (conversionHeartSubType === undefined) {
+      return undefined;
+    }
+
+    // Prevent internal code from running, which will prevent the player from picking up the heart,
+    // but will still allow the heart to bounce off of the player.
+    return false;
+  };
+
+  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+  private postPEffectUpdateReordered = (player: EntityPlayer) => {
+    const character = player.GetPlayerType();
+    const conversionHeartSubType =
+      this.characterHealthReplacementMap.get(character);
+    if (conversionHeartSubType === undefined) {
+      return;
+    }
+
+    convertRedHeartContainers(player, conversionHeartSubType);
+    removeRedHearts(player);
+  };
+
+  /**
+   * Helper function to make a character that has the same health mechanic as Blue Baby (red heart
+   * containers --> soul hearts) or Dark Judas (red heart containers --> black hearts).
+   *
+   * Call this function once at the beginning of your mod to declare the health conversion type.
+   */
+  @Exported
+  public registerCharacterHealthConversion(
+    playerType: PlayerType,
+    conversionHeartSubType: ConversionHeartSubType,
+  ): void {
+    if (this.characterHealthReplacementMap.has(playerType)) {
+      error(
+        `Failed to register a character of type ${playerType} because there is already an existing registered character with that type.`,
+      );
+    }
+
+    this.characterHealthReplacementMap.set(playerType, conversionHeartSubType);
+  }
+}
+
+function convertRedHeartContainers(
+  player: EntityPlayer,
+  heartSubType: ConversionHeartSubType,
+) {
+  const maxHearts = player.GetMaxHearts();
+  if (maxHearts === 0) {
+    return;
+  }
+
+  player.AddMaxHearts(maxHearts * -1, false);
+
+  switch (heartSubType) {
+    case HeartSubType.SOUL: {
+      player.AddSoulHearts(maxHearts);
+      break;
+    }
+
+    case HeartSubType.BLACK: {
+      player.AddBlackHearts(maxHearts);
+      break;
+    }
+  }
+}
+
+/**
+ * We also have to check for normal red hearts, so that the player is not able to fill bone hearts
+ * (by e.g. picking up a healing item like Breakfast).
+ */
+function removeRedHearts(player: EntityPlayer) {
+  const hearts = player.GetHearts();
+  if (hearts > 0) {
+    player.AddHearts(hearts * -1);
+  }
+}

package/src/classes/features/other/CharacterStats.ts

@@ -0,0 +1,67 @@
+import {
+  CacheFlag,
+  ModCallback,
+  PlayerType,
+} from "isaac-typescript-definitions";
+import { Exported } from "../../../decorators";
+import { addStat, getDefaultPlayerStat } from "../../../functions/stats";
+import { Feature } from "../../private/Feature";
+
+type StatMap = Map<CacheFlag, number> | ReadonlyMap<CacheFlag, number>;
+
+/** Easily create custom characters that have base stats different from that of Isaac. */
+export class CharacterStats extends Feature {
+  private charactersStatMap = new Map<PlayerType, StatMap>();
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.EVALUATE_CACHE, [this.evaluateCache]], // 8
+    ];
+  }
+
+  // ModCallback.EVALUATE_CACHE (8)
+  private evaluateCache = (player: EntityPlayer, cacheFlag: CacheFlag) => {
+    const character = player.GetPlayerType();
+    const statMap = this.charactersStatMap.get(character);
+    if (statMap === undefined) {
+      return;
+    }
+
+    const stat = statMap.get(cacheFlag);
+    const defaultStat = getDefaultPlayerStat(cacheFlag);
+    if (stat === undefined || defaultStat === undefined) {
+      return;
+    }
+    const delta = stat - defaultStat;
+
+    addStat(player, cacheFlag, delta);
+  };
+
+  /**
+   * Helper function to manage the stats for a vanilla or custom character. Call this function once
+   * at the beginning of your mod to declare the starting stats.
+   *
+   * You must provide this function with a map of CacheFlag to the default stat amount. For example,
+   * the default amount of damage is 3.5. To make a custom character start with 4.5 damage:
+   *
+   * ```ts
+   * const fooDefaultStats = new Map<CacheFlag, number>([
+   *   [CacheFlag.DAMAGE, 4.5],
+   * ])
+   * registerCharacterStats(PlayerTypeCustom.FOO, fooDefaultStats);
+   * ```
+   *
+   * Note that the format for the `CacheFlag.FIRE_DELAY` value should be in the tears stat format,
+   * not the `MaxFireDelay` format.
+   */
+  @Exported
+  public registerCharacterStats(
+    playerType: PlayerType,
+    statMap: Map<CacheFlag, number> | ReadonlyMap<CacheFlag, number>,
+  ): void {
+    this.charactersStatMap.set(playerType, statMap);
+  }
+}

package/src/classes/features/other/CollectibleItemPoolType.ts

@@ -0,0 +1,66 @@
+import {
+  ItemPoolType,
+  ModCallback,
+  PickupVariant,
+} from "isaac-typescript-definitions";
+import { game } from "../../../core/cachedClasses";
+import { Exported } from "../../../decorators";
+import { getEntityID } from "../../../functions/entities";
+import { isCollectible } from "../../../functions/pickupVariants";
+import { getRoomItemPoolType } from "../../../functions/rooms";
+import { Feature } from "../../private/Feature";
+
+/**
+ * The item pool type of a collectible is not stored on the collectible. Thus, we scan for incoming
+ * item pool types in the `PRE_GET_COLLECTIBLE` callback, and then assume that the next spawned
+ * collectible has this item pool type.
+ */
+export class CollectibleItemPoolType extends Feature {
+  /** @internal */
+  public override v = {
+    run: {
+      collectibleItemPoolTypeMap: new Map<PtrHash, ItemPoolType>(),
+    },
+  };
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.POST_PICKUP_INIT,
+        [this.postPickupInitCollectible, PickupVariant.COLLECTIBLE],
+      ], // 34
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_INIT (34)
+  // PickupVariant.COLLECTIBLE (100)
+  private postPickupInitCollectible = (pickup: EntityPickup) => {
+    const itemPool = game.GetItemPool();
+    const ptrHash = GetPtrHash(pickup);
+    const lastItemPoolType = itemPool.GetLastPool();
+
+    this.v.run.collectibleItemPoolTypeMap.set(ptrHash, lastItemPoolType);
+  };
+
+  /**
+   * Helper function to get the item pool type that a given collectible came from. Since there is no
+   * native method in the API to get this, we listen in the `PRE_GET_COLLECTIBLE` callback for item
+   * pool types, and then assume that the next spawned collectible will match.
+   */
+  @Exported
+  public getCollectibleItemPoolType(collectible: EntityPickup): ItemPoolType {
+    if (!isCollectible(collectible)) {
+      const entityID = getEntityID(collectible);
+      error(
+        `The "getCollectibleItemPoolType" function was given a non-collectible: ${entityID}`,
+      );
+    }
+
+    const ptrHash = GetPtrHash(collectible);
+    const itemPoolType = this.v.run.collectibleItemPoolTypeMap.get(ptrHash);
+    return itemPoolType === undefined ? getRoomItemPoolType() : itemPoolType;
+  }
+}

package/src/classes/features/other/CustomHotkeys.ts

@@ -0,0 +1,146 @@
+import { Keyboard, ModCallback } from "isaac-typescript-definitions";
+import { Exported } from "../../../decorators";
+import { isKeyboardPressed } from "../../../functions/input";
+import { DefaultMap } from "../../DefaultMap";
+import { Feature } from "../../private/Feature";
+
+export class CustomHotkeys extends Feature {
+  /**
+   * The keys are the keyboard keys that trigger the hotkey. The values are the functions that
+   * contain the arbitrary code to run.
+   */
+  private staticHotkeyFunctionMap = new Map<Keyboard, () => void>();
+
+  /**
+   * The keys are the functions that determine what the hotkey key is. The values are the functions
+   * that contain the arbitrary code to run.
+   */
+  private dynamicHotkeyFunctionMap = new Map<
+    () => Keyboard | undefined,
+    () => void
+  >();
+
+  private keyPressedMap = new DefaultMap<Keyboard, boolean>(false);
+
+  /** @internal */
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_RENDER, [this.postRender]], // 2
+    ];
+  }
+
+  // ModCallback.POST_RENDER (2)
+  private postRender = () => {
+    for (const [
+      keyboard,
+      triggerFunc,
+    ] of this.staticHotkeyFunctionMap.entries()) {
+      this.checkIfTriggered(keyboard, triggerFunc);
+    }
+
+    for (const [
+      keyboardFunc,
+      triggerFunc,
+    ] of this.dynamicHotkeyFunctionMap.entries()) {
+      const keyboard = keyboardFunc();
+      if (keyboard !== undefined) {
+        this.checkIfTriggered(keyboard, triggerFunc);
+      }
+    }
+  };
+
+  private checkIfTriggered(keyboard: Keyboard, triggerFunc: () => void) {
+    const isPressed = isKeyboardPressed(keyboard);
+    const wasPreviouslyPressed = this.keyPressedMap.getAndSetDefault(keyboard);
+    this.keyPressedMap.set(keyboard, isPressed);
+
+    if (isPressed && !wasPreviouslyPressed) {
+      triggerFunc();
+    }
+  }
+
+  /**
+   * Helper function to run arbitrary code when you press and release a specific keyboard key.
+   *
+   * This can be used to easily set up custom hotkeys to facilitate custom game features or to
+   * assist in debugging.
+   *
+   * This is different from the `setHotkey` function in that the keyboard activation key is not
+   * hardcoded and is instead the return value of a provided function. This is useful for situations
+   * where the key can change (like if end-users can specify a custom hotkey using Mod Config Menu).
+   *
+   * @param getKeyFunc The function that returns the key that will trigger the hotkey.
+   * @param triggerFunc A function containing the arbitrary code that you want to execute when the
+   *                    hotkey is triggered.
+   */
+  @Exported
+  public setConditionalHotkey(
+    getKeyFunc: () => Keyboard | undefined,
+    triggerFunc: () => void,
+  ): void {
+    if (this.dynamicHotkeyFunctionMap.has(getKeyFunc)) {
+      error(
+        "Failed to register a hotkey due to a custom hotkey already being defined for the submitted function.",
+      );
+    }
+
+    this.dynamicHotkeyFunctionMap.set(getKeyFunc, triggerFunc);
+  }
+
+  /**
+   * Helper function to run arbitrary code when you press and release a specific keyboard key.
+   *
+   * This can be used to easily set up custom hotkeys to facilitate custom game features or to
+   * assist in debugging.
+   *
+   * @param keyboard The key that you want to trigger the hotkey.
+   * @param triggerFunc A function containing the arbitrary code that you want to execute when the
+   *                    hotkey is triggered.
+   */
+  @Exported
+  public setHotkey(keyboard: Keyboard, triggerFunc: () => void): void {
+    if (this.staticHotkeyFunctionMap.has(keyboard)) {
+      error(
+        `Failed to register a hotkey due to a hotkey already being defined for: Keyboard.${Keyboard[keyboard]} (${keyboard})`,
+      );
+    }
+
+    this.staticHotkeyFunctionMap.set(keyboard, triggerFunc);
+  }
+
+  /**
+   * Helper function to remove a hotkey created with the `setConditionalHotkey` function.
+   *
+   * @param getKeyFunc Equal to the `getKeyFunc` that you passed when initially registering the
+   *                   hotkey.
+   */
+  @Exported
+  public unsetConditionalHotkey(getKeyFunc: () => Keyboard | undefined): void {
+    if (!this.dynamicHotkeyFunctionMap.has(getKeyFunc)) {
+      error(
+        "Failed to unregister a hotkey since there is no existing hotkey defined for the submitted function.",
+      );
+    }
+
+    this.dynamicHotkeyFunctionMap.delete(getKeyFunc);
+  }
+
+  /**
+   * Helper function to remove a hotkey created with the `setHotkey` function.
+   *
+   * @param keyboard Equal to the keyboard value that you passed when initially registering the
+   *                 hotkey.
+   */
+  @Exported
+  public unsetHotkey(keyboard: Keyboard): void {
+    if (!this.staticHotkeyFunctionMap.has(keyboard)) {
+      error(
+        `Failed to unregister a hotkey since there is no existing hotkey defined for: Keyboard.${Keyboard[keyboard]} (${keyboard})`,
+      );
+    }
+
+    this.staticHotkeyFunctionMap.delete(keyboard);
+  }
+}