isaacscript-common 84.0.1 → 84.1.0

package/dist/classes/features/other/customStages/backdrop.js

@@ -0,0 +1,195 @@
+"use strict";
+// This file handles drawing the walls and floors for custom stages.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCustomStageBackdrop = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../../core/cachedClasses");
+const constants_1 = require("../../../../core/constants");
+const LadderSubTypeCustom_1 = require("../../../../enums/LadderSubTypeCustom");
+const array_1 = require("../../../../functions/array");
+const entitiesSpecific_1 = require("../../../../functions/entitiesSpecific");
+const rng_1 = require("../../../../functions/rng");
+const roomShape_1 = require("../../../../functions/roomShape");
+const string_1 = require("../../../../functions/string");
+const utils_1 = require("../../../../functions/utils");
+const ReadonlySet_1 = require("../../../../types/ReadonlySet");
+const constants_2 = require("./constants");
+var BackdropKind;
+(function (BackdropKind) {
+    /** The "N" stands for narrow rooms. */
+    BackdropKind["N_FLOOR"] = "nFloors";
+    /** The "L" stands for L rooms. */
+    BackdropKind["L_FLOOR"] = "lFloors";
+    BackdropKind["WALL"] = "walls";
+    BackdropKind["CORNER"] = "corners";
+})(BackdropKind || (BackdropKind = {}));
+/** This is created by the vanilla Basement files. */
+const DEFAULT_BACKDROP = {
+    nFloors: [`${constants_2.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/nfloor.png`],
+    lFloors: [`${constants_2.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/lfloor.png`],
+    walls: [`${constants_2.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/wall.png`],
+    corners: [`${constants_2.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/backdrop/corner.png`],
+};
+const ROOM_SHAPE_WALL_ANM2_LAYERS = {
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_1x1]: 44,
+    [isaac_typescript_definitions_1.RoomShape.IH]: 36,
+    [isaac_typescript_definitions_1.RoomShape.IV]: 28,
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_1x2]: 58,
+    [isaac_typescript_definitions_1.RoomShape.IIV]: 42,
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_2x1]: 63,
+    [isaac_typescript_definitions_1.RoomShape.IIH]: 62,
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_2x2]: 63,
+    [isaac_typescript_definitions_1.RoomShape.LTL]: 63,
+    [isaac_typescript_definitions_1.RoomShape.LTR]: 63,
+    [isaac_typescript_definitions_1.RoomShape.LBL]: 63,
+    [isaac_typescript_definitions_1.RoomShape.LBR]: 63, // 12
+};
+// We don't use `as const` since we need the object to be indexable by all `RoomShape`.
+// eslint-disable-next-line isaacscript/require-capital-const-assertions
+const ROOM_SHAPE_WALL_EXTRA_ANM2_LAYERS = {
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_2x1]: 7,
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_2x2]: 21,
+    [isaac_typescript_definitions_1.RoomShape.LTL]: 19,
+    [isaac_typescript_definitions_1.RoomShape.LTR]: 19,
+    [isaac_typescript_definitions_1.RoomShape.LBL]: 19,
+    [isaac_typescript_definitions_1.RoomShape.LBR]: 19, // 12
+};
+const WALL_OFFSET = Vector(-80, -80);
+/** Corresponds to "floor-backdrop.anm2". */
+const L_FLOOR_ANM2_LAYERS = [16, 17];
+/** Corresponds to "floor-backdrop.anm2". */
+const N_FLOOR_ANM2_LAYERS = [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 = isaac_typescript_definitions_1.EffectVariant.LADDER;
+const BACKDROP_EFFECT_SUB_TYPE = LadderSubTypeCustom_1.LadderSubTypeCustom.CUSTOM_BACKDROP;
+const BACKDROP_ROOM_TYPE_SET = new ReadonlySet_1.ReadonlySet([
+    isaac_typescript_definitions_1.RoomType.DEFAULT,
+    isaac_typescript_definitions_1.RoomType.BOSS,
+    isaac_typescript_definitions_1.RoomType.MINI_BOSS,
+]);
+function setCustomStageBackdrop(customStage) {
+    const room = cachedClasses_1.game.GetRoom();
+    const roomType = room.GetType();
+    const decorationSeed = room.GetDecorationSeed();
+    const rng = (0, rng_1.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);
+}
+exports.setCustomStageBackdrop = setCustomStageBackdrop;
+function getBackdropPNGPath(customStage, backdropKind, rng) {
+    const backdrop = customStage.backdropPNGPaths ?? DEFAULT_BACKDROP;
+    const pathArray = backdrop[backdropKind];
+    const randomPath = (0, array_1.getRandomArrayElement)(pathArray, rng);
+    return (0, string_1.removeCharactersBefore)(randomPath, "gfx/");
+}
+function spawnWallEntity(customStage, rng, isExtraWall) {
+    const room = cachedClasses_1.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;
+    const wallEffect = (0, entitiesSpecific_1.spawnEffectWithSeed)(BACKDROP_EFFECT_VARIANT, BACKDROP_EFFECT_SUB_TYPE, constants_1.VectorZero, seed);
+    wallEffect.AddEntityFlags(isaac_typescript_definitions_1.EntityFlag.RENDER_WALL);
+    const sprite = wallEffect.GetSprite();
+    sprite.Load(`${constants_2.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];
+    (0, utils_1.assertDefined)(numWallLayers, `Failed to get the layers when creating the backdrop for custom stage: ${customStage.name}`);
+    if ((0, roomShape_1.isLRoomShape)(roomShape)) {
+        const cornerPNGPath = getBackdropPNGPath(customStage, BackdropKind.CORNER, rng);
+        sprite.ReplaceSpritesheet(0, cornerPNGPath);
+    }
+    for (const layerID of (0, utils_1.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();
+    const roomShapeName = isaac_typescript_definitions_1.RoomShape[roomShape];
+    const animation = (0, string_1.trimPrefix)(roomShapeName, "SHAPE_");
+    const modifiedAnimation = isExtraWall ? `${animation}X` : animation;
+    sprite.Play(modifiedAnimation, true);
+}
+function spawnSecondWallEntity(customStage, rng) {
+    const room = cachedClasses_1.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, rng) {
+    const room = cachedClasses_1.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;
+    const floorEffect = (0, entitiesSpecific_1.spawnEffectWithSeed)(BACKDROP_EFFECT_VARIANT, 0, constants_1.VectorZero, seed);
+    floorEffect.AddEntityFlags(isaac_typescript_definitions_1.EntityFlag.RENDER_FLOOR);
+    const sprite = floorEffect.GetSprite();
+    sprite.Load(`${constants_2.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/floor-backdrop.anm2`, false);
+    const numFloorLayers = getNumFloorLayers(roomShape);
+    if (numFloorLayers !== undefined) {
+        for (const layerID of (0, utils_1.eRange)(numFloorLayers)) {
+            // The wall spritesheet is used for the "normal" floors.
+            const wallPNGPath = getBackdropPNGPath(customStage, BackdropKind.WALL, rng);
+            sprite.ReplaceSpritesheet(layerID, wallPNGPath);
+        }
+    }
+    else if ((0, roomShape_1.isLRoomShape)(roomShape)) {
+        for (const layerID of L_FLOOR_ANM2_LAYERS) {
+            const LFloorPNGPath = getBackdropPNGPath(customStage, BackdropKind.L_FLOOR, rng);
+            sprite.ReplaceSpritesheet(layerID, LFloorPNGPath);
+        }
+    }
+    else if ((0, roomShape_1.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();
+    const roomShapeName = isaac_typescript_definitions_1.RoomShape[roomShape];
+    const animation = (0, string_1.trimPrefix)(roomShapeName, "SHAPE_");
+    sprite.Play(animation, true);
+}
+function getNumFloorLayers(roomShape) {
+    switch (roomShape) {
+        case isaac_typescript_definitions_1.RoomShape.SHAPE_1x1: {
+            return 4;
+        }
+        case isaac_typescript_definitions_1.RoomShape.SHAPE_1x2:
+        case isaac_typescript_definitions_1.RoomShape.SHAPE_2x1: {
+            return 8;
+        }
+        case isaac_typescript_definitions_1.RoomShape.SHAPE_2x2: {
+            return 16;
+        }
+        default: {
+            // We have explicit logic elsewhere to handle narrow rooms and L rooms.
+            return undefined;
+        }
+    }
+}

package/dist/classes/features/other/customStages/constants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_FLOOR_STAGE_TYPE = exports.CUSTOM_FLOOR_STAGE = exports.DEFAULT_BASE_STAGE_TYPE = exports.DEFAULT_BASE_STAGE = exports.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH = exports.CUSTOM_STAGE_FEATURE_NAME = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+exports.CUSTOM_STAGE_FEATURE_NAME = "CustomStage";
+exports.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH = "gfx/isaacscript-custom-stage";
+exports.DEFAULT_BASE_STAGE = isaac_typescript_definitions_1.LevelStage.BASEMENT_2;
+exports.DEFAULT_BASE_STAGE_TYPE = isaac_typescript_definitions_1.StageType.ORIGINAL;
+/**
+ * Equal to -1. Setting the stage to an invalid stage value is useful in that it prevents backdrops
+ * and shadows from loading.
+ */
+exports.CUSTOM_FLOOR_STAGE = -1;
+/**
+ * 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).
+ */
+exports.CUSTOM_FLOOR_STAGE_TYPE = isaac_typescript_definitions_1.StageType.WRATH_OF_THE_LAMB;

package/dist/classes/features/other/customStages/gridEntities.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertVanillaTrapdoors = exports.setCustomDoorGraphics = exports.setCustomPitGraphics = exports.setCustomRockGraphics = exports.setCustomDecorationGraphics = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntities_1 = require("../../../../functions/gridEntities");
+const stage_1 = require("../../../../functions/stage");
+const string_1 = require("../../../../functions/string");
+const constants_1 = require("./constants");
+/** For `GridEntityType.DECORATION` (1). */
+function setCustomDecorationGraphics(customStage, gridEntity) {
+    // 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 !== isaac_typescript_definitions_1.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 = (0, string_1.removeCharactersBefore)(customStage.decorationsANM2Path, "gfx/");
+        sprite.Load(anm2Path, true);
+    }
+    else if (customStage.decorationsPNGPath !== undefined) {
+        const pngPath = (0, string_1.removeCharactersBefore)(customStage.decorationsPNGPath, "gfx/");
+        sprite.ReplaceSpritesheet(0, pngPath);
+        sprite.LoadGraphics();
+    }
+}
+exports.setCustomDecorationGraphics = setCustomDecorationGraphics;
+/** For `GridEntityType.ROCK` (2). */
+function setCustomRockGraphics(customStage, gridEntity) {
+    // 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 = (0, string_1.removeCharactersBefore)(customStage.rocksANM2Path, "gfx/");
+                sprite.Load(anm2Path, true);
+            }
+            else if (customStage.rocksPNGPath !== undefined) {
+                const pngPath = (0, string_1.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 = (0, string_1.removeCharactersBefore)(customStage.rocksPNGPath, "gfx/");
+                sprite.ReplaceSpritesheet(1, pngPath);
+                sprite.LoadGraphics();
+            }
+            break;
+        }
+    }
+}
+exports.setCustomRockGraphics = setCustomRockGraphics;
+/** For `GridEntityType.PIT` (7). */
+function setCustomPitGraphics(customStage, gridEntity) {
+    // 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 = (0, string_1.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();
+    }
+}
+exports.setCustomPitGraphics = setCustomPitGraphics;
+/** For `GridEntityType.DOOR` (16). */
+function setCustomDoorGraphics(customStage, gridEntity) {
+    // 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 = (0, string_1.removeCharactersBefore)(doorPNGPath, "gfx/");
+        sprite.ReplaceSpritesheet(0, fixedPath);
+        sprite.LoadGraphics();
+    }
+}
+exports.setCustomDoorGraphics = setCustomDoorGraphics;
+function getNewDoorPNGPath(customStage, fileName) {
+    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;
+}
+function convertVanillaTrapdoors(customStage, gridEntity, isFirstFloor, customTrapdoors) {
+    const gridEntityType = gridEntity.GetType();
+    if (gridEntityType !== isaac_typescript_definitions_1.GridEntityType.TRAPDOOR) {
+        return;
+    }
+    (0, gridEntities_1.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, isaac_typescript_definitions_1.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 ?? constants_1.DEFAULT_BASE_STAGE;
+        const destinationStage = (baseStage + 2);
+        const destinationStageType = (0, stage_1.calculateStageType)(destinationStage);
+        customTrapdoors.spawnCustomTrapdoor(gridEntity.Position, undefined, destinationStage, destinationStageType);
+    }
+}
+exports.convertVanillaTrapdoors = convertVanillaTrapdoors;

package/dist/classes/features/other/customStages/shadows.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setShadows = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../../core/cachedClasses");
+const LadderSubTypeCustom_1 = require("../../../../enums/LadderSubTypeCustom");
+const array_1 = require("../../../../functions/array");
+const entitiesSpecific_1 = require("../../../../functions/entitiesSpecific");
+const string_1 = require("../../../../functions/string");
+const constants_1 = require("./constants");
+/**
+ * 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 = isaac_typescript_definitions_1.EffectVariant.LADDER;
+const SHADOW_EFFECT_SUB_TYPE = LadderSubTypeCustom_1.LadderSubTypeCustom.CUSTOM_SHADOW;
+/** The animation comes from StageAPI. */
+const ROOM_SHAPE_TO_SHADOW_ANIMATION = {
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_1x1]: "1x1",
+    [isaac_typescript_definitions_1.RoomShape.IH]: "1x1",
+    [isaac_typescript_definitions_1.RoomShape.IV]: "1x1",
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_1x2]: "1x2",
+    [isaac_typescript_definitions_1.RoomShape.IIV]: "1x2",
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_2x1]: "2x1",
+    [isaac_typescript_definitions_1.RoomShape.IIH]: "2x1",
+    [isaac_typescript_definitions_1.RoomShape.SHAPE_2x2]: "2x2",
+    [isaac_typescript_definitions_1.RoomShape.LTL]: "2x2",
+    [isaac_typescript_definitions_1.RoomShape.LTR]: "2x2",
+    [isaac_typescript_definitions_1.RoomShape.LBL]: "2x2",
+    [isaac_typescript_definitions_1.RoomShape.LBR]: "2x2", // 12
+};
+const FADED_BLACK = Color(0, 0, 0, 0.25);
+function setShadows(customStage) {
+    if (customStage.shadows === undefined) {
+        return;
+    }
+    const room = cachedClasses_1.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;
+    const shadowEffect = (0, entitiesSpecific_1.spawnEffectWithSeed)(SHADOW_EFFECT_VARIANT, SHADOW_EFFECT_SUB_TYPE, centerPos, seed);
+    const sprite = shadowEffect.GetSprite();
+    sprite.Load(`${constants_1.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/stage-shadow.anm2`, false);
+    const decorationSeed = room.GetDecorationSeed();
+    const shadow = (0, array_1.getRandomArrayElement)(shadows, decorationSeed);
+    const pngPath = (0, string_1.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);
+}
+exports.setShadows = setShadows;