isaacscript-common 3.17.0 → 4.0.2

package/functions/roomGrid.ts

@@ -0,0 +1,109 @@
+import { RoomShape } from "isaac-typescript-definitions";
+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: int, y: int): Vector {
+  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: int,
+  roomShape: RoomShape,
+): Vector {
+  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: Vector): Vector {
+  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: Vector,
+  roomShape: RoomShape,
+): boolean {
+  return isLRoom(roomShape)
+    ? isValidGridPositionLRoom(gridPosition, roomShape)
+    : isValidGridPositionNormal(gridPosition, roomShape);
+}
+
+function isValidGridPositionNormal(gridPosition: Vector, roomShape: RoomShape) {
+  const topLeft = getRoomShapeTopLeftPosition(roomShape);
+  const bottomRight = getRoomShapeBottomRightPosition(roomShape);
+  return inRectangle(gridPosition, topLeft, bottomRight);
+}
+
+function isValidGridPositionLRoom(gridPosition: Vector, roomShape: 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: Vector): Vector {
+  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: Vector): Vector {
+  const x = worldPos.X / 40 - 2;
+  const y = worldPos.Y / 40 - 4;
+  return Vector(x, y);
+}

package/functions/roomShape.ts

@@ -0,0 +1,80 @@
+import { DoorSlot, RoomShape } from "isaac-typescript-definitions";
+import { ROOM_SHAPE_BOUNDS } from "../objects/roomShapeBounds";
+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";
+
+/**
+ * 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: RoomShape,
+  doorSlot: DoorSlot,
+): int | undefined {
+  const doorSlotToGridIndexMap =
+    ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA[roomShape];
+  return doorSlotToGridIndexMap.get(doorSlot);
+}
+
+/**
+ * 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 getRoomShapeBottomRightPosition(roomShape: RoomShape): Vector {
+  return ROOM_SHAPE_TO_BOTTOM_RIGHT_POSITION[roomShape];
+}
+
+/**
+ * Helper function to get the bounds of a room shape, which are a box representing its contents.
+ * This does not include the tiles that the walls are on. L rooms use the same bounds as a 2x2 room.
+ */
+export function getRoomShapeBounds(roomShape: RoomShape): Vector {
+  return ROOM_SHAPE_BOUNDS[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: RoomShape): Vector {
+  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: RoomShape): Vector {
+  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: RoomShape): int {
+  return ROOM_SHAPE_VOLUMES[roomShape];
+}
+
+export function getRoomShapeWidth(roomShape: RoomShape): int {
+  return ROOM_SHAPE_TO_GRID_WIDTH[roomShape];
+}
+
+export function isLRoom(roomShape: RoomShape): boolean {
+  return L_ROOM_SHAPES_SET.has(roomShape);
+}

package/functions/rooms.lua

@@ -32,7 +32,6 @@ local NUM_DIMENSIONS = ____constants.NUM_DIMENSIONS
 local ____roomShapeToDoorSlotsToGridIndexDelta = require("objects.roomShapeToDoorSlotsToGridIndexDelta")
 local ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA = ____roomShapeToDoorSlotsToGridIndexDelta.ROOM_SHAPE_TO_DOOR_SLOTS_TO_GRID_INDEX_DELTA
 local ____roomTypeNames = require("objects.roomTypeNames")
-local DEFAULT_ROOM_TYPE_NAME = ____roomTypeNames.DEFAULT_ROOM_TYPE_NAME
 local ROOM_TYPE_NAMES = ____roomTypeNames.ROOM_TYPE_NAMES
 local ____mineShaftRoomSubTypesSet = require("sets.mineShaftRoomSubTypesSet")
 local MINE_SHAFT_ROOM_SUB_TYPE_SET = ____mineShaftRoomSubTypesSet.MINE_SHAFT_ROOM_SUB_TYPE_SET
@@ -208,8 +207,7 @@ end
 -- 
 -- For example, `RoomType.TREASURE` will return "Treasure Room".
 function ____exports.getRoomTypeName(self, roomType)
-    local roomTypeName = ROOM_TYPE_NAMES[roomType]
-    return roomTypeName == nil and DEFAULT_ROOM_TYPE_NAME or roomTypeName
+    return ROOM_TYPE_NAMES[roomType]
 end
 --- 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