isaacscript-common 14.0.0 → 14.1.1

package/src/classes/ModUpgraded.ts

@@ -1,27 +1,21 @@
 import { ModCallback } from "isaac-typescript-definitions";
+import { getCallbacks } from "../callbacks";
+import { ISCFeature } from "../enums/ISCFeature";
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { ModCallbackCustom2 } from "../enums/ModCallbackCustom2";
-import { saveDataManager } from "../features/saveDataManager/exports";
+import { getFeatures } from "../features";
+import {
+  saveDataManager,
+  saveDataManagerRemove,
+} from "../features/saveDataManager/exports";
 import { getTime } from "../functions/debugFunctions";
 import { getParentFunctionDescription } from "../functions/log";
-import { getTSTLClassName } from "../functions/tstlClass";
+import { getTSTLClassMethods, getTSTLClassName } from "../functions/tstlClass";
 import { AddCallbackParametersCustom } from "../interfaces/private/AddCallbackParametersCustom";
 import { AddCallbackParametersCustom2 } from "../interfaces/private/AddCallbackParametersCustom2";
 import { CALLBACK_REGISTER_FUNCTIONS } from "../objects/callbackRegisterFunctions";
-import { PostAmbushFinished } from "./callbacks/PostAmbushFinished";
-import { PostAmbushStarted } from "./callbacks/PostAmbushStarted";
-import { PostBombExploded } from "./callbacks/PostBombExploded";
-import { PostBombInitLate } from "./callbacks/PostBombInitLate";
-import { PostBoneSwing } from "./callbacks/PostBoneSwing";
-import { PostCollectibleEmpty } from "./callbacks/PostCollectibleEmpty";
-import { PostCollectibleInitFirst } from "./callbacks/PostCollectibleInitFirst";
-import { PostCursedTeleport } from "./callbacks/PostCursedTeleport";
-import { PostKnifeInitLate } from "./callbacks/PostKnifeInitLate";
-import { PostNewRoomEarly } from "./callbacks/PostNewRoomEarly";
-import { PostPitRender } from "./callbacks/PostPitRender";
-import { PostRoomClearChanged } from "./callbacks/PostRoomClearChanged";
-import { PostSpikesRender } from "./callbacks/PostSpikesRender";
-import { CustomCallback } from "./private/CustomCallback";
+import { FunctionTuple } from "../types/FunctionTuple";
+import { Feature } from "./private/Feature";
 
 /**
  * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
@@ -36,10 +30,10 @@ export class ModUpgraded implements Mod {
   // -----------------
 
   /**
-   * The vanilla mod object stores the name of the mod for some reason. (It is never used or
-   * referenced. (We match the casing of the vanilla variable.)
+   * The `RegisterMod` function stores the name of the mod on the mod object for some reason. (It is
+   * never used or referenced.)
    */
-  Name: string;
+  public Name: string;
 
   // ----------------
   // Custom variables
