isaacscript-common 14.1.3 → 15.0.0

package/src/classes/features/other/customStages/backdrop.ts

@@ -0,0 +1,282 @@
+// 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 "../../../../core/cachedClasses";
+import { VectorZero } from "../../../../core/constants";
+import { LadderSubTypeCustom } from "../../../../enums/LadderSubTypeCustom";
+import { getRandomArrayElement } from "../../../../functions/array";
+import { spawnEffectWithSeed } from "../../../../functions/entitiesSpecific";
+import { newRNG } from "../../../../functions/rng";
+import { isLRoom, isNarrowRoom } from "../../../../functions/roomShape";
+import {
+  removeCharactersBefore,
+  trimPrefix,
+} from "../../../../functions/string";
+import { eRange, iRange } from "../../../../functions/utils";
+import { CustomStage } from "../../../../interfaces/private/CustomStage";
+import { ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH } from "./constants";
+
+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);
+
+/** Corresponds to "floor-backdrop.anm2". */
+const L_FLOOR_ANM2_LAYERS: readonly int[] = [16, 17];
+
+/** 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_EFFECT_SUB_TYPE = LadderSubTypeCustom.CUSTOM_BACKDROP;
+
+const BACKDROP_ROOM_TYPE_SET: ReadonlySet<RoomType> = new Set([
+  RoomType.DEFAULT,
+  RoomType.BOSS,
+  RoomType.MINI_BOSS,
+]);
+
+export function setCustomStageBackdrop(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];
+  const randomPath = getRandomArrayElement(pathArray, rng);
+  return removeCharactersBefore(randomPath, "gfx/");
+}
+
+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 seed = 1 as Seed;
+  const wallEffect = spawnEffectWithSeed(
+    BACKDROP_EFFECT_VARIANT,
+    BACKDROP_EFFECT_SUB_TYPE,
+    VectorZero,
+    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 seed = 1 as Seed;
+  const floorEffect = spawnEffectWithSeed(
+    BACKDROP_EFFECT_VARIANT,
+    0,
+    VectorZero,
+    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/classes/features/other/customStages/constants.ts

@@ -0,0 +1,21 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+
+export const CUSTOM_STAGE_FEATURE_NAME = "CustomStage";
+
+export const ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH = "gfx/isaacscript-custom-stage";
+
+export const DEFAULT_BASE_STAGE = LevelStage.BASEMENT_2;
+export const DEFAULT_BASE_STAGE_TYPE = StageType.ORIGINAL;
+
+/**
+ * Equal to -1. Setting the stage to an invalid stage value is useful in that it prevents backdrops
+ * and shadows from loading.
+ */
+export const CUSTOM_FLOOR_STAGE = -1 as LevelStage;
+
+/**
+ * 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).
+ */
+export const CUSTOM_FLOOR_STAGE_TYPE = StageType.WRATH_OF_THE_LAMB;

package/src/classes/features/other/customStages/gridEntities.ts

