isaacscript-common 6.11.2 → 6.12.0

package/src/constants.ts

@@ -2,12 +2,10 @@ import {
   CollectibleType,
   Dimension,
   ItemPoolType,
-  LevelStage,
-  RoomType,
   TrinketSlot,
 } from "isaac-typescript-definitions";
 import { NUM_NORMAL_PILL_COLORS } from "./constantsFirstLast";
-import { getEnumLength, getLastEnumValue } from "./functions/enums";
+import { getEnumLength } from "./functions/enums";
 
 /**
  * The distance of the laser when Azazel does not have any range up items yet. For more info, see
@@ -112,9 +110,6 @@ export const MIN_PLAYER_SHOT_SPEED_STAT = 0.6;
 /** If you set `EntityPlayer.Speed` lower than this value, it will have no effect. */
 export const MIN_PLAYER_SPEED_STAT = 0.1;
 
-export const FIRST_ROOM_TYPE = RoomType.DEFAULT;
-export const LAST_ROOM_TYPE = getLastEnumValue(RoomType);
-
 /**
  * The maximum speed stat that a player can have. Any additional speed beyond this will not take
  * effect.
@@ -133,9 +128,6 @@ export const NEW_FLOOR_STARTING_POSITION_GREED_MODE = Vector(320, 280);
  */
 export const NEW_RUN_PLAYER_STARTING_POSITION = Vector(320, 380);
 
-export const FIRST_STAGE = LevelStage.BASEMENT_1;
-export const LAST_STAGE = getLastEnumValue(LevelStage);
-
 /** Corresponds to the maximum value for `EntityPlayer.SamsonBerserkCharge`. */
 export const MAX_TAINTED_SAMSON_BERSERK_CHARGE = 100000;
 

package/src/constantsFirstLast.ts

@@ -1,9 +1,11 @@
 import {
   Card,
   CollectibleType,
+  LevelStage,
   PillColor,
   PillEffect,
   PlayerType,
+  RoomType,
   TrinketType,
 } from "isaac-typescript-definitions";
 import { itemConfig } from "./cachedClasses";
@@ -208,3 +210,17 @@ export const LAST_VANILLA_CHARACTER = getLastEnumValue(PlayerType);
  */
 export const FIRST_MODDED_CHARACTER = ((LAST_VANILLA_CHARACTER as int) +
   1) as PlayerType;
+
+// ----------
+// Room Types
+// ----------
+
+export const FIRST_ROOM_TYPE = RoomType.DEFAULT;
+export const LAST_ROOM_TYPE = getLastEnumValue(RoomType);
+
+// ------
+// Stages
+// ------
+
+export const FIRST_STAGE = LevelStage.BASEMENT_1;
+export const LAST_STAGE = getLastEnumValue(LevelStage);

package/src/enums/ModCallbackCustom.ts

