@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/util/getTileInfo.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumberOfTileType = getNumberOfTileType;
+exports.getTileInfo = getTileInfo;
+const isTile_1 = require("./isTile");
+const offsets = {
+    none: { x: 0, y: 0 },
+    top: { x: 0, y: -1 },
+    bottom: { x: 0, y: 1 },
+    left: { x: -1, y: 0 },
+    topLeft: { x: -1, y: -1 },
+    bottomLeft: { x: -1, y: 1 },
+    right: { x: 1, y: 0 },
+    topRight: { x: 1, y: -1 },
+    bottomRight: { x: 1, y: 1 },
+};
+function getNumberOfTileType(tileType) {
+    if (tileType === "x" || tileType == null)
+        return "x";
+    const parsedNumber = Number(tileType);
+    if (isNaN(parsedNumber)) {
+        const offset = 9;
+        return tileType.charCodeAt(0) - 96 + offset;
+    }
+    return parsedNumber;
+}
+const getTile = (tiles, x, y, offset = "none") => {
+    x = x + offsets[offset].x;
+    y = y + offsets[offset].y;
+    if (tiles[y] == null)
+        return "x";
+    if (tiles[y][x] == null)
+        return "x";
+    return getNumberOfTileType(tiles[y][x]);
+};
+function getTileInfo(tiles, x, y) {
+    const type = getTile(tiles, x, y);
+    const leftType = getTile(tiles, x - 1, y);
+    const topType = getTile(tiles, x, y - 1);
+    const topLeftDiagonalType = getTile(tiles, x - 1, y - 1);
+    const bottomLeftDiagonalType = getTile(tiles, x - 1, y + 1);
+    const bottomType = getTile(tiles, x, y + 1);
+    const rightType = getTile(tiles, x + 1, y);
+    // A row door can be identified if its surrounded by nothing to the left, top and bottom.
+    const rowDoor = topType === "x" &&
+        leftType === "x" &&
+        topLeftDiagonalType === "x" &&
+        bottomType === "x" &&
+        bottomLeftDiagonalType === "x" &&
+        (0, isTile_1.isTile)(rightType) &&
+        (0, isTile_1.isTile)(type);
+    const stairs = getStairs(tiles, x, y);
+    const baseHeight = (0, isTile_1.isTile)(type) ? type : undefined;
+    return {
+        rowEdge: leftType === "x" && (0, isTile_1.isTile)(type),
+        colEdge: topType === "x" && (0, isTile_1.isTile)(type),
+        innerEdge: topLeftDiagonalType === "x" &&
+            (0, isTile_1.isTile)(type) &&
+            (0, isTile_1.isTile)(topType) &&
+            (0, isTile_1.isTile)(leftType),
+        stairs: stairs,
+        height: baseHeight,
+        rowDoor: rowDoor,
+    };
+}
+/**
+ * Get stair information for the tile at the given x/y position.
+ */
+function getStairs(tiles, x, y) {
+    const type = getTile(tiles, x, y);
+    const topType = getTile(tiles, x, y, "top");
+    const leftType = getTile(tiles, x, y, "left");
+    const rightType = getTile(tiles, x, y, "right");
+    const topLeftType = getTile(tiles, x, y, "topLeft");
+    const bottomLeftType = getTile(tiles, x, y, "bottomLeft");
+    const topRightType = getTile(tiles, x, y, "topRight");
+    if ((0, isTile_1.isTile)(topType) && (0, isTile_1.isTile)(type)) {
+        const diff = Number(topType) - Number(type);
+        if (diff === 1) {
+            return { direction: 0 };
+        }
+    }
+    if ((0, isTile_1.isTile)(leftType) && (0, isTile_1.isTile)(type)) {
+        const diff = Number(leftType) - Number(type);
+        if (diff === 1) {
+            return { direction: 2 };
+        }
+    }
+    if ((0, isTile_1.isTile)(bottomLeftType) && (0, isTile_1.isTile)(type) && (leftType === 'x' || Number(leftType) <= Number(type))) {
+        const diff = Number(bottomLeftType) - Number(type);
+        if (diff === 1) {
+            return { cornerType: 'left', isCorner: true };
+        }
+    }
+    if ((0, isTile_1.isTile)(topRightType) && (0, isTile_1.isTile)(type) && (rightType === 'x' || Number(rightType) <= Number(type))) {
+        const diff = Number(topRightType) - Number(type);
+        if (diff === 1) {
+            return { cornerType: 'right', isCorner: true };
+        }
+    }
+    if ((0, isTile_1.isTile)(topLeftType) && (0, isTile_1.isTile)(type) && (leftType === 'x' || Number(leftType) <= Number(type))) {
+        const diff = Number(topLeftType) - Number(type);
+        if (diff === 1) {
+            return { cornerType: 'front', isCorner: true };
+        }
+    }
+}