@@ -0,0 +1,253 @@
+import { GridEntityType, LevelStage } from "isaac-typescript-definitions";
+import { removeGridEntity } from "../../../../functions/gridEntities";
+import { calculateStageType } from "../../../../functions/stage";
+import { removeCharactersBefore } from "../../../../functions/string";
+import { CustomStage } from "../../../../interfaces/private/CustomStage";
+import { CustomTrapdoors } from "../CustomTrapdoors";
+import { DEFAULT_BASE_STAGE } from "./constants";
+
+/** 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 &&
+    customStage.decorationsANM2Path === undefined
+  ) {
+    return;
+  }
+
+  const gridEntityType = gridEntity.GetType();
+  if (gridEntityType !== GridEntityType.DECORATION) {
+    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") {
+    return;
+  }
+
+  if (customStage.decorationsANM2Path !== undefined) {
+    const anm2Path = removeCharactersBefore(
+      customStage.decorationsANM2Path,
+      "gfx/",
+    );
+    sprite.Load(anm2Path, true);
+  } else if (customStage.decorationsPNGPath !== undefined) {
+    const pngPath = removeCharactersBefore(
+      customStage.decorationsPNGPath,
+      "gfx/",
+    );
+    sprite.ReplaceSpritesheet(0, pngPath);
+    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 &&
+    customStage.rocksANM2Path === undefined
+  ) {
+    return;
+  }
+
+  const gridEntityRock = gridEntity.ToRock();
+  if (gridEntityRock === undefined) {
+    return;
+  }
+
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+
+  switch (fileName) {
+    case "gfx/grid/grid_rock.anm2": {
+      // The normal case of a rock.
+      if (customStage.rocksANM2Path !== undefined) {
+        const anm2Path = removeCharactersBefore(
+          customStage.rocksANM2Path,
+          "gfx/",
+        );
+        sprite.Load(anm2Path, true);
+      } else if (customStage.rocksPNGPath !== undefined) {
+        const pngPath = removeCharactersBefore(
+          customStage.rocksPNGPath,
+          "gfx/",
+        );
+        sprite.ReplaceSpritesheet(0, pngPath);
+        sprite.LoadGraphics();
+      }
+
+      break;
+    }
+
+    case "gfx/grid/grid_pit.anm2": {
+      // The case of when a rock is blown on a pit to make a bridge.
+      if (customStage.rocksPNGPath !== undefined) {
+        const pngPath = removeCharactersBefore(
+          customStage.rocksPNGPath,
+          "gfx/",
+        );
+        sprite.ReplaceSpritesheet(1, pngPath);
+        sprite.LoadGraphics();
+      }
+
+      break;
+    }
+  }
+}
+
+/** 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 pngPath = removeCharactersBefore(customStage.pitsPNGPath, "gfx/");
+
+  const gridEntityPit = gridEntity.ToPit();
+  if (gridEntityPit === undefined) {
+    return;
+  }
+
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+  if (fileName === "gfx/grid/grid_pit.anm2") {
+    sprite.ReplaceSpritesheet(0, pngPath);
+    sprite.LoadGraphics();
+  }
+}
+
+/** For `GridEntityType.DOOR` (16). */
+export function setCustomDoorGraphics(
+  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.doorPNGPaths === undefined) {
+    return;
+  }
+
+  const gridEntityDoor = gridEntity.ToDoor();
+  if (gridEntityDoor === undefined) {
+    return;
+  }
+
+  const sprite = gridEntity.GetSprite();
+  const fileName = sprite.GetFilename();
+  const doorPNGPath = getNewDoorPNGPath(customStage, fileName);
+  if (doorPNGPath !== undefined) {
+    const fixedPath = removeCharactersBefore(doorPNGPath, "gfx/");
+    sprite.ReplaceSpritesheet(0, fixedPath);
+    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;
+}
+
+export function convertVanillaTrapdoors(
+  customStage: CustomStage,
+  gridEntity: GridEntity,
+  isFirstFloor: boolean,
+  customTrapdoors: CustomTrapdoors,
+): void {
+  const gridEntityType = gridEntity.GetType();
+  if (gridEntityType !== GridEntityType.TRAPDOOR) {
+    return;
+  }
+
+  removeGridEntity(gridEntity, true);
+
+  if (isFirstFloor) {
+    // If we are on the first floor of a custom stage, then the destination will be the second floor
+    // of the custom stage. (e.g. Caves 1 to Caves 2)
+    customTrapdoors.spawnCustomTrapdoor(
+      gridEntity.Position,
+      customStage.name,
+      LevelStage.BASEMENT_2,
+    );
+  } else {
+    // If we are on the second floor of a custom stage, then the destination will be the vanilla
+    // floor equivalent to 2 floors after the floor used as a basis for the custom stage.
+    const baseStage =
+      customStage.baseStage === undefined
+        ? DEFAULT_BASE_STAGE
+        : customStage.baseStage;
+    const destinationStage = (baseStage + 2) as LevelStage;
+    const destinationStageType = calculateStageType(destinationStage);
+
+    customTrapdoors.spawnCustomTrapdoor(
+      gridEntity.Position,
+      undefined,
+      destinationStage,
+      destinationStageType,
+    );
+  }
+}