@@ -336,7 +336,7 @@ export enum ModCallbackCustom {
   POST_GREED_MODE_WAVE,
 
   /**
-   * Fires from the `POST_UPDATE` update when a grid entity changes to a state that corresponds to
+   * Fires from the `POST_UPDATE` callback when a grid entity changes to a state that corresponds to
    * the broken state for the respective grid entity type.
    *
    * When registering the callback, takes an optional second argument that will make the callback
@@ -363,6 +363,38 @@ export enum ModCallbackCustom {
    */
   POST_GRID_ENTITY_COLLISION,
 
+  /**
+   * Fires from the `POST_RENDER` callback on every frame that a grid entity created with the
+   * `spawnCustomGridEntity` helper function exists.
+   *
+   * When registering the callback, takes an optional second argument that will make the callback
+   * only fire if it matches the `GridEntityType` provided.
+   *
+   * ```ts
+   * function postGridEntityRenderCustom(
+   *   gridEntity: GridEntity,
+   *   gridEntityTypeCustom: GridEntityType,
+   * ): void {}
+   * ```
+   */
+  POST_GRID_ENTITY_CUSTOM_RENDER,
+
+  /**
+   * Fires from the `POST_UPDATE` callback on every frame that a grid entity created with the
+   * `spawnCustomGridEntity` helper function exists.
+   *
+   * When registering the callback, takes an optional second argument that will make the callback
+   * only fire if it matches the `GridEntityType` provided.
+   *
+   * ```ts
+   * function postGridEntityUpdateCustom(
+   *   gridEntity: GridEntity,
+   *   gridEntityTypeCustom: GridEntityType,
+   * ): void {}
+   * ```
+   */
+  POST_GRID_ENTITY_CUSTOM_UPDATE,
+
   /**
    * Fires when a new grid entity is initialized. Specifically, this is either:
    *
@@ -664,13 +696,6 @@ export enum ModCallbackCustom {
    * This callback is useful because pickups will despawn upon leaving the room and respawn upon
    * re-entering the room.
    *
-   * For most cases, this callback will simply fire when `POST_PICKUP_INIT` fires and the player is
-   * not re-entering a previously visited room.
-   *
-   * The special case is when a player enters a post-Ascent Treasure Room or Boss Room. For these
-   * cases, the `InitSeed` of any pickups seen from previous floors is kept track of to prevent the
-   * callback from firing when re-entering the room.
-   *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if the collectible type matches the `PickupVariant` provided.
    *

package/src/features/customGridEntity.ts

@@ -274,3 +274,28 @@ export function removeCustomGrid(
 
   return decoration;
 }
+
+/**
+ * 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.
+ */
+export function getCustomGridEntities(): Array<
+  [gridEntity: GridEntity, data: CustomGridEntityData]
+> {
+  const roomListIndex = getRoomListIndex();
+  const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+  if (roomCustomGridEntities === undefined) {
+    return [];
+  }
+
+  const room = game.GetRoom();
+  const customGridEntities: Array<[GridEntity, CustomGridEntityData]> = [];
+  for (const [gridIndex, data] of roomCustomGridEntities.entries()) {
+    const gridEntity = room.GetGridEntity(gridIndex);
+    if (gridEntity !== undefined) {
+      customGridEntities.push([gridEntity, data]);
+    }
+  }
+
+  return customGridEntities;
+}

package/src/features/customTrapdoor/customTrapdoorConstants.ts

@@ -19,5 +19,5 @@ export const ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL: ReadonlySet<string> =
 
 export const PIXELATION_TO_BLACK_FRAMES = 52;
 
-export const OTHER_PLAYER_TRAPDOOR_JUMP_DELAY_GAME_FRAMES = 10;
-export const OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES = 8;
+export const OTHER_PLAYER_TRAPDOOR_JUMP_DELAY_GAME_FRAMES = 6;
+export const OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES = 5;

package/src/features/customTrapdoor/init.ts

@@ -21,6 +21,7 @@ import { saveDataManager } from "../saveDataManager/exports";
 import { drawBlackSprite } from "./blackSprite";
 import {
   CUSTOM_TRAPDOOR_FEATURE_NAME,
+  GridEntityTypeCustom,
   PIXELATION_TO_BLACK_FRAMES,
 } from "./customTrapdoorConstants";
 import { checkCustomTrapdoorOpenClose } from "./openClose";
@@ -33,8 +34,9 @@ export function customTrapdoorInit(mod: ModUpgraded): void {
   mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
   mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
   mod.AddCallbackCustom(
-    ModCallbackCustom.POST_GRID_ENTITY_UPDATE,
-    postGridEntityUpdateTrapdoor,
+    ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE,
+    postGridEntityCustomUpdateTrapdoor,
+    GridEntityTypeCustom.TRAPDOOR_CUSTOM,
   );
 }
 
@@ -198,9 +200,9 @@ function checkJumpComplete(player: EntityPlayer) {
   }
 }
 
