@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/util/tilemap/getRowWalls.js

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

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

package/dist/util/tilemap/hasWallTiles.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasWallTiles = hasWallTiles;
+const parseTileMap_1 = require("../parseTileMap");
+function hasWallTiles(tilemap) {
+    if (tilemap.length === 0)
+        return false;
+    return (0, parseTileMap_1.parseTileMap)(tilemap).tilemap.some((row) => row.some((tile) => tile.type === "wall"));
+}

package/dist/util/tilemap/padTileMap.d.ts

@@ -0,0 +1,6 @@
+import { TileType } from "../../types/TileType";
+export declare function padTileMap(tilemap: TileType[][]): {
+    tilemap: TileType[][];
+    offsetX: number;
+    offsetY: number;
+};

package/dist/util/tilemap/padTileMap.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.padTileMap = padTileMap;
+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,
+    };
+}

package/dist/util/tilemap/traceWalls.d.ts

@@ -0,0 +1,25 @@
+import { TileType } from "../../types/TileType";
+export interface TracedWall {
+    x: number;
+    y: number;
+    /** 0 = +x, 1 = +y, 2 = -x, 3 = -y. */
+    direction: number;
+    length: number;
+    /** The stretch runs along the padding rather than along real floor. */
+    border: boolean;
+    leftTurn: boolean;
+    hidden: boolean;
+    /** The outline turns away from this stretch, so it is cut back on that side. */
+    cutLeft?: boolean;
+    cutRight?: boolean;
+    /** The next stretch is drawn, so this one meets it instead of ending open. */
+    joinsNext?: boolean;
+    /** Sits on an outer corner rather than an inner one. */
+    turnsOut?: boolean;
+}
+export interface TracedWalls {
+    walls: TracedWall[];
+    /** Height of the lowest floor the outline touches, per stretch. */
+    heights: number[];
+}
+export declare function traceWalls(tilemap: TileType[][]): TracedWalls;

