@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/objects/room/util/LegacyWallGeometry.js

@@ -0,0 +1,89 @@
+export class LegacyWallGeometry {
+    constructor(_heightmap) {
+        this._heightmap = _heightmap;
+        this._width = _heightmap[0].length;
+        this._height = _heightmap.length;
+        this._scale = 64;
+        this._wallTop = getWallTop(_heightmap);
+    }
+    getLocation(roomX, roomY, offsetX, offsetY, wall) {
+        let rX = roomX;
+        let rY = roomY;
+        let rZ = this.getHeight(roomX, roomY);
+        if (wall == LegacyWallGeometry.LEFT_WALL) {
+            rX = rX + (offsetX / (this._scale / 2) - 0.5);
+            rY = rY + 0.5;
+            rZ = rZ - (offsetY - offsetX / 2) / (this._scale / 2);
+        }
+        else {
+            rY = rY + ((this._scale / 2 - offsetX) / (this._scale / 2) - 0.5);
+            rX = rX + 0.5;
+            rZ = rZ - (offsetY - (this._scale / 2 - offsetX) / 2) / (this._scale / 2);
+        }
+        return {
+            x: rX,
+            y: rY,
+            z: rZ,
+        };
+    }
+    /** Inverse of `getLocation`, ported from nitro's `getOldLocation`. */
+    getSpot(x, y, z, wall) {
+        const half = this._scale / 2;
+        if (wall == LegacyWallGeometry.RIGHT_WALL) {
+            const roomX = Math.floor(x - 0.5);
+            const roomY = Math.floor(y + 0.5);
+            const offsetX = half - (y - roomY + 0.5) * half;
+            const offsetY = (this.getHeight(roomX, roomY) - z) * half + (half - offsetX) / 2;
+            return { roomX, roomY, offsetX, offsetY };
+        }
+        const roomX = Math.floor(x + 0.5);
+        const roomY = Math.floor(y - 0.5);
+        const offsetX = (x + 0.5 - roomX) * half;
+        const offsetY = (this.getHeight(roomX, roomY) - z) * half + offsetX / 2;
+        return { roomX, roomY, offsetX, offsetY };
+    }
+    /**
+     * Height of the tile a wall item hangs on. Anywhere there is no floor — a wall
+     * or a gap in the model — Habbo answers with the height of the wall top, not
+     * zero, and wall item offsets are measured against that.
+     */
+    getHeight(x, y) {
+        if (x < 0 || x >= this._width || y < 0 || y >= this._height)
+            return this._wallTop;
+        const row = this._heightmap[y];
+        if (row == null)
+            return this._wallTop;
+        const cell = row[x];
+        if (cell == null)
+            return this._wallTop;
+        switch (cell.type) {
+            case "stairs":
+            case "stairCorner":
+            case "door":
+            case "tile":
+                return cell.z;
+        }
+        return this._wallTop;
+    }
+}
+LegacyWallGeometry.RIGHT_WALL = "l";
+LegacyWallGeometry.LEFT_WALL = "r";
+/** Habbo caps how much taller than the floor a wall may grow. */
+LegacyWallGeometry.MAX_WALL_ADDITIONAL_HEIGHT = 20;
+/** Habbo's default wall height, in tiles. */
+LegacyWallGeometry.WALL_HEIGHT = 3.6;
+function getWallTop(heightmap) {
+    let highest = 0;
+    heightmap.forEach((row) => row.forEach((cell) => {
+        switch (cell.type) {
+            case "stairs":
+            case "stairCorner":
+            case "door":
+            case "tile":
+                if (cell.z > highest)
+                    highest = cell.z;
+        }
+    }));
+    return (Math.min(LegacyWallGeometry.MAX_WALL_ADDITIONAL_HEIGHT, highest) +
+        LegacyWallGeometry.WALL_HEIGHT);
+}

package/dist-esm/objects/room/util/createPlaneMatrix.js

@@ -0,0 +1,27 @@
+import * as PIXI from "pixi.js";
+export function createPlaneMatrix(points, { width, height, x, y, }) {
+    let diffDxCx = points.d.x - points.c.x;
+    let diffDyCy = points.d.y - points.c.y;
+    let diffBxCx = points.b.x - points.c.x;
+    let diffByCy = points.b.y - points.c.y;
+    if (Math.abs(diffBxCx - width) <= 1) {
+        diffBxCx = width;
+    }
+    if (Math.abs(diffByCy - width) <= 1) {
+        diffByCy = width;
+    }
+    if (Math.abs(diffDxCx - height) <= 1) {
+        diffDxCx = height;
+    }
+    if (Math.abs(diffDyCy - height) <= 1) {
+        diffDyCy = height;
+    }
+    const a = diffBxCx / width;
+    const b = diffByCy / width;
+    const c = diffDxCx / height;
+    const d = diffDyCy / height;
+    const baseX = x + points.c.x;
+    const baseY = y + points.c.y;
+    const matrix = new PIXI.Matrix(a, b, c, d, baseX, baseY);
+    return matrix;
+}

