@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/interfaces/IMoveable.d.ts

@@ -0,0 +1,4 @@
+export interface IMoveable {
+    move(roomX: number, roomY: number, roomZ: number): void;
+    clearMovement(): void;
+}

package/dist/objects/interfaces/IMoveable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/interfaces/IScreenPositioned.d.ts

@@ -0,0 +1,6 @@
+export interface IScreenPositioned {
+    screenPosition: {
+        x: number;
+        y: number;
+    } | undefined;
+}

package/dist/objects/interfaces/IScreenPositioned.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/room/ILandscapeContainer.d.ts

@@ -0,0 +1,6 @@
+export interface ILandscapeContainer {
+    getMaskLevel(roomX: number, roomY: number): {
+        roomX: number;
+        roomY: number;
+    };
+}

package/dist/objects/room/ILandscapeContainer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/room/IRoomRectangle.d.ts

@@ -0,0 +1,9 @@
+export interface IRoomRectangle {
+    rectangle: Rectangle;
+}
+export interface Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/dist/objects/room/IRoomRectangle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/room/ITileColorable.d.ts

@@ -0,0 +1,7 @@
+import type * as PIXI from "pixi.js";
+export interface ITileColorable {
+    tileLeftColor: number;
+    tileRightColor: number;
+    tileTopColor: number;
+    tileTexture: PIXI.Texture;
+}

package/dist/objects/room/ITileColorable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/room/IWallColorable.d.ts

@@ -0,0 +1,7 @@
+import type * as PIXI from "pixi.js";
+export interface IWallColorable {
+    wallLeftColor: number;
+    wallRightColor: number;
+    wallTopColor: number;
+    wallTexture: PIXI.Texture;
+}

package/dist/objects/room/IWallColorable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/room/Landscape.d.ts

@@ -0,0 +1,92 @@
+import * as PIXI from "pixi.js";
+import { ParsedTileType } from "../../util/parseTileMap";
+import { RoomObject } from "../RoomObject";
+import { IRoomPart } from "./parts/IRoomPart";
+import { RoomPartData } from "./parts/RoomPartData";
+interface WallCollectionMeta {
+    type: "rowWall" | "colWall";
+    start: number;
+    end: number;
+    level: number;
+}
+/**
+ * A landscape is a stack of layers drawn behind the walls, in the same shape
+ * Habbo ships inside its room visualization data: a static layer is a material
+ * tiled across every wall of one orientation, an animated layer is a set of
+ * items that drift across it. Positions and speeds are normalised (0..1) over
+ * the whole landscape, which is what keeps it continuous from wall to wall.
+ */
+export interface LandscapeAnimationItem {
+    asset: string;
+    x: number;
+    y: number;
+    speedX: number;
+    speedY: number;
+    /** Spread added to `x`/`y` once when the landscape is set, so repeated items
+     * (clouds, birds) don't stack on top of each other. */
+    randomX?: number;
+    randomY?: number;
+}
+export interface LandscapeLayer {
+    material?: string;
+    color?: number;
+    align?: "top" | "bottom";
+    offset?: number;
+    items?: LandscapeAnimationItem[];
+}
+export interface LandscapeVisualization {
+    layers: LandscapeLayer[];
+}
+export declare class Landscape extends RoomObject implements IRoomPart {
+    private _container;
+    private _leftTexture;
+    private _rightTexture;
+    private _wallHeight;
+    private _wallHeightWithZ;
+    private _leftTexturePromise;
+    private _rightTexturePromise;
+    private _masks;
+    private _color;
+    private _unsubscribe;
+    private _visualization;
+    private _assets;
+    private _animated;
+    private _startedAt;
+    private _partNode;
+    constructor();
+    get color(): string | undefined;
+    set color(value: string | undefined);
+    get leftTexture(): Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined;
+    set leftTexture(value: Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined);
+    get rightTexture(): Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined;
+    set rightTexture(value: Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined);
+    setVisualization(visualization: LandscapeVisualization, assets?: Record<string, PIXI.Texture>): void;
+    update(data: RoomPartData): void;
+    destroyed(): void;
+    registered(): void;
+    private _updateAnimatedItems;
+    private _createDefaultMask;
+    private _getMask;
+    /**
+     * Draws one landscape layer into a wall. `planeOffset` is how far along the
+     * whole landscape this wall starts, and `span` its total width, so a material
+     * tiles seamlessly and an item drifting off one wall arrives on the next.
+     */
+    private _createLayer;
+    private _updateLandscapeImages;
+}
+/**
+ * Where an animated item sits after `elapsed` ms. Speeds are room units per
+ * second across the whole landscape, so the item crosses it in the same time
+ * no matter how large the room is.
+ */
+export declare function getLandscapeItemPosition(item: LandscapeAnimationItem, span: number, height: number, elapsed: number): {
+    x: number;
+    y: number;
+};
+export declare function getWallCollectionMeta(parsedTileMap: ParsedTileType[][]): WallCollectionMeta[];
+export declare function getStartingWall(parsedTileMap: ParsedTileType[][]): {
+    x: number;
+    y: number;
+} | undefined;
+export {};

