@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/FloorFurniture.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloorFurniture = void 0;
+const RoomObject_1 = require("../RoomObject");
+const getZOrder_1 = require("../../util/getZOrder");
+const BaseFurniture_1 = require("./BaseFurniture");
+const ObjectAnimation_1 = require("../animation/ObjectAnimation");
+const getFurnitureFetch_1 = require("./util/getFurnitureFetch");
+class FloorFurniture extends RoomObject_1.RoomObject {
+    constructor(options) {
+        var _a;
+        super();
+        this.placementType = "floor";
+        this._animatedPosition = { roomX: 0, roomY: 0, roomZ: 0 };
+        this._moving = false;
+        this._type = options.type;
+        this._id = options.id;
+        this._roomX = options.roomX;
+        this._roomY = options.roomY;
+        this._roomZ = options.roomZ;
+        if ("type" in options) {
+            this._type = options.type;
+        }
+        this._baseFurniture = new BaseFurniture_1.BaseFurniture({
+            animation: options.animation,
+            direction: options.direction,
+            type: (0, getFurnitureFetch_1.getFurnitureFetch)(options, "floor"),
+        });
+        (_a = options.behaviors) === null || _a === void 0 ? void 0 : _a.forEach((behavior) => behavior.setParent(this));
+    }
+    /**
+     * Moves and animates the furniture to a new position.
+     *
+     * @param roomX New x-Position
+     * @param roomY New y-Position
+     * @param roomZ New z-Position
+     */
+    move(roomX, roomY, roomZ) {
+        var _a;
+        (_a = this._moveAnimation) === null || _a === void 0 ? void 0 : _a.move({ roomX: this.roomX, roomY: this.roomY, roomZ: this.roomZ }, { roomX, roomY, roomZ }, undefined);
+        this._roomX = roomX;
+        this._roomY = roomY;
+        this._roomZ = roomZ;
+    }
+    /**
+     * Places the furniture at a position without animating there. Dragging
+     * updates the position many times per second, where gliding would make the
+     * furniture trail the cursor instead of following it.
+     *
+     * @param roomX New x-Position
+     * @param roomY New y-Position
+     * @param roomZ New z-Position
+     */
+    setPosition(roomX, roomY, roomZ) {
+        var _a;
+        if (this._roomX === roomX && this._roomY === roomY && this._roomZ === roomZ && !this._moving) {
+            return;
+        }
+        (_a = this._moveAnimation) === null || _a === void 0 ? void 0 : _a.stop();
+        this._moving = false;
+        this._roomX = roomX;
+        this._roomY = roomY;
+        this._roomZ = roomZ;
+        this._updatePosition();
+    }
+    /**
+     * Clears the enqueued movement animations of the furniture
+     */
+    clearMovement() {
+        var _a;
+        const current = (_a = this._moveAnimation) === null || _a === void 0 ? void 0 : _a.clear();
+        if (current != null) {
+            this.roomX = current.roomX;
+            this.roomY = current.roomY;
+            this.roomZ = current.roomZ;
+        }
+    }
+    destroyed() {
+        var _a;
+        this._baseFurniture.destroy();
+        (_a = this._moveAnimation) === null || _a === void 0 ? void 0 : _a.destroy();
+    }
+    registered() {
+        const { x, y } = this.geometry.getPosition(this.roomX, this.roomY, this.roomZ);
+        this._baseFurniture.x = x;
+        this._baseFurniture.y = y;
+        this._baseFurniture.zIndex = (0, getZOrder_1.getZOrder)(Math.round(this.roomX), Math.round(this.roomY), this.roomZ);
+        this._baseFurniture.dependencies = {
+            animationTicker: this.animationTicker,
+            furnitureLoader: this.furnitureLoader,
+            placeholder: this.configuration.placeholder,
+            configuration: this.configuration,
+            visualization: this.roomVisualization,
+            eventManager: this.eventManager,
+        };
+        this._moveAnimation = new ObjectAnimation_1.ObjectAnimation(this.animationTicker, {
+            onStart: () => {
+                this._moving = true;
+            },
+            onStop: () => {
+                this._moving = false;
+            },
+            onUpdatePosition: (position) => {
+                this._animatedPosition = position;
+                this._updatePosition();
+            },
+        }, this.configuration.furnitureMovementDuration);
+        this._updatePosition();
+    }
+    /**
+     * If set to true, displays the furniture in the highlight state.
+     */
+    get highlight() {
+        return this._baseFurniture.highlight;
+    }
+    set highlight(value) {
+        this._baseFurniture.highlight = value;
+    }
+    get activeWired() {
+        return this._baseFurniture.activeWired;
+    }
+    set activeWired(value) {
+        this._baseFurniture.activeWired = value;
+    }
+    /**
+     * Alpha value of the furniture
+     */
+    get alpha() {
+        return this._baseFurniture.alpha;
+    }
+    set alpha(value) {
+        this._baseFurniture.alpha = value;
+    }
+    /**
+     * Type of the furniture
+     */
+    get type() {
+        return this._type;
+    }
+    /**
+     * Callback triggered when the furniture has been clicked on.
+     */
+    get onClick() {
+        return this._baseFurniture.onClick;
+    }
+    set onClick(value) {
+        this._baseFurniture.onClick = value;
+    }
+    /**
+     * Callback triggered when the furniture has been double clicked on.
+     */
+    get onDoubleClick() {
+        return this._baseFurniture.onDoubleClick;
+    }
+    set onDoubleClick(value) {
+        this._baseFurniture.onDoubleClick = value;
+    }
+    get onPointerDown() {
+        return this._baseFurniture.onPointerDown;
+    }
+    set onPointerDown(value) {
+        this._baseFurniture.onPointerDown = value;
+    }
+    get onPointerUp() {
+        return this._baseFurniture.onPointerUp;
+    }
+    set onPointerUp(value) {
+        this._baseFurniture.onPointerUp = value;
+    }
+    get onPointerOver() {
+        return this._baseFurniture.onPointerOver;
+    }
+    set onPointerOver(value) {
+        this._baseFurniture.onPointerOver = value;
+    }
+    get onPointerOut() {
+        return this._baseFurniture.onPointerOut;
+    }
+    set onPointerOut(value) {
+        this._baseFurniture.onPointerOut = value;
+    }
+    /**
+     * ID of the furniture
+     */
+    get id() {
+        return this._id;
+    }
+    /**
+     * The extra data provided through the `index.bin` file of the furniture.
+     * This contains the `logic` and `visualization` stings which specify some
+     * furniture behavior.
+     */
+    get extradata() {
+        return this._baseFurniture.extradata;
+    }
+    /**
+     * Valid directions of the furniture.
+     */
+    get validDirections() {
+        return this._baseFurniture.validDirections;
+    }
+    get validAnimations() {
+        return this._baseFurniture.validAnimations;
+    }
+    get dimensions() {
+        return this._baseFurniture.dimensions;
+    }
+    /**
+     * Animation of the furniture
+     */
+    get animation() {
+        return this._baseFurniture.animation;
+    }
+    set animation(value) {
+        this._baseFurniture.animation = value;
+    }
+    /**
+     * Direction of the furniture
+     */
+    get direction() {
+        return this._baseFurniture.direction;
+    }
+    set direction(value) {
+        this._baseFurniture.direction = value;
+    }
+    rotate() {
+        return this._baseFurniture.rotate;
+    }
+    /**
+     * The x position of the avatar in the room.
+     * The y-Axis is marked in the following graphic:
+     *
+     * ```
+     *    |
+     *    |
+     *    |
+     *   / \
+     *  /   \   <- x-Axis
+     * /     \
+     * ```
+     */
+    get roomX() {
+        return this._roomX;
+    }
+    set roomX(value) {
+        this._roomX = value;
+        this._updatePosition();
+    }
+    /**
+     * The y position of the avatar in the room.
+     * The y-Axis is marked in the following graphic:
+     *
+     * ```
+     *              |
+     *              |
+     *              |
+     *             / \
+     * y-Axis ->  /   \
+     *           /     \
+     * ```
+     */
+    get roomY() {
+        return this._roomY;
+    }
+    set roomY(value) {
+        this._roomY = value;
+        this._updatePosition();
+    }
+    /**
+     * The z position of the avatar in the room.
+     * The z-Axis is marked in the following graphic:
+     *
+     * ```
+     *              |
+     *   z-Axis ->  |
+     *              |
+     *             / \
+     *            /   \
+     *           /     \
+     * ```
+     */
+    get roomZ() {
+        return this._roomZ;
+    }
+    set roomZ(value) {
+        this._roomZ = value;
+        this._updatePosition();
+    }
+    get height() {
+        return this._baseFurniture.height;
+    }
+    get visualization() {
+        return this._baseFurniture.visualization;
+    }
+    set visualization(value) {
+        this._baseFurniture.visualization = value;
+    }
+    _getDisplayRoomPosition() {
+        if (this._moving) {
+            return this._animatedPosition;
+        }
+        return {
+            roomX: this.roomX,
+            roomY: this.roomY,
+            roomZ: this.roomZ,
+        };
+    }
+    _updatePosition() {
+        if (!this.mounted)
+            return;
+        const { roomX, roomY, roomZ } = this._getDisplayRoomPosition();
+        const { x, y } = this.geometry.getPosition(roomX, roomY, roomZ);
+        const roomXrounded = Math.round(roomX);
+        const roomYrounded = Math.round(roomY);
+        this._baseFurniture.x = x;
+        this._baseFurniture.y = y;
+        this._baseFurniture.zIndex = (0, getZOrder_1.getZOrder)(roomXrounded, roomYrounded, this.roomZ);
+    }
+}
+exports.FloorFurniture = FloorFurniture;

