isaacscript-common 84.0.1 → 84.1.1

package/dist/functions/rng.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeed = exports.setAllRNGToStartSeed = exports.setAllRNGToSeed = exports.serializeRNG = exports.rngEquals = exports.newRNG = exports.isSerializedRNG = exports.isRNG = exports.getRandomSeed = exports.deserializeRNG = exports.copyRNG = void 0;
+const cachedClasses_1 = require("../core/cachedClasses");
+const SerializationBrand_1 = require("../enums/private/SerializationBrand");
+const debugFunctions_1 = require("./debugFunctions");
+const isaacAPIClass_1 = require("./isaacAPIClass");
+const log_1 = require("./log");
+const table_1 = require("./table");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * This is the ShiftIdx that Blade recommended after having reviewing the game's internal functions.
+ * Any value between 0 and 80 should work equally well.
+ * https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
+ */
+const RECOMMENDED_SHIFT_IDX = 35;
+const OBJECT_NAME = "RNG";
+const KEYS = ["seed"];
+/** Helper function to copy an `RNG` Isaac API class. */
+function copyRNG(rng) {
+    if (!isRNG(rng)) {
+        error(`Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`);
+    }
+    const seed = rng.GetSeed();
+    return newRNG(seed);
+}
+exports.copyRNG = copyRNG;
+/**
+ * Helper function to convert a `SerializedRNG` object to a normal `RNG` object. (This is used by
+ * the save data manager when reading data from the "save#.dat" file.)
+ */
+function deserializeRNG(rng) {
+    if (!(0, types_1.isTable)(rng)) {
+        error(`Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`);
+    }
+    const [seed] = (0, table_1.getNumbersFromTable)(rng, OBJECT_NAME, ...KEYS);
+    (0, utils_1.assertDefined)(seed, `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: seed`);
+    return newRNG(seed);
+}
+exports.deserializeRNG = deserializeRNG;
+/**
+ * Helper function to get a random `Seed` value to be used in spawning entities and so on. Use this
+ * instead of calling the `Random` function directly since that can return a value of 0 and crash
+ * the game.
+ */
+function getRandomSeed() {
+    const randomNumber = Random(); // eslint-disable-line deprecation/deprecation
+    const safeRandomNumber = randomNumber === 0 ? 1 : randomNumber;
+    return safeRandomNumber;
+}
+exports.getRandomSeed = getRandomSeed;
+/** Helper function to check if something is an instantiated `RNG` object. */
+function isRNG(object) {
+    return (0, isaacAPIClass_1.isIsaacAPIClassOfType)(object, OBJECT_NAME);
+}
+exports.isRNG = isRNG;
+/**
+ * Used to determine is the given table is a serialized `RNG` object created by the `deepCopy`
+ * function.
+ */
+function isSerializedRNG(object) {
+    if (!(0, types_1.isTable)(object)) {
+        return false;
+    }
+    return (0, table_1.tableHasKeys)(object, ...KEYS) && object.has(SerializationBrand_1.SerializationBrand.RNG);
+}
+exports.isSerializedRNG = isSerializedRNG;
+/**
+ * Helper function to initialize a new RNG object using Blade's recommended shift index.
+ *
+ * @param seed Optional. The seed to initialize it with. Default is a random seed.
+ */
+function newRNG(seed = getRandomSeed()) {
+    const rng = RNG();
+    setSeed(rng, seed);
+    return rng;
+}
+exports.newRNG = newRNG;
+function rngEquals(rng1, rng2) {
+    return (0, isaacAPIClass_1.isaacAPIClassEquals)(rng1, rng2, KEYS);
+}
+exports.rngEquals = rngEquals;
+/**
+ * Helper function to convert a `RNG` object to a `SerializedRNG` object. (This is used by the save
+ * data manager when writing data from the "save#.dat" file.)
+ */
+function serializeRNG(rng) {
+    if (!isRNG(rng)) {
+        error(`Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`);
+    }
+    const seed = rng.GetSeed();
+    const rngTable = new LuaMap();
+    rngTable.set("seed", seed);
+    rngTable.set(SerializationBrand_1.SerializationBrand.RNG, "");
+    return rngTable;
+}
+exports.serializeRNG = serializeRNG;
+/**
+ * Helper function to iterate over the provided object and set the seed for all of the values that
+ * are RNG objects equal to a particular seed.
+ */
+function setAllRNGToSeed(object, seed) {
+    if (!(0, types_1.isTable)(object)) {
+        error(`Failed to iterate over the object containing RNG objects since the type of the provided object was: ${typeof object}`);
+    }
+    let setAtLeastOneSeed = false;
+    for (const [_key, value] of object) {
+        if (isRNG(value)) {
+            setSeed(value, seed);
+            setAtLeastOneSeed = true;
+        }
+    }
+    if (!setAtLeastOneSeed) {
+        error(`Failed to set all RNG objects to seed ${seed} because the parent object did not contain any RNG objects.`);
+    }
+}
+exports.setAllRNGToSeed = setAllRNGToSeed;
+/**
+ * Helper function to iterate over the provided object and set the seed for all of the values that
+ * are RNG objects equal to the start seed for the current run.
+ */
+function setAllRNGToStartSeed(object) {
+    const seeds = cachedClasses_1.game.GetSeeds();
+    const startSeed = seeds.GetStartSeed();
+    setAllRNGToSeed(object, startSeed);
+}
+exports.setAllRNGToStartSeed = setAllRNGToStartSeed;
+/** Helper function to set a seed to an RNG object using Blade's recommended shift index. */
+function setSeed(rng, seed) {
+    if (seed === 0) {
+        seed = getRandomSeed();
+        (0, log_1.logError)("Failed to set a RNG object to a seed of 0. Using a random value instead.");
+        (0, debugFunctions_1.traceback)();
+    }
+    // The game expects seeds in the range of 1 to 4294967295 (1^32 - 1).
+    // eslint-disable-next-line deprecation/deprecation
+    rng.SetSeed(seed, RECOMMENDED_SHIFT_IDX);
+}
+exports.setSeed = setSeed;

