isaacscript-common 13.3.4 → 14.1.0

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

@@ -0,0 +1,82 @@
+import {
+  CollectibleType,
+  ModCallback,
+  PlayerType,
+  UseFlag,
+} from "isaac-typescript-definitions";
+import { getPlayersOfType, isTaintedLazarus } from "../../../functions/players";
+import { PostFirstFlip } from "../../callbacks/PostFirstFlip";
+import { PostFlip } from "../../callbacks/PostFlip";
+import { Feature } from "../../private/Feature";
+
+export class FlipDetection extends Feature {
+  public override v = {
+    run: {
+      /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
+      usedFlipAtLeastOnce: false,
+    },
+  };
+
+  private postFlip: PostFlip;
+  private postFirstFlip: PostFirstFlip;
+
+  constructor(postFlip: PostFlip, postFirstFlip: PostFirstFlip) {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_USE_ITEM, [this.useItemFlip, CollectibleType.FLIP]], // 3
+    ];
+
+    this.postFlip = postFlip;
+    this.postFirstFlip = postFirstFlip;
+  }
+
+  // ModCallback.POST_USE_ITEM (3)
+  // CollectibleType.FLIP (711)
+  private useItemFlip = (
+    _collectibleType: CollectibleType,
+    _rng: RNG,
+    player: EntityPlayer,
+    _useFlags: BitFlags<UseFlag>,
+    _activeSlot: int,
+    _customVarData: int,
+  ): boolean | undefined => {
+    if (!isTaintedLazarus(player)) {
+      return undefined;
+    }
+
+    // The player passed as part of the callback will be the old Lazarus that used the Flip item. We
+    // pass the new Lazarus to the callback subscribers.
+    const newLazarus = getNewLazarus(player);
+    if (newLazarus === undefined) {
+      return undefined;
+    }
+
+    if (!this.v.run.usedFlipAtLeastOnce) {
+      this.v.run.usedFlipAtLeastOnce = true;
+      this.postFirstFlip.fire(newLazarus, player);
+    }
+
+    this.postFlip.fire(newLazarus, player);
+
+    return undefined;
+  };
+}
+
+function getNewLazarus(oldLazarus: EntityPlayer): EntityPlayer | undefined {
+  const oldCharacter = oldLazarus.GetPlayerType();
+
+  let newCharacter: PlayerType;
+  if (oldCharacter === PlayerType.LAZARUS_B) {
+    newCharacter = PlayerType.LAZARUS_2_B;
+  } else if (oldCharacter === PlayerType.LAZARUS_2_B) {
+    newCharacter = PlayerType.LAZARUS_B;
+  } else {
+    return undefined;
+  }
+
+  const playersOfType = getPlayersOfType(newCharacter);
+  return playersOfType.find(
+    (player) => player.FrameCount === oldLazarus.FrameCount,
+  );
+}

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

