@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/util/parseTileMap.js

@@ -0,0 +1,185 @@
+import { findEntranceTile } from "./tilemap/findEntranceTile";
+import { getTileInfo } from "./getTileInfo";
+import { wallsFromContour } from "./tilemap/wallsFromContour";
+import { padTileMap } from "./tilemap/padTileMap";
+/**
+ * Parses the standard tilemap format into a format with the following meta data:
+ * - Walls
+ * - Door
+ * - Stairs
+ * @param tilemap
+ */
+export function parseTileMap(tilemap) {
+    var _a;
+    const contour = wallsFromContour(tilemap);
+    const wallInfo = new Walls(contour.rowWalls, contour.colWalls);
+    const entrance = findEntranceTile(tilemap);
+    const isEntrance = (x, y) => entrance != null && entrance.x === x && entrance.y === y;
+    padTileMap(tilemap);
+    const result = tilemap.map((row) => row.map(() => ({ type: "hidden" })));
+    let lowestTile;
+    let highestTile;
+    let hasDoor = false;
+    function applyHighLowTile(current) {
+        if (highestTile == null || current > highestTile) {
+            highestTile = current;
+        }
+        if (lowestTile == null || current < lowestTile) {
+            lowestTile = current;
+        }
+    }
+    for (let y = 0; y < tilemap.length; y++) {
+        for (let x = 0; x < tilemap[y].length; x++) {
+            const resultX = x;
+            const resultY = y;
+            const tileInfo = getTileInfo(tilemap, x, y);
+            const tileInfoBelow = getTileInfo(tilemap, x, y + 1);
+            const tileInfoRight = getTileInfo(tilemap, x + 1, y);
+            const wall = wallInfo.getWall(x, y);
+            if (wall != null) {
+                switch (wall.kind) {
+                    case "column": {
+                        const colWallHeightDiff = tileInfoBelow.height != null
+                            ? Math.abs(tileInfoBelow.height - wall.height)
+                            : 0;
+                        result[resultY][resultX] = {
+                            kind: "colWall",
+                            type: "wall",
+                            height: wall.height,
+                            hideBorder: colWallHeightDiff > 0,
+                        };
+                        break;
+                    }
+                    case "row": {
+                        const rowWallHeightDiff = tileInfoRight.height != null
+                            ? Math.abs(tileInfoRight.height - wall.height)
+                            : 0;
+                        result[resultY][resultX] = {
+                            kind: "rowWall",
+                            type: "wall",
+                            height: wall.height,
+                            hideBorder: tileInfoBelow.rowDoor || rowWallHeightDiff > 0,
+                        };
+                        break;
+                    }
+                    case "innerCorner": {
+                        result[resultY][resultX] = {
+                            kind: "innerCorner",
+                            type: "wall",
+                            height: wall.height,
+                        };
+                        break;
+                    }
+                    case "outerCorner": {
+                        result[resultY][resultX] = {
+                            kind: "outerCorner",
+                            type: "wall",
+                            height: wall.height,
+                        };
+                        break;
+                    }
+                }
+            }
+            if (!isEntrance(x, y) || hasDoor) {
+                if (tileInfo.stairs != null && tileInfo.height != null) {
+                    if (tileInfo.stairs.isCorner) {
+                        result[resultY][resultX] = {
+                            type: "stairCorner",
+                            kind: tileInfo.stairs.cornerType,
+                            z: tileInfo.height,
+                        };
+                    }
+                    else if (tileInfo.stairs.direction != null) {
+                        result[resultY][resultX] = {
+                            type: "stairs",
+                            kind: tileInfo.stairs.direction,
+                            z: tileInfo.height,
+                        };
+                    }
+                    applyHighLowTile(tileInfo.height);
+                }
+                else if (tileInfo.height != null) {
+                    result[resultY][resultX] = { type: "tile", z: tileInfo.height };
+                    applyHighLowTile(tileInfo.height);
+                }
+            }
+            else {
+                hasDoor = true;
+                result[resultY][resultX] = {
+                    type: "door",
+                    z: (_a = tileInfo.height) !== null && _a !== void 0 ? _a : 0,
+                    wall: wallInfo.getWall(x, y) != null,
+                };
+            }
+        }
+    }
+    let largestDiff = 0;
+    if (lowestTile != null && highestTile != null) {
+        largestDiff = highestTile - lowestTile;
+    }
+    const wallOffsets = {
+        x: 1,
+        y: 1,
+    };
+    return {
+        tilemap: result,
+        largestDiff,
+        highestTile: highestTile !== null && highestTile !== void 0 ? highestTile : 0,
+        wallOffsets,
+        // When the tilemap has a door, we offset the objects in the room by one in the x direction.
+        // This makes it so objects appear at the same position, for a room without a door
+        // and for a room with a door.
+        positionOffsets: { x: 0, y: 0 },
+        maskOffsets: { x: -wallOffsets.x, y: -wallOffsets.y },
+    };
+}
+class Walls {
+    constructor(rowWalls, colWalls) {
+        this._rowWalls = new Map();
+        this._colWalls = new Map();
+        rowWalls.forEach((info) => {
+            for (let y = info.startY; y <= info.endY; y++) {
+                this._rowWalls.set(`${info.x}_${y}`, info);
+            }
+        });
+        colWalls.forEach((info) => {
+            for (let x = info.startX; x <= info.endX; x++) {
+                this._colWalls.set(`${x}_${info.y}`, info);
+            }
+        });
+    }
+    getWall(x, y) {
+        const rightColWall = this._getColWall(x + 1, y);
+        const bottomRowWall = this._getRowWall(x, y + 1);
+        if (rightColWall != null && bottomRowWall != null) {
+            // This is a outer corner
+            return {
+                kind: "outerCorner",
+                height: Math.min(rightColWall.height, bottomRowWall.height),
+            };
+        }
+        const leftColWall = this._getColWall(x, y);
+        const topRowWall = this._getRowWall(x, y);
+        if (leftColWall != null && topRowWall != null) {
+            return {
+                kind: "innerCorner",
+                height: Math.min(leftColWall.height, topRowWall.height),
+            };
+        }
+        const rowWall = this._getRowWall(x, y);
+        if (rowWall != null)
+            return {
+                kind: "row",
+                height: rowWall.height,
+            };
+        const colWall = this._getColWall(x, y);
+        if (colWall != null)
+            return { kind: "column", height: colWall.height };
+    }
+    _getRowWall(x, y) {
+        return this._rowWalls.get(`${x}_${y}`);
+    }
+    _getColWall(x, y) {
+        return this._colWalls.get(`${x}_${y}`);
+    }
+}