package/dist/functions/rockAlt.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUrnRewards = exports.getRockAltType = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const backdropTypeToRockAltType_1 = require("../objects/backdropTypeToRockAltType");
+const entitiesSpecific_1 = require("./entitiesSpecific");
+const gridEntities_1 = require("./gridEntities");
+const pickupsSpecific_1 = require("./pickupsSpecific");
+/**
+ * Helper function to get the alternate rock type (i.e. urn, mushroom, etc.) that the current room
+ * will have.
+ *
+ * The rock type is based on the backdrop of the room.
+ *
+ * For example, if you change the backdrop of the starting room of the run to `BackdropType.CAVES`,
+ * and then spawn `GridEntityType.ROCK_ALT`, it will be a mushroom instead of an urn. Additionally,
+ * if it is destroyed, it will generate mushroom-appropriate rewards.
+ *
+ * On the other hand, if an urn is spawned first before the backdrop is changed to
+ * `BackdropType.CAVES`, the graphic of the urn will not switch to a mushroom. However, when
+ * destroyed, the urn will still generate mushroom-appropriate rewards.
+ */
+function getRockAltType() {
+    const room = cachedClasses_1.game.GetRoom();
+    const backdropType = room.GetBackdropType();
+    return backdropTypeToRockAltType_1.BACKDROP_TYPE_TO_ROCK_ALT_TYPE[backdropType];
+}
+exports.getRockAltType = getRockAltType;
+/**
+ * Helper function to remove all coins, trinkets, and so on that spawned from breaking an urn.
+ *
+ * The rewards are based on the ones from the wiki:
+ * https://bindingofisaacrebirth.fandom.com/wiki/Rocks#Urns
+ */
+function removeUrnRewards(gridEntity) {
+    // Coins
+    const coins = (0, pickupsSpecific_1.getCoins)();
+    (0, gridEntities_1.removeEntitiesSpawnedFromGridEntity)(coins, gridEntity);
+    // A Quarter
+    const quarters = (0, pickupsSpecific_1.getCollectibles)(isaac_typescript_definitions_1.CollectibleType.QUARTER);
+    (0, gridEntities_1.removeEntitiesSpawnedFromGridEntity)(quarters, gridEntity);
+    // Swallowed Penny
+    const swallowedPennies = (0, pickupsSpecific_1.getTrinkets)(isaac_typescript_definitions_1.TrinketType.SWALLOWED_PENNY);
+    (0, gridEntities_1.removeEntitiesSpawnedFromGridEntity)(swallowedPennies, gridEntity);
+    // Spiders
+    const spiders = (0, entitiesSpecific_1.getNPCs)(isaac_typescript_definitions_1.EntityType.SPIDER);
+    (0, gridEntities_1.removeEntitiesSpawnedFromGridEntity)(spiders, gridEntity);
+}
+exports.removeUrnRewards = removeUrnRewards;

