isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.2

package/functions/rng.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="typescript-to-lua/language-extensions" />
 /// <reference types="isaac-typescript-definitions" />
 /// <reference types="isaac-typescript-definitions" />
+/// <reference types="typescript-to-lua/language-extensions" />
 import { SerializationType } from "../enums/SerializationType";
 declare type SerializedRNG = LuaTable<string, unknown> & {
     readonly __serializedRNGBrand: symbol;

package/functions/rng.js

@@ -0,0 +1,117 @@
+import { game } from "../cachedClasses";
+import { SerializationBrand } from "../enums/private/SerializationBrand";
+import { SerializationType } from "../enums/SerializationType";
+import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
+import { getNumbersFromTable, tableHasKeys } from "./table";
+import { isTable } from "./types";
+/**
+ * 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 KEYS = ["seed"];
+const OBJECT_NAME = "RNG";
+export function copyRNG(rng, serializationType = SerializationType.NONE) {
+    switch (serializationType) {
+        case SerializationType.NONE: {
+            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);
+        }
+        case SerializationType.SERIALIZE: {
+            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 LuaTable();
+            rngTable.set("seed", seed);
+            rngTable.set(SerializationBrand.RNG, "");
+            return rngTable;
+        }
+        case SerializationType.DESERIALIZE: {
+            if (!isTable(rng)) {
+                error(`Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`);
+            }
+            const [seedNumber] = getNumbersFromTable(rng, OBJECT_NAME, ...KEYS);
+            const seed = seedNumber;
+            return newRNG(seed);
+        }
+    }
+}
+/**
+ * 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.
+ */
+export function getRandomSeed() {
+    const randomNumber = Random();
+    const safeRandomNumber = randomNumber === 0 ? 1 : randomNumber;
+    return safeRandomNumber;
+}
+/** Helper function to check if something is an instantiated RNG object. */
+export function isRNG(object) {
+    return isIsaacAPIClassOfType(object, OBJECT_NAME);
+}
+/**
+ * Used to determine is the given table is a serialized `RNG` object created by the save data
+ * manager and/or the `deepCopy` function.
+ */
+export function isSerializedRNG(object) {
+    if (!isTable(object)) {
+        return false;
+    }
+    return tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.RNG);
+}
+/**
+ * Helper function to initialize an RNG object using Blade's recommended shift index.
+ *
+ * @param seed The seed to initialize it with. Default is `getRandomSeed()`.
+ */
+export function newRNG(seed = getRandomSeed()) {
+    const rng = RNG();
+    setSeed(rng, seed);
+    return rng;
+}
+export function rngEquals(rng1, rng2) {
+    return isaacAPIClassEquals(rng1, rng2, KEYS);
+}
+/**
+ * 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.
+ */
+export function setAllRNGToSeed(object, seed) {
+    if (!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 pairs(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.`);
+    }
+}
+/**
+ * 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.
+ */
+export function setAllRNGToStartSeed(object) {
+    const seeds = game.GetSeeds();
+    const startSeed = seeds.GetStartSeed();
+    setAllRNGToSeed(object, startSeed);
+}
+/** Helper function to set a seed to an RNG object using Blade's recommended shift index. */
+export function setSeed(rng, seed) {
+    if (seed === 0) {
+        error("You cannot set an RNG object to a seed of 0, or the game will crash.");
+    }
+    // The game expects seeds in the range of 1 to 4294967295 (1^32 - 1).
+    rng.SetSeed(seed, RECOMMENDED_SHIFT_IDX);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/roomData.js

@@ -0,0 +1,174 @@
+import { DoorSlotFlag, } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { doorSlotFlagToDoorSlot } from "./doors";
+import { getEnumValues } from "./enums";
+import { hasFlag } from "./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.
+ */
+export function getRoomAllowedDoors(roomGridIndex) {
+    const allowedDoors = new Set();
+    const roomData = getRoomData(roomGridIndex);
+    if (roomData === undefined) {
+        return allowedDoors;
+    }
+    const doorSlotFlags = getEnumValues(DoorSlotFlag);
+    for (const doorSlotFlag of doorSlotFlags) {
+        if (hasFlag(roomData.Doors, doorSlotFlag)) {
+            const doorSlot = doorSlotFlagToDoorSlot(doorSlotFlag);
+            allowedDoors.add(doorSlot);
+        }
+    }
+    return allowedDoors;
+}
+/**
+ * Helper function to get the room data for the provided room.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function getRoomData(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.Data;
+}
+/**
+ * Helper function to get the descriptor for a room.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function getRoomDescriptor(roomGridIndex) {
+    const level = game.GetLevel();
+    if (roomGridIndex === undefined) {
+        roomGridIndex = getRoomGridIndex();
+    }
+    return level.GetRoomByIdx(roomGridIndex);
+}
+/**
+ * Alias for the `Level.GetCurrentRoomDesc` method. Use this to make it more clear what type of
+ * `RoomDescriptor` object that you are retrieving.
+ */
+export function getRoomDescriptorReadOnly() {
+    const level = game.GetLevel();
+    return level.GetCurrentRoomDesc();
+}
+/**
+ * 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).
+ *
+ * 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.
+ */
+export function getRoomGridIndex() {
+    const level = game.GetLevel();
+    const currentRoomIndex = level.GetCurrentRoomIndex();
+    // Both `RoomDescriptor.GridIndex` and `RoomDescriptor.SafeGridIndex` will always be equal to -1
+    // for rooms outside of the grid. Thus, we revert to using the `Level.GetCurrentRoomIndex` method
+    // for these cases.
+    if (currentRoomIndex < 0) {
+        return currentRoomIndex;
+    }
+    const roomDescriptor = getRoomDescriptorReadOnly();
+    return roomDescriptor.SafeGridIndex;
+}
+/**
+ * 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.
+ */
+export function getRoomListIndex(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.ListIndex;
+}
+/**
+ * Helper function to get the name of the room as it appears in the STB/XML data.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @returns The room name. Returns "Unknown" if the type was not found.
+ */
+export function getRoomName(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? "Unknown" : roomData.Name;
+}
+/**
+ * Helper function to get the name of the room as it appears in the STB/XML data.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @returns The room name. Returns "Unknown" if the type was not found.
+ */
+export function getRoomShape(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? undefined : roomData.Shape;
+}
+/**
+ * Helper function to get the stage ID for a room from the XML/STB data. The room stage ID will
+ * correspond to the first number in the filename of the XML/STB file. For example, a Depths room
+ * would have a stage ID of 7.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @returns The room stage ID. Returns -1 if the stage ID was not found.
+ */
+export function getRoomStageID(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? -1 : roomData.StageID;
+}
+/**
+ * Helper function to get the sub-type for a room from the XML/STB data. The room sub-type will
+ * correspond to different things depending on what XML/STB file it draws from. For example, in the
+ * "00.special rooms.stb" file, an Angel Room with a sub-type of 0 will correspond to a normal Angel
+ * Room and a sub-type of 1 will correspond to an Angel Room shop for The Stairway.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @returns The room sub-type. Returns -1 if the sub-type was not found.
+ */
+export function getRoomSubType(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? -1 : roomData.Subtype;
+}
+/**
+ * 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 type was not found.
+ */
+export function getRoomType(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? -1 : roomData.Type;
+}
+/**
+ * Helper function to get the variant for a room from the XML/STB data. You can think of a room
+ * variant as its identifier. For example, to go to Basement room #123, you would use a console
+ * command of `goto d.123` while on the Basement.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ * @returns The room variant. Returns -1 if the variant was not found.
+ */
+export function getRoomVariant(roomGridIndex) {
+    const roomData = getRoomData(roomGridIndex);
+    return roomData === undefined ? -1 : roomData.Variant;
+}
+/**
+ * Note that the room visited count will be inaccurate during the period before the PostNewRoom
+ * 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 PostNewRoom callback fires.
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function getRoomVisitedCount(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.VisitedCount;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/roomGrid.js

@@ -0,0 +1,81 @@
+import { L_ROOM_SHAPE_TO_RECTANGLES } from "../objects/LRoomShapeToRectangles";
+import { inRectangle } from "./math";
+import { getRoomShapeBottomRightPosition, getRoomShapeTopLeftPosition, getRoomShapeWidth, isLRoom, } from "./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)`.
+ */
+export function gridCoordinatesToWorldPosition(x, y) {
+    const gridPosition = Vector(x, y);
+    return gridPositionToWorldPosition(gridPosition);
+}
+/**
+ * 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)".
+ */
+export function gridIndexToGridPosition(gridIndex, roomShape) {
+    const gridWidth = getRoomShapeWidth(roomShape);
+    const x = (gridIndex % gridWidth) - 1;
+    const y = Math.floor(gridIndex / gridWidth) - 1;
+    return Vector(x, y);
+}
+/**
+ * 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)`.
+ */
+export function gridPositionToWorldPosition(gridPosition) {
+    const x = (gridPosition.X + 2) * 40;
+    const y = (gridPosition.Y + 4) * 40;
+    return Vector(x, y);
+}
+/**
+ * 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)".
+ */
+export function isValidGridPosition(gridPosition, roomShape) {
+    return isLRoom(roomShape)
+        ? isValidGridPositionLRoom(gridPosition, roomShape)
+        : isValidGridPositionNormal(gridPosition, roomShape);
+}
+function isValidGridPositionNormal(gridPosition, roomShape) {
+    const topLeft = getRoomShapeTopLeftPosition(roomShape);
+    const bottomRight = getRoomShapeBottomRightPosition(roomShape);
+    return inRectangle(gridPosition, topLeft, bottomRight);
+}
+function isValidGridPositionLRoom(gridPosition, roomShape) {
+    const rectangles = L_ROOM_SHAPE_TO_RECTANGLES[roomShape];
+    if (rectangles === undefined) {
+        return false;
+    }
+    const [verticalTopLeft, verticalBottomRight, horizontalTopLeft, horizontalBottomRight,] = rectangles;
+    return (inRectangle(gridPosition, verticalTopLeft, verticalBottomRight) ||
+        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)".
+ */
+export function worldPositionToGridPosition(worldPos) {
+    const x = Math.round(worldPos.X / 40 - 2);
+    const y = Math.round(worldPos.Y / 40 - 4);
+    return Vector(x, y);
+}
+/**
+ * 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.
+ */
+export function worldPositionToGridPositionFast(worldPos) {
+    const x = worldPos.X / 40 - 2;
+    const y = worldPos.Y / 40 - 4;
+    return Vector(x, y);
+}
+//# sourceMappingURL=data:application/json;base64,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

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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