package/dist/objects/furniture/FurnitureData.d.ts

@@ -0,0 +1,14 @@
+import { FurnitureId, FurnitureInfo, IFurnitureData } from "../../interfaces/IFurnitureData";
+import { IFurniture } from "./IFurniture";
+export declare class FurnitureData implements IFurnitureData {
+    private _getFurniData;
+    private _data;
+    constructor(_getFurniData: () => Promise<string>);
+    static create(resourcePath?: string): FurnitureData;
+    getRevisionForType(type: string): Promise<number | undefined>;
+    getInfo(type: string): Promise<FurnitureInfo | undefined>;
+    getTypeById(id: FurnitureId, placementType: "wall" | "floor"): Promise<string | undefined>;
+    getInfoForFurniture(furniture: IFurniture): Promise<FurnitureInfo | undefined>;
+    getInfos(): Promise<[string, FurnitureInfo][]>;
+    private _prepareData;
+}

package/dist/objects/furniture/FurnitureData.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureData = void 0;
+const xml2js_1 = require("xml2js");
+const furnitureDataTransformers_1 = require("../../util/furnitureDataTransformers");
+class FurnitureData {
+    constructor(_getFurniData) {
+        this._getFurniData = _getFurniData;
+        this._data = this._prepareData();
+    }
+    static create(resourcePath = "") {
+        return new FurnitureData(async () => fetch(`${resourcePath}/furnidata.xml`).then((response) => response.text()));
+    }
+    async getRevisionForType(type) {
+        const info = await this.getInfo(type);
+        return info === null || info === void 0 ? void 0 : info.revision;
+    }
+    async getInfo(type) {
+        const data = await this._data;
+        return data.typeToInfo[type];
+    }
+    async getTypeById(id, placementType) {
+        const data = await this._data;
+        const type = placementType != "floor" ? data.floorIdToType[id] : data.wallIdToType[id];
+        if (type == null)
+            return;
+        return type;
+    }
+    async getInfoForFurniture(furniture) {
+        if (furniture.id != null) {
+            const type = await this.getTypeById(furniture.id, furniture.placementType);
+            if (type != null) {
+                return this.getInfo(type);
+            }
+        }
+        if (furniture.type != null) {
+            return this.getInfo(furniture.type);
+        }
+    }
+    async getInfos() {
+        const data = await this._data;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return Object.entries(data.typeToInfo).map(([key, info]) => [key, info]);
+    }
+    async _prepareData() {
+        const furniDataString = await this._getFurniData();
+        const parsed = await (0, xml2js_1.parseStringPromise)(furniDataString);
+        const typeToInfo = {};
+        const floorIdToType = {};
+        const wallIdToType = {};
+        const register = (data, furnitureType) => {
+            data.forEach((element) => {
+                const type = element.$.classname;
+                const id = element.$.id;
+                typeToInfo[type] = (0, furnitureDataTransformers_1.formatFurnitureData)(element);
+                if (furnitureType === "floor") {
+                    if (floorIdToType[id] != null)
+                        throw new Error(`Floor furniture with id ${id} already exists`);
+                    floorIdToType[id] = type;
+                }
+                else if (furnitureType === "wall") {
+                    if (wallIdToType[id] != null)
+                        throw new Error(`Wall furniture with id ${id} already exists`);
+                    wallIdToType[id] = type;
+                }
+            });
+        };
+        register(parsed.furnidata.roomitemtypes[0].furnitype, "wall");
+        register(parsed.furnidata.wallitemtypes[0].furnitype, "floor");
+        return { typeToInfo, floorIdToType, wallIdToType };
+    }
+}
+exports.FurnitureData = FurnitureData;