@@ -0,0 +1,160 @@
+// This provides the logic for the following callbacks:
+// - `POST_GAME_STARTED_REORDERED`
+// - `POST_GAME_STARTED_REORDERED_LAST`
+// - `POST_NEW_LEVEL_REORDERED`
+// - `POST_NEW_ROOM_REORDERED`
+
+// By default, callbacks fire in the following order:
+// - `POST_NEW_ROOM` --> `POST_NEW_LEVEL` --> `POST_GAME_STARTED`
+
+// It is easier to write mod code if the callbacks run in a more logical order:
+// - `POST_GAME_STARTED` --> `POST_NEW_LEVEL` --> `POST_NEW_ROOM`
+
+// Manually reorganize the callback execution so that this is the case.
+
+import {
+  CollectibleType,
+  LevelStage,
+  ModCallback,
+  StageType,
+} from "isaac-typescript-definitions";
+import { game } from "../../../core/cachedClasses";
+import { Exported } from "../../../decorators";
+import { PostGameStartedReordered } from "../../callbacks/PostGameStartedReordered";
+import { PostGameStartedReorderedLast } from "../../callbacks/PostGameStartedReorderedLast";
+import { PostNewLevelReordered } from "../../callbacks/PostNewLevelReordered";
+import { PostNewRoomReordered } from "../../callbacks/PostNewRoomReordered";
+import { Feature } from "../../private/Feature";
+
+export class GameReorderedCallbacks extends Feature {
+  private currentStage: int | null = null;
+  private currentStageType: int | null = null;
+  private usedGlowingHourGlass = false;
+  private forceNewLevel = false;
+  private forceNewRoom = false;
+
+  private postGameStartedReordered: PostGameStartedReordered;
+  private postNewLevelReordered: PostNewLevelReordered;
+  private postNewRoomReordered: PostNewRoomReordered;
+  private postGameStartedReorderedLast: PostGameStartedReorderedLast;
+
+  constructor(
+    postGameStartedReordered: PostGameStartedReordered,
+    postNewLevelReordered: PostNewLevelReordered,
+    postNewRoomReordered: PostNewRoomReordered,
+    postGameStartedReorderedLast: PostGameStartedReorderedLast,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      [
+        ModCallback.POST_USE_ITEM,
+        [this.useItemGlowingHourGlass, CollectibleType.GLOWING_HOUR_GLASS],
+      ], // 3
+      [ModCallback.POST_GAME_STARTED, [this.postGameStarted]], // 15
+      [ModCallback.POST_NEW_LEVEL, [this.postNewLevel]], // 18
+      [ModCallback.POST_NEW_ROOM, [this.postNewRoom]], // 19
+    ];
+
+    this.postGameStartedReordered = postGameStartedReordered;
+    this.postNewLevelReordered = postNewLevelReordered;
+    this.postNewRoomReordered = postNewRoomReordered;
+    this.postGameStartedReorderedLast = postGameStartedReorderedLast;
+  }
+
+  // ModCallback.POST_USE_ITEM (3)
+  // CollectibleType.GLOWING_HOUR_GLASS (422)
+  private useItemGlowingHourGlass = (): boolean | undefined => {
+    // If Glowing Hour Glass is used on the first room of a floor, it will send the player to the
+    // previous floor without triggering the `POST_NEW_LEVEL` callback. Manually check for this.
+    this.usedGlowingHourGlass = true;
+
+    return undefined;
+  };
+
+  // ModCallback.POST_GAME_STARTED (15)
+  private postGameStarted = (isContinued: boolean): void => {
+    this.recordCurrentStage();
+    this.postGameStartedReordered.fire(isContinued);
+    this.postNewLevelReordered.fire();
+    this.postNewRoomReordered.fire();
+    this.postGameStartedReorderedLast.fire(isContinued);
+  };
+
+  // ModCallback.POST_NEW_LEVEL (18)
+  private postNewLevel = (): void => {
+    const gameFrameCount = game.GetFrameCount();
+
+    if (gameFrameCount === 0 && !this.forceNewLevel) {
+      // Wait for the `POST_GAME_STARTED` callback to fire.
+      return;
+    }
+    this.forceNewLevel = false;
+
+    this.recordCurrentStage();
+    this.postNewLevelReordered.fire();
+    this.postNewRoomReordered.fire();
+  };
+
+  // ModCallback.POST_NEW_ROOM (19)
+  private postNewRoom = (): void => {
+    const gameFrameCount = game.GetFrameCount();
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+
+    if (this.usedGlowingHourGlass) {
+      this.usedGlowingHourGlass = false;
+
+      if (this.currentStage !== stage || this.currentStageType !== stageType) {
+        // The player has used the Glowing Hour Glass to take them to the previous floor (which does
+        // not trigger the `POST_NEW_LEVEL` callback). Emulate what happens in the `POST_NEW_LEVEL`
+        // callback.
+        this.recordCurrentStage();
+        this.postNewLevelReordered.fire();
+        this.postNewRoomReordered.fire();
+        return;
+      }
+    }
+
+    if (
+      (gameFrameCount === 0 ||
+        this.currentStage !== stage ||
+        this.currentStageType !== stageType) &&
+      !this.forceNewRoom
+    ) {
+      return;
+    }
+    this.forceNewRoom = false;
+
+    this.postNewRoomReordered.fire();
+  };
+
+  private recordCurrentStage(): void {
+    const level = game.GetLevel();
+    const stage = level.GetStage();
+    const stageType = level.GetStageType();
+
+    this.currentStage = stage;
+    this.currentStageType = stageType;
+  }
+
+  @Exported()
+  public forceNewLevelCallback(): void {
+    this.forceNewLevel = true;
+  }
+
+  @Exported()
+  public forceNewRoomCallback(): void {
+    this.forceNewRoom = true;
+  }
+
+  @Exported()
+  public reorderedCallbacksSetStage(
+    stage: LevelStage,
+    stageType: StageType,
+  ): void {
+    this.currentStage = stage;
+    this.currentStageType = stageType;
+  }
+}

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