package/dist/util/getZOrder.d.ts

@@ -0,0 +1 @@
+export declare function getZOrder(x: number, y: number, z: number): number;

package/dist/util/getZOrder.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZOrder = getZOrder;
+function getZOrder(x, y, z) {
+    return x * 1000 + y * 1000 + z;
+}

package/dist/util/isPointInside.d.ts

@@ -0,0 +1 @@
+export declare function isPointInside(point: [number, number], vs: [number, number][]): boolean;

package/dist/util/isPointInside.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPointInside = isPointInside;
+function isPointInside(point, vs) {
+    const x = point[0];
+    const y = point[1];
+    let inside = false;
+    for (let i = 0, j = vs.length - 1; i < vs.length; j = i++) {
+        const xi = vs[i][0];
+        const yi = vs[i][1];
+        const xj = vs[j][0];
+        const yj = vs[j][1];
+        const intersect = yi > y != yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}

package/dist/util/isSetEqual.d.ts

@@ -0,0 +1 @@
+export declare function isSetEqual<T>(as: Set<T>, bs: Set<T>): boolean;

package/dist/util/isSetEqual.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSetEqual = isSetEqual;
+function isSetEqual(as, bs) {
+    if (as.size !== bs.size)
+        return false;
+    for (const a of as)
+        if (!bs.has(a))
+            return false;
+    return true;
+}

package/dist/util/isTile.d.ts

@@ -0,0 +1 @@
+export declare const isTile: (type: number | "x") => type is number;

package/dist/util/isTile.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTile = void 0;
+const isTile = (type) => !isNaN(Number(type));
+exports.isTile = isTile;

package/dist/util/loadImageFromBlob.d.ts

@@ -0,0 +1 @@
+export declare function loadImageFromBlob(blob: Blob): Promise<string>;

package/dist/util/loadImageFromBlob.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImageFromBlob = loadImageFromBlob;
+async function loadImageFromBlob(blob) {
+    const reader = new FileReader();
+    const url = await new Promise((resolve) => {
+        reader.readAsDataURL(blob);
+        reader.onloadend = () => {
+            resolve(reader.result);
+        };
+    });
+    return url;
+}

package/dist/util/loadImageFromUrl.d.ts

@@ -0,0 +1 @@
+export declare function loadImageFromUrl(imageUrl: string): Promise<HTMLImageElement>;

package/dist/util/loadImageFromUrl.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImageFromUrl = loadImageFromUrl;
+async function loadImageFromUrl(imageUrl) {
+    const image = new Image();
+    image.src = imageUrl;
+    await new Promise((resolve, reject) => {
+        image.onload = () => {
+            resolve({ width: image.width, height: image.height });
+        };
+        image.onerror = (value) => reject(value);
+    });
+    return image;
+}

package/dist/util/loadRoomTexture.d.ts

@@ -0,0 +1,2 @@
+import * as PIXI from "pixi.js";
+export declare function loadRoomTexture(url: string): Promise<PIXI.Texture>;

package/dist/util/loadRoomTexture.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRoomTexture = loadRoomTexture;
+const PIXI = __importStar(require("pixi.js"));
+const applyTextureProperties_1 = require("./applyTextureProperties");
+async function loadRoomTexture(url) {
+    const image = new Image();
+    image.crossOrigin = "anonymous";
+    image.src = url;
+    await new Promise((resolve) => {
+        image.onload = () => {
+            resolve();
+        };
+    });
+    const texture = PIXI.Texture.from(image);
+    (0, applyTextureProperties_1.applyTextureProperties)(texture);
+    return texture;
+}

package/dist/util/mock.d.ts

@@ -0,0 +1 @@
+export declare function mock<T>(value: Partial<T>): T;

package/dist/util/mock.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mock = mock;
+function mock(value) {
+    return value;
+}

package/dist/util/notNullOrUndefined.d.ts

@@ -0,0 +1 @@
+export declare function notNullOrUndefined<T>(value: T | null | undefined): value is T;

package/dist/util/notNullOrUndefined.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notNullOrUndefined = notNullOrUndefined;
+function notNullOrUndefined(value) {
+    return value != null;
+}

package/dist/util/parseTileMap.d.ts

@@ -0,0 +1,49 @@
+import { TileType } from "../types/TileType";
+export type ParsedTileWall = {
+    type: "wall";
+    kind: "colWall" | "rowWall" | "innerCorner" | "outerCorner";
+    height: number;
+    hideBorder?: boolean;
+};
+export type ParsedTileType = ParsedTileWall | {
+    type: "tile";
+    z: number;
+} | {
+    type: "hidden";
+} | {
+    type: "stairs";
+    kind: 0 | 2;
+    z: number;
+} | {
+    type: "stairCorner";
+    kind: "left" | "right" | "front";
+    z: number;
+} | {
+    type: "door";
+    z: number;
+    wall: boolean;
+};
+/**
+ * Parses the standard tilemap format into a format with the following meta data:
+ * - Walls
+ * - Door
+ * - Stairs
+ * @param tilemap
+ */
+export declare function parseTileMap(tilemap: TileType[][]): {
+    tilemap: ParsedTileType[][];
+    largestDiff: number;
+    highestTile: number;
+    wallOffsets: {
+        x: number;
+        y: number;
+    };
+    positionOffsets: {
+        x: number;
+        y: number;
+    };
+    maskOffsets: {
+        x: number;
+        y: number;
+    };
+};

package/dist/util/parseTileMap.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTileMap = parseTileMap;
+const findEntranceTile_1 = require("./tilemap/findEntranceTile");
+const getTileInfo_1 = require("./getTileInfo");
+const wallsFromContour_1 = require("./tilemap/wallsFromContour");
+const padTileMap_1 = require("./tilemap/padTileMap");
+/**
+ * Parses the standard tilemap format into a format with the following meta data:
+ * - Walls
+ * - Door
+ * - Stairs
+ * @param tilemap
+ */
+function parseTileMap(tilemap) {
+    var _a;
+    const contour = (0, wallsFromContour_1.wallsFromContour)(tilemap);
+    const wallInfo = new Walls(contour.rowWalls, contour.colWalls);
+    const entrance = (0, findEntranceTile_1.findEntranceTile)(tilemap);
+    const isEntrance = (x, y) => entrance != null && entrance.x === x && entrance.y === y;
+    (0, padTileMap_1.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 = (0, getTileInfo_1.getTileInfo)(tilemap, x, y);
+            const tileInfoBelow = (0, getTileInfo_1.getTileInfo)(tilemap, x, y + 1);
+            const tileInfoRight = (0, getTileInfo_1.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/util/parseTileMapString.d.ts

@@ -0,0 +1,2 @@
+import { TileType } from "../types/TileType";
+export declare function parseTileMapString(str: string): TileType[][];

package/dist/util/parseTileMapString.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTileMapString = parseTileMapString;
+function toTileType(str) {
+    return str;
+}
+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/util/tilemap/findEntranceTile.d.ts

@@ -0,0 +1,5 @@
+import { TileType } from "../../types/TileType";
+export declare function findEntranceTile(tilemap: TileType[][]): {
+    x: number;
+    y: number;
+} | undefined;

package/dist/util/tilemap/findEntranceTile.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEntranceTile = findEntranceTile;
+const getTileInfo_1 = require("../getTileInfo");
+function findEntranceTile(tilemap) {
+    const firstFloorColumn = [];
+    tilemap.forEach((row) => {
+        let column = row.length + 1;
+        for (let x = 0; x < row.length; x++) {
+            if ((0, getTileInfo_1.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/util/tilemap/getColumnWalls.d.ts

@@ -0,0 +1,8 @@
+import { TileType } from "../../types/TileType";
+export type ColumnWall = {
+    startX: number;
+    endX: number;
+    y: number;
+    height: number;
+};
+export declare function getColumnWalls(tilemap: TileType[][]): ColumnWall[];

package/dist/util/tilemap/getColumnWalls.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnWalls = getColumnWalls;
+const getTileInfo_1 = require("../getTileInfo");
+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 = (0, getTileInfo_1.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/util/tilemap/getRowWalls.d.ts

@@ -0,0 +1,8 @@
+import { TileType } from "../../types/TileType";
+export type RowWall = {
+    startY: number;
+    endY: number;
+    x: number;
+    height: number;
+};
+export declare function getRowWalls(tilemap: TileType[][]): RowWall[];