package/dist-esm/objects/room/util/getMaskId.js

@@ -0,0 +1,10 @@
+export function getMaskId(direction, roomX, roomY) {
+    switch (direction) {
+        case 2:
+        case 6:
+            return `x_${roomX}`;
+        case 0:
+        case 4:
+            return `y_${roomY}`;
+    }
+}

package/dist-esm/objects/room/util/getPosition.js

@@ -0,0 +1,11 @@
+export function getPosition(roomX, roomY, roomZ, wallOffsets) {
+    roomX = roomX + wallOffsets.x;
+    roomY = roomY + wallOffsets.y;
+    const base = 32;
+    const xPos = roomX * base - roomY * base;
+    const yPos = roomX * (base / 2) + roomY * (base / 2);
+    return {
+        x: xPos,
+        y: yPos - roomZ * 32,
+    };
+}

package/dist-esm/objects/room/util/getTileColors.js

@@ -0,0 +1,30 @@
+export function getTileColors(color) {
+    const tileTint = fromHex(color);
+    const borderLeftTint = fromHex(adjust(color, -20));
+    const borderRightTint = fromHex(adjust(color, -40));
+    return {
+        tileTint,
+        borderLeftTint,
+        borderRightTint,
+    };
+}
+export function getWallColors(color) {
+    const leftTint = fromHex(color);
+    const topTint = fromHex(adjust(color, -103));
+    const rightTint = fromHex(adjust(color, -52));
+    return {
+        topTint,
+        leftTint,
+        rightTint,
+    };
+}
+function fromHex(color) {
+    return parseInt(color.replace("#", "0x"), 16);
+}
+function adjust(color, amount) {
+    return ("#" +
+        color
+            .replace(/^#/, "")
+            .replace(/../g, (color) => ("0" +
+            Math.min(255, Math.max(0, parseInt(color, 16) + amount)).toString(16)).substr(-2)));
+}

package/dist-esm/objects/room/util/getTileMapBounds.js

@@ -0,0 +1,37 @@
+import { getPosition } from "./getPosition";
+export function getTileMapBounds(tilemap, wallOffsets) {
+    let minX;
+    let minY;
+    let maxX;
+    let maxY;
+    tilemap.forEach((row, y) => {
+        row.forEach((column, x) => {
+            if (column.type !== "tile")
+                return;
+            const position = getPosition(x, y, column.z, wallOffsets);
+            const localMaxX = position.x + 64;
+            const localMaxY = position.y + 32;
+            if (minX == null || position.x < minX) {
+                minX = position.x;
+            }
+            if (minY == null || position.y < minY) {
+                minY = position.y;
+            }
+            if (maxX == null || localMaxX > maxX) {
+                maxX = localMaxX;
+            }
+            if (maxY == null || localMaxY > maxY) {
+                maxY = localMaxY;
+            }
+        });
+    });
+    if (minX == null || minY == null || maxX == null || maxY == null) {
+        throw new Error("Couldnt figure out dimensions");
+    }
+    return {
+        minX,
+        minY: minY - 32,
+        maxX,
+        maxY: maxY - 32,
+    };
+}

package/dist-esm/objects/room/util/getTilePosition.js

@@ -0,0 +1,6 @@
+import * as PIXI from "pixi.js";
+export function getTilePosition(roomX, roomY) {
+    const xEven = roomX % 2 === 0;
+    const yEven = roomY % 2 === 0;
+    return new PIXI.Point(xEven ? 0 : 32, yEven ? 32 : 0);
+}

package/dist-esm/objects/room/util/getTilePositionForTile.js

@@ -0,0 +1,8 @@
+import { getTilePosition } from "./getTilePosition";
+export function getTilePositionForTile(roomX, roomY) {
+    return {
+        top: getTilePosition(roomX, roomY),
+        left: getTilePosition(roomX, roomY + 1),
+        right: getTilePosition(roomX + 1, roomY),
+    };
+}

package/dist-esm/types/RoomPosition.js

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

package/dist-esm/types/TileType.js

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

package/dist-esm/types/WallPosition.js

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

package/dist-esm/types/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist-esm/util/applyTextureProperties.js

@@ -0,0 +1,3 @@
+export function applyTextureProperties(texture) {
+    texture.source.scaleMode = "nearest";
+}

package/dist-esm/util/associateBy.js

@@ -0,0 +1,8 @@
+export function associateBy(arr, getKey) {
+    const map = new Map();
+    arr.forEach((value) => {
+        const key = getKey(value);
+        map.set(key, value);
+    });
+    return map;
+}

package/dist-esm/util/furnitureDataTransformers.js

@@ -0,0 +1,53 @@
+export function transformFirst(transform, defaultValue) {
+    return (arr) => {
+        const value = arr[0];
+        if (value === "")
+            return defaultValue;
+        return transform(value);
+    };
+}
+function booleanTransform(value) {
+    return value === "1";
+}
+function numberTransform(value) {
+    return Number(value);
+}
+function stringTransform(value) {
+    return value;
+}
+export function formatFurnitureData(data) {
+    const keys = Object.keys(data);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const obj = {};
+    keys.forEach((key) => {
+        const castedKey = key;
+        const transformer = furnitureDataTransformers[castedKey];
+        if (transformer != null) {
+            const value = data[key];
+            obj[castedKey] = transformer(value);
+        }
+    });
+    return obj;
+}
+export const furnitureDataTransformers = {
+    adurl: transformFirst(stringTransform, undefined),
+    bc: transformFirst(booleanTransform, false),
+    buyout: transformFirst(booleanTransform, false),
+    canlayon: transformFirst(booleanTransform, false),
+    cansiton: transformFirst(booleanTransform, false),
+    canstandon: transformFirst(booleanTransform, false),
+    defaultdir: transformFirst(numberTransform, 0),
+    description: transformFirst(stringTransform, undefined),
+    environment: transformFirst(stringTransform, undefined),
+    excludeddynamic: transformFirst(booleanTransform, false),
+    furniline: transformFirst(stringTransform, undefined),
+    name: transformFirst(stringTransform, undefined),
+    offerid: transformFirst(numberTransform, undefined),
+    rare: transformFirst(booleanTransform, false),
+    rentbuyout: transformFirst(booleanTransform, false),
+    rentofferid: transformFirst(numberTransform, undefined),
+    revision: transformFirst(numberTransform, undefined),
+    specialtype: transformFirst(numberTransform, undefined),
+    xdim: transformFirst(numberTransform, undefined),
+    ydim: transformFirst(numberTransform, undefined),
+};

package/dist-esm/util/getIntFromHex.js

@@ -0,0 +1,3 @@
+export function getIntFromHex(str) {
+    return parseInt(str.replace(/^#/, ""), 16);
+}

package/dist-esm/util/getNumberFromAttribute.js

@@ -0,0 +1,8 @@
+export function getNumberFromAttribute(value) {
+    if (value == null)
+        return;
+    const numberValue = Number(value);
+    if (isNaN(numberValue))
+        return;
+    return numberValue;
+}

package/dist-esm/util/getTileInfo.js

@@ -0,0 +1,103 @@
+import { isTile } from "./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 },
+};
+export 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]);
+};
+export 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" &&
+        isTile(rightType) &&
+        isTile(type);
+    const stairs = getStairs(tiles, x, y);
+    const baseHeight = isTile(type) ? type : undefined;
+    return {
+        rowEdge: leftType === "x" && isTile(type),
+        colEdge: topType === "x" && isTile(type),
+        innerEdge: topLeftDiagonalType === "x" &&
+            isTile(type) &&
+            isTile(topType) &&
+            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 (isTile(topType) && isTile(type)) {
+        const diff = Number(topType) - Number(type);
+        if (diff === 1) {
+            return { direction: 0 };
+        }
+    }
+    if (isTile(leftType) && isTile(type)) {
+        const diff = Number(leftType) - Number(type);
+        if (diff === 1) {
+            return { direction: 2 };
+        }
+    }
+    if (isTile(bottomLeftType) && isTile(type) && (leftType === 'x' || Number(leftType) <= Number(type))) {
+        const diff = Number(bottomLeftType) - Number(type);
+        if (diff === 1) {
+            return { cornerType: 'left', isCorner: true };
+        }
+    }
+    if (isTile(topRightType) && isTile(type) && (rightType === 'x' || Number(rightType) <= Number(type))) {
+        const diff = Number(topRightType) - Number(type);
+        if (diff === 1) {
+            return { cornerType: 'right', isCorner: true };
+        }
+    }
+    if (isTile(topLeftType) && isTile(type) && (leftType === 'x' || Number(leftType) <= Number(type))) {
+        const diff = Number(topLeftType) - Number(type);
+        if (diff === 1) {
+            return { cornerType: 'front', isCorner: true };
+        }
+    }
+}

package/dist-esm/util/getZOrder.js

@@ -0,0 +1,3 @@
+export function getZOrder(x, y, z) {
+    return x * 1000 + y * 1000 + z;
+}

package/dist-esm/util/isPointInside.js

@@ -0,0 +1,15 @@
+export 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-esm/util/isSetEqual.js

@@ -0,0 +1,8 @@
+export 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-esm/util/isTile.js

@@ -0,0 +1 @@
+export const isTile = (type) => !isNaN(Number(type));

package/dist-esm/util/loadImageFromBlob.js

@@ -0,0 +1,10 @@
+export 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-esm/util/loadImageFromUrl.js

@@ -0,0 +1,11 @@
+export 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-esm/util/loadRoomTexture.js

@@ -0,0 +1,15 @@
+import * as PIXI from "pixi.js";
+import { applyTextureProperties } from "./applyTextureProperties";
+export 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);
+    applyTextureProperties(texture);
+    return texture;
+}

package/dist-esm/util/mock.js

@@ -0,0 +1,3 @@
+export function mock(value) {
+    return value;
+}

package/dist-esm/util/notNullOrUndefined.js

@@ -0,0 +1,3 @@
+export function notNullOrUndefined(value) {
+    return value != null;
+}