package/dist/objects/furniture/FurnitureExtraData.d.ts

@@ -0,0 +1,4 @@
+export interface FurnitureExtraData {
+    visualization?: string;
+    logic?: string;
+}

package/dist/objects/furniture/FurnitureExtraData.js

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

package/dist/objects/furniture/FurnitureFetchInfo.d.ts

@@ -0,0 +1,5 @@
+import { FurnitureId } from "../../interfaces/IFurnitureData";
+export type FurnitureFetchInfo = {
+    id?: FurnitureId;
+    type?: string;
+};

package/dist/objects/furniture/FurnitureFetchInfo.js

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

package/dist/objects/furniture/FurnitureHelper.d.ts

@@ -0,0 +1,17 @@
+import { Wsproom } from "../Wsproom";
+import { IFurnitureExtended } from "./IFurniture";
+export declare class FurnitureHelper {
+    static getFurniPreview(furniId: string, wsproom: Wsproom): Promise<HTMLImageElement>;
+    static getFurniIcon(furniId: string, wsproom: Wsproom): Promise<HTMLImageElement>;
+    static getFurniOptions(furni: IFurnitureExtended, wsproom: Wsproom): Promise<FurniOptions | undefined>;
+}
+interface FurniOptions {
+    name?: string;
+    type: string;
+    description?: string;
+    image: string;
+    move: (callback: () => void) => void;
+    rotate: () => void;
+    pickup: (callback: () => void) => void;
+}
+export {};

