@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/objects/furniture/FloorFurniture.js

@@ -0,0 +1,316 @@
+import { RoomObject } from "../RoomObject";
+import { getZOrder } from "../../util/getZOrder";
+import { BaseFurniture } from "./BaseFurniture";
+import { ObjectAnimation } from "../animation/ObjectAnimation";
+import { getFurnitureFetch } from "./util/getFurnitureFetch";
+export class FloorFurniture extends 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({
+            animation: options.animation,
+            direction: options.direction,
+            type: 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 = 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(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 = getZOrder(roomXrounded, roomYrounded, this.roomZ);
+    }
+}

package/dist-esm/objects/furniture/FurnitureData.js

@@ -0,0 +1,69 @@
+import { parseStringPromise } from "xml2js";
+import { formatFurnitureData } from "../../util/furnitureDataTransformers";
+export 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 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] = 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 };
+    }
+}

package/dist-esm/objects/furniture/FurnitureExtraData.js

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

package/dist-esm/objects/furniture/FurnitureFetchInfo.js

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

package/dist-esm/objects/furniture/FurnitureHelper.js

@@ -0,0 +1,53 @@
+import * as PIXI from "pixi.js";
+import { BaseFurniture } from "./BaseFurniture";
+export class FurnitureHelper {
+    static getFurniPreview(furniId, wsproom) {
+        return new Promise((resolve, reject) => {
+            const container = new PIXI.Container();
+            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.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(); },
+        };
+    }
+}

package/dist-esm/objects/furniture/FurnitureLoader.js

@@ -0,0 +1,81 @@
+import { LegacyAssetBundle } from "../../assets/LegacyAssetBundle";
+import { WsproomAssetBundle } from "../../assets/WsproomAssetBundle";
+import { JsonFurnitureAssetBundle } from "./JsonFurnitureAssetBundle";
+import { loadFurni } from "./util/loadFurni";
+import { XmlFurnitureAssetBundle } from "./XmlFurnitureAssetBundle";
+export 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(`${resourcePath}/hof_furni/${normalizePath(revision, type)}`);
+                return new XmlFurnitureAssetBundle(type, bundle);
+            },
+        });
+    }
+    static createForJson(furnitureData, resourcePath = "") {
+        return new FurnitureLoader({
+            furnitureData,
+            getAssetBundle: async (type, revision) => {
+                const bundle = await WsproomAssetBundle.fromUrl(`${resourcePath}/hof_furni/${normalizePath(revision, type)}.wsproom`);
+                return new 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 = 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;
+    }
+}
+const normalizePath = (revision, type) => {
+    if (revision == null)
+        return type;
+    return `${revision}/${type}`;
+};

package/dist-esm/objects/furniture/FurnitureRoomVisualization.js

@@ -0,0 +1,22 @@
+export 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,
+        };
+    }
+}

package/dist-esm/objects/furniture/FurnitureSprite.js

@@ -0,0 +1,65 @@
+import { HitSprite } from "../hitdetection/HitSprite";
+export class FurnitureSprite extends HitSprite {
+    constructor() {
+        super(...arguments);
+        this._baseX = 0;
+        this._baseY = 0;
+        this._baseZIndex = 0;
+        this._offsetX = 0;
+        this._offsetY = 0;
+        this._offsetZIndex = 0;
+    }
+    get offsetX() {
+        return this._offsetX;
+    }
+    set offsetX(value) {
+        this._offsetX = value;
+        this._update();
+    }
+    get offsetY() {
+        return this._offsetY;
+    }
+    set offsetY(value) {
+        this._offsetY = value;
+        this._update();
+    }
+    get offsetZIndex() {
+        return this._offsetZIndex;
+    }
+    set offsetZIndex(value) {
+        this._offsetZIndex = value;
+        this._update();
+    }
+    get baseX() {
+        return this._baseX;
+    }
+    set baseX(value) {
+        this._baseX = value;
+        this._update();
+    }
+    get baseY() {
+        return this._baseY;
+    }
+    set baseY(value) {
+        this._baseY = value;
+        this._update();
+    }
+    get baseZIndex() {
+        return this._baseZIndex;
+    }
+    set baseZIndex(value) {
+        this._baseZIndex = value;
+        this._update();
+    }
+    get assetName() {
+        return this._assetName;
+    }
+    set assetName(value) {
+        this._assetName = value;
+    }
+    _update() {
+        this.x = this.baseX + this.offsetX;
+        this.y = this.baseY + this.offsetY;
+        this.zIndex = this.baseZIndex + this.offsetZIndex;
+    }
+}