@@ -0,0 +1,90 @@
+// This provides the logic for the following callbacks:
+// - `POST_GRID_ENTITY_COLLISION`
+// - `POST_GRID_ENTITY_CUSTOM_COLLISION`
+
+import { GridCollisionClass, ModCallback } from "isaac-typescript-definitions";
+import {
+  getCollidingEntitiesWithGridEntity,
+  getGridEntities,
+} from "../../../functions/gridEntities";
+import { PostGridEntityCollision } from "../../callbacks/PostGridEntityCollision";
+import { PostGridEntityCustomCollision } from "../../callbacks/PostGridEntityCustomCollision";
+import { DefaultMap } from "../../DefaultMap";
+import { Feature } from "../../private/Feature";
+import { CustomGridEntities } from "./CustomGridEntities";
+
+export class GridEntityCollisionDetection extends Feature {
+  public override v = {
+    room: {
+      /** Indexed by grid entity pointer hash. */
+      collidingEntitiesMap: new DefaultMap<PtrHash, Set<PtrHash>>(
+        () => new Set(),
+      ),
+    },
+  };
+
+  private postGridEntityCollision: PostGridEntityCollision;
+  private postGridEntityCustomCollision: PostGridEntityCustomCollision;
+  private customGridEntities: CustomGridEntities;
+
+  constructor(
+    postGridEntityCollision: PostGridEntityCollision,
+    postGridEntityCustomCollision: PostGridEntityCustomCollision,
+    customGridEntities: CustomGridEntities,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+
+    this.postGridEntityCollision = postGridEntityCollision;
+    this.postGridEntityCustomCollision = postGridEntityCustomCollision;
+    this.customGridEntities = customGridEntities;
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    const gridEntities = getGridEntities();
+    const gridEntitiesWithCollision = gridEntities.filter(
+      (gridEntity) => gridEntity.CollisionClass !== GridCollisionClass.NONE,
+    );
+    for (const gridEntity of gridEntitiesWithCollision) {
+      const gridEntityPtrHash = GetPtrHash(gridEntity);
+      const oldCollidingEntities =
+        this.v.room.collidingEntitiesMap.getAndSetDefault(gridEntityPtrHash);
+
+      // Check for new colliding entities.
+      const collidingEntities = getCollidingEntitiesWithGridEntity(gridEntity);
+      for (const entity of collidingEntities) {
+        const entityPtrHash = GetPtrHash(entity);
+        if (!oldCollidingEntities.has(entityPtrHash)) {
+          oldCollidingEntities.add(entityPtrHash);
+
+          const gridEntityTypeCustom =
+            this.customGridEntities.getCustomGridEntityType(gridEntity);
+          if (gridEntityTypeCustom === undefined) {
+            this.postGridEntityCollision.fire(gridEntity, entity);
+          } else {
+            this.postGridEntityCustomCollision.fire(
+              gridEntity,
+              gridEntityTypeCustom,
+              entity,
+            );
+          }
+        }
+      }
+
+      // Remove old colliding entities.
+      const collidingEntitiesPtrHashes = collidingEntities.map((entity) =>
+        GetPtrHash(entity),
+      );
+      const collidingEntitiesPtrHashSet = new Set(collidingEntitiesPtrHashes);
+      for (const oldCollidingEntityPtrHash of oldCollidingEntities.values()) {
+        if (!collidingEntitiesPtrHashSet.has(oldCollidingEntityPtrHash)) {
+          oldCollidingEntities.delete(oldCollidingEntityPtrHash);
+        }
+      }
+    }
+  };
+}

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