package/dist-esm/util/parseTileMapString.js

@@ -0,0 +1,13 @@
+function toTileType(str) {
+    return str;
+}
+export function parseTileMapString(str) {
+    // Thanks @Fusion for this code to sanitize the tilemap string into a readable format.
+    str = str.replace(/\r/g, "\n");
+    str = str.replace(/ /g, "");
+    return str
+        .split("\n")
+        .map((row) => row.trim())
+        .filter((row) => row.length > 0)
+        .map((row) => row.split("").map(toTileType));
+}

package/dist-esm/util/tilemap/findEntranceTile.js

@@ -0,0 +1,21 @@
+import { getNumberOfTileType } from "../getTileInfo";
+export function findEntranceTile(tilemap) {
+    const firstFloorColumn = [];
+    tilemap.forEach((row) => {
+        let column = row.length + 1;
+        for (let x = 0; x < row.length; x++) {
+            if (getNumberOfTileType(row[x]) !== "x") {
+                column = x;
+                break;
+            }
+        }
+        firstFloorColumn.push(column);
+    });
+    for (let y = 1; y < firstFloorColumn.length - 1; y++) {
+        if (firstFloorColumn[y] <= firstFloorColumn[y - 1] - 1 &&
+            firstFloorColumn[y] <= firstFloorColumn[y + 1] - 1) {
+            return { x: firstFloorColumn[y], y };
+        }
+    }
+    return undefined;
+}