@@ -51,25 +45,11 @@ export class ModUpgraded implements Mod {
   private debug: boolean;
   private timeThreshold: float | undefined;
 
-  private callbacks: {
-    readonly [key in ModCallbackCustom2]: CustomCallback<key>;
-  } = {
-    [ModCallbackCustom2.POST_AMBUSH_FINISHED]: new PostAmbushFinished(),
-    [ModCallbackCustom2.POST_AMBUSH_STARTED]: new PostAmbushStarted(),
-    [ModCallbackCustom2.POST_BOMB_EXPLODED]: new PostBombExploded(),
-    [ModCallbackCustom2.POST_BOMB_INIT_LATE]: new PostBombInitLate(),
-    [ModCallbackCustom2.POST_BONE_SWING]: new PostBoneSwing(),
-    [ModCallbackCustom2.POST_COLLECTIBLE_EMPTY]: new PostCollectibleEmpty(),
-    [ModCallbackCustom2.POST_COLLECTIBLE_INIT_FIRST]:
-      new PostCollectibleInitFirst(),
-    [ModCallbackCustom2.POST_CURSED_TELEPORT]: new PostCursedTeleport(),
-
-    [ModCallbackCustom2.POST_KNIFE_INIT_LATE]: new PostKnifeInitLate(),
-    [ModCallbackCustom2.POST_NEW_ROOM_EARLY]: new PostNewRoomEarly(),
-    [ModCallbackCustom2.POST_PIT_RENDER]: new PostPitRender(),
-    [ModCallbackCustom2.POST_ROOM_CLEAR_CHANGED]: new PostRoomClearChanged(),
-    [ModCallbackCustom2.POST_SPIKES_RENDER]: new PostSpikesRender(),
-  };
+  private callbacks;
+
+  // Features must be marked as internal to prevent TypeDoc from complaining.
+  /** @internal */
+  private features;
 
   // -----------
   // Constructor
@@ -80,13 +60,20 @@ export class ModUpgraded implements Mod {
     this.mod = mod;
     this.debug = debug;
     this.timeThreshold = timeThreshold;
+    this.callbacks = getCallbacks();
+    this.features = getFeatures(this.callbacks);
   }
 
   // ---------------
   // Vanilla methods
   // ---------------
 
-  AddCallback<T extends ModCallback>(
+  /**
+   * Registers a function to be executed when an in-game event happens. For example, the
+   * `ModCallback.POST_UPDATE` event corresponds to being executed once at the end of every game
+   * logic frame.
+   */
+  public AddCallback<T extends ModCallback>(
     modCallback: T,
     ...args: AddCallbackParameters[T]
   ): void {
@@ -139,39 +126,55 @@ export class ModUpgraded implements Mod {
     }
   }
 
-  HasData(): boolean {
+  /** Returns whether or not a corresponding "save#.dat" file exists for the current mod. */
+  public HasData(): boolean {
     return this.mod.HasData();
   }
 
-  LoadData(): string {
+  /**
+   * Returns a string containing all of the data inside of the corresponding "save#.dat" file for
+   * this mod.
+   */
+  public LoadData(): string {
     return this.mod.LoadData();
   }
 
   /**
-   * This method does not care about the tertiary argument. Regardless of the conditions of how you
-   * registered the callback, it will be removed.
+   * Unregisters a function that was previously registered with the `AddCallback` method.
+   *
+   * This method does not care about the tertiary argument. In other words, regardless of the
+   * conditions of how you registered the callback, it will be removed.
    */
-  RemoveCallback<T extends ModCallback>(
+  public RemoveCallback<T extends ModCallback>(
     modCallback: T,
     callback: AddCallbackParameters[T][0],
   ): void {
     this.mod.RemoveCallback(modCallback, callback);
   }
 
-  RemoveData(): void {
+  /** Deletes the corresponding "save#.dat" file for this mod, if it exists. */
+  public RemoveData(): void {
     this.mod.RemoveData();
   }
 
-  SaveData(data: string): void {
+  /**
+   * Creates or updates the corresponding "save#.dat" file for this mod with the provided string.
+   */
+  public SaveData(data: string): void {
     this.mod.SaveData(data);
   }
 
-  // --------------
-  // Custom methods
-  // --------------
+  // ---------------------
+  // Custom public methods
+  // ---------------------
 
+  /**
+   * Registers a function to be executed when an in-game event happens. This method is specifically
+   * for events that are provided by the IsaacScript standard library. For example, the
+   * `ModCallbackCustom.POST_BOMB_EXPLODE` event corresponds to when a bomb explodes.
+   */
   // eslint-disable-next-line class-methods-use-this
-  AddCallbackCustom<T extends ModCallbackCustom>(
+  public AddCallbackCustom<T extends ModCallbackCustom>(
     modCallbackCustom: T,
     ...args: AddCallbackParametersCustom[T]
   ): void {
@@ -180,56 +183,122 @@ export class ModUpgraded implements Mod {
     callbackRegisterFunction(...args);
   }
 
-  AddCallbackCustom2<T extends ModCallbackCustom2>(
+  /** Adds a callback in the new callback system format. This method is only temporary. */
+  public AddCallbackCustom2<T extends ModCallbackCustom2>(
     modCallbackCustom: T,
     ...args: AddCallbackParametersCustom2[T]
   ): void {
-    const callback = this.callbacks[modCallbackCustom];
-    callback.add(...args);
+    const callbackClass = this.callbacks[modCallbackCustom];
+    // @ts-expect-error The compiler is not smart enough to figure out that the parameters match.
+    callbackClass.add(...args);
+    this.initFeature(callbackClass);
+  }
+
+  /**
+   * Unregisters a function that was previously registered with the `AddCallbackCustom` method.
+   *
+   * This method does not care about the tertiary argument. In other words, regardless of the
+   * conditions of how you registered the callback, it will be removed.
+   */
+  public RemoveCallbackCustom<T extends ModCallbackCustom2>(
+    modCallbackCustom: T,
+    callback: AddCallbackParametersCustom2[T][0],
+  ): void {
+    const callbackClass = this.callbacks[modCallbackCustom];
+    // @ts-expect-error The compiler is not smart enough to figure out that the parameters match.
+    callbackClass.remove(callback);
+    if (!callbackClass.hasSubscriptions()) {
+      this.uninitFeature(callbackClass);
+    }
+  }
+
+  /**
+   * This method should only be used by the `upgradeMod` function. Returns the class methods from
+   * the features that were added.
+   */
+  public initOptionalFeature(feature: ISCFeature): FunctionTuple[] {
+    const featureClass = this.features[feature];
+    this.initFeature(featureClass);
+
+    return getTSTLClassMethods(featureClass);
+  }
+
+  // ----------------------
+  // Custom private methods
+  // ----------------------
 
-    if (callback.initialized) {
+  /** This is used to initialize both custom callbacks and "extra features". */
+  private initFeature(feature: Feature): void {
+    if (feature.initialized) {
       return;
     }
-    callback.initialized = true;
+    feature.initialized = true;
 
-    if (callback.otherCallbacksUsed !== undefined) {
-      for (const callbackTuple of callback.otherCallbacksUsed) {
+    if (feature.featuresUsed !== undefined) {
+      for (const featureUsed of feature.featuresUsed) {
+        const featureClass = this.features[featureUsed];
+        this.initFeature(featureClass);
+      }
+    }
+
+    if (feature.callbacksUsed !== undefined) {
+      for (const callbackTuple of feature.callbacksUsed) {
         const [modCallback, callbackArgs] = callbackTuple;
         this.AddCallback(modCallback, ...callbackArgs);
       }
     }
 
-    if (callback.otherCustomCallbacksUsed !== undefined) {
-      for (const callbackTuple of callback.otherCustomCallbacksUsed) {
+    if (feature.customCallbacksUsed !== undefined) {
+      for (const callbackTuple of feature.customCallbacksUsed) {
         const [modCallback, callbackArgs] = callbackTuple;
-        this.AddCallbackCustom(modCallback, ...callbackArgs);
+        this.AddCallbackCustom2(modCallback, ...callbackArgs);
       }
     }
 
-    if (callback.v !== undefined) {
-      const callbackName = getTSTLClassName(callback);
-      if (callbackName === undefined) {
-        error(
-          `Failed to get the name of the callback: ModCallbackCustom.${ModCallbackCustom2[modCallbackCustom]} (${modCallbackCustom})`,
-        );
+    if (feature.v !== undefined) {
+      const className = getTSTLClassName(feature);
+      if (className === undefined) {
+        error("Failed to get the name of a feature.");
       }
-      saveDataManager(callbackName, callback.v);
+      saveDataManager(className, feature.v);
     }
-
-    /*
-    if (callback.feature !== undefined) {}
-    */
   }
 
-  /**
-   * This method does not care about the tertiary argument. Regardless of the conditions of how you
-   * registered the callback, it will be removed.
-   */
-  RemoveCallbackCustom<T extends ModCallbackCustom>(
-    modCallback: T,
-    callback: AddCallbackParametersCustom[T][0],
-  ): void {
-    // TODO
-    print(this, modCallback, callback);
+  private uninitFeature(feature: Feature): void {
+    if (!feature.initialized) {
+      return;
+    }
+    feature.initialized = false;
+
+    if (feature.featuresUsed !== undefined) {
+      for (const featureUsed of feature.featuresUsed) {
+        const featureClass = this.features[featureUsed];
+        this.uninitFeature(featureClass);
+      }
+    }
+
+    if (feature.callbacksUsed !== undefined) {
+      for (const callbackTuple of feature.callbacksUsed) {
+        const [modCallback, callbackArgs] = callbackTuple;
+        const callback = callbackArgs[0];
+        this.RemoveCallback(modCallback, callback);
+      }
+    }
+
+    if (feature.customCallbacksUsed !== undefined) {
+      for (const callbackTuple of feature.customCallbacksUsed) {
+        const [modCallback, callbackArgs] = callbackTuple;
+        const callback = callbackArgs[0];
+        this.RemoveCallbackCustom(modCallback, callback);
+      }
+    }
+
+    if (feature.v !== undefined) {
+      const className = getTSTLClassName(feature);
+      if (className === undefined) {
+        error("Failed to get the name of a feature.");
+      }
+      saveDataManagerRemove(className);
+    }
   }
 }

package/src/classes/callbacks/PostAmbushFinished.ts

@@ -5,7 +5,7 @@ import { getAmbushType } from "../../functions/ambush";
 import { CustomCallbackAmbush } from "./validation/CustomCallbackAmbush";
 
 export class PostAmbushFinished extends CustomCallbackAmbush<ModCallbackCustom2.POST_AMBUSH_FINISHED> {
-  override v = {
+  public override v = {
     room: {
       ambushDone: false,
     },
@@ -14,12 +14,12 @@ export class PostAmbushFinished extends CustomCallbackAmbush<ModCallbackCustom2.
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
     ];
   }
 
-  postUpdate = (): void => {
+  private postUpdate = (): void => {
     if (this.v.room.ambushDone) {
       return;
     }

package/src/classes/callbacks/PostAmbushStarted.ts

@@ -5,7 +5,7 @@ import { getAmbushType } from "../../functions/ambush";
 import { CustomCallbackAmbush } from "./validation/CustomCallbackAmbush";
 
 export class PostAmbushStarted extends CustomCallbackAmbush<ModCallbackCustom2.POST_AMBUSH_STARTED> {
-  override v = {
+  public override v = {
     room: {
       ambushActive: false,
     },
@@ -14,12 +14,12 @@ export class PostAmbushStarted extends CustomCallbackAmbush<ModCallbackCustom2.P
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
     ];
   }
 
-  postUpdate = (): void => {
+  private postUpdate = (): void => {
     if (this.v.room.ambushActive) {
       return;
     }

package/src/classes/callbacks/PostBombExploded.ts

@@ -7,13 +7,13 @@ export class PostBombExploded extends CustomCallbackBomb<ModCallbackCustom2.POST
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [ModCallback.POST_BOMB_UPDATE, [this.postBombUpdate]], // 58
     ];
   }
 
   // ModCallback.POST_BOMB_UPDATE (58)
-  postBombUpdate = (bomb: EntityBomb): void => {
+  private postBombUpdate = (bomb: EntityBomb): void => {
     if (bomb.FrameCount === BOMB_EXPLODE_FRAME) {
       this.fire(bomb);
     }

package/src/classes/callbacks/PostBombInitLate.ts

@@ -3,7 +3,7 @@ import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
 import { CustomCallbackBomb } from "./validation/CustomCallbackBomb";
 
 export class PostBombInitLate extends CustomCallbackBomb<ModCallbackCustom2.POST_BOMB_INIT_LATE> {
-  override v = {
+  public override v = {
     room: {
       firedSet: new Set<PtrHash>(),
     },
@@ -12,13 +12,13 @@ export class PostBombInitLate extends CustomCallbackBomb<ModCallbackCustom2.POST
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [ModCallback.POST_BOMB_UPDATE, [this.postBombUpdate]], // 58
     ];
   }
 
   // ModCallback.POST_BOMB_UPDATE (58)
-  postBombUpdate = (bomb: EntityBomb): void => {
+  private postBombUpdate = (bomb: EntityBomb): void => {
     const ptrHash = GetPtrHash(bomb);
     if (!this.v.room.firedSet.has(ptrHash)) {
       this.v.room.firedSet.add(ptrHash);

package/src/classes/callbacks/PostBoneSwing.ts

@@ -9,7 +9,7 @@ const BONE_SWING_ANIMATIONS: ReadonlySet<string> = new Set([
 ]);
 
 export class PostBoneSwing extends CustomCallback<ModCallbackCustom2.POST_BONE_SWING> {
-  override v = {
+  public override v = {
     room: {
       boneClubAnimations: new Map<PtrHash, string>(),
     },
@@ -18,13 +18,13 @@ export class PostBoneSwing extends CustomCallback<ModCallbackCustom2.POST_BONE_S
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [ModCallback.POST_KNIFE_RENDER, [this.postKnifeRender]], // 52
     ];
   }
 
   // ModCallback.POST_KNIFE_RENDER (52)
-  postKnifeRender = (knife: EntityKnife): void => {
+  private postKnifeRender = (knife: EntityKnife): void => {
     // The tertiary argument of the `POST_KNIFE_RENDER` callback takes sub-types instead of knife
     // variants.
     if (knife.Variant === KnifeVariant.BONE_CLUB) {
@@ -34,7 +34,7 @@ export class PostBoneSwing extends CustomCallback<ModCallbackCustom2.POST_BONE_S
 
   // ModCallback.POST_KNIFE_RENDER (52)
   // KnifeVariant.BONE_CLUB (1)
-  postKnifeRenderBoneClub(knife: EntityKnife): void {
+  private postKnifeRenderBoneClub(knife: EntityKnife): void {
     const sprite = knife.GetSprite();
     const animation = sprite.GetAnimation();
     const ptrHash = GetPtrHash(knife);
@@ -50,7 +50,10 @@ export class PostBoneSwing extends CustomCallback<ModCallbackCustom2.POST_BONE_S
     }
   }
 
-  boneClubAnimationChanged(knife: EntityKnife, animation: string): void {
+  private boneClubAnimationChanged(
+    knife: EntityKnife,
+    animation: string,
+  ): void {
     if (BONE_SWING_ANIMATIONS.has(animation)) {
       this.fire(knife);
     }

package/src/classes/callbacks/PostCollectibleEmpty.ts

@@ -13,7 +13,7 @@ import {
 type T = ModCallbackCustom2.POST_COLLECTIBLE_EMPTY;
 
 export class PostCollectibleEmpty extends CustomCallback<T> {
-  override v = {
+  public override v = {
     room: {
       collectibleTypeMap: new Map<PtrHash, CollectibleType>(),
     },
@@ -22,7 +22,7 @@ export class PostCollectibleEmpty extends CustomCallback<T> {
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [
         ModCallback.POST_PICKUP_UPDATE,
         [this.postPickupUpdateCollectible, PickupVariant.COLLECTIBLE],
@@ -31,7 +31,7 @@ export class PostCollectibleEmpty extends CustomCallback<T> {
   }
 
   // eslint-disable-next-line class-methods-use-this
-  override shouldFire(
+  protected override shouldFire(
     fireArgs: FireArgs<T>,
     optionalArgs: OptionalArgs<T>,
   ): boolean {
@@ -46,7 +46,7 @@ export class PostCollectibleEmpty extends CustomCallback<T> {
 
   // ModCallback.POST_PICKUP_UPDATE (35)
   // PickupVariant.COLLECTIBLE (100)
-  postPickupUpdateCollectible = (pickup: EntityPickup): void => {
+  private postPickupUpdateCollectible = (pickup: EntityPickup): void => {
     const collectible = pickup as EntityPickupCollectible;
 
     const ptrHash = GetPtrHash(collectible);
@@ -61,7 +61,7 @@ export class PostCollectibleEmpty extends CustomCallback<T> {
     }
   };
 
-  collectibleTypeChanged(
+  private collectibleTypeChanged(
     collectible: EntityPickupCollectible,
     oldCollectibleType: CollectibleType,
   ): void {

package/src/classes/callbacks/PostCollectibleInitFirst.ts

@@ -5,7 +5,7 @@ import { CollectibleIndex } from "../../types/CollectibleIndex";
 import { CustomCallbackCollectible } from "./validation/CustomCallbackCollectible";
 
 export class PostCollectibleInitFirst extends CustomCallbackCollectible<ModCallbackCustom2.POST_COLLECTIBLE_INIT_FIRST> {
-  override v = {
+  public override v = {
     run: {
       seenCollectibles: new Set<CollectibleIndex>(),
     },
@@ -14,7 +14,7 @@ export class PostCollectibleInitFirst extends CustomCallbackCollectible<ModCallb
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [
         ModCallback.POST_PICKUP_INIT,
         [this.postPickupInitCollectible, PickupVariant.COLLECTIBLE],
@@ -24,7 +24,7 @@ export class PostCollectibleInitFirst extends CustomCallbackCollectible<ModCallb
 
   // ModCallback.POST_PICKUP_INIT (34)
   // PickupVariant.COLLECTIBLE (100)
-  postPickupInitCollectible = (pickup: EntityPickup): void => {
+  private postPickupInitCollectible = (pickup: EntityPickup): void => {
     const collectible = pickup as EntityPickupCollectible;
     const collectibleIndex = getCollectibleIndex(collectible);
     if (this.v.run.seenCollectibles.has(collectibleIndex)) {

package/src/classes/callbacks/PostCursedTeleport.ts

@@ -19,7 +19,7 @@ import { PlayerIndex } from "../../types/PlayerIndex";
 import { CustomCallbackPlayer } from "./validation/CustomCallbackPlayer";
 
 export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.POST_CURSED_TELEPORT> {
-  override v = {
+  public override v = {
     run: {
       playersDamageFrameMap: new Map<
         PlayerIndex,
@@ -35,7 +35,7 @@ export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.
   constructor() {
     super();
 
-    this.otherCallbacksUsed = [
+    this.callbacksUsed = [
       [
         ModCallback.ENTITY_TAKE_DMG,
         [this.entityTakeDmgPlayer, EntityType.PLAYER],
@@ -50,7 +50,7 @@ export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.
 
   // ModCallback.ENTITY_TAKE_DMG (11)
   // EntityType.PLAYER (1)
-  entityTakeDmgPlayer = (
+  private entityTakeDmgPlayer = (
     entity: Entity,
     _amount: float,
     damageFlags: BitFlags<DamageFlag>,
@@ -63,7 +63,10 @@ export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.
     return undefined;
   };
 
-  setDamageFrame(entity: Entity, damageFlags: BitFlags<DamageFlag>): void {
+  private setDamageFrame(
+    entity: Entity,
+    damageFlags: BitFlags<DamageFlag>,
+  ): void {
     const gameFrameCount = game.GetFrameCount();
 
     const player = entity.ToPlayer();
@@ -92,7 +95,7 @@ export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.
     mapSetPlayer(this.v.run.playersDamageFrameMap, player, newTrackingArray);
   }
 
-  isPotentialNaturalTeleportFromSacrificeRoom(
+  private isPotentialNaturalTeleportFromSacrificeRoom(
     damageFlags: BitFlags<DamageFlag>,
   ): boolean {
     const room = game.GetRoom();
@@ -108,7 +111,7 @@ export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.
     );
   }
 
-  incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>): void {
+  private incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>): void {
     const room = game.GetRoom();
     const roomType = room.GetType();
     const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
@@ -120,7 +123,7 @@ export class PostCursedTeleport extends CustomCallbackPlayer<ModCallbackCustom2.
 
   // ModCallback.POST_PLAYER_RENDER (32)
   // PlayerVariant.PLAYER (0)
-  postPlayerRenderPlayer = (
+  private postPlayerRenderPlayer = (
     player: EntityPlayer,
     _renderOffset: Vector,
   ): void => {

package/src/classes/callbacks/PostCustomRevive.ts

@@ -0,0 +1,11 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { CustomCallbackRevive } from "./validation/CustomCallbackRevive";
+
+export class PostCustomRevive extends CustomCallbackRevive<ModCallbackCustom2.POST_CUSTOM_REVIVE> {
+  constructor() {
+    super();
+
+    this.featuresUsed = [ISCFeature.CUSTOM_REVIVE];
+  }
+}

package/src/classes/callbacks/PostDiceRoomActivated.ts

@@ -0,0 +1,68 @@
+import {
+  DiceFloorSubType,
+  EffectVariant,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { isCloseEnoughToTriggerDiceFloor } from "../../functions/effects";
+import { getClosestPlayer } from "../../functions/players";
+import {
+  CustomCallback,
+  FireArgs,
+  OptionalArgs,
+} from "../private/CustomCallback";
+
+type T = ModCallbackCustom2.POST_DICE_ROOM_ACTIVATED;
+
+export class PostDiceRoomActivated extends CustomCallback<T> {
+  public override v = {
+    room: {
+      diceRoomActivated: false,
+    },
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.POST_EFFECT_UPDATE,
+        [this.postEffectUpdateDiceFloor, EffectVariant.DICE_FLOOR],
+      ], // 55
+    ];
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  protected override shouldFire(
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean {
+    const [callbackDiceFloorSubType] = optionalArgs;
+    if (callbackDiceFloorSubType === undefined) {
+      return true;
+    }
+
+    const [_player, diceFloorSubType] = fireArgs;
+    return diceFloorSubType === callbackDiceFloorSubType;
+  }
+
+  // ModCallback.POST_EFFECT_UPDATE (55)
+  // EffectVariant.DICE_FLOOR (76)
+  private postEffectUpdateDiceFloor = (effect: EntityEffect): void => {
+    if (this.v.room.diceRoomActivated) {
+      return;
+    }
+
+    // When using the debug console to go to a dice room, the player can appear on top of the dice
+    // floor before they snap to the door.
+    if (effect.FrameCount === 0) {
+      return;
+    }
+
+    const closestPlayer = getClosestPlayer(effect.Position);
+    if (isCloseEnoughToTriggerDiceFloor(closestPlayer, effect)) {
+      this.v.room.diceRoomActivated = true;
+      this.fire(closestPlayer, effect.SubType as DiceFloorSubType);
+    }
+  };
+}