package/dist/util/tilemap/traceWalls.js

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceWalls = traceWalls;
+const getTileInfo_1 = require("../getTileInfo");
+const findEntranceTile_1 = require("./findEntranceTile");
+/**
+ * Habbo does not look for wall edges tile by tile. It picks a single seed — the
+ * first floor tile going down the leftmost column — and walks the outline of the
+ * region that seed belongs to, turning at every corner until it arrives back
+ * where it started. Everything the walk never reaches stays open, which is why a
+ * room made of two disconnected floors only gets walls around one of them.
+ *
+ * The walk is run twice: once treating holes as outside the room, once treating
+ * only the padding as outside. Comparing the two is what tells Habbo which
+ * stretches sit next to a hole and have to be hidden.
+ */
+/** Anything below this is outside the room entirely. */
+const BLOCKED = -110;
+/** A gap in the floor: still inside the room's outline, but has no tile. */
+const HOLE = -100;
+const DIRECTION_VECTORS = [
+    { x: 1, y: 0 },
+    { x: 0, y: 1 },
+    { x: -1, y: 0 },
+    { x: 0, y: -1 },
+];
+const NORMAL_VECTORS = [
+    { x: 0, y: 1 },
+    { x: -1, y: 0 },
+    { x: 0, y: -1 },
+    { x: 1, y: 0 },
+];
+/** How far a single straight stretch of wall may run before we give up. */
+const MAX_RUN = 1000;
+/** How many corners one outline may have before we give up. */
+const MAX_CORNERS = 1000;
+class HeightMatrix {
+    constructor(tilemap) {
+        this.width = tilemap.reduce((max, row) => Math.max(max, row.length), 0);
+        this.height = tilemap.length;
+        this._values = tilemap.map((row) => {
+            const values = new Array(this.width).fill(BLOCKED);
+            row.forEach((tile, x) => {
+                const parsed = (0, getTileInfo_1.getNumberOfTileType)(tile);
+                values[x] = parsed === "x" ? BLOCKED : parsed;
+            });
+            return values;
+        });
+        this.updateBounds();
+    }
+    updateBounds() {
+        let minX = this.width;
+        let maxX = -1;
+        let minY = this.height;
+        let maxY = -1;
+        this._values.forEach((row, y) => row.forEach((value, x) => {
+            if (value <= HOLE)
+                return;
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+        }));
+        this.minX = minX;
+        this.maxX = maxX;
+        this.minY = minY;
+        this.maxY = maxY;
+    }
+    set(x, y, value) {
+        if (this._values[y] == null)
+            return;
+        this._values[y][x] = value;
+    }
+    get(x, y) {
+        var _a;
+        var _b;
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
+            return BLOCKED;
+        return (_b = (_a = this._values[y]) === null || _a === void 0 ? void 0 : _a[x]) !== null && _b !== void 0 ? _b : BLOCKED;
+    }
+    get hasFloor() {
+        return this.maxX >= 0;
+    }
+}
+/**
+ * Finds where the outline turns next. Each extractor runs along one side until
+ * either the floor ends (turn inwards) or the floor beside it drops away (turn
+ * outwards).
+ */
+const EXTRACTORS = [
+    // Running along +x, floor on the +y side.
+    (m, x, y, limit) => {
+        for (let step = 1; step < MAX_RUN; step++) {
+            if (m.get(x + step, y) > limit)
+                return { x: x + step - 1, y };
+            if (m.get(x + step, y + 1) <= limit)
+                return { x: x + step, y: y + 1 };
+        }
+        return undefined;
+    },
+    // Running along +y, floor on the -x side.
+    (m, x, y, limit) => {
+        for (let step = 1; step < MAX_RUN; step++) {
+            if (m.get(x, y + step) > limit)
+                return { x, y: y + step - 1 };
+            if (m.get(x - 1, y + step) <= limit)
+                return { x: x - 1, y: y + step };
+        }
+        return undefined;
+    },
+    // Running along -x, floor on the -y side.
+    (m, x, y, limit) => {
+        for (let step = 1; step < MAX_RUN; step++) {
+            if (m.get(x - step, y) > limit)
+                return { x: x - step + 1, y };
+            if (m.get(x - step, y - 1) <= limit)
+                return { x: x - step, y: y - 1 };
+        }
+        return undefined;
+    },
+    // Running along -y, floor on the +x side.
+    (m, x, y, limit) => {
+        for (let step = 1; step < MAX_RUN; step++) {
+            if (m.get(x, y - step) > limit)
+                return { x, y: y - step + 1 };
+            if (m.get(x + 1, y - step) <= limit)
+                return { x: x + 1, y: y - step };
+        }
+        return undefined;
+    },
+];
+function isDuplicate(walls, candidate) {
+    return walls.some((wall) => wall.x === candidate.x &&
+        wall.y === candidate.y &&
+        wall.direction === candidate.direction &&
+        wall.length === candidate.length &&
+        wall.border === candidate.border &&
+        wall.leftTurn === candidate.leftTurn);
+}
+/**
+ * @param treatHolesAsOutside walks the outline Habbo actually renders, where a
+ * gap in the floor ends the room. The other pass keeps holes on the inside, and
+ * comparing the two is what reveals which stretches border a hole.
+ */
+function traceOutline(matrix, seed, treatHolesAsOutside) {
+    const limit = treatHolesAsOutside ? HOLE : BLOCKED;
+    const walls = [];
+    let direction = 0;
+    let corner = { ...seed };
+    for (let guard = 0; guard < MAX_CORNERS; guard++) {
+        // Marks a stretch that runs outside the floor's bounding box. It does not
+        // stop the walk — it only tells hidePeninsulas where a chain begins.
+        const outside = corner.x < matrix.minX ||
+            corner.x > matrix.maxX ||
+            corner.y < matrix.minY ||
+            corner.y > matrix.maxY;
+        const next = EXTRACTORS[direction](matrix, corner.x, corner.y, limit);
+        if (next == null)
+            return walls;
+        const startedAt = direction;
+        let length = Math.abs(next.x - corner.x) + Math.abs(next.y - corner.y);
+        let leftTurn = false;
+        if (corner.x === next.x || corner.y === next.y) {
+            direction = (direction - 1 + EXTRACTORS.length) % EXTRACTORS.length;
+            length++;
+            leftTurn = true;
+        }
+        else {
+            direction = (direction + 1) % EXTRACTORS.length;
+            length--;
+        }
+        const wall = {
+            x: corner.x,
+            y: corner.y,
+            direction: startedAt,
+            length,
+            border: outside,
+            leftTurn,
+            hidden: false,
+        };
+        if (!isDuplicate(walls, wall))
+            walls.push(wall);
+        const closed = next.x === seed.x &&
+            next.y === seed.y &&
+            (next.x !== corner.x || next.y !== corner.y);
+        corner = next;
+        if (closed)
+            break;
+    }
+    return walls;
+}
+/**
+ * Hides stretches that only exist because the outline poked out into a
+ * one-tile-wide spur. Habbo counts left turns along a run of non-border walls;
+ * more than one outstanding left turn means the walk doubled back on itself.
+ */
+function hidePeninsulas(walls) {
+    let index = 0;
+    while (index < walls.length) {
+        const from = index;
+        let to = index;
+        let outstandingLeftTurns = 0;
+        let doubledBack = false;
+        while (index < walls.length && !walls[index].border) {
+            if (walls[index].leftTurn) {
+                outstandingLeftTurns++;
+            }
+            else if (outstandingLeftTurns > 0) {
+                outstandingLeftTurns--;
+            }
+            if (outstandingLeftTurns > 1)
+                doubledBack = true;
+            to = index;
+            index++;
+        }
+        if (doubledBack) {
+            for (let hide = from; hide <= to; hide++)
+                walls[hide].hidden = true;
+        }
+        index++;
+    }
+}
+/**
+ * Trims stretches that run alongside a hole. A stretch that starts over a hole
+ * is pushed forward to where the floor begins; one that runs into a hole is cut
+ * short; one that is over a hole the whole way is dropped.
+ */
+function trimAgainstHoles(matrix, walls) {
+    walls.forEach((wall) => {
+        if (wall.hidden)
+            return;
+        const along = DIRECTION_VECTORS[wall.direction];
+        const normal = NORMAL_VECTORS[wall.direction];
+        let leadingHoles = 0;
+        for (let step = 0; step < wall.length; step++) {
+            const height = matrix.get(wall.x + step * along.x - normal.x, wall.y + step * along.y - normal.y);
+            if (height === HOLE) {
+                if (step > 0 && leadingHoles === 0) {
+                    wall.length = step;
+                    return;
+                }
+                leadingHoles++;
+            }
+            else if (leadingHoles > 0) {
+                wall.x += leadingHoles * along.x;
+                wall.y += leadingHoles * along.y;
+                wall.length -= leadingHoles;
+                return;
+            }
+        }
+        if (leadingHoles === wall.length)
+            wall.hidden = true;
+    });
+}
+/** Lowest floor height the stretch runs against, which sets how tall it is. */
+function heightOf(matrix, wall) {
+    const along = DIRECTION_VECTORS[wall.direction];
+    const normal = NORMAL_VECTORS[wall.direction];
+    let lowest = -1;
+    for (let step = 0; step < wall.length; step++) {
+        const height = matrix.get(wall.x + step * along.x + normal.x, wall.y + step * along.y + normal.y);
+        if (height >= 0 && (height < lowest || lowest < 0))
+            lowest = height;
+    }
+    return lowest < 0 ? 0 : lowest;
+}
+/**
+ * The walk has to start just outside the room, on the tile above the first
+ * floor of the leftmost column that holds any.
+ */
+function findSeed(matrix) {
+    if (!matrix.hasFloor)
+        return undefined;
+    // Walk down the leftmost column that holds floor and stop one tile short of
+    // it, so the walk begins just outside the room.
+    for (let y = matrix.minY; y <= matrix.maxY; y++) {
+        if (matrix.get(matrix.minX, y) > HOLE)
+            return { x: matrix.minX, y: y - 1 };
+    }
+    return undefined;
+}
+const endPointOf = (wall) => {
+    const along = DIRECTION_VECTORS[wall.direction];
+    return {
+        x: wall.x + along.x * wall.length,
+        y: wall.y + along.y * wall.length,
+    };
+};
+/**
+ * Finds the stretch of the untrimmed outline that the given stretch sits on.
+ * Both have to be colinear, and the original has to span the whole of it.
+ */
+function findOriginal(from, to, original) {
+    const verticalRun = from.x === to.x;
+    const horizontalRun = from.y === to.y;
+    if (!verticalRun && !horizontalRun)
+        return -1;
+    const low = verticalRun ? Math.min(from.y, to.y) : Math.min(from.x, to.x);
+    const high = verticalRun ? Math.max(from.y, to.y) : Math.max(from.x, to.x);
+    return original.findIndex((wall) => {
+        const end = endPointOf(wall);
+        if (verticalRun) {
+            if (wall.x !== from.x || end.x !== from.x)
+                return false;
+            return Math.min(wall.y, end.y) <= low && high <= Math.max(wall.y, end.y);
+        }
+        if (wall.y !== from.y || end.y !== from.y)
+            return false;
+        return Math.min(wall.x, end.x) <= low && high <= Math.max(wall.x, end.x);
+    });
+}
+function hideOriginallyHidden(walls, original) {
+    walls.forEach((wall) => {
+        if (wall.hidden)
+            return;
+        const at = findOriginal({ x: wall.x, y: wall.y }, endPointOf(wall), original);
+        if (at < 0 || original[at].hidden)
+            wall.hidden = true;
+    });
+}
+/**
+ * A stretch is cut back on the side where the outline turns away from it. Habbo
+ * reads the turn from the untrimmed outline when the stretch can be found
+ * there, so a wall that got shortened by a hole still joins its neighbours the
+ * way the full room would.
+ */
+function resolveCuts(walls, original) {
+    walls.forEach((wall, index) => {
+        const source = findOriginal({ x: wall.x, y: wall.y }, endPointOf(wall), original) >= 0
+            ? original
+            : walls;
+        const at = source === original
+            ? findOriginal({ x: wall.x, y: wall.y }, endPointOf(wall), original)
+            : index;
+        const after = source[(at + 1) % source.length];
+        const before = source[(at - 1 + source.length) % source.length];
+        wall.cutRight = !walls[(index - 1 + walls.length) % walls.length].leftTurn;
+        wall.cutLeft = !wall.leftTurn;
+        wall.joinsNext = !walls[(index + 1) % walls.length].hidden;
+        wall.turnsOut =
+            (after.direction - wall.direction + 4) % 4 === 3 ||
+                (wall.direction - before.direction + 4) % 4 === 3;
+    });
+}
+function traceWalls(tilemap) {
+    const matrix = new HeightMatrix(tilemap);
+    const entrance = (0, findEntranceTile_1.findEntranceTile)(tilemap);
+    const entranceHeight = entrance ? matrix.get(entrance.x, entrance.y) : 0;
+    if (entrance) {
+        matrix.set(entrance.x, entrance.y, BLOCKED);
+        matrix.updateBounds();
+    }
+    const trace = () => {
+        const seed = findSeed(matrix);
+        if (seed == null)
+            return { walls: [], heights: [] };
+        const walls = traceOutline(matrix, seed, true);
+        const original = traceOutline(matrix, seed, false);
+        hidePeninsulas(original);
+        trimAgainstHoles(matrix, walls);
+        hideOriginallyHidden(walls, original);
+        resolveCuts(walls, original);
+        const visible = walls.filter((wall) => !wall.hidden);
+        return {
+            walls: visible,
+            heights: visible.map((wall) => heightOf(matrix, wall)),
+        };
+    };
+    const traced = trace();
+    if (entrance) {
+        matrix.set(entrance.x, entrance.y, entranceHeight);
+        matrix.updateBounds();
+    }
+    return traced;
+}