@@ -0,0 +1,231 @@
+// This provides the logic for the following callbacks:
+// - `POST_GRID_ENTITY_INIT`
+// - `POST_GRID_ENTITY_CUSTOM_INIT`
+// - `POST_GRID_ENTITY_UPDATE`
+// - `POST_GRID_ENTITY_CUSTOM_UPDATE`
+// - `POST_GRID_ENTITY_REMOVE`
+// - `POST_GRID_ENTITY_CUSTOM_REMOVE`
+// - `POST_GRID_ENTITY_STATE_CHANGED`
+// - `POST_GRID_ENTITY_CUSTOM_STATE_CHANGED`
+// - `POST_GRID_ENTITY_BROKEN`
+// - `POST_GRID_ENTITY_CUSTOM_BROKEN`
+
+import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
+import {
+  getGridEntitiesMap,
+  isGridEntityBroken,
+} from "../../../functions/gridEntities";
+import { PostGridEntityBroken } from "../../callbacks/PostGridEntityBroken";
+import { PostGridEntityCustomBroken } from "../../callbacks/PostGridEntityCustomBroken";
+import { PostGridEntityCustomInit } from "../../callbacks/PostGridEntityCustomInit";
+import { PostGridEntityCustomRemove } from "../../callbacks/PostGridEntityCustomRemove";
+import { PostGridEntityCustomStateChanged } from "../../callbacks/PostGridEntityCustomStateChanged";
+import { PostGridEntityCustomUpdate } from "../../callbacks/PostGridEntityCustomUpdate";
+import { PostGridEntityInit } from "../../callbacks/PostGridEntityInit";
+import { PostGridEntityRemove } from "../../callbacks/PostGridEntityRemove";
+import { PostGridEntityStateChanged } from "../../callbacks/PostGridEntityStateChanged";
+import { PostGridEntityUpdate } from "../../callbacks/PostGridEntityUpdate";
+import { Feature } from "../../private/Feature";
+import { CustomGridEntities } from "./CustomGridEntities";
+
+type GridEntityTuple = [
+  gridEntityType: GridEntityType,
+  variant: int,
+  state: int,
+];
+
+export class GridEntityDetection extends Feature {
+  public override v = {
+    room: {
+      /** Indexed by grid index. */
+      initializedGridEntities: new Map<int, GridEntityTuple>(),
+    },
+  };
+
+  private postGridEntityInit: PostGridEntityInit;
+  private postGridEntityCustomInit: PostGridEntityCustomInit;
+  private postGridEntityUpdate: PostGridEntityUpdate;
+  private postGridEntityCustomUpdate: PostGridEntityCustomUpdate;
+  private postGridEntityRemove: PostGridEntityRemove;
+  private postGridEntityCustomRemove: PostGridEntityCustomRemove;
+  private postGridEntityStateChanged: PostGridEntityStateChanged;
+  private postGridEntityCustomStateChanged: PostGridEntityCustomStateChanged;
+  private postGridEntityBroken: PostGridEntityBroken;
+  private postGridEntityCustomBroken: PostGridEntityCustomBroken;
+  private customGridEntities: CustomGridEntities;
+
+  constructor(
+    postGridEntityInit: PostGridEntityInit,
+    postGridEntityCustomInit: PostGridEntityCustomInit,
+    postGridEntityUpdate: PostGridEntityUpdate,
+    postGridEntityCustomUpdate: PostGridEntityCustomUpdate,
+    postGridEntityRemove: PostGridEntityRemove,
+    postGridEntityCustomRemove: PostGridEntityCustomRemove,
+    postGridEntityStateChanged: PostGridEntityStateChanged,
+    postGridEntityCustomStateChanged: PostGridEntityCustomStateChanged,
+    postGridEntityBroken: PostGridEntityBroken,
+    postGridEntityCustomBroken: PostGridEntityCustomBroken,
+    customGridEntities: CustomGridEntities,
+  ) {
+    super();
+
+    this.featuresUsed = [ISCFeature.RUN_IN_N_FRAMES];
+
+    this.callbacksUsed = [
+      [ModCallback.POST_UPDATE, [this.postUpdate]], // 1
+    ];
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom2.POST_NEW_ROOM_REORDERED, [this.postNewRoomReordered]],
+    ];
+
+    this.postGridEntityInit = postGridEntityInit;
+    this.postGridEntityCustomInit = postGridEntityCustomInit;
+    this.postGridEntityUpdate = postGridEntityUpdate;
+    this.postGridEntityCustomUpdate = postGridEntityCustomUpdate;
+    this.postGridEntityRemove = postGridEntityRemove;
+    this.postGridEntityCustomRemove = postGridEntityCustomRemove;
+    this.postGridEntityStateChanged = postGridEntityStateChanged;
+    this.postGridEntityCustomStateChanged = postGridEntityCustomStateChanged;
+    this.postGridEntityBroken = postGridEntityBroken;
+    this.postGridEntityCustomBroken = postGridEntityCustomBroken;
+    this.customGridEntities = customGridEntities;
+  }
+
+  // ModCallback.POST_UPDATE (1)
+  private postUpdate = (): void => {
+    const gridEntitiesMap = getGridEntitiesMap();
+
+    // We check for removed grid entities first so that grid entities that change type will count as
+    // being removed and fire the PostGridEntityRemoved callback.
+    this.checkGridEntitiesRemoved(gridEntitiesMap);
+
+    for (const [gridIndex, gridEntity] of gridEntitiesMap.entries()) {
+      this.checkGridEntityStateChanged(gridIndex, gridEntity);
+      this.checkNewGridEntity(gridIndex, gridEntity);
+
+      const gridEntityTypeCustom =
+        this.customGridEntities.getCustomGridEntityType(gridIndex);
+      if (gridEntityTypeCustom === undefined) {
+        this.postGridEntityUpdate.fire(gridEntity);
+      } else {
+        this.postGridEntityCustomUpdate.fire(gridEntity, gridEntityTypeCustom);
+      }
+    }
+  };
+
+  private checkGridEntitiesRemoved(
+    gridEntitiesMap: Map<int, GridEntity>,
+  ): void {
+    for (const [
+      gridIndex,
+      gridEntityTuple,
+    ] of this.v.room.initializedGridEntities.entries()) {
+      const [storedGridEntityType, storedGridEntityVariant] = gridEntityTuple;
+      const gridEntity = gridEntitiesMap.get(gridIndex);
+      if (
+        gridEntity === undefined ||
+        gridEntity.GetType() !== storedGridEntityType
+      ) {
+        this.v.room.initializedGridEntities.delete(gridIndex);
+
+        const gridEntityTypeCustom =
+          this.customGridEntities.getCustomGridEntityType(gridIndex);
+        if (gridEntityTypeCustom === undefined) {
+          this.postGridEntityRemove.fire(
+            gridIndex,
+            storedGridEntityType,
+            storedGridEntityVariant,
+          );
+        } else {
+          this.postGridEntityCustomRemove.fire(gridIndex, gridEntityTypeCustom);
+        }
+      }
+    }
+  }
+
+  private checkGridEntityStateChanged(
+    gridIndex: int,
+    gridEntity: GridEntity,
+  ): void {
+    const gridEntityTuple = this.v.room.initializedGridEntities.get(gridIndex);
+    if (gridEntityTuple === undefined) {
+      // This grid entity did not exist a frame ago; we don't want to fire the state changed
+      // callback on the first frame that it exists.
+      return;
+    }
+
+    const [_gridEntityType, _gridEntityVariant, oldState] = gridEntityTuple;
+    const newState = gridEntity.State;
+    if (oldState !== newState) {
+      this.updateTupleInMap(gridEntity);
+
+      const gridEntityTypeCustom =
+        this.customGridEntities.getCustomGridEntityType(gridEntity);
+      if (gridEntityTypeCustom === undefined) {
+        this.postGridEntityStateChanged.fire(gridEntity, oldState, newState);
+      } else {
+        this.postGridEntityCustomStateChanged.fire(
+          gridEntity,
+          gridEntityTypeCustom,
+          oldState,
+          newState,
+        );
+      }
+
+      if (isGridEntityBroken(gridEntity)) {
+        if (gridEntityTypeCustom === undefined) {
+          this.postGridEntityBroken.fire(gridEntity);
+        } else {
+          this.postGridEntityCustomBroken.fire(
+            gridEntity,
+            gridEntityTypeCustom,
+          );
+        }
+      }
+    }
+  }
+
+  private checkNewGridEntity(gridIndex: int, gridEntity: GridEntity): void {
+    const gridEntityType = gridEntity.GetType();
+    const gridEntityTuple = this.v.room.initializedGridEntities.get(gridIndex);
+
+    if (
+      gridEntityTuple === undefined ||
+      gridEntityTuple[0] !== gridEntityType
+    ) {
+      this.updateTupleInMap(gridEntity);
+
+      const gridEntityTypeCustom =
+        this.customGridEntities.getCustomGridEntityType(gridEntity);
+      if (gridEntityTypeCustom === undefined) {
+        this.postGridEntityInit.fire(gridEntity);
+      } else {
+        this.postGridEntityCustomInit.fire(gridEntity, gridEntityTypeCustom);
+      }
+    }
+  }
+
+  private updateTupleInMap(gridEntity: GridEntity): void {
+    const gridEntityType = gridEntity.GetType();
+    const variant = gridEntity.GetVariant();
+    const gridIndex = gridEntity.GetGridIndex();
+    const newTuple: GridEntityTuple = [
+      gridEntityType,
+      variant,
+      gridEntity.State,
+    ];
+    this.v.room.initializedGridEntities.set(gridIndex, newTuple);
+  }
+
+  // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+  private postNewRoomReordered = (): void => {
+    const gridEntitiesMap = getGridEntitiesMap();
+
+    for (const [gridIndex, gridEntity] of gridEntitiesMap.entries()) {
+      this.checkNewGridEntity(gridIndex, gridEntity);
+    }
+  };
+}

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