package/dist/objects/furniture/FurnitureHelper.js

@@ -0,0 +1,90 @@
+"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.FurnitureHelper = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const BaseFurniture_1 = require("./BaseFurniture");
+class FurnitureHelper {
+    static getFurniPreview(furniId, wsproom) {
+        return new Promise((resolve, reject) => {
+            const container = new PIXI.Container();
+            BaseFurniture_1.BaseFurniture.fromWsproom(wsproom, container, {
+                animation: "0",
+                direction: 2,
+                type: { type: furniId, kind: "type" },
+                onLoad: async () => {
+                    const image = (await wsproom.dependencies.application.renderer.extract.image(container));
+                    resolve(image);
+                    container.destroy();
+                },
+            });
+        });
+    }
+    static getFurniIcon(furniId, wsproom) {
+        return new Promise((resolve, reject) => {
+            const container = new PIXI.Container();
+            BaseFurniture_1.BaseFurniture.fromWsproom(wsproom, container, {
+                animation: "0",
+                direction: 2,
+                type: { type: furniId, kind: "type" },
+                onLoad: async () => {
+                    const image = (await wsproom.dependencies.application.renderer.extract.image(container));
+                    resolve(image);
+                    container.destroy();
+                },
+            });
+        });
+    }
+    static async getFurniOptions(furni, wsproom) {
+        var _a;
+        if (!furni.type)
+            return; // If Furniture Type == Undefined, Return Undefined
+        const info = await ((_a = wsproom.dependencies.furnitureData) === null || _a === void 0 ? void 0 : _a.getInfo(furni.type));
+        if (!info)
+            return; // If FurnitureData Fetch Fails, Return Undefined
+        const image = (await this.getFurniPreview(furni.type, wsproom)).src;
+        const validDirections = await furni.validDirections;
+        return {
+            name: info === null || info === void 0 ? void 0 : info.name,
+            type: furni.type,
+            description: info === null || info === void 0 ? void 0 : info.description,
+            image,
+            move: (callback) => { callback(); },
+            rotate: () => { furni.rotate(); },
+            pickup: (callback) => { callback(); },
+        };
+    }
+}
+exports.FurnitureHelper = FurnitureHelper;

package/dist/objects/furniture/FurnitureLoader.d.ts

@@ -0,0 +1,22 @@
+import { IFurnitureData } from "../../interfaces/IFurnitureData";
+import { FurnitureFetch, IFurnitureLoader } from "../../interfaces/IFurnitureLoader";
+import { IFurnitureAssetBundle } from "./IFurnitureAssetBundle";
+import { LoadFurniResult } from "./util/loadFurni";
+export declare class FurnitureLoader implements IFurnitureLoader {
+    private _options;
+    private _furnitureCache;
+    private _artificalDelay;
+    private _assetBundles;
+    constructor(_options: Options);
+    get delay(): number | undefined;
+    set delay(value: number | undefined);
+    static create(furnitureData: IFurnitureData, resourcePath?: string): FurnitureLoader;
+    static createForJson(furnitureData: IFurnitureData, resourcePath?: string): FurnitureLoader;
+    loadFurni(fetch: FurnitureFetch): Promise<LoadFurniResult>;
+    private _getAssetBundle;
+}
+interface Options {
+    furnitureData: IFurnitureData;
+    getAssetBundle: (type: string, revision?: number) => Promise<IFurnitureAssetBundle>;
+}
+export {};