package/dist/util/tilemap/wallsFromContour.d.ts

@@ -0,0 +1,20 @@
+import { TileType } from "../../types/TileType";
+import { ColumnWall } from "./getColumnWalls";
+import { RowWall } from "./getRowWalls";
+/**
+ * Turns the traced outline into the row and column runs the renderer indexes by
+ * tile. The walk reports a corner, a direction and a length; which side of the
+ * room each direction belongs to follows from the normal it carries:
+ *
+ * - running along +x the floor lies below the walk, so the run covers the back
+ *   of the room — a column wall on the row it walks.
+ * - running along -y the floor lies to the right, so the run covers the left of
+ *   the room — a row wall on the column it walks.
+ *
+ * The other two directions come back along the near sides, which the floor
+ * itself hides, so they never reach the renderer.
+ */
+export declare function wallsFromContour(tilemap: TileType[][]): {
+    rowWalls: RowWall[];
+    colWalls: ColumnWall[];
+};

package/dist/util/tilemap/wallsFromContour.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wallsFromContour = wallsFromContour;
+const traceWalls_1 = require("./traceWalls");
+/**
+ * Turns the traced outline into the row and column runs the renderer indexes by
+ * tile. The walk reports a corner, a direction and a length; which side of the
+ * room each direction belongs to follows from the normal it carries:
+ *
+ * - running along +x the floor lies below the walk, so the run covers the back
+ *   of the room — a column wall on the row it walks.
+ * - running along -y the floor lies to the right, so the run covers the left of
+ *   the room — a row wall on the column it walks.
+ *
+ * The other two directions come back along the near sides, which the floor
+ * itself hides, so they never reach the renderer.
+ */
+function wallsFromContour(tilemap) {
+    const { walls, heights } = (0, traceWalls_1.traceWalls)(tilemap);
+    const rowWalls = [];
+    const colWalls = [];
+    walls.forEach((wall, index) => {
+        var _a;
+        const height = (_a = heights[index]) !== null && _a !== void 0 ? _a : 0;
+        switch (wall.direction) {
+            case 0: {
+                // Walks the empty row above the floor, covering the tiles it passes.
+                const startX = wall.x;
+                const endX = wall.x + wall.length - 1;
+                if (endX >= startX) {
+                    colWalls.push({ startX, endX, y: wall.y, height });
+                }
+                break;
+            }
+            case 3: {
+                // Walks up the empty column left of the floor, so the run ends where
+                // the corner is and starts `length` tiles above it.
+                const startY = wall.y - wall.length + 1;
+                const endY = wall.y;
+                if (endY >= startY) {
+                    rowWalls.push({ startY, endY, x: wall.x, height });
+                }
+                break;
+            }
+        }
+    });
+    return { rowWalls, colWalls };
+}