package/dist/functions/roomData.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRoomData = exports.getRoomVisitedCount = exports.getRoomVariant = exports.getRoomType = exports.getRoomSubType = exports.getRoomStageID = exports.getRoomShape = exports.getRoomName = exports.getRoomListIndex = exports.getRoomGridIndex = exports.getRoomDescriptorReadOnly = exports.getRoomDescriptor = exports.getRoomData = exports.getRoomAllowedDoors = void 0;
+const cachedEnumValues_1 = require("../arrays/cachedEnumValues");
+const cachedClasses_1 = require("../core/cachedClasses");
+const doors_1 = require("./doors");
+const flag_1 = require("./flag");
+/**
+ * Helper function to get the set of allowed door slots for the room at the supplied grid index.
+ * This corresponds to the doors that are enabled in the STB/XML file for the room.
+ */
+function getRoomAllowedDoors(roomGridIndex) {
+    const allowedDoors = new Set();
+    const roomData = getRoomData(roomGridIndex);
+    if (roomData === undefined) {
+        return allowedDoors;
+    }
+    for (const doorSlotFlag of cachedEnumValues_1.DOOR_SLOT_FLAG_VALUES) {
+        if ((0, flag_1.hasFlag)(roomData.Doors, doorSlotFlag)) {
+            const doorSlot = (0, doors_1.doorSlotFlagToDoorSlot)(doorSlotFlag);
+            allowedDoors.add(doorSlot);
+        }
+    }
+    return allowedDoors;
+}
+exports.getRoomAllowedDoors = getRoomAllowedDoors;
+function getRoomData(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.Data;
+}
+exports.getRoomData = getRoomData;
+/**
+ * Helper function to get the descriptor for a room.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+function getRoomDescriptor(roomGridIndex) {
+    const level = cachedClasses_1.game.GetLevel();
+    if (roomGridIndex === undefined) {
+        roomGridIndex = getRoomGridIndex();
+    }
+    return level.GetRoomByIdx(roomGridIndex);
+}
+exports.getRoomDescriptor = getRoomDescriptor;
+/**
+ * Alias for the `Level.GetCurrentRoomDesc` method. Use this to make it more clear what type of
+ * `RoomDescriptor` object that you are retrieving.
+ */
+function getRoomDescriptorReadOnly() {
+    const level = cachedClasses_1.game.GetLevel();
+    return level.GetCurrentRoomDesc();
+}
+exports.getRoomDescriptorReadOnly = getRoomDescriptorReadOnly;
+/**
+ * Helper function to get the grid index of the current room.
+ *
+ * - If the current room is inside of the grid, this function will return the `SafeGridIndex` from
+ *   the room descriptor. (The safe grid index is defined as the top-left 1x1 section that the room
+ *   overlaps with, or the top-right 1x1 section of a `RoomType.SHAPE_LTL` room.)
+ * - If the current room is outside of the grid, it will return the index from the
+ *   `Level.GetCurrentRoomIndex` method, since `SafeGridIndex` is bugged for these cases, as
+ *   demonstrated by entering a Genesis room and entering `l
+ *   print(Game():GetLevel():GetCurrentRoomDesc().SafeGridIndex)` into the console. (It prints -1
+ *   instead of -12.)
+ *
+ * Use this function instead of the `Level.GetCurrentRoomIndex` method directly because the latter
+ * will return the specific 1x1 quadrant that the player entered the room at. For most situations,
+ * using the safe grid index is more reliable than this.
+ *
+ * Data structures that store data per room should use the room's `ListIndex` instead of
+ * `SafeGridIndex`, since the former is unique across different dimensions.
+ */
+function getRoomGridIndex() {
+    const level = cachedClasses_1.game.GetLevel();
+    const currentRoomIndex = level.GetCurrentRoomIndex();
+    if (currentRoomIndex < 0) {
+        return currentRoomIndex;
+    }
+    const roomDescriptor = getRoomDescriptorReadOnly();
+    return roomDescriptor.SafeGridIndex;
+}
+exports.getRoomGridIndex = getRoomGridIndex;
+/**
+ * Helper function to get the list grid index of the provided room, which is equal to the index in
+ * the `RoomList.Get` method. In other words, this is equal to the order that the room was created
+ * by the floor generation algorithm.
+ *
+ * Use this as an index for data structures that store data per room, since it is unique across
+ * different dimensions.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+function getRoomListIndex(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.ListIndex;
+}
+exports.getRoomListIndex = getRoomListIndex;
+function getRoomName(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? undefined : roomData.Name;
+}
+exports.getRoomName = getRoomName;
+function getRoomShape(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? undefined : roomData.Shape;
+}
+exports.getRoomShape = getRoomShape;
+function getRoomStageID(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? undefined : roomData.StageID;
+}
+exports.getRoomStageID = getRoomStageID;
+function getRoomSubType(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? undefined : roomData.Subtype;
+}
+exports.getRoomSubType = getRoomSubType;
+/**
+ * Helper function for getting the type of the room with the given grid index.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @returns The room data type. Returns -1 if the room data was not found.
+ */
+function getRoomType(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? undefined : roomData.Type;
+}
+exports.getRoomType = getRoomType;
+function getRoomVariant(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? -1 : roomData.Variant;
+}
+exports.getRoomVariant = getRoomVariant;
+/**
+ * Note that the room visited count will be inaccurate during the period before the `POST_NEW_ROOM`
+ * callback has fired (i.e. when entities are initializing and performing their first update). This
+ * is because the variable is only incremented immediately before the `POST_NEW_ROOM` callback
+ * fires.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+function getRoomVisitedCount(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.VisitedCount;
+}
+exports.getRoomVisitedCount = getRoomVisitedCount;
+/**
+ * Helper function to set the data for a given room. This will change the room type, contents, and
+ * so on.
+ */
+function setRoomData(roomGridIndex, roomData) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    roomDescriptor.Data = roomData;
+}
+exports.setRoomData = setRoomData;

