isaacscript-common/dist/functions/levelGrid.d.ts

Helper functions and features for IsaacScript mods.

/**
 * These functions have to do with the room grid index for the level (i.e. the position that the
 * room is on the grid that represents the map for the level).
 *
 * For functions having to do with the grid index inside of the room, see the "Room Grid" functions.
 *
 * @module
 */
import type { DoorSlot, RoomShape } from "isaac-typescript-definitions";
import { RoomType } from "isaac-typescript-definitions";
/**
 * Helper function to get only the adjacent room grid indexes that exist (i.e. have room data).
 *
 * This is just a filtering of the results of the `getAdjacentExistingRoomGridIndexes` function. See
 * that function for more information.
 *
 * @param roomGridIndex Optional. Default is the current room index.
 */
export declare function getAdjacentExistingRoomGridIndexes(roomGridIndex?: int): readonly int[];
/**
 * Helper function to get only the adjacent room grid indexes that do not exist (i.e. do not have
 * room data).
 *
 * This is just a filtering of the results of the `getAdjacentExistingRoomGridIndexes` function. See
 * that function for more information.
 */
export declare function getAdjacentNonExistingRoomGridIndexes(roomGridIndex?: int): readonly int[];
/**
 * Helper function to get all of the room grid indexes that are adjacent to a given room grid index
 * (even if those room grid indexes do not have any rooms in them).
 *
 * Adjacent room grid indexes that are outside of the grid will not be included in the returned
 * array.
 *
 * If a room grid index is provided that is outside of the grid, then an empty array will be
 * returned.
 *
 * Note that this function does not take the shape of the room into account; it only looks at a
 * single room grid index.
 *
 * @param roomGridIndex Optional. Default is the current room index.
 */
export declare function getAdjacentRoomGridIndexes(roomGridIndex?: int): readonly int[];
/**
 * Helper function to get the room safe grid index for every room on the entire floor. This includes
 * off-grid rooms, such as the Devil Room.
 *
 * Rooms without any data are assumed to be non-existent and are not included.
 */
export declare function getAllRoomGridIndexes(): readonly int[];
/**
 * Helper function to pick a random valid spot on the floor to insert a brand new room. Note that
 * some floors will not have any valid spots. If this is the case, this function will return
 * undefined.
 *
 * If you want to get an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
 * parameter.
 *
 * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
 *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
 *                  a random seed.
 * @param ensureDeadEnd Optional. Whether to pick a valid dead end attached to a normal room. If
 *                      false, the function will randomly pick from any valid location that would
 *                      have a red door.
 * @returns Either a tuple of adjacent room grid index, `DoorSlot`, and new room grid index, or
 *          undefined.
 */
export declare function getNewRoomCandidate(seedOrRNG: Seed | RNG | undefined, ensureDeadEnd?: boolean): {
    readonly adjacentRoomGridIndex: int;
    readonly doorSlot: DoorSlot;
    readonly newRoomGridIndex: int;
} | undefined;
/**
 * Helper function to iterate through the possible doors for a room and see if any of them would be
 * a valid spot to insert a brand new room on the floor.
 *
 * @param roomGridIndex Optional. Default is the current room index.
 * @param ensureDeadEnd Optional. Whether to only include doors that lead to a valid dead end
 *                      attached to a normal room. If false, the function will include all doors
 *                      that would have a red door.
 * @returns A array of tuples of `DoorSlot` and room grid index.
 */
export declare function getNewRoomCandidatesBesideRoom(roomGridIndex?: int, ensureDeadEnd?: boolean): ReadonlyArray<{
    readonly doorSlot: DoorSlot;
    readonly roomGridIndex: int;
}>;
/**
 * Helper function to get all of the spots on the floor to insert a brand new room.
 *
 * @param ensureDeadEnd Optional. Whether to only include spots that are a valid dead end attached
 *                      to a normal room. If false, the function will include all valid spots that
 *                      have a red door.
 * @returns A array of tuples containing the adjacent room grid index, the `DoorSlot`, and the new
 *          room grid index.
 */
export declare function getNewRoomCandidatesForLevel(ensureDeadEnd?: boolean): ReadonlyArray<{
    readonly adjacentRoomGridIndex: int;
    readonly doorSlot: DoorSlot;
    readonly newRoomGridIndex: int;
}>;
/**
 * Helper function to get the grid indexes of all the rooms connected to the given room index,
 * taking the shape of the room into account. (This will only include rooms with valid data.)
 *
 * Returns an empty map if the provided room grid index is out of bounds or has no associated room
 * data.
 *
 * @param roomGridIndex Optional. Default is the current room index.
 * @returns A map of `DoorSlot` to the corresponding room grid index.
 */
export declare function getRoomAdjacentGridIndexes(roomGridIndex?: int): ReadonlyMap<DoorSlot, int>;
/**
 * Helper function to get an array of all of the room descriptors for rooms that match the specified
 * room type.
 *
 * This function only searches through rooms in the current dimension and rooms inside the grid.
 *
 * This function is variadic, meaning that you can specify N arguments to get the combined room
 * descriptors for N room types.
 */
export declare function getRoomDescriptorsForType(...roomTypes: readonly RoomType[]): readonly RoomDescriptor[];
/**
 * 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 declare function getRoomGridIndexesForType(...roomTypes: readonly RoomType[]): readonly int[];
/**
 * Helper function to get only the adjacent room grid indexes for a room shape that exist (i.e. have
 * room data).
 *
 * This is just a filtering of the results of the `getRoomShapeAdjacentGridIndexes` function. See
 * that function for more information.
 */