package/dist/objects/room/Landscape.js

@@ -0,0 +1,389 @@
+"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.Landscape = void 0;
+exports.getLandscapeItemPosition = getLandscapeItemPosition;
+exports.getWallCollectionMeta = getWallCollectionMeta;
+exports.getStartingWall = getStartingWall;
+const PIXI = __importStar(require("pixi.js"));
+const RoomObject_1 = require("../RoomObject");
+const getMaskId_1 = require("./util/getMaskId");
+class Landscape extends RoomObject_1.RoomObject {
+    constructor() {
+        super();
+        this._wallHeight = 0;
+        this._wallHeightWithZ = 0;
+        this._masks = new Map();
+        this._unsubscribe = undefined;
+        this._assets = new Map();
+        this._animated = [];
+    }
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+        this._updateLandscapeImages();
+    }
+    get leftTexture() {
+        return this._leftTexturePromise;
+    }
+    set leftTexture(value) {
+        this._leftTexturePromise = value;
+        Promise.resolve(this._leftTexturePromise).then((value) => {
+            this._leftTexture = value;
+            this._updateLandscapeImages();
+        });
+    }
+    get rightTexture() {
+        return this._rightTexturePromise;
+    }
+    set rightTexture(value) {
+        this._rightTexturePromise = value;
+        Promise.resolve(this._rightTexturePromise).then((value) => {
+            this._rightTexture = value;
+            this._updateLandscapeImages();
+        });
+    }
+    setVisualization(visualization, assets = {}) {
+        this._visualization = {
+            layers: visualization.layers.map((layer) => { var _a; return ({
+                ...layer,
+                items: (_a = layer.items) === null || _a === void 0 ? void 0 : _a.map((item) => { var _a, _b; return ({
+                    ...item,
+                    x: item.x + Math.random() * ((_a = item.randomX) !== null && _a !== void 0 ? _a : 0),
+                    y: item.y + Math.random() * ((_b = item.randomY) !== null && _b !== void 0 ? _b : 0),
+                }); }),
+            }); }),
+        };
+        this._assets = new Map(Object.entries(assets));
+        this._updateLandscapeImages();
+    }
+    update(data) {
+        this._masks = data.masks;
+        this._wallHeightWithZ = data.wallHeight;
+        this._updateLandscapeImages();
+    }
+    destroyed() {
+        var _a, _b;
+        this._unsubscribe && this._unsubscribe();
+        this._unsubscribe = undefined;
+        (_a = this._container) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this._partNode) === null || _b === void 0 ? void 0 : _b.remove();
+    }
+    registered() {
+        this._partNode = this.roomVisualization.addPart(this);
+        this._unsubscribe = this.animationTicker.subscribe(() => this._updateAnimatedItems());
+        this._updateLandscapeImages();
+    }
+    _updateAnimatedItems() {
+        if (this._animated.length === 0)
+            return;
+        if (this._startedAt == null)
+            this._startedAt = performance.now();
+        const elapsed = performance.now() - this._startedAt;
+        this._animated.forEach(({ sprite, item, span, height, planeOffset, wrapX, wrapY }) => {
+            const point = getLandscapeItemPosition(item, span, height, elapsed);
+            sprite.x = point.x - planeOffset + wrapX * span;
+            sprite.y = point.y - height + wrapY * height;
+        });
+    }
+    _createDefaultMask() {
+        return new PIXI.Graphics();
+    }
+    _getMask(direction, roomX, roomY) {
+        const maskId = (0, getMaskId_1.getMaskId)(direction, roomX, roomY);
+        if (maskId != null) {
+            const mask = this._masks.get(maskId);
+            if (mask != null)
+                return mask;
+        }
+        return this._createDefaultMask();
+    }
+    /**
+     * Draws one landscape layer into a wall. `planeOffset` is how far along the
+     * whole landscape this wall starts, and `span` its total width, so a material
+     * tiles seamlessly and an item drifting off one wall arrives on the next.
+     */
+    _createLayer(layer, wall, width, planeOffset, span) {
+        var _a;
+        var _b;
+        const height = this._wallHeightWithZ;
+        if (layer.material != null) {
+            const texture = this._assets.get(layer.material);
+            if (texture != null) {
+                const material = new PIXI.TilingSprite({
+                    texture,
+                    width,
+                    height: layer.align === "top" ? height : texture.height,
+                });
+                material.tilePosition.set(-planeOffset, 0);
+                material.x = 0;
+                material.y =
+                    (layer.align === "top" ? -height : -texture.height) +
+                        ((_b = layer.offset) !== null && _b !== void 0 ? _b : 0);
+                if (layer.color != null)
+                    material.tint = layer.color;
+                wall.addChild(material);
+            }
+        }
+        else if (layer.color != null) {
+            const colored = new PIXI.TilingSprite(PIXI.Texture.WHITE, width, height);
+            colored.tint = layer.color;
+            colored.y = -height;
+            wall.addChild(colored);
+        }
+        (_a = layer.items) === null || _a === void 0 ? void 0 : _a.forEach((item) => {
+            const texture = this._assets.get(item.asset);
+            if (texture == null)
+                return;
+            // Four copies, offset by a full landscape in each axis, so an item that
+            // walks off one edge is already arriving at the opposite one.
+            [
+                [0, 0],
+                [-1, 0],
+                [0, -1],
+                [-1, -1],
+            ].forEach(([wrapX, wrapY]) => {
+                const sprite = new PIXI.Sprite(texture);
+                wall.addChild(sprite);
+                this._animated.push({
+                    sprite,
+                    item,
+                    span,
+                    height,
+                    planeOffset,
+                    wrapX,
+                    wrapY,
+                });
+            });
+        });
+    }
+    _updateLandscapeImages() {
+        var _a;
+        if (!this.mounted)
+            return;
+        const meta = getWallCollectionMeta(this.tilemap.getParsedTileTypes());
+        (_a = this._container) === null || _a === void 0 ? void 0 : _a.destroy();
+        this._animated = [];
+        const container = new PIXI.Container();
+        const spanOf = (type) => meta
+            .filter((entry) => entry.type === type)
+            .reduce((total, entry) => total + Math.abs(entry.end - entry.start) * 32, 0);
+        const rowSpan = spanOf("rowWall");
+        const colSpan = spanOf("colWall");
+        let offsetRow = 0;
+        let offsetCol = 0;
+        meta.forEach((meta) => {
+            const width = Math.abs(meta.end - meta.start) * 32;
+            const wall = new PIXI.Container();
+            if (this._visualization == null) {
+                const colored = new PIXI.TilingSprite(PIXI.Texture.WHITE, width, this._wallHeightWithZ);
+                if (this.color != null) {
+                    colored.tint = parseInt(this.color.slice(1), 16);
+                }
+                else {
+                    colored.tint = 0xffffff;
+                }
+                colored.y = -this._wallHeightWithZ;
+                wall.addChild(colored);
+            }
+            else {
+                this._visualization.layers.forEach((layer) => this._createLayer(layer, wall, width, meta.type === "rowWall" ? offsetRow : offsetCol, meta.type === "rowWall" ? rowSpan : colSpan));
+            }
+            if (meta.type === "rowWall") {
+                const maskLevel = this.landscapeContainer.getMaskLevel(meta.level, 0);
+                const mask = this._getMask(2, maskLevel.roomX, 0);
+                wall.mask = mask;
+                const position = this.geometry.getPosition(meta.level + 1, meta.start, 0);
+                wall.setFromMatrix(new PIXI.Matrix(1, -0.5, 0, 1));
+                wall.x = position.x;
+                wall.y = position.y + 16;
+                if (this._visualization == null && this._leftTexture != null) {
+                    const graphics = new PIXI.TilingSprite({
+                        texture: this._leftTexture,
+                        width,
+                        height: this._leftTexture.height,
+                    });
+                    graphics.tilePosition.set(offsetRow, 0);
+                    graphics.texture = this._leftTexture;
+                    graphics.x = 0;
+                    graphics.y = -this._leftTexture.height;
+                    wall.addChild(graphics);
+                }
+                offsetRow += width;
+            }
+            else if (meta.type === "colWall") {
+                const maskLevel = this.landscapeContainer.getMaskLevel(0, meta.level);
+                const mask = this._getMask(4, 0, maskLevel.roomY);
+                wall.mask = mask;
+                const position = this.geometry.getPosition(meta.start + 1, meta.level + 1, 0);
+                wall.setFromMatrix(new PIXI.Matrix(1, 0.5, 0, 1));
+                wall.x = position.x + 32;
+                wall.y = position.y;
+                if (this._visualization == null && this._rightTexture != null) {
+                    const graphics = new PIXI.TilingSprite({
+                        texture: this._rightTexture,
+                        width,
+                        height: this._rightTexture.height,
+                    });
+                    graphics.texture = this._rightTexture;
+                    graphics.x = 0;
+                    graphics.y = -this._rightTexture.height;
+                    graphics.tilePosition.set(offsetCol, 0);
+                    wall.addChild(graphics);
+                }
+                offsetCol += width;
+            }
+            container.addChild(wall);
+        });
+        this._container = container;
+        this.roomVisualization.landscapeContainer.addChild(container);
+    }
+}
+exports.Landscape = Landscape;
+const wrap = (value) => ((value % 1) + 1) % 1;
+/**
+ * Where an animated item sits after `elapsed` ms. Speeds are room units per
+ * second across the whole landscape, so the item crosses it in the same time
+ * no matter how large the room is.
+ */
+function getLandscapeItemPosition(item, span, height, elapsed) {
+    const tilesX = span / 32;
+    const tilesY = height / 32;
+    return {
+        x: Math.trunc(wrap(item.x + (tilesX > 0 ? (item.speedX / tilesX) * (elapsed / 1000) : 0)) *
+            span),
+        y: Math.trunc(wrap(item.y + (tilesY > 0 ? (item.speedY / tilesY) * (elapsed / 1000) : 0)) *
+            height),
+    };
+}
+const getTile = (parsedTileMap, x, y) => {
+    const row = parsedTileMap[y];
+    if (row == null)
+        return;
+    return row[x];
+};
+function getWallCollectionMeta(parsedTileMap) {
+    const start = getStartingWall(parsedTileMap);
+    if (start == null)
+        return [];
+    let x = start.x;
+    let y = start.y;
+    let done = false;
+    let meta = undefined;
+    const arr = [];
+    const maxSteps = parsedTileMap.length +
+        parsedTileMap.reduce((max, row) => { var _a; return Math.max(max, (_a = row === null || row === void 0 ? void 0 : row.length) !== null && _a !== void 0 ? _a : 0); }, 0) +
+        2;
+    for (let step = 0; step < maxSteps; step++) {
+        const currentWall = getTile(parsedTileMap, x, y);
+        const topWallPosition = { x, y: y - 1 };
+        const rightWallPosition = { x: x + 1, y };
+        const topWall = getTile(parsedTileMap, topWallPosition.x, topWallPosition.y);
+        const rightWall = getTile(parsedTileMap, rightWallPosition.x, rightWallPosition.y);
+        if (currentWall == null ||
+            (currentWall.type !== "wall" && currentWall.type !== "door"))
+            break;
+        const updateMeta = (newMeta) => {
+            if (meta == null) {
+                meta = newMeta;
+                return;
+            }
+            if (meta != null && meta.type !== newMeta.type) {
+                arr.push(meta);
+                meta = newMeta;
+                return;
+            }
+            meta = {
+                ...meta,
+                level: newMeta.level,
+                end: newMeta.end,
+            };
+        };
+        if (currentWall.type === "wall") {
+            switch (currentWall.kind) {
+                case "rowWall":
+                case "innerCorner":
+                    updateMeta({ type: "rowWall", start: y, end: y - 1, level: x });
+                    break;
+                case "colWall":
+                case "outerCorner":
+                    updateMeta({
+                        type: "colWall",
+                        start: x,
+                        end: x + (done ? 0 : 1),
+                        level: y,
+                    });
+                    break;
+            }
+        }
+        else if (currentWall.type === "door") {
+            updateMeta({ type: "rowWall", start: y, end: y - 1, level: x });
+        }
+        if (done) {
+            if (meta != null) {
+                arr.push(meta);
+            }
+            break;
+        }
+        if (topWall != null &&
+            (topWall.type === "wall" || topWall.type === "door")) {
+            x = topWallPosition.x;
+            y = topWallPosition.y;
+        }
+        else if (rightWall != null && rightWall.type === "wall") {
+            x = rightWallPosition.x;
+            y = rightWallPosition.y;
+        }
+        else {
+            done = true;
+        }
+    }
+    return arr;
+}
+function getStartingWall(parsedTileMap) {
+    const startY = parsedTileMap.length - 1;
+    const width = parsedTileMap.reduce((max, row) => { var _a; return Math.max(max, (_a = row === null || row === void 0 ? void 0 : row.length) !== null && _a !== void 0 ? _a : 0); }, 0);
+    for (let x = 0; x < width; x++) {
+        for (let y = startY; y >= 0; y--) {
+            const current = getTile(parsedTileMap, x, y);
+            if (current != null && current.type === "wall") {
+                return { x, y };
+            }
+        }
+    }
+    return undefined;
+}

