@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,376 @@
+import { getNumberOfTileType } from "../getTileInfo";
+import { findEntranceTile } from "./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 = 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;
+    });
+}
+export function traceWalls(tilemap) {
+    const matrix = new HeightMatrix(tilemap);
+    const entrance = 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-esm/util/tilemap/wallsFromContour.js

@@ -0,0 +1,45 @@
+import { traceWalls } from "./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.
+ */
+export function wallsFromContour(tilemap) {
+    const { walls, heights } = 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-esm/util/traverseDOMTree.js

@@ -0,0 +1,5 @@
+export function traverseDOMTree(node, options) {
+    options.enter(node);
+    node.childNodes.forEach((node) => traverseDOMTree(node, options));
+    options.exit(node);
+}

package/package.json

@@ -1,6 +1,105 @@
 {
   "name": "@wiredsnippets/wsproom",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2.0.0",
+  "main": "dist/index.js",
+  "license": "LGPL-3.0-or-later",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/WiredSnippets/wsproom.git"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.15.47",
+    "@swc/jest": "^0.2.39",
+    "@types/axios": "^0.14.0",
+    "@types/bluebird": "^3.5.33",
+    "@types/bytebuffer": "^5.0.42",
+    "@types/glob": "^7.1.3",
+    "@types/jest": "^29.5.14",
+    "@types/jsdom": "^16.2.6",
+    "@types/node": "^14.14.13",
+    "@types/node-fetch": "^2.5.7",
+    "@types/rbush": "^4.0.0",
+    "@types/react": "^16.9.56",
+    "@types/tween.js": "^18.6.1",
+    "@types/ws": "^7.4.0",
+    "@types/xml2js": "^0.4.5",
+    "@typescript-eslint/eslint-plugin": "^4.12.0",
+    "@typescript-eslint/parser": "^4.12.0",
+    "buffer": "^6.0.3",
+    "eslint": "^7.17.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-standard": "^16.0.2",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-react": "^7.22.0",
+    "jest": "^29.7.0",
+    "jest-canvas-mock": "^2.5.2",
+    "jest-environment-jsdom": "^29.7.0",
+    "pixi.js": "^8.6.6",
+    "prettier": "2.2.1",
+    "process": "^0.11.10",
+    "punycode": "^1.4.1",
+    "querystring-es3": "^0.2.1",
+    "request": "^2.88.2",
+    "stream-browserify": "^3.0.0",
+    "string_decoder": "^1.3.0",
+    "ts-jest": "^29.4.9",
+    "ts-mockito": "^2.6.1",
+    "ts-node": "^9.0.0",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@gizeta/swf-reader": "^1.0.0",
+    "@timohausmann/quadtree-js": "^1.2.3",
+    "@tweenjs/tween.js": "^25.0.0",
+    "axios": "^0.21.1",
+    "bin-pack": "^1.0.2",
+    "bluebird": "^3.7.2",
+    "bytebuffer": "^5.0.1",
+    "chalk": "^4.1.0",
+    "detect-edges": "^1.0.1",
+    "easystarjs": "^0.4.4",
+    "events": "^3.2.0",
+    "frame-stream": "2.0.3",
+    "glob": "^11.0.1",
+    "ink": "^5.1.0",
+    "jsdom": "^16.4.0",
+    "jszip": "^3.5.0",
+    "node-fetch": "^2.6.1",
+    "parcel": "^2.9.0",
+    "pixi-stats": "5.1.7",
+    "quadtree-lib": "^1.0.9",
+    "rbush": "^4.0.1",
+    "react": "^18.2.0",
+    "rxjs": "^6.6.3",
+    "stream": "0.0.2",
+    "swf-extract": "^1.1.0",
+    "timers": "^0.1.1",
+    "timers-browserify": "^2.0.11",
+    "tween.js": "^16.6.0",
+    "ws": "^7.4.2",
+    "xml2js": "^0.4.23",
+    "yargs": "16.2.0"
+  },
+  "peerDependencies": {
+    "pixi.js": "^8.6.6"
+  },
+  "bin": {
+    "wsproom": "dist/cli/index.js"
+  },
+  "files": [
+    "/dist",
+    "/dist-esm"
+  ],
+  "module": "dist-esm/index.js",
+  "scripts": {
+    "start": "parcel public/index.html --no-cache",
+    "dev": "tsc --watch",
+    "dump": "tsx src/cli/index.ts dump",
+    "test": "jest",
+    "build": "rm -rf dist dist-esm && tsc && tsc -p tsconfig.esm.json",
+    "storybook": "cd storybook && yarn storybook"
+  }
 }