package/dist/util/traverseDOMTree.d.ts

@@ -0,0 +1,4 @@
+export declare function traverseDOMTree(node: Node, options: {
+    enter: (node: Node) => void;
+    exit: (node: Node) => void;
+}): void;

package/dist/util/traverseDOMTree.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseDOMTree = traverseDOMTree;
+function traverseDOMTree(node, options) {
+    options.enter(node);
+    node.childNodes.forEach((node) => traverseDOMTree(node, options));
+    options.exit(node);
+}

package/dist-esm/__mocks__/setupTests.js

@@ -0,0 +1,34 @@
+"use strict";
+global.Image = class {
+    constructor() {
+        this.width = 0;
+        this.height = 0;
+        setTimeout(() => {
+            if (this.onload)
+                this.onload();
+        }, 0);
+    }
+};
+// Mock PIXI.Texture.from to avoid WebGL requirement in tests
+jest.mock('pixi.js', () => {
+    const actual = jest.requireActual('pixi.js');
+    return {
+        ...actual,
+        Texture: {
+            ...actual.Texture,
+            from: (resource) => {
+                const source = {
+                    resource,
+                    resolution: 1,
+                    pixelWidth: resource.width || 2,
+                    pixelHeight: resource.height || 2,
+                    scaleMode: "linear",
+                };
+                return {
+                    source,
+                    orig: { x: 0, y: 0 },
+                };
+            },
+        },
+    };
+});

package/dist-esm/assets/IAssetBundle.js

@@ -0,0 +1 @@
+export {};

package/dist-esm/assets/LegacyAssetBundle.js

@@ -0,0 +1,25 @@
+export class LegacyAssetBundle {
+    constructor(_folderUrl) {
+        this._folderUrl = _folderUrl;
+        this._blobs = new Map();
+        this._strings = new Map();
+    }
+    async getBlob(name) {
+        const current = this._blobs.get(name);
+        if (current != null)
+            return current;
+        const imageUrl = `${this._folderUrl}/${name}`;
+        const blob = fetch(imageUrl).then((response) => response.blob());
+        this._blobs.set(name, blob);
+        return blob;
+    }
+    async getString(name) {
+        const current = this._strings.get(name);
+        if (current != null)
+            return current;
+        const imageUrl = `${this._folderUrl}/${name}`;
+        const string = fetch(imageUrl).then((response) => response.text());
+        this._strings.set(name, string);
+        return string;
+    }
+}