@@ -0,0 +1,126 @@
+// This handles logic for the following callbacks:
+// - POST_PEFFECT_UPDATE_REORDERED
+// - POST_PLAYER_RENDER_REORDERED
+// - POST_PLAYER_UPDATE_REORDERED
+
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom2 } from "../../../enums/ModCallbackCustom2";
+import { emptyArray } from "../../../functions/array";
+import {
+  getPlayerFromIndex,
+  getPlayerIndex,
+} from "../../../functions/playerIndex";
+import { PlayerIndex } from "../../../types/PlayerIndex";
+import { PostPEffectUpdateReordered } from "../../callbacks/PostPEffectUpdateReordered";
+import { PostPlayerRenderReordered } from "../../callbacks/PostPlayerRenderReordered";
+import { PostPlayerUpdateReordered } from "../../callbacks/PostPlayerUpdateReordered";
+import { Feature } from "../../private/Feature";
+
+export class PlayerReorderedCallbacks extends Feature {
+  public override v = {
+    run: {
+      postGameStartedFiredOnThisRun: false,
+
+      postPEffectUpdateQueue: [] as PlayerIndex[],
+      postPlayerUpdateQueue: [] as PlayerIndex[],
+      postPlayerRenderQueue: [] as PlayerIndex[],
+    },
+  };
+
+  private postPEffectUpdateReordered: PostPEffectUpdateReordered;
+  private postPlayerRenderReordered: PostPlayerRenderReordered;
+  private postPlayerUpdateReordered: PostPlayerUpdateReordered;
+
+  constructor(
+    postPEffectUpdateReordered: PostPEffectUpdateReordered,
+    postPlayerRenderReordered: PostPlayerRenderReordered,
+    postPlayerUpdateReordered: PostPlayerUpdateReordered,
+  ) {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PEFFECT_UPDATE, [this.postPEffectUpdate]], // 4
+      [ModCallback.POST_PLAYER_UPDATE, [this.postPlayerUpdate]], // 31
+      [ModCallback.POST_PLAYER_RENDER, [this.postPlayerRender]], // 32
+    ];
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom2.POST_GAME_STARTED_REORDERED_LAST,
+        [this.postGameStartedReorderedLast],
+      ], // 19
+    ];
+
+    this.postPEffectUpdateReordered = postPEffectUpdateReordered;
+    this.postPlayerRenderReordered = postPlayerRenderReordered;
+    this.postPlayerUpdateReordered = postPlayerUpdateReordered;
+  }
+
+  // ModCallback.POST_PEFFECT_UPDATE (4)
+  private postPEffectUpdate = (player: EntityPlayer): void => {
+    if (this.v.run.postGameStartedFiredOnThisRun) {
+      this.postPEffectUpdateReordered.fire(player);
+    } else {
+      // Defer callback execution until the `POST_GAME_STARTED` callback fires.
+      const playerIndex = getPlayerIndex(player);
+      this.v.run.postPEffectUpdateQueue.push(playerIndex);
+    }
+  };
+
+  // ModCallback.POST_PLAYER_UPDATE (31)
+  private postPlayerUpdate = (player: EntityPlayer): void => {
+    if (this.v.run.postGameStartedFiredOnThisRun) {
+      this.postPlayerUpdateReordered.fire(player);
+    } else {
+      // Defer callback execution until the `POST_GAME_STARTED` callback fires.
+      const playerIndex = getPlayerIndex(player);
+      this.v.run.postPlayerUpdateQueue.push(playerIndex);
+    }
+  };
+
+  // ModCallback.POST_PLAYER_RENDER (32)
+  private postPlayerRender = (
+    player: EntityPlayer,
+    _renderOffset: Vector,
+  ): void => {
+    if (this.v.run.postGameStartedFiredOnThisRun) {
+      this.postPlayerRenderReordered.fire(player);
+    } else {
+      // Defer callback execution until the `POST_GAME_STARTED` callback fires.
+      const playerIndex = getPlayerIndex(player);
+      this.v.run.postPlayerRenderQueue.push(playerIndex);
+    }
+  };
+
+  // ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST
+  private postGameStartedReorderedLast = (): void => {
+    this.v.run.postGameStartedFiredOnThisRun = true;
+
+    dequeue(
+      this.v.run.postPEffectUpdateQueue,
+      this.postPEffectUpdateReordered.fire,
+    );
+    dequeue(
+      this.v.run.postPlayerUpdateQueue,
+      this.postPlayerUpdateReordered.fire,
+    );
+    dequeue(
+      this.v.run.postPlayerRenderQueue,
+      this.postPlayerRenderReordered.fire,
+    );
+  };
+}
+
+function dequeue(
+  playerIndexes: PlayerIndex[],
+  fireFunc: (player: EntityPlayer) => void,
+) {
+  for (const playerIndex of playerIndexes) {
+    const player = getPlayerFromIndex(playerIndex);
+    if (player !== undefined) {
+      fireFunc(player);
+    }
+  }
+
+  emptyArray(playerIndexes);
+}