package/dist/functions/roomGrid.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * These functions have to do with the grid index inside of a room (i.e. the grid index that grid
+ * entities use).
+ *
+ * For functions having to do with the room grid index of the level, see the "Level Grid" functions.
+ *
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.worldPositionToGridPositionFast = exports.worldPositionToGridPosition = exports.isValidGridPosition = exports.gridPositionToWorldPosition = exports.gridIndexToGridPosition = exports.gridCoordinatesToWorldPosition = void 0;
+const LRoomShapeToRectangles_1 = require("../objects/LRoomShapeToRectangles");
+const math_1 = require("./math");
+const roomShape_1 = require("./roomShape");
+/**
+ * Helper function to convert grid coordinates to a world position `Vector`.
+ *
+ * For example, the coordinates of (0, 0) are equal to `Vector(80, 160)`.
+ */
+function gridCoordinatesToWorldPosition(x, y) {
+    const gridPosition = Vector(x, y);
+    return gridPositionToWorldPosition(gridPosition);
+}
+exports.gridCoordinatesToWorldPosition = gridCoordinatesToWorldPosition;
+/**
+ * Helper function to convert a grid index to a grid position.
+ *
+ * For example, in a 1x1 room, grid index 0 is equal to "Vector(-1, -1) and grid index 16 is equal
+ * to "Vector(0, 0)".
+ */
+function gridIndexToGridPosition(gridIndex, roomShape) {
+    const gridWidth = (0, roomShape_1.getRoomShapeWidth)(roomShape);
+    const x = (gridIndex % gridWidth) - 1;
+    const y = Math.floor(gridIndex / gridWidth) - 1;
+    return Vector(x, y);
+}
+exports.gridIndexToGridPosition = gridIndexToGridPosition;
+/**
+ * Helper function to convert a grid position `Vector` to a world position `Vector`.
+ *
+ * For example, the coordinates of (0, 0) are equal to `Vector(80, 160)`.
+ */
+function gridPositionToWorldPosition(gridPosition) {
+    const x = (gridPosition.X + 2) * 40;
+    const y = (gridPosition.Y + 4) * 40;
+    return Vector(x, y);
+}
+exports.gridPositionToWorldPosition = gridPositionToWorldPosition;
+/**
+ * Test if a grid position is actually in the given `RoomShape`.
+ *
+ * In this context, the grid position of the top-left wall is "Vector(-1, -1)".
+ */
+function isValidGridPosition(gridPosition, roomShape) {
+    return (0, roomShape_1.isLRoomShape)(roomShape)
+        ? isValidGridPositionLRoom(gridPosition, roomShape)
+        : isValidGridPositionNormal(gridPosition, roomShape);
+}
+exports.isValidGridPosition = isValidGridPosition;
+function isValidGridPositionNormal(gridPosition, roomShape) {
+    const topLeft = (0, roomShape_1.getRoomShapeTopLeftPosition)(roomShape);
+    const bottomRight = (0, roomShape_1.getRoomShapeBottomRightPosition)(roomShape);
+    return (0, math_1.inRectangle)(gridPosition, topLeft, bottomRight);
+}
+function isValidGridPositionLRoom(gridPosition, roomShape) {
+    const rectangles = LRoomShapeToRectangles_1.L_ROOM_SHAPE_TO_RECTANGLES[roomShape];
+    if (rectangles === undefined) {
+        return false;
+    }
+    const { verticalTopLeft, verticalBottomRight, horizontalTopLeft, horizontalBottomRight, } = rectangles;
+    return ((0, math_1.inRectangle)(gridPosition, verticalTopLeft, verticalBottomRight) ||
+        (0, math_1.inRectangle)(gridPosition, horizontalTopLeft, horizontalBottomRight));
+}
+/**
+ * Helper function to convert a world position `Vector` to a grid position `Vector`.
+ *
+ * In this context, the grid position of the top-left wall is "Vector(-1, -1)".
+ */
+function worldPositionToGridPosition(worldPos) {
+    const x = Math.round(worldPos.X / 40 - 2);
+    const y = Math.round(worldPos.Y / 40 - 4);
+    return Vector(x, y);
+}
+exports.worldPositionToGridPosition = worldPositionToGridPosition;
+/**
+ * Helper function to convert a world position `Vector` to a grid position `Vector`.
+ *
+ * In this context, the grid position of the top-left wall is "Vector(-1, -1)".
+ *
+ * This is similar to the `worldPositionToGridPosition` function, but the values are not rounded.
+ */
+function worldPositionToGridPositionFast(worldPos) {
+    const x = worldPos.X / 40 - 2;
+    const y = worldPos.Y / 40 - 4;
+    return Vector(x, y);
+}
+exports.worldPositionToGridPositionFast = worldPositionToGridPositionFast;