export declare function getRoomShapeAdjacentExistingGridIndexes(safeRoomGridIndex: int, roomShape: RoomShape): ReadonlyMap<DoorSlot, int>;
/**
 * Helper function to get the room grid index delta that each hypothetical door in a given room
 * shape would go to.
 *
 * This is used by the `getRoomShapeAdjacentGridIndexes` function.
 *
 * @returns A map of `DoorSlot` to the corresponding room grid index delta.
 */
export declare function getRoomShapeAdjacentGridIndexDeltas(roomShape: RoomShape): ReadonlyMap<DoorSlot, int>;
/**
 * Helper function to get the room grid index that each hypothetical door in a given room shape
 * would go to. (This will not include room grid indexes that are outside of the grid.)
 *
 * @param safeRoomGridIndex This must be the room safe grid index (i.e. the top-left room grid index
 *                          for the respective room).
 * @param roomShape The shape of the hypothetical room.
 * @returns A map of `DoorSlot` to the corresponding room grid index.
 */
export declare function getRoomShapeAdjacentGridIndexes(safeRoomGridIndex: int, roomShape: RoomShape): ReadonlyMap<DoorSlot, int>;
/**
 * Helper function to get only the adjacent room grid indexes for a room shape that do not exist
 * (i.e. do not have room data).
 *
 * This is just a filtering of the results of the `getRoomShapeAdjacentGridIndexes` function. See
 * that function for more information.
 */
export declare function getRoomShapeAdjacentNonExistingGridIndexes(safeRoomGridIndex: int, roomShape: RoomShape): ReadonlyMap<DoorSlot, int>;
/**
 * Helper function to determine if the current room grid index is inside of the normal 13x13 level
 * grid.
 *
 * For example, Devil Rooms and the Mega Satan room are not considered to be inside the grid.
 */
export declare function inGrid(): boolean;
/**
 * Helper function to detect if the current room was created by the Red Key item.
 *
 * Under the hood, this checks for the `RoomDescriptorFlag.FLAG_RED_ROOM` flag.
 */
export declare function inRedKeyRoom(): boolean;
/**
 * Helper function to check if the given room grid index is a dead end. Specifically, this is
 * defined as having only one adjacent room that exists.
 *
 * Note that this function does not take the shape of the room into account; it only looks at a
 * single room grid index.
 *
 * This function does not care if the given room grid index actually exists, so you can use it to
 * check if a hypothetical room would be a dead end.
 *
 * @param roomGridIndex Optional. Default is the current room index.
 */
export declare function isDeadEnd(roomGridIndex?: int): boolean;
export declare function isDoorSlotValidAtGridIndex(doorSlot: DoorSlot, roomGridIndex: int): boolean;
export declare function isDoorSlotValidAtGridIndexForRedRoom(doorSlot: DoorSlot, roomGridIndex: int): boolean;
/**
 * 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 declare function isRedKeyRoom(roomGridIndex: int): boolean;
/**
 * Helper function to determine if a given room grid index is inside of the normal 13x13 level grid.
 *
 * For example, Devil Rooms and the Mega Satan room are not considered to be inside the grid.
 *
 * @param roomGridIndex Optional. Default is the current room index.
 */
export declare function isRoomInsideGrid(roomGridIndex?: int): boolean;
/**
 * Helper function to generate a new room on the floor.
 *
 * If you want to generate an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
 * parameter.
 *
 * Under the hood, this function uses the `Level.MakeRedRoomDoor` method to create the room.
 *
 * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
 *                  `RNG.Next` method will be called. Default is `Level.GetDungeonPlacementSeed`.
 *                  Note that the RNG is only used to select the random location to put the room on
 *                  the floor; it does not influence the randomly chosen room contents. (That is
 *                  performed by the game and can not be manipulated prior to its generation.)
 * @param ensureDeadEnd Optional. Whether to place the room at a valid dead end attached to a normal
 *                      room. If false, it will randomly appear at any valid location that would
 *                      have a red door.
 * @param customRoomData Optional. By default, the newly created room will have data corresponding
 *                       to the game's randomly generated red room. If you provide this function
 *                       with room data, it will be used to override the vanilla data.
 * @returns The room grid index of the new room or undefined if the floor had no valid dead ends to
 *          place a room.
 */
export declare function newRoom(seedOrRNG: Seed | RNG | undefined, ensureDeadEnd?: boolean, customRoomData?: RoomConfig): int | undefined;
/**
 * Helper function to check if a room exists at the given room grid index. (A room will exist if it
 * has non-undefined data in the room descriptor.)
 */
export declare function roomExists(roomGridIndex: int): boolean;
/**
 * Helper function to get the coordinates of a given room grid index. The floor is represented by a
 * 13x13 grid.
 *
 * - Since the starting room is in the center, the starting room grid index of 84 is equal to
 *   coordinates of (6, 6).
 * - The top-left grid index of 0 is equal to coordinates of: (12, 0)
 * - The top-right grid index of 12 is equal to coordinates of: (0, 0)
 * - The bottom-left grid index of 156 is equal to coordinates of: (0, 12)
 * - The bottom-right grid index of 168 is equal to coordinates of: (12, 12)
 */
export declare function roomGridIndexToVector(roomGridIndex: int): Readonly<Vector>;
/**
 * Helper function to convert a room grid index expressed as a vector back into an integer.
 *
 * Also see the `roomGridIndexToVector` helper function.
 */
export declare function vectorToRoomGridIndex(roomVector: Vector): int;
//# sourceMappingURL=levelGrid.d.ts.map