@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/BaseFurniture.js

@@ -0,0 +1,519 @@
+"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.BaseFurniture = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const ClickHandler_1 = require("../hitdetection/ClickHandler");
+const FurnitureSprite_1 = require("./FurnitureSprite");
+const AnimatedFurnitureVisualization_1 = require("./visualization/AnimatedFurnitureVisualization");
+const getDirectionForFurniture_1 = require("./util/getDirectionForFurniture");
+const IEventGroup_1 = require("../events/interfaces/IEventGroup");
+const EventManager_1 = require("../events/EventManager");
+const FurnitureVisualizationView_1 = require("./FurnitureVisualizationView");
+const EventOverOutHandler_1 = require("../events/EventOverOutHandler");
+class BaseFurniture {
+    constructor({ type, direction, animation = "0", getMaskId = () => undefined, dependencies, onLoad, }) {
+        this._sprites = new Map();
+        this._x = 0;
+        this._y = 0;
+        this._zIndex = 0;
+        this._direction = 0;
+        this._clickHandler = new ClickHandler_1.ClickHandler();
+        this._overOutHandler = new EventOverOutHandler_1.EventOverOutHandler();
+        this._fallbackVisualization = new AnimatedFurnitureVisualization_1.AnimatedFurnitureVisualization();
+        this._refreshPosition = false;
+        this._refreshFurniture = false;
+        this._refreshZIndex = false;
+        this._highlight = false;
+        this._activeWired = false;
+        this._alpha = 1;
+        this._destroyed = false;
+        this._maskNodes = [];
+        this._maskSprites = [];
+        this._cancelTicker = undefined;
+        this._onTicker = () => {
+            if (this._destroyed)
+                return;
+            if (this._refreshFurniture) {
+                this._refreshFurniture = false;
+                this._updateFurniture();
+            }
+            if (this._refreshPosition) {
+                this._refreshPosition = false;
+                this._updatePosition();
+            }
+            if (this._refreshZIndex) {
+                this._refreshZIndex = false;
+                this._updateZIndex();
+            }
+        };
+        this._direction = direction;
+        this._animation = animation || "0";
+        this._type = type;
+        this._getMaskId = getMaskId;
+        this._onLoad = onLoad;
+        if (dependencies != null) {
+            this.dependencies = dependencies;
+        }
+        this._loadFurniResultPromise = new Promise((resolve, reject) => {
+            this._resolveLoadFurniResult = resolve;
+            this._rejectLoadFurniResult = reject;
+        });
+        this._loadFurniResultPromise.catch(() => undefined);
+    }
+    static fromRoomContext(context, props) {
+        return new BaseFurniture({
+            dependencies: {
+                placeholder: context.configuration.placeholder,
+                animationTicker: context.animationTicker,
+                furnitureLoader: context.furnitureLoader,
+                visualization: context.visualization,
+                application: context.application,
+                eventManager: context.eventManager,
+                configuration: context.configuration,
+            },
+            ...props,
+        });
+    }
+    static fromWsproom(wsproom, container, props) {
+        return new BaseFurniture({
+            dependencies: {
+                animationTicker: wsproom.dependencies.animationTicker,
+                furnitureLoader: wsproom.dependencies.furnitureLoader,
+                placeholder: wsproom.dependencies.configuration.placeholder,
+                configuration: wsproom.dependencies.configuration,
+                application: wsproom.dependencies.application,
+                eventManager: EventManager_1.NOOP_EVENT_MANAGER,
+                visualization: {
+                    container,
+                    addMask: () => {
+                        return {
+                            remove: () => {
+                                // Do nothing
+                            },
+                            update: () => {
+                                // Do nothing
+                            },
+                            sprite: null,
+                        };
+                    },
+                },
+            },
+            ...props,
+        });
+    }
+    get dependencies() {
+        if (this._dependencies == null)
+            throw new Error("Invalid dependencies");
+        return this._dependencies;
+    }
+    set dependencies(value) {
+        this._dependencies = value;
+        // Allow recycling furniture across room.changeTileMap / re-addRoomObject.
+        this._destroyed = false;
+        this._clickHandler.reset();
+        this._loadFurniture();
+    }
+    get visualization() {
+        if (this._visualization == null)
+            return this._fallbackVisualization;
+        return this._visualization;
+    }
+    set visualization(value) {
+        var _a;
+        (_a = this._visualization) === null || _a === void 0 ? void 0 : _a.destroy();
+        this._visualization = value;
+        this._updateFurniture();
+    }
+    get mounted() {
+        return this._dependencies != null;
+    }
+    get height() {
+        return this._loadFurniResultPromise.then((result) => {
+            var _a;
+            // TODO-DEV: Fix this
+            return (_a = result.logicData) === null || _a === void 0 ? void 0 : _a.dimensions.z;
+        });
+    }
+    set height(value) {
+        this.height = value;
+    }
+    /**
+     * Tile footprint of the furniture, in room tiles.
+     */
+    get dimensions() {
+        return this._loadFurniResultPromise.then((result) => {
+            var _a;
+            const dimensions = (_a = result.logicData) === null || _a === void 0 ? void 0 : _a.dimensions;
+            if (dimensions == null)
+                return undefined;
+            return { x: dimensions.x, y: dimensions.y };
+        });
+    }
+    get extradata() {
+        return this._loadFurniResultPromise.then((result) => {
+            return result.getExtraData();
+        });
+    }
+    get validDirections() {
+        return this._loadFurniResultPromise.then((result) => {
+            return result.directions;
+        });
+    }
+    get validAnimations() {
+        return this._loadFurniResultPromise.then((result) => {
+            var _a;
+            var _b;
+            return (_b = (_a = result.visualizationData) === null || _a === void 0 ? void 0 : _a.getAnimationIds(64)) !== null && _b !== void 0 ? _b : [];
+        });
+    }
+    get highlight() {
+        return this._highlight;
+    }
+    set highlight(value) {
+        this._highlight = value;
+        this._refreshFurniture = true;
+        this._scheduleTicker();
+    }
+    get activeWired() {
+        return this._activeWired;
+    }
+    set activeWired(value) {
+        this._activeWired = value;
+        if (this._view != null) {
+            this._view.activeWired = value;
+            this._view.updateLayers();
+        }
+    }
+    get alpha() {
+        return this._alpha;
+    }
+    set alpha(value) {
+        this._alpha = value;
+        this._refreshFurniture = true;
+        this._scheduleTicker();
+    }
+    get onClick() {
+        return this._clickHandler.onClick;
+    }
+    set onClick(value) {
+        this._clickHandler.onClick = value;
+    }
+    get onDoubleClick() {
+        return this._clickHandler.onDoubleClick;
+    }
+    set onDoubleClick(value) {
+        this._clickHandler.onDoubleClick = value;
+    }
+    get onPointerDown() {
+        return this._clickHandler.onPointerDown;
+    }
+    set onPointerDown(value) {
+        this._clickHandler.onPointerDown = value;
+    }
+    get onPointerUp() {
+        return this._clickHandler.onPointerUp;
+    }
+    set onPointerUp(value) {
+        this._clickHandler.onPointerUp = value;
+    }
+    get onPointerOut() {
+        return this._overOutHandler.onOut;
+    }
+    set onPointerOut(value) {
+        this._overOutHandler.onOut = value;
+    }
+    get onPointerOver() {
+        return this._overOutHandler.onOver;
+    }
+    set onPointerOver(value) {
+        this._overOutHandler.onOver = value;
+    }
+    get x() {
+        return this._x;
+    }
+    set x(value) {
+        if (value !== this.x) {
+            this._x = value;
+            this._refreshPosition = true;
+            this._scheduleTicker();
+        }
+    }
+    get y() {
+        return this._y;
+    }
+    set y(value) {
+        if (value !== this.y) {
+            this._y = value;
+            this._refreshPosition = true;
+            this._scheduleTicker();
+        }
+    }
+    get zIndex() {
+        return this._zIndex;
+    }
+    set zIndex(value) {
+        if (value !== this.zIndex) {
+            this._zIndex = value;
+            this._refreshZIndex = true;
+            this._scheduleTicker();
+        }
+    }
+    get direction() {
+        return this._direction;
+    }
+    set direction(value) {
+        this._direction = value;
+        this._updateDirection();
+    }
+    async rotate() {
+        var _a, _b;
+        if (!this._validDirections) {
+            this._validDirections = ((_a = this._loadFurniResult) === null || _a === void 0 ? void 0 : _a.directions) || await this.validDirections;
+        }
+        const currIndex = (_b = this._validDirections) === null || _b === void 0 ? void 0 : _b.indexOf(this._direction);
+        this.direction = (0, getDirectionForFurniture_1.getDirectionForFurniture)(this._validDirections[currIndex + 1], this._validDirections);
+    }
+    get animation() {
+        return this._animation;
+    }
+    set animation(value) {
+        this._animation = value;
+        if (this.mounted) {
+            this.visualization.updateAnimation(this.animation);
+            this._handleAnimationChange();
+        }
+    }
+    get maskId() {
+        return this._getMaskId;
+    }
+    set maskId(value) {
+        this._getMaskId = value;
+    }
+    getEventGroupIdentifier() {
+        return IEventGroup_1.FURNITURE;
+    }
+    destroy() {
+        var _a, _b;
+        this._destroySprites();
+        this._destroyed = true;
+        BaseFurniture._dirtyFurniture.delete(this);
+        this._cancelTicker && this._cancelTicker();
+        this._cancelTicker = undefined;
+        (_a = this._visualization) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this._view) === null || _b === void 0 ? void 0 : _b.destroy();
+    }
+    _scheduleTicker() {
+        BaseFurniture._dirtyFurniture.add(this);
+        if (!BaseFurniture._flushScheduled) {
+            BaseFurniture._flushScheduled = true;
+            PIXI.Ticker.shared.addOnce(BaseFurniture._flushDirty);
+        }
+    }
+    _updateDirection() {
+        if (!this.mounted)
+            return;
+        if (this._validDirections != null) {
+            this.visualization.updateDirection((0, getDirectionForFurniture_1.getDirectionForFurniture)(this.direction, this._validDirections));
+        }
+    }
+    _updateSprites(cb) {
+        this._sprites.forEach(cb);
+        if (this._unknownSprite != null) {
+            cb(this._unknownSprite);
+        }
+    }
+    _updateZIndex() {
+        this._updateSprites((element) => {
+            element.baseZIndex = this.zIndex;
+        });
+    }
+    _updatePosition() {
+        this._updateSprites((element) => {
+            element.baseX = this.x;
+            element.baseY = this.y;
+        });
+        if (this._view == null)
+            return;
+        this._view.x = this.x;
+        this._view.y = this.y;
+        this._view.zIndex = this.zIndex;
+        this._view.updateLayers();
+    }
+    _updateFurniture() {
+        if (!this.mounted)
+            return;
+        if (this._loadFurniResult != null) {
+            this._updateFurnitureSprites(this._loadFurniResult);
+        }
+        else {
+            this._updateUnknown();
+        }
+    }
+    _updateUnknown() {
+        if (!this.mounted)
+            return;
+        if (this._unknownSprite == null) {
+            this._unknownSprite = new FurnitureSprite_1.FurnitureSprite({
+                eventManager: this.dependencies.eventManager,
+                group: this,
+            });
+            this._unknownSprite.baseX = this.x;
+            this._unknownSprite.baseY = this.y;
+            this._unknownSprite.offsetY = -32;
+            if (this._unknownTexture != null) {
+                this._unknownSprite.texture = this._unknownTexture;
+            }
+            this._unknownSprite.zIndex = this.zIndex;
+            this.dependencies.visualization.container.addChild(this._unknownSprite);
+            this._updatePosition();
+        }
+    }
+    _createNewView(loadFurniResult) {
+        var _a;
+        var _b, _c, _d;
+        (_a = this._view) === null || _a === void 0 ? void 0 : _a.destroy();
+        const view = new FurnitureVisualizationView_1.FurnitureVisualizationView(this.dependencies.eventManager, this._clickHandler, this._overOutHandler, this.dependencies.visualization.container, loadFurniResult, this.dependencies.configuration);
+        view.x = this.x;
+        view.y = this.y;
+        view.zIndex = this.zIndex;
+        view.alpha = (_b = this.alpha) !== null && _b !== void 0 ? _b : 1;
+        view.highlight = (_c = this.highlight) !== null && _c !== void 0 ? _c : false;
+        view.activeWired = (_d = this.activeWired) !== null && _d !== void 0 ? _d : false;
+        this._view = view;
+        return view;
+    }
+    _updateFurnitureSprites(loadFurniResult) {
+        var _a;
+        if (!this.mounted)
+            return;
+        this._maskNodes.forEach((node) => node.remove());
+        this._maskNodes = [];
+        (_a = this._unknownSprite) === null || _a === void 0 ? void 0 : _a.destroy();
+        this._unknownSprite = undefined;
+        this.visualization.setView(this._createNewView(loadFurniResult));
+        this.visualization.update(this);
+        this._validDirections = loadFurniResult.directions;
+        this._updateDirection();
+        this.visualization.updateAnimation(this.animation);
+        this.visualization.updateFrame(this.dependencies.animationTicker.current());
+        this._handleAnimationChange();
+        this._updatePosition();
+        this._updateMasks();
+    }
+    /**
+     * Hands the furni's mask sprites to the room, keyed by the wall they belong
+     * to. The landscape looks masks up by that id, so a window that never
+     * registers here leaves its wall unmasked.
+     */
+    _updateMasks() {
+        const view = this._view;
+        if (view == null)
+            return;
+        const maskId = this._getMaskId(this.direction);
+        if (maskId == null)
+            return;
+        view.getMaskSprites().forEach((sprite) => {
+            this._maskNodes.push(this.dependencies.visualization.addMask(maskId, sprite));
+        });
+    }
+    _destroySprites() {
+        var _a;
+        this._sprites.forEach((sprite) => sprite.destroy());
+        this._maskNodes.forEach((node) => node.remove());
+        (_a = this._unknownSprite) === null || _a === void 0 ? void 0 : _a.destroy();
+        this._sprites = new Map();
+    }
+    _loadFurniture() {
+        var _a;
+        if (!this.mounted)
+            return;
+        this._unknownTexture = (_a = this.dependencies.placeholder) !== null && _a !== void 0 ? _a : undefined;
+        this.dependencies.furnitureLoader
+            .loadFurni(this._type)
+            .then((result) => {
+            if (this._destroyed)
+                return;
+            this._loadFurniResult = result;
+            this._resolveLoadFurniResult && this._resolveLoadFurniResult(result);
+            this._updateFurniture();
+            if (this._onLoad) {
+                this._onLoad();
+            }
+        })
+            .catch((error) => {
+            if (this._destroyed)
+                return;
+            this._rejectLoadFurniResult && this._rejectLoadFurniResult(error);
+        });
+        this._updateFurniture();
+    }
+    _handleAnimationChange() {
+        if (this.visualization.isAnimated(this.animation) &&
+            this._cancelTicker == null) {
+            let lastFrame;
+            this._cancelTicker = this.dependencies.animationTicker.subscribe((frame) => {
+                if (frame === lastFrame)
+                    return;
+                lastFrame = frame;
+                this.visualization.updateFrame(frame);
+            });
+            this.visualization.update(this);
+            this.visualization.updateFrame(this.dependencies.animationTicker.current());
+        }
+        if (!this.visualization.isAnimated(this.animation)) {
+            if (this._cancelTicker != null) {
+                this._cancelTicker();
+                this._cancelTicker = undefined;
+            }
+            this.visualization.update(this);
+            this.visualization.updateFrame(this.dependencies.animationTicker.current());
+        }
+    }
+    _getAlpha({ layerAlpha, baseAlpha, }) {
+        if (layerAlpha != null)
+            return (layerAlpha / 255) * baseAlpha;
+        return baseAlpha;
+    }
+}
+exports.BaseFurniture = BaseFurniture;
+BaseFurniture._dirtyFurniture = new Set();
+BaseFurniture._flushScheduled = false;
+BaseFurniture._flushDirty = () => {
+    BaseFurniture._flushScheduled = false;
+    const dirty = Array.from(BaseFurniture._dirtyFurniture);
+    BaseFurniture._dirtyFurniture.clear();
+    dirty.forEach((furniture) => furniture._onTicker());
+};

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