-// ModCallbackCustom.POST_GRID_ENTITY_UPDATE
-// GridEntityType.TRAPDOOR (17)
-function postGridEntityUpdateTrapdoor(gridEntity: GridEntity) {
+// ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE
+// GridEntityTypeCustom.TRAPDOOR_CUSTOM
+function postGridEntityCustomUpdateTrapdoor(gridEntity: GridEntity) {
   const roomListIndex = getRoomListIndex();
   const gridIndex = gridEntity.GetGridIndex();
 

package/src/features/customTrapdoor/touched.ts

@@ -1,20 +1,23 @@
 import {
+  ButtonAction,
   EntityCollisionClass,
+  EntityGridCollisionClass,
   EntityPartition,
   PlayerType,
 } from "isaac-typescript-definitions";
 import { VectorZero } from "../../constants";
 import { StageTravelState } from "../../enums/private/StageTravelState";
+import { easeOutSine } from "../../functions/easing";
 import {
+  getAllPlayers,
   getOtherPlayers,
-  getPlayers,
   isChildPlayer,
 } from "../../functions/playerIndex";
 import { isCharacter } from "../../functions/players";
 import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
-import { disableAllInputs } from "../disableInputs";
+import { disableAllInputsExceptFor } from "../disableInputs";
 import { isPlayerUsingPony } from "../ponyDetection";
-import { runInNGameFrames, runNextGameFrame } from "../runInNFrames";
+import { runInNGameFrames, runNextRenderFrame } from "../runInNFrames";
 import {
   ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL,
   CUSTOM_TRAPDOOR_FEATURE_NAME,
@@ -78,7 +81,8 @@ function playerTouchedCustomTrapdoor(
   v.run.state = StageTravelState.PLAYERS_JUMPING_DOWN;
   v.run.destination = trapdoorDescription.destination;
 
-  disableAllInputs(CUSTOM_TRAPDOOR_FEATURE_NAME);
+  const whitelist = new Set([ButtonAction.CONSOLE]);
+  disableAllInputsExceptFor(CUSTOM_TRAPDOOR_FEATURE_NAME, whitelist);
   setPlayerAttributes(player, gridEntity.Position);
   dropTaintedForgotten(player);
 
@@ -95,6 +99,35 @@ function playerTouchedCustomTrapdoor(
   });
 }
 
+function setPlayerAttributes(trapdoorPlayer: EntityPlayer, position: Vector) {
+  // Snap the player to the exact position of the trapdoor so that they cleanly jump down the hole.
+  trapdoorPlayer.Position = position;
+
+  for (const player of getAllPlayers()) {
+    // Disable the controls to prevent the player from moving, shooting, and so on. (We also disable
+    // the inputs in the `INPUT_ACTION` callback, but that does not prevent mouse inputs.)
+    player.ControlsEnabled = false;
+
+    // Freeze all players.
+    player.Velocity = VectorZero;
+
+    // We don't want enemy attacks to move the players.
+    player.EntityCollisionClass = EntityCollisionClass.NONE;
+    player.GridCollisionClass = EntityGridCollisionClass.NONE;
+
+    player.SubType = -1;
+  }
+}
+
+function dropTaintedForgotten(player: EntityPlayer) {
+  if (isCharacter(player, PlayerType.THE_FORGOTTEN_B)) {
+    const taintedSoul = player.GetOtherTwin();
+    if (taintedSoul !== undefined) {
+      taintedSoul.ThrowHeldEntity(VectorZero);
+    }
+  }
+}
+
 function startDelayedJump(entityPtr: EntityPtr, trapdoorPosition: Vector) {
   const entity = entityPtr.Ref;
   if (entity === undefined) {
@@ -108,14 +141,18 @@ function startDelayedJump(entityPtr: EntityPtr, trapdoorPosition: Vector) {
 
   player.PlayExtraAnimation("Trapdoor");
 
-  adjustPlayerVelocityToTrapdoor(entityPtr, player.Position, trapdoorPosition);
+  adjustPlayerPositionToTrapdoor(entityPtr, player.Position, trapdoorPosition);
 }
 
-function adjustPlayerVelocityToTrapdoor(
+function adjustPlayerPositionToTrapdoor(
   entityPtr: EntityPtr,
   startPos: Vector,
   endPos: Vector,
 ) {
+  if (v.run.state !== StageTravelState.PLAYERS_JUMPING_DOWN) {
+    return;
+  }
+
   const entity = entityPtr.Ref;
   if (entity === undefined) {
     return;
@@ -126,50 +163,33 @@ function adjustPlayerVelocityToTrapdoor(
     return;
   }
 
+  runNextRenderFrame(() => {
+    adjustPlayerPositionToTrapdoor(entityPtr, startPos, endPos);
+  });
+
   const sprite = player.GetSprite();
   if (sprite.IsFinished("Trapdoor")) {
+    player.Position = endPos;
+    player.Velocity = VectorZero;
     return;
   }
 
   const frame = sprite.GetFrame();
-  if (frame > OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES) {
+  if (frame >= OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES) {
     // We have already arrived at the trapdoor.
+    player.Position = endPos;
+    player.Velocity = VectorZero;
     return;
   }
 
+  // Make the player jump towards the trapdoor. We use an easing function so that the distance
+  // traveled is not linear, emulating what the game does.
   const totalDifference = endPos.sub(startPos);
-  const differencePerFrame = totalDifference.div(
-    OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES,
-  );
-  const differenceForThisFrame = differencePerFrame.mul(frame + 1);
+  const progress = frame / OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES;
+  const easeProgress = easeOutSine(progress);
+  const differenceForThisFrame = totalDifference.mul(easeProgress);
   const targetPosition = startPos.add(differenceForThisFrame);
-  const calculatedVelocity = player.Position.sub(targetPosition);
-
-  player.Velocity = calculatedVelocity;
-
-  runNextGameFrame(() => {
-    adjustPlayerVelocityToTrapdoor(entityPtr, startPos, endPos);
-  });
-}
 
-function setPlayerAttributes(trapdoorPlayer: EntityPlayer, position: Vector) {
-  // Snap the player to the exact position of the trapdoor so that they cleanly jump down the hole.
-  trapdoorPlayer.Position = position;
-
-  for (const player of getPlayers()) {
-    // Freeze all players.
-    player.Velocity = VectorZero;
-
-    // We don't want enemy attacks to move the players.
-    player.EntityCollisionClass = EntityCollisionClass.NONE;
-  }
-}
-
-function dropTaintedForgotten(player: EntityPlayer) {
-  if (isCharacter(player, PlayerType.THE_FORGOTTEN_B)) {
-    const taintedSoul = player.GetOtherTwin();
-    if (taintedSoul !== undefined) {
-      taintedSoul.ThrowHeldEntity(VectorZero);
-    }
-  }
+  player.Position = targetPosition;
+  player.Velocity = VectorZero;
 }

package/src/features/deployJSONRoom.ts

@@ -225,7 +225,7 @@ function respawnPersistentEntities() {
  * Specifically, this will clear the current room of all entities and grid entities, and then spawn
  * all of the entries and grid entities in the provided JSON room.
  *
- * This function is meant to be used in the PostNewRoom callback.
+ * This function is meant to be used in the `POST_NEW_ROOM` callback.
  *
  * For example:
  *
@@ -277,7 +277,7 @@ export function deployJSONRoom(
  * Specifically, this will clear the current room of all entities and grid entities, and then spawn
  * all of the entries and grid entities in one of the provided JSON rooms.
  *
- * This function is meant to be used in the PostNewRoom callback.
+ * This function is meant to be used in the `POST_NEW_ROOM` callback.
  *
  * Note that this function does not simply choose a random element in the provided array; it will
  * properly account for each room weight using the algorithm from:
@@ -355,8 +355,8 @@ export function emptyRoom(fillWithDecorations: boolean): void {
 }
 
 /**
- * We remove entities in the PostNewRoom callback instead of in the PreRoomEntitySpawn callback so
- * that they will not re-appear when we re-enter the room.
+ * We remove entities in the `POST_NEW_ROOM` callback instead of in the PreRoomEntitySpawn callback
+ * so that they will not re-appear when we re-enter the room.
  */
 function removeSpecificNPCs() {
   const room = game.GetRoom();

package/src/features/extraConsoleCommands/listCommands.ts

@@ -33,19 +33,17 @@ import {
   TrinketType,
 } from "isaac-typescript-definitions";
 import { game, sfxManager } from "../../cachedClasses";
-import {
-  FIRST_ROOM_TYPE,
-  FIRST_STAGE,
-  LAST_ROOM_TYPE,
-  LAST_STAGE,
-  MAX_LEVEL_GRID_INDEX,
-} from "../../constants";
+import { MAX_LEVEL_GRID_INDEX } from "../../constants";
 import {
   FIRST_CARD,
   FIRST_CHARACTER,
   FIRST_PILL_EFFECT,
+  FIRST_ROOM_TYPE,
+  FIRST_STAGE,
   LAST_CARD,
   LAST_PILL_EFFECT,
+  LAST_ROOM_TYPE,
+  LAST_STAGE,
   LAST_VANILLA_CHARACTER,
 } from "../../constantsFirstLast";
 import { HealthType } from "../../enums/HealthType";

package/src/features/pause.ts

@@ -4,17 +4,36 @@ import {
   InputHook,
   ModCallback,
 } from "isaac-typescript-definitions";
+import { VectorZero } from "../constants";
+import {
+  getProjectiles,
+  getTears,
+  removeAllProjectiles,
+  removeAllTears,
+} from "../functions/entitiesSpecific";
+import { isTear } from "../functions/isaacAPIClass";
 import { logError } from "../functions/log";
+import { getAllPlayers } from "../functions/playerIndex";
 import { useActiveItemTemp } from "../functions/players";
 import { disableAllInputsExceptFor, enableAllInputs } from "./disableInputs";
 import { saveDataManager } from "./saveDataManager/exports";
 
 const FEATURE_NAME = "pause";
 
+interface InitialDescription {
+  position: Vector;
+  positionOffset: Vector;
+  velocity: Vector;
+  height: float;
+  fallingSpeed: float;
+  fallingAcceleration: float;
+}
+
 const v = {
   run: {
     isPseudoPaused: false,
     shouldUnpause: false,
+    initialDescriptions: new Map<PtrHash, InitialDescription>(),
   },
 };
 
@@ -37,8 +56,34 @@ function postUpdate() {
     return;
   }
 
-  const player = Isaac.GetPlayer();
-  useActiveItemTemp(player, CollectibleType.PAUSE);
+  const firstPlayer = Isaac.GetPlayer();
+  useActiveItemTemp(firstPlayer, CollectibleType.PAUSE);
+
+  stopTearsAndProjectilesFromMoving();
+}
+
+function stopTearsAndProjectilesFromMoving() {
+  const tearsAndProjectiles = [...getTears(), ...getProjectiles()];
+
+  for (const tearOrProjectile of tearsAndProjectiles) {
+    const ptrHash = GetPtrHash(tearOrProjectile);
+    const initialDescription = v.run.initialDescriptions.get(ptrHash);
+    if (initialDescription === undefined) {
+      continue;
+    }
+
+    tearOrProjectile.Position = initialDescription.position;
+    tearOrProjectile.PositionOffset = initialDescription.positionOffset;
+    tearOrProjectile.Velocity = VectorZero;
+    tearOrProjectile.Height = initialDescription.height;
+    tearOrProjectile.FallingSpeed = 0;
+    if (isTear(tearOrProjectile)) {
+      tearOrProjectile.FallingAcceleration =
+        initialDescription.fallingAcceleration;
+    } else {
+      tearOrProjectile.FallingAccel = initialDescription.fallingAcceleration;
+    }
+  }
 }
 
 // ModCallback.INPUT_ACTION (13)
@@ -57,8 +102,8 @@ function inputActionGetActionValue(
   }
   v.run.shouldUnpause = false;
 
-  // Returning a value of 1 for a single frame will be enough for the game to register an unpause
-  // but not enough for a tear to actually be fired.
+  // Returning a value of 1 for a single sub-frame will be enough for the game to register an
+  // unpause but not enough for a tear to actually be fired.
   return 1;
 }
 
@@ -68,7 +113,7 @@ function inputActionGetActionValue(
  *
  * Under the hood, this function:
  * - uses the Pause collectible on every game frame
- * - disables any player inputs (except for `ButtonAction.MENU_CONFIRM`)
+ * - disables any player inputs (except for `ButtonAction.MENU_CONFIRM` and `ButtonAction.CONSOLE`)
  */
 export function pause(): void {
   if (v.run.isPseudoPaused) {
@@ -79,8 +124,43 @@ export function pause(): void {
   }
   v.run.isPseudoPaused = true;
 
-  const whitelist = new Set([ButtonAction.MENU_CONFIRM]);
+  // Tears/projectiles in the room will move slightly on every frame, even when the Pause
+  // collectible is active. Thus, we manually reset the initial positions and heights on every
+  // frame.
+  v.run.initialDescriptions.clear();
+  const tearsAndProjectiles = [...getTears(), ...getProjectiles()];
+  for (const tearOrProjectile of tearsAndProjectiles) {
+    const ptrHash = GetPtrHash(tearOrProjectile);
+    const initialDescription: InitialDescription = {
+      position: tearOrProjectile.Position,
+      positionOffset: tearOrProjectile.PositionOffset,
+      velocity: tearOrProjectile.Velocity,
+      height: tearOrProjectile.Height,
+      fallingSpeed: tearOrProjectile.FallingSpeed,
+      fallingAcceleration: isTear(tearOrProjectile)
+        ? tearOrProjectile.FallingAcceleration
+        : tearOrProjectile.FallingAccel,
+    };
+    v.run.initialDescriptions.set(ptrHash, initialDescription);
+  }
+
+  const firstPlayer = Isaac.GetPlayer();
+  useActiveItemTemp(firstPlayer, CollectibleType.PAUSE);
+
+  const whitelist = new Set([ButtonAction.MENU_CONFIRM, ButtonAction.CONSOLE]);
   disableAllInputsExceptFor(FEATURE_NAME, whitelist);
+
+  for (const player of getAllPlayers()) {
+    // Disable the controls to prevent the players from moving, shooting, and so on. (We also
+    // disable the inputs in the `INPUT_ACTION` callback, but that does not prevent mouse inputs.)
+    player.ControlsEnabled = false;
+
+    // Prevent the players from leaving the room. (If we don't reset the velocity, they can continue
+    // to move towards a door.)
+    player.Velocity = VectorZero;
+  }
+
+  stopTearsAndProjectilesFromMoving();
 }
 
 /** Helper function to put things back to normal after the `pause` function was used. */
@@ -92,7 +172,17 @@ export function unpause(): void {
     return;
   }
   v.run.isPseudoPaused = false;
+  v.run.shouldUnpause = true;
 
   enableAllInputs(FEATURE_NAME);
-  v.run.shouldUnpause = true;
+  for (const player of getAllPlayers()) {
+    player.ControlsEnabled = true;
+  }
+
+  // After a vanilla pause, the tears will not resume their normal velocity and will "stick" to the
+  // air. Even if we try to help the tears along by explicitly resetting all of the velocity-related
+  // variables to their initial values, this will not make a difference. Thus, revert to removing
+  // all of the tears and projectiles in the room.
+  removeAllTears();
+  removeAllProjectiles();
 }

package/src/features/persistentEntities.ts

@@ -3,12 +3,12 @@ import {
   EntityType,
   ModCallback,
 } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
 import { spawn } from "../functions/entities";
 import { getRoomListIndex } from "../functions/roomData";
+import { getLatestRoomDescription } from "./roomHistory";
 import { saveDataManager } from "./saveDataManager/exports";
 
 interface PersistentEntityDescription {
@@ -64,18 +64,19 @@ function postEntityRemove(entity: Entity) {
   const index = tuple[0];
 
   // The persistent entity is despawning, presumably because the player is in the process of leaving
-  // the room. Keep track of the position for later. We use the previous room list index because at
-  // this point, the PostNewRoom callback has already fired and we are in a new room.
-  const level = game.GetLevel();
-  const previousRoomGridIndex = level.GetPreviousRoomIndex();
-  const previousRoomListIndex = getRoomListIndex(previousRoomGridIndex);
-  v.level.persistentEntities.set(index, {
+  // the room. Keep track of the position for later. We use the previous room list index because
+  // even though the `POST_NEW_ROOM` callback was not fired yet, we have already traveled to the
+  // next room.
+  const previousRoomDescription = getLatestRoomDescription();
+  const previousRoomListIndex = previousRoomDescription.roomListIndex;
+  const persistentEntityDescription: PersistentEntityDescription = {
     entityType: entity.Type,
     variant: entity.Variant,
     subType: entity.SubType,
     roomListIndex: previousRoomListIndex,
     position: entity.Position,
-  });
+  };
+  v.level.persistentEntities.set(index, persistentEntityDescription);
 }
 
 // ModCallbackCustom.POST_NEW_ROOM_REORDERED