package/src/classes/features/other/customStages/shadows.ts

@@ -0,0 +1,80 @@
+import { EffectVariant, RoomShape } from "isaac-typescript-definitions";
+import { game } from "../../../../core/cachedClasses";
+import { LadderSubTypeCustom } from "../../../../enums/LadderSubTypeCustom";
+import { getRandomArrayElement } from "../../../../functions/array";
+import { spawnEffectWithSeed } from "../../../../functions/entitiesSpecific";
+import { removeCharactersBefore } from "../../../../functions/string";
+import { CustomStage } from "../../../../interfaces/private/CustomStage";
+import { ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH } from "./constants";
+
+type ShadowAnimation = "1x1" | "1x2" | "2x1" | "2x2";
+
+/**
+ * Normally, we would make a custom entity to represent a shadow 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 SHADOW_EFFECT_VARIANT = EffectVariant.LADDER;
+const SHADOW_EFFECT_SUB_TYPE = LadderSubTypeCustom.CUSTOM_SHADOW;
+
+/** The animation comes from StageAPI. */
+const ROOM_SHAPE_TO_SHADOW_ANIMATION: {
+  readonly [key in RoomShape]: ShadowAnimation;
+} = {
+  [RoomShape.SHAPE_1x1]: "1x1", // 1
+  [RoomShape.IH]: "1x1", // 2
+  [RoomShape.IV]: "1x1", // 3
+  [RoomShape.SHAPE_1x2]: "1x2", // 4
+  [RoomShape.IIV]: "1x2", // 5
+  [RoomShape.SHAPE_2x1]: "2x1", // 6
+  [RoomShape.IIH]: "2x1", // 7
+  [RoomShape.SHAPE_2x2]: "2x2", // 8
+  [RoomShape.LTL]: "2x2", // 9
+  [RoomShape.LTR]: "2x2", // 10
+  [RoomShape.LBL]: "2x2", // 11
+  [RoomShape.LBR]: "2x2", // 12
+} as const;
+
+const FADED_BLACK = Color(0, 0, 0, 0.25);
+
+export function setShadows(customStage: CustomStage): void {
+  if (customStage.shadows === undefined) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomShape = room.GetRoomShape();
+  const centerPos = room.GetCenterPos();
+  const animation = ROOM_SHAPE_TO_SHADOW_ANIMATION[roomShape];
+  const shadows = customStage.shadows[animation];
+  if (shadows === undefined) {
+    return;
+  }
+
+  // We spawn an effect instead of simply rendering a static sprite so that the effect will properly
+  // slide in during a room transition animation. (It looks stupid if the shadow stays statically
+  // rendering throughout this animation.)
+  const seed = 1 as Seed;
+  const shadowEffect = spawnEffectWithSeed(
+    SHADOW_EFFECT_VARIANT,
+    SHADOW_EFFECT_SUB_TYPE,
+    centerPos,
+    seed,
+  );
+
+  const sprite = shadowEffect.GetSprite();
+  sprite.Load(`${ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/stage-shadow.anm2`, false);
+  const decorationSeed = room.GetDecorationSeed();
+  const shadow = getRandomArrayElement(shadows, decorationSeed);
+  const pngPath = removeCharactersBefore(shadow.pngPath, "gfx/");
+  sprite.ReplaceSpritesheet(0, pngPath);
+  sprite.LoadGraphics();
+  sprite.SetFrame(animation, 0);
+  sprite.Color =
+    shadow.color === undefined
+      ? FADED_BLACK
+      : Color(shadow.color.r, shadow.color.g, shadow.color.b, shadow.color.a);
+}