@@ -0,0 +1,163 @@
+import { RoomObject } from "../RoomObject";
+import { IFurniture, IFurnitureBehavior } from "./IFurniture";
+import { IMoveable } from "../interfaces/IMoveable";
+import { FurnitureFetchInfo } from "./FurnitureFetchInfo";
+import { FurnitureId } from "../../interfaces/IFurnitureData";
+export declare class FloorFurniture extends RoomObject implements IFurniture, IMoveable {
+    readonly placementType = "floor";
+    private _baseFurniture;
+    private _moveAnimation;
+    private _animatedPosition;
+    private _moving;
+    private readonly _id;
+    private readonly _type;
+    private _roomX;
+    private _roomY;
+    private _roomZ;
+    constructor(options: {
+        roomX: number;
+        roomY: number;
+        roomZ: number;
+        direction: number;
+        animation?: string;
+        behaviors?: IFurnitureBehavior<FloorFurniture>[];
+    } & FurnitureFetchInfo);
+    /**
+     * 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: number, roomY: number, roomZ: number): void;
+    /**
+     * 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: number, roomY: number, roomZ: number): void;
+    /**
+     * Clears the enqueued movement animations of the furniture
+     */
+    clearMovement(): void;
+    destroyed(): void;
+    registered(): void;
+    /**
+     * If set to true, displays the furniture in the highlight state.
+     */
+    get highlight(): string | boolean;
+    set highlight(value: string | boolean);
+    get activeWired(): boolean;
+    set activeWired(value: boolean);
+    /**
+     * Alpha value of the furniture
+     */
+    get alpha(): number;
+    set alpha(value: number);
+    /**
+     * Type of the furniture
+     */
+    get type(): string | undefined;
+    /**
+     * Callback triggered when the furniture has been clicked on.
+     */
+    get onClick(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onClick(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    /**
+     * Callback triggered when the furniture has been double clicked on.
+     */
+    get onDoubleClick(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onDoubleClick(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onPointerDown(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onPointerDown(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onPointerUp(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onPointerUp(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    get onPointerOver(): ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined;
+    set onPointerOver(value: ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined);
+    get onPointerOut(): ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined;
+    set onPointerOut(value: ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined);
+    /**
+     * ID of the furniture
+     */
+    get id(): FurnitureId | undefined;
+    /**
+     * 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(): Promise<import("./FurnitureExtraData").FurnitureExtraData>;
+    /**
+     * Valid directions of the furniture.
+     */
+    get validDirections(): Promise<number[]>;
+    get validAnimations(): Promise<number[]>;
+    get dimensions(): Promise<{
+        x: number;
+        y: number;
+    } | undefined>;
+    /**
+     * Animation of the furniture
+     */
+    get animation(): string;
+    set animation(value: string);
+    /**
+     * Direction of the furniture
+     */
+    get direction(): number;
+    set direction(value: number);
+    rotate(): () => Promise<void>;
+    /**
+     * The x position of the avatar in the room.
+     * The y-Axis is marked in the following graphic:
+     *
+     * ```
+     *    |
+     *    |
+     *    |
+     *   / \
+     *  /   \   <- x-Axis
+     * /     \
+     * ```
+     */
+    get roomX(): number;
+    set roomX(value: number);
+    /**
+     * The y position of the avatar in the room.
+     * The y-Axis is marked in the following graphic:
+     *
+     * ```
+     *              |
+     *              |
+     *              |
+     *             / \
+     * y-Axis ->  /   \
+     *           /     \
+     * ```
+     */
+    get roomY(): number;
+    set roomY(value: number);
+    /**
+     * The z position of the avatar in the room.
+     * The z-Axis is marked in the following graphic:
+     *
+     * ```
+     *              |
+     *   z-Axis ->  |
+     *              |
+     *             / \
+     *            /   \
+     *           /     \
+     * ```
+     */
+    get roomZ(): number;
+    set roomZ(value: number);
+    get height(): Promise<number | undefined>;
+    get visualization(): import("./IFurnitureVisualization").IFurnitureVisualization;
+    set visualization(value: import("./IFurnitureVisualization").IFurnitureVisualization);
+    private _getDisplayRoomPosition;
+    private _updatePosition;
+}