package/dist/objects/furniture/FurnitureLoader.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureLoader = void 0;
+const LegacyAssetBundle_1 = require("../../assets/LegacyAssetBundle");
+const WsproomAssetBundle_1 = require("../../assets/WsproomAssetBundle");
+const JsonFurnitureAssetBundle_1 = require("./JsonFurnitureAssetBundle");
+const loadFurni_1 = require("./util/loadFurni");
+const XmlFurnitureAssetBundle_1 = require("./XmlFurnitureAssetBundle");
+class FurnitureLoader {
+    constructor(_options) {
+        this._options = _options;
+        this._furnitureCache = new Map();
+        this._assetBundles = new Map();
+    }
+    get delay() {
+        return this._artificalDelay;
+    }
+    set delay(value) {
+        this._artificalDelay = value;
+    }
+    static create(furnitureData, resourcePath = "") {
+        return new FurnitureLoader({
+            furnitureData,
+            getAssetBundle: async (type, revision) => {
+                const bundle = new LegacyAssetBundle_1.LegacyAssetBundle(`${resourcePath}/hof_furni/${normalizePath(revision, type)}`);
+                return new XmlFurnitureAssetBundle_1.XmlFurnitureAssetBundle(type, bundle);
+            },
+        });
+    }
+    static createForJson(furnitureData, resourcePath = "") {
+        return new FurnitureLoader({
+            furnitureData,
+            getAssetBundle: async (type, revision) => {
+                const bundle = await WsproomAssetBundle_1.WsproomAssetBundle.fromUrl(`${resourcePath}/hof_furni/${normalizePath(revision, type)}.wsproom`);
+                return new JsonFurnitureAssetBundle_1.JsonFurnitureAssetBundle(bundle);
+            },
+        });
+    }
+    async loadFurni(fetch) {
+        if (this.delay != null) {
+            await new Promise((resolve) => setTimeout(resolve, this.delay));
+        }
+        let typeWithColor;
+        if (fetch.kind === "id") {
+            const type = await this._options.furnitureData.getTypeById(fetch.id, fetch.placementType);
+            if (type == null)
+                throw new Error("Couldn't determine type for furniture.");
+            typeWithColor = type;
+        }
+        else {
+            typeWithColor = fetch.type;
+        }
+        const typeSplitted = typeWithColor.split("*");
+        const type = typeSplitted[0];
+        const revision = await this._options.furnitureData.getRevisionForType(typeWithColor);
+        let furniture = this._furnitureCache.get(typeWithColor);
+        if (furniture != null) {
+            return furniture;
+        }
+        furniture = (0, loadFurni_1.loadFurni)(typeWithColor, await this._getAssetBundle(type, revision));
+        this._furnitureCache.set(typeWithColor, furniture);
+        furniture.catch(() => {
+            this._furnitureCache.delete(typeWithColor);
+        });
+        return furniture;
+    }
+    _getAssetBundle(type, revision) {
+        const key = `${type}_${revision}`;
+        const current = this._assetBundles.get(key);
+        if (current != null)
+            return current;
+        const bundle = this._options.getAssetBundle(type, revision);
+        this._assetBundles.set(key, bundle);
+        bundle.catch(() => {
+            this._assetBundles.delete(key);
+        });
+        return bundle;
+    }
+}
+exports.FurnitureLoader = FurnitureLoader;
+const normalizePath = (revision, type) => {
+    if (revision == null)
+        return type;
+    return `${revision}/${type}`;
+};

package/dist/objects/furniture/FurnitureRoomVisualization.d.ts

@@ -0,0 +1,10 @@
+import { MaskNode } from "../../interfaces/IRoomVisualization";
+import { IFurnitureRoomVisualization } from "./BaseFurniture";
+import type * as PIXI from "pixi.js";
+export declare class FurnitureRoomVisualization implements IFurnitureRoomVisualization {
+    private _container;
+    constructor(_container: PIXI.Container);
+    get container(): PIXI.Container<PIXI.ContainerChild>;
+    static fromContainer(container: PIXI.Container): FurnitureRoomVisualization;
+    addMask(): MaskNode;
+}

package/dist/objects/furniture/FurnitureRoomVisualization.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureRoomVisualization = void 0;
+class FurnitureRoomVisualization {
+    constructor(_container) {
+        this._container = _container;
+    }
+    get container() {
+        return this._container;
+    }
+    static fromContainer(container) {
+        return new FurnitureRoomVisualization(container);
+    }
+    addMask() {
+        return {
+            remove: () => {
+                // Do nothing
+            },
+            update: () => {
+                // Do nothing
+            },
+            sprite: null,
+        };
+    }
+}
+exports.FurnitureRoomVisualization = FurnitureRoomVisualization;