isaacscript-common 6.6.0 → 6.6.1-dev.2

package/functions/roomShape.js

@@ -0,0 +1,99 @@
+import { RoomShape } from "isaac-typescript-definitions";
+import { ROOM_SHAPE_BOUNDS } from "../objects/roomShapeBounds";
+import { ROOM_SHAPE_CORNERS } from "../objects/roomShapeCorners";
+import { ROOM_SHAPE_LAYOUT_SIZES } from "../objects/roomShapeLayoutSizes";
+import { ROOM_SHAPE_TO_BOTTOM_RIGHT_POSITION } from "../objects/roomShapeToBottomRightPosition";
+import { ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA } from "../objects/roomShapeToDoorSlotsToGridIndexDelta";
+import { ROOM_SHAPE_TO_GRID_WIDTH } from "../objects/roomShapeToGridWidth";
+import { ROOM_SHAPE_TO_TOP_LEFT_POSITION } from "../objects/roomShapeToTopLeftPosition";
+import { ROOM_SHAPE_VOLUMES } from "../objects/roomShapeVolumes";
+import { L_ROOM_SHAPES_SET } from "../sets/LRoomShapesSet";
+import { NARROW_ROOM_SHAPES_SET } from "../sets/narrowRoomShapesSet";
+/**
+ * Helper function to get the grid index delta that a door out of the given room shape would lead
+ * to. For example, if you went through the bottom door in a room of `RoomShape.SHAPE_1x2`, you
+ * would end up in a room with a grid index that is +26 units from the `SafeGridIndex` of where you
+ * started.
+ */
+export function getGridIndexDelta(roomShape, doorSlot) {
+    const doorSlotToGridIndexMap = ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA[roomShape];
+    return doorSlotToGridIndexMap.get(doorSlot);
+}
+/**
+ * Helper function to see if a given room shape will grant a single charge or a double charge to the
+ * player's active item(s).
+ *
+ * For example, `RoomShape.SHAPE_2x2` will return 2.
+ */
+export function getRoomShapeBottomRightPosition(roomShape) {
+    return ROOM_SHAPE_TO_BOTTOM_RIGHT_POSITION[roomShape];
+}
+/**
+ * Helper function to get the grid position of the bottom-right tile of a given room shape.
+ *
+ * "Vector(0, 0)" corresponds to the top left tile of a room, not including the walls. (The top-left
+ * wall would be at "Vector(-1, -1)".)
+ */
+export function getRoomShapeBounds(roomShape) {
+    return ROOM_SHAPE_BOUNDS[roomShape];
+}
+/**
+ * Helper function to get the number of charges that a given room shape will grant to a player upon
+ * clearing it.
+ *
+ * For example, `RoomShape.SHAPE_2x2` will return 2.
+ */
+export function getRoomShapeCharges(roomShape) {
+    return isRoomShapeDoubleCharge(roomShape) ? 2 : 1;
+}
+/** Helper function to get the corners that exist in the given room shape. */
+export function getRoomShapeCorners(roomShape) {
+    return ROOM_SHAPE_CORNERS[roomShape];
+}
+/**
+ * Helper function to get the dimensions of a room shape's layout. This is NOT the size of the
+ * room's actual contents! For that, use the `getRoomShapeBounds` function.
+ *
+ * For example, a horizontal narrow room has a layout size of equal to that of a 1x1 room.
+ */
+export function getRoomShapeLayoutSize(roomShape) {
+    return ROOM_SHAPE_LAYOUT_SIZES[roomShape];
+}
+/**
+ * Helper function to get the grid position of the top-left tile of a given room shape.
+ *
+ * "Vector(0, 0)" corresponds to the top left tile of a room, not including the walls. (The top-left
+ * wall would be at "Vector(-1, -1)".)
+ */
+export function getRoomShapeTopLeftPosition(roomShape) {
+    return ROOM_SHAPE_TO_TOP_LEFT_POSITION[roomShape];
+}
+/**
+ * Helper function to get the volume of a room shape, which is the amount of tiles that are inside
+ * the room.
+ *
+ * (This cannot be directly calculated from the bounds since L rooms are a special case.)
+ */
+export function getRoomShapeVolume(roomShape) {
+    return ROOM_SHAPE_VOLUMES[roomShape];
+}
+export function getRoomShapeWidth(roomShape) {
+    return ROOM_SHAPE_TO_GRID_WIDTH[roomShape];
+}
+export function isLRoom(roomShape) {
+    return L_ROOM_SHAPES_SET.has(roomShape);
+}
+export function isNarrowRoom(roomShape) {
+    return NARROW_ROOM_SHAPES_SET.has(roomShape);
+}
+/**
+ * Helper function to see if a given room shape will grant a single charge or a double charge to the
+ * player's active item(s).
+ *
+ * For example, `RoomShape.SHAPE_2x2` will return true.
+ */
+export function isRoomShapeDoubleCharge(roomShape) {
+    // 2x2 rooms and L rooms should grant 2 charges.
+    return roomShape >= RoomShape.SHAPE_2x2;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/roomShape.lua

@@ -94,3 +94,5 @@ function ____exports.isNarrowRoom(self, roomShape)
     return NARROW_ROOM_SHAPES_SET:has(roomShape)
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3Jvb21TaGFwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2Q0FBb0M7QUFBakI7QUFFbkIsNEJBQWtDO0FBQXpCO0FBQ1QsNkJBQW1DO0FBQTFCO0FBQ1QsaUNBQXdDO0FBQS9CO0FBQ1QsMkNBQW9EO0FBQTNDO0FBQ1QsaURBQTZEO0FBQXBEO0FBQ1QsaUNBQXlDO0FBQWhDO0FBQ1QsdUNBQWdEO0FBQXZDO0FBQ1QsNkJBQW1DO0FBQTFCO0FBQ1QsMkJBQWtDO0FBQXpCO0FBQ1QsZ0NBQXVDO0FBQTlCOzs7OztBQTRHVCxtREFBd0M7QUFFdEMsV0FBTyxhQUFhO0FBRnRCOzs7OztBQXBHQSw2Q0FDRSxXQUNBO0FBRU0sbUNBQ0osNkNBQTZDO0FBQy9DLFdBQU8sdUJBQXVCLElBQUk7QUFOcEM7Ozs7O0FBZUEsMkRBQ0U7QUFFQSxXQUFPLG9DQUFvQztBQUg3Qzs7Ozs7QUFZQSw4Q0FDRTtBQUVBLFdBQU8sa0JBQWtCO0FBSDNCOzs7OztBQVlBLCtDQUFvQztBQUNsQyxXQUFPLHlDQUF3QixlQUFhLEtBQUk7QUFEbEQ7O0FBS0EsK0NBQW9DO0FBQ2xDLFdBQU8sbUJBQW1CO0FBRDVCOzs7OztBQVVBLGtEQUNFO0FBRUEsV0FBTyx3QkFBd0I7QUFIakM7Ozs7O0FBWUEsdURBQ0U7QUFFQSxXQUFPLGdDQUFnQztBQUh6Qzs7Ozs7QUFZQSw4Q0FBbUM7QUFDakMsV0FBTyxtQkFBbUI7QUFENUI7QUFJQSw2Q0FBa0M7QUFDaEMsV0FBTyx5QkFBeUI7QUFEbEM7QUFJQSxtQ0FBd0I7QUFDdEIsV0FBTyxrQkFBa0IsSUFBSTtBQUQvQjtBQUlBLHdDQUE2QjtBQUMzQixXQUFPLHVCQUF1QixJQUFJO0FBRHBDIiwiZmlsZSI6InJvb21TaGFwZS5sdWEiLCJzb3VyY2VSb290IjoiIn0=

package/functions/rooms.js

@@ -0,0 +1,487 @@
+import { AngelRoomSubType, Dimension, Direction, DoorSlot, DungeonSubType, GridRoom, HomeRoomSubType, RoomDescriptorFlag, RoomShape, RoomTransitionAnim, RoomType, SoundEffect, StageID, } from "isaac-typescript-definitions";
+import { game, sfxManager } from "../cachedClasses";
+import { LEVEL_GRID_ROW_WIDTH, MAX_LEVEL_GRID_INDEX, NUM_DIMENSIONS, } from "../constants";
+import { ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA } from "../objects/roomShapeToDoorSlotsToGridIndexDelta";
+import { ROOM_TYPE_NAMES } from "../objects/roomTypeNames";
+import { MINE_SHAFT_ROOM_SUB_TYPE_SET } from "../sets/mineShaftRoomSubTypesSet";
+import { closeAllDoors, getDoors, isHiddenSecretRoomDoor, openDoorFast, } from "./doors";
+import { getEntities } from "./entity";
+import { hasFlag } from "./flag";
+import { getEntityPositions, getEntityVelocities, setEntityPositions, setEntityVelocities, } from "./positionVelocity";
+import { getRoomAllowedDoors, getRoomData, getRoomDescriptor, getRoomDescriptorReadOnly, getRoomGridIndex, getRoomName, getRoomShape, getRoomStageID, getRoomSubType, } from "./roomData";
+import { getGridIndexDelta } from "./roomShape";
+import { erange, irange } from "./utils";
+/**
+ * Helper function for quickly switching to a new room without playing a particular animation. Use
+ * this helper function over invoking the `Game.ChangeRoom` method directly to ensure that you do
+ * not forget to set the `LeaveDoor` property and to prevent crashing on invalid room grid indexes.
+ */
+export function changeRoom(roomGridIndex) {
+    const level = game.GetLevel();
+    const roomData = getRoomData(roomGridIndex);
+    if (roomData === undefined) {
+        error(`Failed to change the room to grid index ${roomGridIndex} because that room does not exist.`);
+    }
+    // LeaveDoor must be set before every `Game.ChangeRoom` invocation or else the function can send
+    // you to the wrong room.
+    level.LeaveDoor = DoorSlot.NO_DOOR_SLOT;
+    game.ChangeRoom(roomGridIndex);
+}
+/**
+ * Helper function to get an array with every valid `Dimension` (not including `Dimension.CURRENT`).
+ */
+export function getAllDimensions() {
+    return erange(NUM_DIMENSIONS);
+}
+/** Helper function to get the grid index for every room on the entire floor. */
+export function getAllRoomGridIndexes() {
+    const rooms = getRooms();
+    return rooms.map((roomDescriptor) => roomDescriptor.SafeGridIndex);
+}
+/**
+ * Helper function to get the current dimension. Most of the time, this will be `Dimension.MAIN`,
+ * but it can change if e.g. the player is in the mirror world of Downpour/Dross.
+ */
+export function getDimension() {
+    const level = game.GetLevel();
+    const roomGridIndex = getRoomGridIndex();
+    const roomDescription = level.GetRoomByIdx(roomGridIndex, Dimension.CURRENT);
+    const currentRoomHash = GetPtrHash(roomDescription);
+    for (const dimension of getAllDimensions()) {
+        const dimensionRoomDescription = level.GetRoomByIdx(roomGridIndex, dimension);
+        const dimensionRoomHash = GetPtrHash(dimensionRoomDescription);
+        if (dimensionRoomHash === currentRoomHash) {
+            return dimension;
+        }
+    }
+    error("Failed to get the current dimension.");
+}
+/**
+ * Helper function to get the number of rooms that are currently on the floor layout. This does not
+ * include off-grid rooms, like the Devil Room.
+ */
+export function getNumRooms() {
+    const rooms = getRooms();
+    return rooms.length;
+}
+/**
+ * Helper function to get an array of all of the safe grid indexes for rooms that match the
+ * specified room type.
+ *
+ * This function only searches through rooms in the current dimension.
+ *
+ * This function is variadic, meaning that you can specify N arguments to get the combined grid
+ * indexes for N room types.
+ */
+export function getRoomGridIndexesForType(...roomTypes) {
+    const roomTypesSet = new Set([...roomTypes]);
+    const rooms = getRooms();
+    const matchingRooms = rooms.filter((roomDescriptor) => roomDescriptor.Data !== undefined &&
+        roomTypesSet.has(roomDescriptor.Data.Type));
+    return matchingRooms.map((roomDescriptor) => roomDescriptor.SafeGridIndex);
+}
+/**
+ * Helper function to get the item pool type for the current room. For example, this returns
+ * `ItemPoolType.ItemPoolType.POOL_ANGEL` if you are in an Angel Room.
+ */
+export function getRoomItemPoolType() {
+    const itemPool = game.GetItemPool();
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomSeed = room.GetSpawnSeed();
+    return itemPool.GetPoolForRoom(roomType, roomSeed);
+}
+/**
+ * Helper function to get the grid indexes of all the rooms connected to the given room index.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function getRoomNeighbors(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    if (roomDescriptor.SafeGridIndex < 0 ||
+        roomDescriptor.SafeGridIndex > MAX_LEVEL_GRID_INDEX) {
+        return [];
+    }
+    const roomData = roomDescriptor.Data;
+    if (roomData === undefined) {
+        return [];
+    }
+    const roomShape = roomData.Shape;
+    const gridIndexDeltas = getRoomShapeNeighborGridIndexDeltas(roomShape);
+    const gridIndexes = gridIndexDeltas.map((gridIndexDelta) => roomDescriptor.SafeGridIndex + gridIndexDelta);
+    return gridIndexes.filter((gridIndex) => roomExists(gridIndex));
+}
+export function getRoomShapeNeighborGridIndexDeltas(roomShape) {
+    return [...ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA[roomShape].values()];
+}
+/**
+ * Helper function to get the proper name of a room type.
+ *
+ * For example, `RoomType.TREASURE` will return "Treasure Room".
+ */
+export function getRoomTypeName(roomType) {
+    return ROOM_TYPE_NAMES[roomType];
+}
+/**
+ * Helper function to get the room descriptor for every room on the level, including off-grid rooms.
+ * Uses the `Level.GetRooms` method to accomplish this. Rooms without data are assumed to be
+ * non-existent and are not added to the list.
+ *
+ * @param includeExtraDimensionalRooms Optional. On some floors (e.g. Downpour 2, Mines 2),
+ *                                 extra-dimensional rooms are automatically generated and can be
+ *                                 seen when you iterate over the `RoomList`. Default is false.
+ */
+export function getRooms(includeExtraDimensionalRooms = false) {
+    const level = game.GetLevel();
+    const roomList = level.GetRooms();
+    const roomsMap = new Map();
+    if (includeExtraDimensionalRooms) {
+        for (let i = 0; i < roomList.Size; i++) {
+            const roomDescriptor = roomList.Get(i);
+            if (roomDescriptor !== undefined && roomDescriptor.Data !== undefined) {
+                roomsMap.set(roomDescriptor.ListIndex, roomDescriptor);
+            }
+        }
+    }
+    else {
+        for (const roomGridIndex of irange(MAX_LEVEL_GRID_INDEX)) {
+            const roomDescriptor = level.GetRoomByIdx(roomGridIndex);
+            if (roomDescriptor.Data !== undefined) {
+                roomsMap.set(roomDescriptor.ListIndex, roomDescriptor);
+            }
+        }
+    }
+    return [...roomsMap.values()];
+}
+/**
+ * Helper function to get the room descriptor for every room on the level except for rooms that are
+ * not on the grid. Uses the `Level.GetRooms` method to accomplish this. Rooms without data are
+ * assumed to be non-existent and are not added to the list.
+ *
+ * @param includeExtraDimensionalRooms Optional. On some floors (e.g. Downpour 2, Mines 2),
+ *                                 extra-dimensional rooms are automatically be generated and can be
+ *                                 seen when you iterate over the `RoomList`. Default is false.
+ */
+export function getRoomsInGrid(includeExtraDimensionalRooms = false) {
+    const rooms = getRooms(includeExtraDimensionalRooms);
+    return rooms.filter((roomDescriptor) => roomDescriptor.SafeGridIndex >= 0);
+}
+/**
+ * Helper function to get the room descriptor for every room on the level in a specific dimension.
+ * Uses the `Level.GetRooms` method to accomplish this. Rooms without data are assumed to be
+ * non-existent and are not added to the list.
+ *
+ * @returns A map of room ListIndex to RoomDescriptor.
+ */
+export function getRoomsOfDimension(dimension) {
+    const level = game.GetLevel();
+    const roomsMap = new Map();
+    for (const roomGridIndex of irange(MAX_LEVEL_GRID_INDEX)) {
+        const roomDescriptor = level.GetRoomByIdx(roomGridIndex, dimension);
+        if (roomDescriptor.Data !== undefined) {
+            roomsMap.set(roomDescriptor.ListIndex, roomDescriptor);
+        }
+    }
+    return [...roomsMap.values()];
+}
+/**
+ * Helper function to determine if the current room shape is equal to `RoomShape.1x2` or
+ * `RoomShape.2x1`.
+ */
+export function in2x1Room() {
+    const room = game.GetRoom();
+    const roomShape = room.GetRoomShape();
+    return roomShape === RoomShape.SHAPE_1x2 || roomShape === RoomShape.SHAPE_2x1;
+}
+export function inAngelShop() {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomSubType = getRoomSubType();
+    // eslint-disable-next-line isaacscript/strict-enums
+    return roomType === RoomType.ANGEL && roomSubType === AngelRoomSubType.SHOP;
+}
+export function inBeastRoom() {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomSubType = getRoomSubType();
+    return (
+    // eslint-disable-next-line isaacscript/strict-enums
+    roomType === RoomType.DUNGEON && roomSubType === DungeonSubType.BEAST_ROOM);
+}
+/**
+ * Helper function to check if the current room is a boss room for a particular boss. This will only
+ * work for bosses that have dedicated boss rooms in the "00.special rooms.stb" file.
+ */
+export function inBossRoomOf(bossID) {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomStageID = getRoomStageID();
+    const roomSubType = getRoomSubType();
+    return (roomType === RoomType.BOSS &&
+        roomStageID === StageID.SPECIAL_ROOMS &&
+        roomSubType === bossID // eslint-disable-line isaacscript/strict-enums
+    );
+}
+/**
+ * Helper function for determining whether the current room is a crawl space. Use this function over
+ * comparing to `RoomType.DUNGEON` or `GridRoom.DUNGEON_IDX` since there is a special case of the
+ * player being in a boss fight that take place in a dungeon.
+ */
+export function inCrawlSpace() {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomSubType = getRoomSubType();
+    // eslint-disable-next-line isaacscript/strict-enums
+    return roomType === RoomType.DUNGEON && roomSubType === DungeonSubType.NORMAL;
+}
+/**
+ * We cannot use the standard code in the `inDimension` function for this purpose since it is bugged
+ * with the Death Certificate area.
+ */
+export function inDeathCertificateArea() {
+    const roomStageID = getRoomStageID();
+    const roomSubType = getRoomSubType();
+    return (roomStageID === StageID.HOME &&
+        // eslint-disable-next-line isaacscript/strict-enums
+        (roomSubType === HomeRoomSubType.DEATH_CERTIFICATE_ENTRANCE ||
+            // eslint-disable-next-line isaacscript/strict-enums
+            roomSubType === HomeRoomSubType.DEATH_CERTIFICATE_ITEMS));
+}
+/**
+ * Helper function to detect if the current room is a Treasure Room created when entering with a
+ * Devil's Crown trinket. Under the hood, this checks for the `RoomDescriptorFlag.DEVIL_TREASURE`
+ * flag.
+ */
+export function inDevilsCrownTreasureRoom() {
+    const roomDescriptor = getRoomDescriptorReadOnly();
+    return hasFlag(roomDescriptor.Flags, RoomDescriptorFlag.DEVIL_TREASURE);
+}
+export function inDimension(dimension) {
+    return dimension === getDimension();
+}
+export function inDoubleTrouble() {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomName = getRoomName();
+    return roomType === RoomType.BOSS && roomName.includes("Double Trouble");
+}
+export function inGenesisRoom() {
+    const roomGridIndex = getRoomGridIndex();
+    // eslint-disable-next-line isaacscript/strict-enums
+    return roomGridIndex === GridRoom.GENESIS;
+}
+/** Helper function to determine if the current room shape is one of the four L room shapes. */
+export function inLRoom() {
+    const room = game.GetRoom();
+    const roomShape = room.GetRoomShape();
+    return (roomShape === RoomShape.LTL ||
+        roomShape === RoomShape.LTR ||
+        roomShape === RoomShape.LBL ||
+        roomShape === RoomShape.LBR);
+}
+export function inMegaSatanRoom() {
+    const roomGridIndex = getRoomGridIndex();
+    // eslint-disable-next-line isaacscript/strict-enums
+    return roomGridIndex === GridRoom.MEGA_SATAN;
+}
+/**
+ * Helper function to determine if the current room is part of the Repentance "escape sequence" in
+ * the Mines/Ashpit.
+ */
+export function inMineShaft() {
+    const roomStageID = getRoomStageID();
+    const roomSubType = getRoomSubType();
+    return ((roomStageID === StageID.MINES || roomStageID === StageID.ASHPIT) &&
+        // eslint-disable-next-line isaacscript/strict-enums
+        MINE_SHAFT_ROOM_SUB_TYPE_SET.has(roomSubType));
+}
+/**
+ * Helper function to check if the current room is a miniboss room for a particular miniboss. This
+ * will only work for mini-bosses that have dedicated boss rooms in the "00.special rooms.stb" file.
+ */
+export function inMinibossRoomOf(minibossID) {
+    const room = game.GetRoom();
+    const roomType = room.GetType();
+    const roomStageID = getRoomStageID();
+    const roomSubType = getRoomSubType();
+    return (roomType === RoomType.MINI_BOSS &&
+        roomStageID === StageID.SPECIAL_ROOMS &&
+        roomSubType === minibossID // eslint-disable-line isaacscript/strict-enums
+    );
+}
+/**
+ * Helper function for checking if the room is a secret shop (from the Member Card collectible).
+ *
+ * Secret shops are simply copies of normal shops, but with the backdrop of a secret room. In other
+ * words, they will have the same room type, room variant, and room sub-type of a normal shop. Thus,
+ * the only way to detect them is by using the grid index.
+ */
+export function inSecretShop() {
+    const roomGridIndex = getRoomGridIndex();
+    // eslint-disable-next-line isaacscript/strict-enums
+    return roomGridIndex === GridRoom.SECRET_SHOP;
+}
+/**
+ * Helper function to determine whether or not the current room is the starting room of a floor. It
+ * only returns true for the starting room of the primary dimension (meaning that being in the
+ * starting room of the mirror world does not count).
+ */
+export function inStartingRoom() {
+    const level = game.GetLevel();
+    const startingRoomGridIndex = level.GetStartingRoomIndex();
+    const roomGridIndex = getRoomGridIndex();
+    return roomGridIndex === startingRoomGridIndex && inDimension(Dimension.MAIN);
+}
+/**
+ * Helper function to loop through every room on the floor and see if it has been cleared.
+ *
+ * This function will only check rooms in the current dimension.
+ *
+ * @param onlyCheckRoomTypes Optional. A whitelist of room types. If specified, room types not in
+ *                           the array will be ignored. If not specified, then all rooms will be
+ *                           checked. Undefined by default.
+ */
+export function isAllRoomsClear(onlyCheckRoomTypes) {
+    const roomTypeWhitelist = onlyCheckRoomTypes === undefined ? null : new Set(onlyCheckRoomTypes);
+    const rooms = getRooms();
+    const matchingRooms = roomTypeWhitelist === null
+        ? rooms
+        : rooms.filter((roomDescriptor) => roomDescriptor.Data !== undefined &&
+            roomTypeWhitelist.has(roomDescriptor.Data.Type));
+    return matchingRooms.every((roomDescriptor) => roomDescriptor.Clear);
+}
+export function isDoorSlotValidAtGridIndex(doorSlot, roomGridIndex) {
+    const allowedDoors = getRoomAllowedDoors(roomGridIndex);
+    return allowedDoors.has(doorSlot);
+}
+export function isDoorSlotValidAtGridIndexForRedRoom(doorSlot, roomGridIndex) {
+    const doorSlotValidAtGridIndex = isDoorSlotValidAtGridIndex(doorSlot, roomGridIndex);
+    if (!doorSlotValidAtGridIndex) {
+        return false;
+    }
+    const roomShape = getRoomShape(roomGridIndex);
+    if (roomShape === undefined) {
+        return false;
+    }
+    const delta = getGridIndexDelta(roomShape, doorSlot);
+    if (delta === undefined) {
+        return false;
+    }
+    const redRoomGridIndex = roomGridIndex + delta;
+    return (!roomExists(redRoomGridIndex) &&
+        redRoomGridIndex >= 0 &&
+        redRoomGridIndex <= MAX_LEVEL_GRID_INDEX);
+}
+/**
+ * Helper function to detect if the provided room was created by the Red Key item. Under the hood,
+ * this checks for the `RoomDescriptorFlag.FLAG_RED_ROOM` flag.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function isRedKeyRoom(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return hasFlag(roomDescriptor.Flags, RoomDescriptorFlag.RED_ROOM);
+}
+/**
+ * Helper function to determine if the provided room is part of the floor layout. For example, Devil
+ * Rooms and the Mega Satan room are not considered to be inside the map.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function isRoomInsideMap(roomGridIndex) {
+    if (roomGridIndex === undefined) {
+        roomGridIndex = getRoomGridIndex();
+    }
+    return roomGridIndex >= 0;
+}
+/** Helper function to check if a room exists at the given room grid index. */
+export function roomExists(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData !== undefined;
+}
+/**
+ * Helper function to get the coordinates of a given grid index. The floor is represented by a 13x13
+ * grid. For example, since the starting room is in the center, the starting room grid index of 84
+ * be equal to coordinates of (?, ?).
+ */
+export function roomGridIndexToXY(roomGridIndex) {
+    const x = roomGridIndex % LEVEL_GRID_ROW_WIDTH;
+    const y = Math.floor(roomGridIndex / LEVEL_GRID_ROW_WIDTH);
+    return [x, y];
+}
+/**
+ * If the `Room.Update` method is called in a PostNewRoom callback, then some entities will slide
+ * around (such as the player). Since those entity velocities are already at zero, setting them to
+ * zero will have no effect. Thus, a generic solution is to record all of the entity
+ * positions/velocities before updating the room, and then restore those positions/velocities.
+ */
+export function roomUpdateSafe() {
+    const room = game.GetRoom();
+    const entities = getEntities();
+    const entityPositions = getEntityPositions(entities);
+    const entityVelocities = getEntityVelocities(entities);
+    room.Update();
+    setEntityPositions(entityPositions, entities);
+    setEntityVelocities(entityVelocities, entities);
+}
+/**
+ * Helper function to convert an uncleared room to a cleared room in the PostNewRoom callback. This
+ * is useful because if enemies are removed in this callback, a room drop will be awarded and the
+ * doors will start closed and then open.
+ */
+export function setRoomCleared() {
+    const room = game.GetRoom();
+    const roomClear = room.IsClear();
+    // If the room is already cleared, we don't have to do anything.
+    if (roomClear) {
+        return;
+    }
+    room.SetClear(true);
+    for (const door of getDoors()) {
+        if (isHiddenSecretRoomDoor(door)) {
+            continue;
+        }
+        // We don't use the `EntityDoor.Open` method since that will cause the door to play an
+        // animation.
+        openDoorFast(door);
+        // If this is a mini-boss room, then the door would be barred in addition to being closed.
+        // Ensure that the bar is not visible.
+        door.ExtraVisible = false;
+    }
+    sfxManager.Stop(SoundEffect.DOOR_HEAVY_OPEN);
+    // If the room contained Mom's Hands, then a screen shake will be queued. Override it with a 0
+    // frame shake.
+    game.ShakeScreen(0);
+}
+/**
+ * Helper function to emulate what happens when you bomb an Angel Statue or push a Reward Plate that
+ * spawns an NPC.
+ */
+export function setRoomUncleared() {
+    const room = game.GetRoom();
+    room.SetClear(false);
+    closeAllDoors();
+}
+/**
+ * Helper function to change the current room. It can be used for both teleportation and "normal"
+ * room transitions, depending on what is passed for the `direction` and `roomTransitionAnim`
+ * arguments. Use this function instead of invoking the `Game.StartRoomTransition` method directly
+ * so that you do not forget to set `Level.LeaveDoor` property and to prevent crashing on invalid
+ * room grid indexes.
+ *
+ * @param roomGridIndex The room grid index of the destination room.
+ * @param direction Optional. Default is `Direction.NO_DIRECTION`.
+ * @param roomTransitionAnim Optional. Default is `RoomTransitionAnim.TELEPORT`.
+ */
+export function teleport(roomGridIndex, direction = Direction.NO_DIRECTION, roomTransitionAnim = RoomTransitionAnim.TELEPORT) {
+    const level = game.GetLevel();
+    const roomData = getRoomData(roomGridIndex);
+    if (roomData === undefined) {
+        error(`Failed to change the room to grid index ${roomGridIndex} because that room does not exist.`);
+    }
+    // This must be set before every `Game.StartRoomTransition` method invocation or else the function
+    // can send you to the wrong room.
+    level.LeaveDoor = DoorSlot.NO_DOOR_SLOT;
+    game.StartRoomTransition(roomGridIndex, direction, roomTransitionAnim);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rooms.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/rooms.ts"],"names":[],"mappings":"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"}

package/functions/rooms.lua

@@ -490,3 +490,5 @@ function ____exports.teleport(self, roomGridIndex, direction, roomTransitionAnim
     game:StartRoomTransition(roomGridIndex, direction, roomTransitionAnim)
 end
 return ____exports
+
+--# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL3Jvb21zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7QUFBQSw2Q0FpQk87QUFoQkw7QUFFQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFHQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFFRiwwQkFBaUM7QUFBeEI7QUFBTTtBQUNmLHNCQUlPO0FBSEw7QUFDQTtBQUNBO0FBRUYsaURBQTZEO0FBQXBEO0FBQ1QsMEJBQWdDO0FBQXZCO0FBQ1QscUNBQTZDO0FBQXBDO0FBQ1Qsa0JBS087QUFKTDtBQUNBO0FBQ0E7QUFDQTtBQUVGLG1CQUE0QjtBQUFuQjtBQUNULGlCQUF3QjtBQUFmO0FBQ1QsNkJBS087QUFKTDtBQUNBO0FBQ0E7QUFDQTtBQUVGLHFCQVVPO0FBVEw7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBRUYsc0JBQWtDO0FBQXpCO0FBQ1Qsa0JBQStCO0FBQXRCO0FBQVE7QUFzSWpCLCtEQUNFO0FBRUEsV0FBTyxDQUFDLGFBQUcsNkNBQTZDLFdBQVc7QUFIckU7Ozs7Ozs7O0FBd0JBLG9DQUNFO09BQUE7UUFBQSwrQkFBK0I7O0FBRXpCLGtCQUFRLEtBQUs7QUFDYixxQkFBVyxNQUFNO0FBRWpCLHFCQUFXLFVBQUk7T0FDakI7O0FBQ08sc0JBQUk7a0JBQUcsSUFBSTtBQUNaLHVDQUFpQixTQUFTLElBQUk7bUJBQ2hDLDBCQUFnQztvQkFDbEMsU0FBUyxJQUFJLDBCQUEwQjs7QUFIUjs7OztBQU9uQyxrQkFBVyx3QkFBaUIsWUFBTztBQUMzQixtQ0FBaUIsTUFBTSxhQUFhO2VBQ3RDO2dCQUNGLFNBQVMsSUFBSSwwQkFBMEI7Ozs7QUFLN0MsV0FBTyxDQUFDLGFBQUcsU0FBUztBQXZCdEI7O0FBbVZBLHNDQUEyQjtBQUNuQixxQkFBVyxpQkFBWTtBQUM3QixXQUFPO0FBRlQ7Ozs7QUExZUEsc0NBQTJCO0FBQ25CLGtCQUFRLEtBQUs7QUFFYixxQkFBVyxpQkFBWTtPQUN6QjtRQUNGLE9BQ0UsdURBQTJDLG1CQUFhOztBQU01RCxzQkFBa0I7SUFFbEIsS0FBSyxXQUFXO0FBZGxCOztBQW9CQTtBQUNFLFdBQU8sWUFBTztBQURoQjs7QUFLQTtBQUNRLGtCQUFRO0FBQ2QsV0FBTztRQUFBO1FBQVUsZUFBQyxnQkFBbUIsbUNBQXBCOztBQUZuQjs7O0FBU0E7QUFDUSxrQkFBUSxLQUFLO0FBQ2IsMEJBQWdCO0FBQ2hCLDRCQUFrQixNQUFNLGFBQWEsZUFBZTtBQUNwRCw0QkFBa0IsV0FBVztBQUVuQyxjQUFXLG9CQUFhO0FBQ2hCLHlDQUEyQixNQUFNLGFBQ3JDLGVBQ0E7QUFFSSxrQ0FBb0IsV0FBVztXQUVqQyxxQkFBc0I7QUFDeEIsbUJBQU87OztJQUlYLE1BQU07QUFsQlI7OztBQXlCQTtBQUNRLGtCQUFRO0FBQ2QsV0FBTztBQUZUOzs7Ozs7OztBQWNBO0FBQ1EseUJBQWUsVUFBSSxLQUFjLENBQUM7QUFFbEMsa0JBQVE7QUFDUiwwQkFBZ0I7UUFBQTtRQUNwQixlQUFDLGdCQUNDLHNDQUNBLGFBQWEsSUFBSSx5QkFGbkI7O0FBS0YsV0FBTztRQUFBO1FBQWtCLGVBQUMsZ0JBQW1CLG1DQUFwQjs7QUFWM0I7OztBQWlCQTtBQUNRLHFCQUFXLEtBQUs7QUFDaEIsaUJBQU8sS0FBSztBQUNaLHFCQUFXLEtBQUs7QUFDaEIscUJBQVcsS0FBSztBQUV0QixXQUFPLFNBQVMsZUFBZSxVQUFVO0FBTjNDOzs7O0FBY0EsNENBQWlDO0FBQ3pCLDJCQUFpQix1QkFBa0I7T0FHdkMsK0JBQStCLEtBQy9CLCtCQUErQjtBQUUvQixlQUFPOztBQUdILHFCQUFXO09BQ2I7QUFDRixlQUFPOztBQUdILHNCQUFZO0FBQ1osNEJBQWtCLHFEQUFvQztBQUN0RCx3QkFBYztRQUFBO1FBQ2xCLGVBQUMsZ0JBQW1CLHNDQUErQixjQUFuRDs7QUFFRixXQUFPO1FBQUE7UUFBbUIsZUFBQyxXQUFjLG1DQUFXLFVBQTFCOztBQXBCNUI7Ozs7QUFrQ0EsMkNBQWdDO0FBQzlCLFdBQU8sZ0JBQWdCO0FBRHpCOzs7Ozs7OztBQWdEQSwwQ0FDRTtPQUFBO1FBQUEsK0JBQStCOztBQUV6QixrQkFBUSwwQkFBUztBQUN2QixXQUFPO1FBQUE7UUFBYSxlQUFDLGdCQUFtQix1Q0FBZ0MsQ0FBcEQ7O0FBSnRCOzs7Ozs7QUFjQSwrQ0FBb0M7QUFDNUIsa0JBQVEsS0FBSztBQUViLHFCQUFXLFVBQUk7QUFDckIsY0FBVyx3QkFBaUIsWUFBTztBQUMzQiwrQkFBaUIsTUFBTSxhQUFhLGVBQWU7V0FDckQ7WUFDRixTQUFTLElBQUksMEJBQTBCOzs7QUFJM0MsV0FBTyxDQUFDLGFBQUcsU0FBUztBQVh0Qjs7O0FBa0JBO0FBQ1EsaUJBQU8sS0FBSztBQUNaLHNCQUFZLEtBQUs7QUFFdkIsV0FBTyxhQUFjLHVCQUF1QixhQUFjO0FBSjVEO0FBT0E7QUFDUSxpQkFBTyxLQUFLO0FBQ1oscUJBQVcsS0FBSztBQUNoQix3QkFBYztBQUdwQixXQUFPLFlBQWEsbUJBQWtCLGVBQWdCO0FBTnhEO0FBU0E7QUFDUSxpQkFBTyxLQUFLO0FBQ1oscUJBQVcsS0FBSztBQUNoQix3QkFBYztBQUVwQixXQUVFLFlBQWEscUJBQW9CLGVBQWdCO0FBUHJEOzs7QUFlQSx3Q0FBNkI7QUFDckIsaUJBQU8sS0FBSztBQUNaLHFCQUFXLEtBQUs7QUFDaEIsd0JBQWM7QUFDZCx3QkFBYztBQUVwQixXQUNFLFlBQWEsa0JBQ2IsZUFBZ0IsMEJBQ2hCLGVBQWdCO0FBVHBCOzs7O0FBa0JBO0FBQ1EsaUJBQU8sS0FBSztBQUNaLHFCQUFXLEtBQUs7QUFDaEIsd0JBQWM7QUFHcEIsV0FBTyxZQUFhLHFCQUFvQixlQUFnQjtBQU4xRDs7O0FBYUE7QUFDUSx3QkFBYztBQUNkLHdCQUFjO0FBRXBCLFdBQ0UsZUFBZ0IsaUJBRWYsZ0JBQWdCLDhDQUVmLGVBQWdCO0FBVHRCOzs7O0FBa0JBO0FBQ1EsMkJBQWlCO0FBQ3ZCLFdBQU8sYUFBUSxzQkFBc0I7QUFGdkM7QUFLQSx1Q0FBNEI7QUFDMUIsV0FBTyxhQUFjO0FBRHZCO0FBSUE7QUFDUSxpQkFBTyxLQUFLO0FBQ1oscUJBQVcsS0FBSztBQUNoQixxQkFBVztBQUVqQixXQUFPLFlBQWEsa0JBQWlCLCtCQUFrQjtBQUx6RDtBQVFBO0FBQ1EsMEJBQWdCO0FBR3RCLFdBQU8saUJBQWtCO0FBSjNCOztBQVFBO0FBQ1EsaUJBQU8sS0FBSztBQUNaLHNCQUFZLEtBQUs7QUFFdkIsV0FDRSxhQUFjLGlCQUNkLGFBQWMsaUJBQ2QsYUFBYyxpQkFDZCxhQUFjO0FBUmxCO0FBWUE7QUFDUSwwQkFBZ0I7QUFHdEIsV0FBTyxpQkFBa0I7QUFKM0I7OztBQVdBO0FBQ1Esd0JBQWM7QUFDZCx3QkFBYztBQUVwQixXQUNFLENBQUMsZUFBZ0IsaUJBQWlCLGVBQWdCLG9CQUVsRCw2QkFBNkIsSUFBSTtBQVByQzs7O0FBZUEsNENBQWlDO0FBQ3pCLGlCQUFPLEtBQUs7QUFDWixxQkFBVyxLQUFLO0FBQ2hCLHdCQUFjO0FBQ2Qsd0JBQWM7QUFFcEIsV0FDRSxZQUFhLHVCQUNiLGVBQWdCLDBCQUNoQixlQUFnQjtBQVRwQjs7Ozs7O0FBb0JBO0FBQ1EsMEJBQWdCO0FBR3RCLFdBQU8saUJBQWtCO0FBSjNCOzs7O0FBWUE7QUFDUSxrQkFBUSxLQUFLO0FBQ2Isa0NBQXdCLE1BQU07QUFDOUIsMEJBQWdCO0FBRXRCLFdBQU8saUJBQWtCLDBCQUF5Qiw2QkFBWTtBQUxoRTs7Ozs7Ozs7QUFpQkEsMkNBQWdDO0FBRTVCO09BQUE7QUFBbUM7O0FBQU8sK0JBQUksS0FBSTs7QUFEOUM7QUFFQSxrQkFBUTtBQUNSLDBCQUNKLHFCQUFzQixRQUNsQixTQUNBO1FBQUE7UUFDRSxlQUFDLGdCQUNDLHNDQUNBLGtCQUFrQixJQUFJLHlCQUZ4Qjs7QUFLUixXQUFPO1FBQUE7UUFBb0IsZUFBQyxnQkFBbUIsMkJBQXBCOztBQWI3QjtBQWdCQSxzREFDRSxVQUNBO0FBRU0seUJBQWUseUJBQW9CO0FBQ3pDLFdBQU8sYUFBYSxJQUFJO0FBTDFCO0FBUUEsZ0VBQ0UsVUFDQTtBQUVNLHFDQUEyQiw0Q0FDL0IsVUFDQTtXQUVHO0FBQ0gsZUFBTzs7QUFHSCxzQkFBWSxrQkFBYTtPQUMzQjtBQUNGLGVBQU87O0FBR0gsa0JBQVEsdUJBQWtCLFdBQVc7T0FDdkM7QUFDRixlQUFPOztBQUdILDZCQUFtQixnQkFBZ0I7QUFDekMsV0FDRSxJQUFDLDRCQUFXLHNCQUNaLG9CQUFvQixNQUNwQixvQkFBb0I7QUExQnhCOzs7OztBQW9DQSx3Q0FBNkI7QUFDckIsMkJBQWlCLHVCQUFrQjtBQUN6QyxXQUFPLGFBQVEsc0JBQXNCO0FBRnZDOzs7OztBQVdBLDJDQUFnQztPQUMxQjtBQUNGLHdCQUFnQjs7QUFHbEIsV0FBTyxpQkFBaUI7QUFMMUI7Ozs7QUFtQkEsNkNBQWtDO0FBQzFCLGNBQUksZ0JBQWdCO0FBQ3BCLGNBQUksV0FBVyxnQkFBZ0I7QUFFckMsV0FBTyxDQUFDLEdBQUc7QUFKYjs7Ozs7QUFhQTtBQUNRLGlCQUFPLEtBQUs7QUFDWixxQkFBVztBQUVYLDRCQUFrQix3QkFBbUI7QUFDckMsNkJBQW1CLHlCQUFvQjtJQUU3QyxLQUFLO0lBRUwsd0JBQW1CLGlCQUFpQjtJQUNwQyx5QkFBb0Isa0JBQWtCO0FBVnhDOzs7O0FBa0JBO0FBQ1EsaUJBQU8sS0FBSztBQUNaLHNCQUFZLEtBQUs7T0FHbkI7QUFDRjs7SUFHRixLQUFLLFNBQVM7QUFFZCxjQUFXLGVBQVE7O2VBQ2IsNEJBQXVCO0FBQ3pCOztZQUtGLGtCQUFhO0FBSWIsZ0NBQW9COzs7O0lBR3RCLFdBQVcsS0FBSztJQUloQixLQUFLLFlBQVk7QUE3Qm5COzs7QUFvQ0E7QUFDUSxpQkFBTyxLQUFLO0lBRWxCLEtBQUssU0FBUztJQUNkO0FBSkY7Ozs7Ozs7Ozs7QUFrQkEsb0NBQ0UsZUFDQSxXQUNBO09BREE7UUFBQSxZQUFZOztPQUNaO1FBQUEscUJBQXFCOztBQUVmLGtCQUFRLEtBQUs7QUFFYixxQkFBVyxpQkFBWTtPQUN6QjtRQUNGLE9BQ0UsdURBQTJDLG1CQUFhOztBQU01RCxzQkFBa0I7SUFFbEIsS0FBSyxvQkFBb0IsZUFBZSxXQUFXO0FBbEJyRCIsImZpbGUiOiJyb29tcy5sdWEiLCJzb3VyY2VSb290IjoiIn0=