package/dist-esm/util/tilemap/getColumnWalls.js

@@ -0,0 +1,40 @@
+import { getTileInfo } from "../getTileInfo";
+export function getColumnWalls(tilemap) {
+    var _a;
+    const walls = [];
+    for (let y = 0; y < tilemap.length; y++) {
+        let wallEndX;
+        let wallStartX;
+        let height;
+        const flush = () => {
+            if (wallEndX != null && wallStartX != null) {
+                walls.push({
+                    startX: wallStartX,
+                    endX: wallEndX,
+                    y: y - 1,
+                    height: height !== null && height !== void 0 ? height : 0,
+                });
+            }
+            wallEndX = undefined;
+            wallStartX = undefined;
+            height = undefined;
+        };
+        for (let x = tilemap[y].length - 1; x >= 0; x--) {
+            const current = getTileInfo(tilemap, x, y);
+            if (current.colEdge && !current.rowDoor) {
+                if (wallEndX == null) {
+                    wallEndX = x;
+                }
+                wallStartX = x;
+                if (height == null || ((_a = current.height) !== null && _a !== void 0 ? _a : 0) < height) {
+                    height = current.height;
+                }
+            }
+            else {
+                flush();
+            }
+        }
+        flush();
+    }
+    return walls;
+}

package/dist-esm/util/tilemap/getRowWalls.js

@@ -0,0 +1,40 @@
+import { getTileInfo } from "../getTileInfo";
+export function getRowWalls(tilemap) {
+    var _a;
+    const walls = [];
+    for (let x = 0; x < tilemap[0].length; x++) {
+        let wallEndY;
+        let wallStartY;
+        let height;
+        const flush = () => {
+            if (wallEndY != null && wallStartY != null) {
+                walls.push({
+                    startY: wallStartY,
+                    endY: wallEndY,
+                    x: x - 1,
+                    height: height !== null && height !== void 0 ? height : 0,
+                });
+            }
+            wallEndY = undefined;
+            wallStartY = undefined;
+            height = undefined;
+        };
+        for (let y = tilemap.length - 1; y >= 0; y--) {
+            const current = getTileInfo(tilemap, x, y);
+            if (current.rowEdge && !current.rowDoor) {
+                if (wallEndY == null) {
+                    wallEndY = y;
+                }
+                wallStartY = y;
+                if (height == null || ((_a = current.height) !== null && _a !== void 0 ? _a : 0) < height) {
+                    height = current.height;
+                }
+            }
+            else {
+                flush();
+            }
+        }
+        flush();
+    }
+    return walls;
+}

package/dist-esm/util/tilemap/hasWallTiles.js

@@ -0,0 +1,6 @@
+import { parseTileMap } from "../parseTileMap";
+export function hasWallTiles(tilemap) {
+    if (tilemap.length === 0)
+        return false;
+    return parseTileMap(tilemap).tilemap.some((row) => row.some((tile) => tile.type === "wall"));
+}

package/dist-esm/util/tilemap/padTileMap.js

@@ -0,0 +1,21 @@
+export function padTileMap(tilemap) {
+    const firstRow = tilemap[0];
+    if (firstRow == null)
+        throw new Error("Invalid row");
+    let offsetY = 0;
+    let offsetX = 0;
+    if (firstRow.some((type) => type !== "x")) {
+        tilemap = [firstRow.map(() => "x"), ...tilemap];
+        offsetY += 1;
+    }
+    const nonPrefixedRows = tilemap.filter((row) => row[0] !== "x");
+    if (nonPrefixedRows.length > 1) {
+        tilemap = tilemap.map((row) => ["x", ...row]);
+        offsetX += 1;
+    }
+    return {
+        tilemap,
+        offsetX,
+        offsetY,
+    };
+}