package/dist/functions/roomShape.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRoomShapeDoubleCharge = exports.isNarrowRoom = exports.isLRoomShape = exports.isBigRoomShape = exports.is2x1RoomShape = exports.getRoomShapeWidth = exports.getRoomShapeVolume = exports.getRoomShapeTopLeftPosition = exports.getRoomShapeLayoutSize = exports.getRoomShapeCorners = exports.getRoomShapeCharges = exports.getRoomShapeBounds = exports.getRoomShapeBottomRightPosition = exports.getGridIndexDelta = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const roomShapeBounds_1 = require("../objects/roomShapeBounds");
+const roomShapeCorners_1 = require("../objects/roomShapeCorners");
+const roomShapeLayoutSizes_1 = require("../objects/roomShapeLayoutSizes");
+const roomShapeToBottomRightPosition_1 = require("../objects/roomShapeToBottomRightPosition");
+const roomShapeToDoorSlotsToGridIndexDelta_1 = require("../objects/roomShapeToDoorSlotsToGridIndexDelta");
+const roomShapeToGridWidth_1 = require("../objects/roomShapeToGridWidth");
+const roomShapeToTopLeftPosition_1 = require("../objects/roomShapeToTopLeftPosition");
+const roomShapeVolumes_1 = require("../objects/roomShapeVolumes");
+const LRoomShapesSet_1 = require("../sets/LRoomShapesSet");
+const bigRoomShapesSet_1 = require("../sets/bigRoomShapesSet");
+const narrowRoomShapesSet_1 = require("../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.
+ */
+function getGridIndexDelta(roomShape, doorSlot) {
+    const doorSlotToGridIndexMap = roomShapeToDoorSlotsToGridIndexDelta_1.ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA[roomShape];
+    return doorSlotToGridIndexMap.get(doorSlot);
+}
+exports.getGridIndexDelta = getGridIndexDelta;
+/**
+ * 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.
+ */
+function getRoomShapeBottomRightPosition(roomShape) {
+    return roomShapeToBottomRightPosition_1.ROOM_SHAPE_TO_BOTTOM_RIGHT_POSITION[roomShape];
+}
+exports.getRoomShapeBottomRightPosition = getRoomShapeBottomRightPosition;
+/**
+ * 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)".)
+ */
+function getRoomShapeBounds(roomShape) {
+    return roomShapeBounds_1.ROOM_SHAPE_BOUNDS[roomShape];
+}
+exports.getRoomShapeBounds = getRoomShapeBounds;
+/**
+ * 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.
+ */
+function getRoomShapeCharges(roomShape) {
+    return isRoomShapeDoubleCharge(roomShape) ? 2 : 1;
+}
+exports.getRoomShapeCharges = getRoomShapeCharges;
+/**
+ * Helper function to get the corners that exist in the given room shape.
+ *
+ * Note that these corner locations are not accurate for the Mother Boss Room and the Home closet
+ * rooms. (Those rooms have custom shapes.)
+ */
+function getRoomShapeCorners(roomShape) {
+    return roomShapeCorners_1.ROOM_SHAPE_CORNERS[roomShape];
+}
+exports.getRoomShapeCorners = getRoomShapeCorners;
+/**
+ * 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.
+ */
+function getRoomShapeLayoutSize(roomShape) {
+    return roomShapeLayoutSizes_1.ROOM_SHAPE_LAYOUT_SIZES[roomShape];
+}
+exports.getRoomShapeLayoutSize = getRoomShapeLayoutSize;
+/**
+ * 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)".)
+ */
+function getRoomShapeTopLeftPosition(roomShape) {
+    return roomShapeToTopLeftPosition_1.ROOM_SHAPE_TO_TOP_LEFT_POSITION[roomShape];
+}
+exports.getRoomShapeTopLeftPosition = getRoomShapeTopLeftPosition;
+/**
+ * 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.)
+ */
+function getRoomShapeVolume(roomShape) {
+    return roomShapeVolumes_1.ROOM_SHAPE_VOLUMES[roomShape];
+}
+exports.getRoomShapeVolume = getRoomShapeVolume;
+function getRoomShapeWidth(roomShape) {
+    return roomShapeToGridWidth_1.ROOM_SHAPE_TO_GRID_WIDTH[roomShape];
+}
+exports.getRoomShapeWidth = getRoomShapeWidth;
+/**
+ * Helper function to determine if the provided room is equal to `RoomShape.1x2` (4) or
+ * `RoomShape.2x1` (6).
+ */
+function is2x1RoomShape(roomShape) {
+    return roomShape === isaac_typescript_definitions_1.RoomShape.SHAPE_1x2 || roomShape === isaac_typescript_definitions_1.RoomShape.SHAPE_2x1;
+}
+exports.is2x1RoomShape = is2x1RoomShape;
+/**
+ * Helper function to detect if the provided room shape is big. Specifically, this is all 1x2 rooms,
+ * 2x2 rooms, and L rooms.
+ */
+function isBigRoomShape(roomShape) {
+    return bigRoomShapesSet_1.BIG_ROOM_SHAPES_SET.has(roomShape);
+}
+exports.isBigRoomShape = isBigRoomShape;
+/**
+ * Helper function to determine if the provided room is equal to `RoomShape.LTL` (9),
+ * `RoomShape.LTR` (10), `RoomShape.LBL` (11), or `RoomShape.LBR` (12).
+ */
+function isLRoomShape(roomShape) {
+    return LRoomShapesSet_1.L_ROOM_SHAPES_SET.has(roomShape);
+}
+exports.isLRoomShape = isLRoomShape;
+/**
+ * Helper function to determine if the provided room is equal to `RoomShape.IH` (2), `RoomShape.IV`
+ * (3), `RoomShape.IIV` (5), or `RoomShape.IIH` (7).
+ */
+function isNarrowRoom(roomShape) {
+    return narrowRoomShapesSet_1.NARROW_ROOM_SHAPES_SET.has(roomShape);
+}
+exports.isNarrowRoom = isNarrowRoom;
+/**
+ * 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.
+ */
+function isRoomShapeDoubleCharge(roomShape) {
+    // 2x2 rooms and L rooms should grant 2 charges.
+    return roomShape >= isaac_typescript_definitions_1.RoomShape.SHAPE_2x2;
+}
+exports.isRoomShapeDoubleCharge = isRoomShapeDoubleCharge;