package/dist/objects/room/ParsedTileMap.d.ts

@@ -0,0 +1,14 @@
+import { TileType } from "../../types/TileType";
+export declare class ParsedTileMap {
+    private tilemap;
+    private _data;
+    get highestTile(): number;
+    get largestDiff(): number;
+    get parsedTileTypes(): import("../../util/parseTileMap").ParsedTileType[][];
+    get wallOffsets(): {
+        x: number;
+        y: number;
+    };
+    constructor(tilemap: TileType[][]);
+    getRawTileMap(): TileType[][];
+}

package/dist/objects/room/ParsedTileMap.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsedTileMap = void 0;
+const parseTileMap_1 = require("../../util/parseTileMap");
+class ParsedTileMap {
+    get highestTile() {
+        return this._data.highestTile;
+    }
+    get largestDiff() {
+        return this._data.largestDiff;
+    }
+    get parsedTileTypes() {
+        return this._data.tilemap;
+    }
+    get wallOffsets() {
+        return this._data.wallOffsets;
+    }
+    constructor(tilemap) {
+        this.tilemap = tilemap;
+        this._data = (0, parseTileMap_1.parseTileMap)(tilemap);
+    }
+    getRawTileMap() {
+        return this.tilemap.map((row) => [...row]);
+    }
+}
+exports.ParsedTileMap = ParsedTileMap;

package/dist/objects/room/Pathfinding.d.ts

@@ -0,0 +1,31 @@
+import { FloorFurniture, FurnitureData, Room } from "../../";
+import { FurnitureInfo } from "../../interfaces/IFurnitureData";
+import { RoomPosition } from "../../types/RoomPosition";
+import { TileType } from "../../types/TileType";
+export declare class Pathfinding {
+    grid: number[][];
+    baseGrid: number[][];
+    door?: RoomPosition;
+    private room;
+    private furnitureData;
+    private furniGrid;
+    constructor(room: Room, tilemap: TileType[][], furnitureData: FurnitureData);
+    private locateDoor;
+    calculateFurnisFilledSpace(): Promise<void>;
+    private calculateFilledSpace;
+    private resetFurniGrid;
+    private addToGrid;
+    private determineNegativeMesh;
+    getFurnisOnTile(position: RoomPosition): {
+        roomObject: FloorFurniture;
+        info: FurnitureInfo;
+    }[];
+    findPath(origin: RoomPosition, target: RoomPosition): Promise<{
+        roomX: number;
+        roomY: number;
+        roomZ: number;
+        direction: number | undefined;
+    }[]>;
+    private clone;
+    private getAvatarDirectionFromDiff;
+}