isaacscript-common 6.6.1-dev.0 → 6.6.1-dev.4

package/src/features/customStage/backdrop.ts

@@ -0,0 +1,274 @@
+// This file handles drawing the walls and floors for custom stages.
+
+// cspell:ignore LTRX,LTLX,LBRX,LBLX
+
+import {
+  EffectVariant,
+  EntityFlag,
+  RoomShape,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { VectorZero } from "../../constants";
+import { getRandomArrayElement } from "../../functions/array";
+import { spawnEffectWithSeed } from "../../functions/entitySpecific";
+import { newRNG } from "../../functions/rng";
+import { isLRoom, isNarrowRoom } from "../../functions/roomShape";
+import { trimPrefix } from "../../functions/string";
+import { erange, irange } from "../../functions/utils";
+import { CustomStage } from "../../interfaces/CustomStage";
+import { ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH } from "./customStageConstants";
+
+enum BackdropKind {
+  /** The "N" stands for narrow rooms. */
+  N_FLOOR = "nFloors",
+
+  /** The "L" stands for L rooms. */
+  L_FLOOR = "lFloors",
+
+  WALL = "walls",
+  CORNER = "corners",
+}
+
+/** This is created by the vanilla Basement files. */
+const DEFAULT_BACKDROP: NonNullable<CustomStage["backdropPNGPaths"]> = {
+  nFloors: [`${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/nfloor.png`],
+  lFloors: [`${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/lfloor.png`], // cspell:ignore lfloor
+  walls: [`${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/wall.png`],
+  corners: [`${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/corner.png`],
+} as const;
+
+const ROOM_SHAPE_WALL_ANM2_LAYERS: {
+  readonly [key in RoomShape]: int;
+} = {
+  [RoomShape.SHAPE_1x1]: 44, // 1
+  [RoomShape.IH]: 36, // 2
+  [RoomShape.IV]: 28, // 3
+  [RoomShape.SHAPE_1x2]: 58, // 4
+  [RoomShape.IIV]: 42, // 5
+  [RoomShape.SHAPE_2x1]: 63, // 6
+  [RoomShape.IIH]: 62, // 7
+  [RoomShape.SHAPE_2x2]: 63, // 8
+  [RoomShape.LTL]: 63, // 9
+  [RoomShape.LTR]: 63, // 10
+  [RoomShape.LBL]: 63, // 11
+  [RoomShape.LBR]: 63, // 12
+} as const;
+
+const ROOM_SHAPE_WALL_EXTRA_ANM2_LAYERS: {
+  readonly [key in RoomShape]?: int;
+} = {
+  [RoomShape.SHAPE_2x1]: 7, // 6
+  [RoomShape.SHAPE_2x2]: 21, // 8
+  [RoomShape.LTL]: 19, // 9
+  [RoomShape.LTR]: 19, // 10
+  [RoomShape.LBL]: 19, // 11
+  [RoomShape.LBR]: 19, // 12
+} as const;
+
+const WALL_OFFSET = Vector(-80, -80);
+
+/** This corresponds to "floor-backdrop.anm2". */
+const L_FLOOR_ANM2_LAYERS: readonly int[] = [16, 17];
+
+/** This corresponds to "floor-backdrop.anm2". */
+const N_FLOOR_ANM2_LAYERS: readonly int[] = [18, 19];
+
+/**
+ * Normally, we would make a custom entity to represent a backdrop effect, but we don't want to
+ * interfere with the "entities2.xml" file in end-user mods. Thus, we must select a vanilla effect
+ * to masquerade as a backdrop effect.
+ *
+ * We arbitrarily choose a ladder for this purpose because it will not automatically despawn after
+ * time passes, like most other effects.
+ */
+const BACKDROP_EFFECT_VARIANT = EffectVariant.LADDER;
+
+const BACKDROP_ROOM_TYPE_SET: ReadonlySet<RoomType> = new Set([
+  RoomType.DEFAULT,
+  RoomType.BOSS,
+  RoomType.MINI_BOSS,
+]);
+
+export function setBackdrop(customStage: CustomStage): void {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const decorationSeed = room.GetDecorationSeed();
+  const rng = newRNG(decorationSeed);
+
+  // We do not want to set the backdrop inside shops, Curse Rooms, and so on.
+  if (!BACKDROP_ROOM_TYPE_SET.has(roomType)) {
+    return;
+  }
+
+  spawnWallEntity(customStage, rng, false);
+  spawnSecondWallEntity(customStage, rng);
+  spawnFloorEntity(customStage, rng);
+}
+
+function getBackdropPNGPath(
+  customStage: CustomStage,
+  backdropKind: BackdropKind,
+  rng: RNG,
+) {
+  const backdrop =
+    customStage.backdropPNGPaths === undefined
+      ? DEFAULT_BACKDROP
+      : customStage.backdropPNGPaths;
+
+  const pathArray = backdrop[backdropKind];
+  return getRandomArrayElement(pathArray, rng);
+}
+
+function spawnWallEntity(
+  customStage: CustomStage,
+  rng: RNG,
+  isExtraWall: boolean,
+) {
+  const room = game.GetRoom();
+  const roomShape = room.GetRoomShape();
+
+  // We spawn an effect instead of simply rendering a static sprite in order to emulate how vanilla
+  // does this. (`EntityFlag.RENDER_WALL` is intended for this purpose.)
+  const wallEffect = spawnEffectWithSeed(
+    BACKDROP_EFFECT_VARIANT,
+    0,
+    VectorZero,
+    1 as Seed,
+  );
+  wallEffect.AddEntityFlags(EntityFlag.RENDER_WALL);
+
+  const sprite = wallEffect.GetSprite();
+  sprite.Load(`${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/wall-backdrop.anm2`, false);
+
+  const wallLayersArray = isExtraWall
+    ? ROOM_SHAPE_WALL_EXTRA_ANM2_LAYERS
+    : ROOM_SHAPE_WALL_ANM2_LAYERS;
+  const numWallLayers = wallLayersArray[roomShape];
+  if (numWallLayers === undefined) {
+    error(
+      `Failed to get the layers when creating the backdrop for custom stage: ${customStage.name}`,
+    );
+  }
+
+  if (isLRoom(roomShape)) {
+    const cornerPNGPath = getBackdropPNGPath(
+      customStage,
+      BackdropKind.CORNER,
+      rng,
+    );
+    sprite.ReplaceSpritesheet(0, cornerPNGPath);
+  }
+
+  for (const layerID of irange(1, numWallLayers)) {
+    const wallPNGPath = getBackdropPNGPath(customStage, BackdropKind.WALL, rng);
+    sprite.ReplaceSpritesheet(layerID, wallPNGPath);
+  }
+
+  const topLeftPos = room.GetTopLeftPos();
+  const renderPos = topLeftPos.add(WALL_OFFSET);
+  const modifiedOffset = renderPos.div(40).mul(26);
+  wallEffect.SpriteOffset = modifiedOffset;
+
+  sprite.LoadGraphics();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const roomShapeName = RoomShape[roomShape]!;
+  const animation = trimPrefix(roomShapeName, "SHAPE_");
+  const modifiedAnimation = isExtraWall ? `${animation}X` : animation;
+  sprite.Play(modifiedAnimation, true);
+}
+
+function spawnSecondWallEntity(customStage: CustomStage, rng: RNG) {
+  const room = game.GetRoom();
+  const roomShape = room.GetRoomShape();
+  const extraLayers = ROOM_SHAPE_WALL_EXTRA_ANM2_LAYERS[roomShape];
+  const roomShapeHasExtraLayers = extraLayers !== undefined;
+  if (roomShapeHasExtraLayers) {
+    spawnWallEntity(customStage, rng, true);
+  }
+}
+
+function spawnFloorEntity(customStage: CustomStage, rng: RNG) {
+  const room = game.GetRoom();
+  const roomShape = room.GetRoomShape();
+
+  // We spawn an effect instead of simply rendering a static sprite in order to emulate how vanilla
+  // does this. (`EntityFlag.RENDER_FLOOR` is intended for this purpose.)
+  const floorEffect = spawnEffectWithSeed(
+    BACKDROP_EFFECT_VARIANT,
+    0,
+    VectorZero,
+    1 as Seed,
+  );
+  floorEffect.AddEntityFlags(EntityFlag.RENDER_FLOOR);
+
+  const sprite = floorEffect.GetSprite();
+  sprite.Load(
+    `${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/floor-backdrop.anm2`,
+    false,
+  );
+
+  const numFloorLayers = getNumFloorLayers(roomShape);
+  if (numFloorLayers !== undefined) {
+    for (const layerID of erange(0, numFloorLayers)) {
+      // The wall spritesheet is used for the "normal" floors.
+      const wallPNGPath = getBackdropPNGPath(
+        customStage,
+        BackdropKind.WALL,
+        rng,
+      );
+      sprite.ReplaceSpritesheet(layerID, wallPNGPath);
+    }
+  } else if (isLRoom(roomShape)) {
+    for (const layerID of L_FLOOR_ANM2_LAYERS) {
+      const LFloorPNGPath = getBackdropPNGPath(
+        customStage,
+        BackdropKind.L_FLOOR,
+        rng,
+      );
+      sprite.ReplaceSpritesheet(layerID, LFloorPNGPath);
+    }
+  } else if (isNarrowRoom(roomShape)) {
+    for (const layerID of N_FLOOR_ANM2_LAYERS) {
+      const NFloorPNGPath = getBackdropPNGPath(
+        customStage,
+        BackdropKind.N_FLOOR,
+        rng,
+      );
+      sprite.ReplaceSpritesheet(layerID, NFloorPNGPath);
+    }
+  }
+
+  const topLeftPos = room.GetTopLeftPos();
+  const renderPos = topLeftPos;
+  const modifiedOffset = renderPos.div(40).mul(26); // The magic numbers are copied from StageAPI.
+  floorEffect.SpriteOffset = modifiedOffset;
+
+  sprite.LoadGraphics();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const roomShapeName = RoomShape[roomShape]!;
+  const animation = trimPrefix(roomShapeName, "SHAPE_");
+  sprite.Play(animation, true);
+}
+
+function getNumFloorLayers(roomShape: RoomShape) {
+  switch (roomShape) {
+    case RoomShape.SHAPE_1x1: {
+      return 4;
+    }
+
+    case RoomShape.SHAPE_1x2:
+    case RoomShape.SHAPE_2x1: {
+      return 8;
+    }
+
+    case RoomShape.SHAPE_2x2: {
+      return 16;
+    }
+
+    default: {
+      // We have explicit logic elsewhere to handle narrow rooms and L rooms.
+      return undefined;
+    }
+  }
+}

package/src/features/customStage/customStageConstants.ts

@@ -0,0 +1 @@
+export const ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH = "gfx/isaacscript-custom-stage";

package/src/features/customStage/exports.ts

@@ -0,0 +1,201 @@
+import {
+  Direction,
+  EntityType,
+  GridRoom,
+  LevelStage,
+  RoomShape,
+  RoomTransitionAnim,
+  RoomType,
+  StageType,
+} from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { reorderedCallbacksSetStage } from "../../callbacks/reorderedCallbacks";
+import { getEntityIDFromConstituents } from "../../functions/entity";
+import { log, logError } from "../../functions/log";
+import { movePlayersToCenter } from "../../functions/playerCenter";
+import { newRNG } from "../../functions/rng";
+import { getRoomData } from "../../functions/roomData";
+import { getRooms } from "../../functions/rooms";
+import { getGotoCommand, setStage } from "../../functions/stage";
+import { runNextRoom } from "../runNextRoom";
+import { getRandomCustomStageRoom } from "./util";
+import v, {
+  customBossPNGPaths,
+  customStageCachedRoomData,
+  customStagesMap,
+} from "./v";
+import { playVersusScreenAnimation } from "./versusScreen";
+
+const DEFAULT_BASE_STAGE = LevelStage.BASEMENT_2;
+const DEFAULT_BASE_STAGE_TYPE = StageType.ORIGINAL;
+
+/**
+ * Helper function to warp to a custom stage/level.
+ *
+ * Custom stages/levels must first be defined in the "tsconfig.json" file. See the documentation for
+ * more details: https://isaacscript.github.io/main/custom-stages/
+ */
+export function setCustomStage(name: string, verbose = false): void {
+  const customStage = customStagesMap.get(name);
+  if (customStage === undefined) {
+    error(
+      `Failed to set the custom stage of "${name}" because it was not found in the custom stages map. (This means that you probably forgot to define it in your "tsconfig.json" file.) See the website for more details on how to set up custom stages.`,
+    );
+  }
+
+  const level = game.GetLevel();
+  const startingRoomGridIndex = level.GetStartingRoomIndex();
+  const seeds = game.GetSeeds();
+  const startSeed = seeds.GetStartSeed();
+  const rng = newRNG(startSeed);
+
+  v.run.currentCustomStage = customStage;
+
+  const baseStage =
+    customStage.baseStage === undefined
+      ? DEFAULT_BASE_STAGE
+      : (customStage.baseStage as LevelStage);
+  const baseStageType =
+    customStage.baseStageType === undefined
+      ? DEFAULT_BASE_STAGE_TYPE
+      : (customStage.baseStageType as StageType);
+  setStage(baseStage, baseStageType);
+
+  // Now, we need to pick a custom room for each vanilla room.
+  for (const room of getRooms()) {
+    // The starting floor of each room should stay empty.
+    if (room.SafeGridIndex === startingRoomGridIndex) {
+      continue;
+    }
+
+    if (room.Data === undefined) {
+      continue;
+    }
+
+    const roomType = room.Data.Type;
+    const roomShapeMap = customStage.roomTypeMap.get(roomType);
+    if (roomShapeMap === undefined) {
+      // Only show errors for non-default room types. (By default, we won't replace shops and other
+      // special rooms.)
+      if (roomType === RoomType.DEFAULT) {
+        logError(
+          `Failed to find any custom rooms for RoomType.${RoomType[roomType]} (${roomType}) for custom stage: ${name}`,
+        );
+      }
+      continue;
+    }
+
+    const roomShape = room.Data.Shape;
+    const roomDoorSlotFlagMap = roomShapeMap.get(roomShape);
+    if (roomDoorSlotFlagMap === undefined) {
+      logError(
+        `Failed to find any custom rooms for RoomType.${RoomType[roomType]} (${roomType}) + RoomShape.${RoomShape[roomShape]} (${roomShape}) for custom stage: ${name}`,
+      );
+      continue;
+    }
+
+    const doorSlotFlags = room.Data.Doors;
+    const roomsMetadata = roomDoorSlotFlagMap.get(doorSlotFlags);
+    if (roomsMetadata === undefined) {
+      logError(
+        `Failed to find any custom rooms for RoomType.${RoomType[roomType]} (${roomType}) + RoomShape.${RoomShape[roomShape]} (${roomShape}) + DoorSlotFlags ${doorSlotFlags} for custom stage: ${name}`,
+      );
+      continue;
+    }
+
+    const randomRoom = getRandomCustomStageRoom(roomsMetadata, rng, verbose);
+
+    let newRoomData = customStageCachedRoomData.get(randomRoom.variant);
+    if (newRoomData === undefined) {
+      // We need the room data for this room. We can leverage the "goto" console command to load it
+      // into the "debug" slot. This is convenient because we do not actually have to travel to the
+      // room.
+      const command = getGotoCommand(roomType, randomRoom.variant);
+      Isaac.ExecuteCommand(command);
+      newRoomData = getRoomData(GridRoom.DEBUG);
+      if (newRoomData === undefined) {
+        logError(
+          `Failed to get the room data for room variant ${randomRoom.variant} for custom stage: ${name}`,
+        );
+        continue;
+      }
+      customStageCachedRoomData.set(randomRoom.variant, newRoomData);
+    }
+
+    room.Data = newRoomData;
+  }
+
+  // Set the stage to an invalid value, which will prevent the walls and floors from loading. We
+  // must use `StageType.WRATH_OF_THE_LAMB` instead of `StageType.ORIGINAL` or else the walls will
+  // not render properly. DeadInfinity suspects that this might be because it is trying to use the
+  // Dark Room's backdrop (instead of The Chest).
+  const stage = -1 as LevelStage;
+  const stageType = StageType.WRATH_OF_THE_LAMB;
+  level.SetStage(stage, stageType);
+  reorderedCallbacksSetStage(stage, stageType);
+
+  // We must reload the current room in order for the `Level.SetStage` method to take effect.
+  // Furthermore, we need to cancel the queued warp to the `GridRoom.DEBUG` room. We can accomplish
+  // both of these things by initiating a room transition to the starting room of the floor. (We
+  // assume that since we just warped to a new floor, we are already in the starting room.)
+  game.StartRoomTransition(
+    startingRoomGridIndex,
+    Direction.NO_DIRECTION,
+    RoomTransitionAnim.FADE,
+  );
+
+  // We do more setup once the room is reloaded from the transition.
+  runNextRoom(postRoomTransition);
+}
+
+function postRoomTransition() {
+  // After the room transition, the players will be placed next to a door, but they should be in the
+  // center of the room to emulate what happens on a vanilla stage.
+  movePlayersToCenter();
+}
+
+export function setCustomStageDebug(): void {
+  const customStage = v.run.currentCustomStage;
+  if (customStage === null) {
+    log("No custom stage is currently loaded.");
+    return;
+  }
+
+  playVersusScreenAnimation(customStage, true);
+}
+
+/**
+ * By default, unknown bosses will be drawn on the boss "versus" screen as "???". If your custom
+ * stage has custom bosses, you can use this function to register the corresponding graphic file
+ * files for them.
+ *
+ * For reference:
+ * - The vanilla name sprite for Monstro is located at "C:\Program Files
+ *   (x86)\Steam\steamapps\common\The Binding of Isaac
+ *   Rebirth\resources\gfx\ui\boss\bossname_20.0_monstro.png".
+ * - The vanilla portrait sprite for Monstro is located at "C:\Program Files
+ *   (x86)\Steam\steamapps\common\The Binding of Isaac
+ *   Rebirth\resources\gfx\ui\boss\portrait_20.0_monstro.png".
+ *
+ * (Note that boss metadata like this cannot be specified with the rest of the custom stage metadata
+ * in the "tsconfig.json" file because there is not a way to retrieve the name of an entity at
+ * run-time.)
+ *
+ * @param entityType The entity type of the custom boss.
+ * @param variant The variant of the custom boss.
+ * @param subType The sub-type of the custom boss.
+ * @param namePNGPath The full path to the PNG file that contains the name of the boss that will be
+ *                    displayed on the top of the boss "versus" screen.
+ * @param portraitPNGPath The full path to the PNG file that contains the portrait of the boss that
+ *                        will be displayed on the right side of the boss "versus" screen.
+ */
+export function registerCustomBoss(
+  entityType: EntityType,
+  variant: int,
+  subType: int,
+  namePNGPath: string,
+  portraitPNGPath: string,
+): void {
+  const entityID = getEntityIDFromConstituents(entityType, variant, subType);
+  customBossPNGPaths.set(entityID, [namePNGPath, portraitPNGPath]);
+}

package/src/features/customStage/gridEntities.ts

@@ -0,0 +1,195 @@
+import {
+  CollectibleType,
+  EntityType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { DecorationVariant } from "../../enums/DecorationVariant";
+import { removeEntities } from "../../functions/entity";
+import { getNPCs } from "../../functions/entitySpecific";
+import {
+  getCoins,
+  getCollectibles,
+  getTrinkets,
+} from "../../functions/pickups";
+import { vectorEquals } from "../../functions/vector";
+import { CustomStage } from "../../interfaces/CustomStage";
+
+/** For `GridEntityType.DECORATION` (1) */
+export function setCustomDecorationGraphics(
+  customStage: CustomStage,
+  gridEntity: GridEntity,
+): void {
+  // If the end-user did not specify custom decoration graphics, default to Basement graphics. (We
+  // don't have to adjust anything for this case.)
+  if (customStage.decorationsPNGPath === undefined) {
+    return;
+  }
+
+  // Ignore custom grid entities. (They are represented as decorations with a non-zero variant.)
+  const variant = gridEntity.GetVariant();
+  if (variant !== (DecorationVariant.VANILLA_DECORATION as int)) {
+    return;
+  }
+
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+  // On Windows, this is: gfx/grid/Props_01_Basement.anm2
+  if (fileName.toLowerCase() === "gfx/grid/props_01_basement.anm2") {
+    sprite.ReplaceSpritesheet(0, customStage.decorationsPNGPath);
+    sprite.LoadGraphics();
+  }
+}
+
+/** For `GridEntityType.ROCK` (2) */
+export function setCustomRockGraphics(
+  customStage: CustomStage,
+  gridEntity: GridEntity,
+): void {
+  // If the end-user did not specify custom rock graphics, default to Basement graphics. (We don't
+  // have to adjust anything for this case.)
+  if (customStage.rocksPNGPath === undefined) {
+    return;
+  }
+
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+  if (fileName === "gfx/grid/grid_rock.anm2") {
+    sprite.ReplaceSpritesheet(0, customStage.rocksPNGPath);
+    sprite.LoadGraphics();
+  } else if (fileName === "gfx/grid/grid_pit.anm2") {
+    sprite.ReplaceSpritesheet(1, customStage.rocksPNGPath);
+    sprite.LoadGraphics();
+  }
+}
+
+/** For `GridEntityType.PIT` (7) */
+export function setCustomPitGraphics(
+  customStage: CustomStage,
+  gridEntity: GridEntity,
+): void {
+  // If the end-user did not specify custom pit graphics, default to Basement graphics. (We don't
+  // have to adjust anything for this case.)
+  if (customStage.pitsPNGPath === undefined) {
+    return;
+  }
+
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+  if (fileName === "gfx/grid/grid_pit.anm2") {
+    sprite.ReplaceSpritesheet(0, customStage.pitsPNGPath);
+    sprite.LoadGraphics();
+  }
+}
+
+/** For GridEntityType.DOOR (16) */
+export function setCustomDoorGraphics(
+  customStage: CustomStage,
+  gridEntity: GridEntity,
+): void {
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+  const doorPNGPath = getNewDoorPNGPath(customStage, fileName);
+  if (doorPNGPath !== undefined) {
+    sprite.ReplaceSpritesheet(0, doorPNGPath);
+    sprite.LoadGraphics();
+  }
+}
+
+function getNewDoorPNGPath(
+  customStage: CustomStage,
+  fileName: string,
+): string | undefined {
+  switch (fileName) {
+    case "gfx/grid/door_01_normaldoor.anm2": {
+      return customStage.doorPNGPaths?.normal;
+    }
+
+    case "gfx/grid/door_02_treasureroomdoor.anm2": {
+      return customStage.doorPNGPaths?.treasureRoom;
+    }
+
+    case "gfx/grid/door_03_ambushroomdoor.anm2": {
+      return customStage.doorPNGPaths?.normalChallengeRoom;
+    }
+
+    case "gfx/grid/door_04_selfsacrificeroomdoor.anm2": {
+      return customStage.doorPNGPaths?.curseRoom;
+    }
+
+    case "gfx/grid/door_05_arcaderoomdoor.anm2": {
+      return customStage.doorPNGPaths?.arcade;
+    }
+
+    case "gfx/grid/door_07_devilroomdoor.anm2": {
+      return customStage.doorPNGPaths?.devilRoom;
+    }
+
+    case "gfx/grid/door_07_holyroomdoor.anm2": {
+      return customStage.doorPNGPaths?.angelRoom;
+    }
+
+    case "gfx/grid/door_08_holeinwall.anm2": {
+      return customStage.doorPNGPaths?.secretRoom;
+    }
+
+    case "gfx/grid/door_09_bossambushroomdoor.anm2": {
+      return customStage.doorPNGPaths?.bossChallengeRoom;
+    }
+
+    case "gfx/grid/door_10_bossroomdoor.anm2": {
+      return customStage.doorPNGPaths?.bossRoom;
+    }
+
+    case "gfx/grid/door_15_bossrushdoor.anm2": {
+      return customStage.doorPNGPaths?.bossRush;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * The rewards are based on the ones from the wiki:
+ * https://bindingofisaacrebirth.fandom.com/wiki/Rocks#Urns
+ *
+ * On the bugged stage of -1, only urns will spawn, so we do not have to handle the case of mushroom
+ * rewards, skull rewards, and so on.
+ */
+export function removeUrnRewards(
+  customStage: CustomStage,
+  gridEntity: GridEntity,
+): void {
+  // Assume that if the end-user does not have custom rock graphics specified, they want to keep the
+  // vanilla urn reward functionality.
+  if (customStage.rocksPNGPath === undefined) {
+    return;
+  }
+
+  // Spiders
+  const spiders = getNPCs(EntityType.SPIDER);
+  removeEntitiesSpawnedFromGridEntity(spiders, gridEntity);
+
+  // Coins
+  const coins = getCoins();
+  removeEntitiesSpawnedFromGridEntity(coins, gridEntity);
+
+  // A Quarter
+  const quarters = getCollectibles(CollectibleType.QUARTER);
+  removeEntitiesSpawnedFromGridEntity(quarters, gridEntity);
+
+  // Swallowed Penny
+  const swallowedPennies = getTrinkets(TrinketType.SWALLOWED_PENNY);
+  removeEntitiesSpawnedFromGridEntity(swallowedPennies, gridEntity);
+}
+
+function removeEntitiesSpawnedFromGridEntity(
+  entities: Entity[],
+  gridEntity: GridEntity,
+) {
+  const entitiesFromGridEntity = entities.filter(
+    (entity) =>
+      entity.FrameCount === 0 &&
+      vectorEquals(entity.Position, gridEntity.Position),
+  );
+  removeEntities(entitiesFromGridEntity);
+}