@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,482 @@
+import * as PIXI from "pixi.js";
+import { ClickHandler } from "../hitdetection/ClickHandler";
+import { FurnitureSprite } from "./FurnitureSprite";
+import { AnimatedFurnitureVisualization } from "./visualization/AnimatedFurnitureVisualization";
+import { getDirectionForFurniture } from "./util/getDirectionForFurniture";
+import { FURNITURE, } from "../events/interfaces/IEventGroup";
+import { NOOP_EVENT_MANAGER } from "../events/EventManager";
+import { FurnitureVisualizationView } from "./FurnitureVisualizationView";
+import { EventOverOutHandler } from "../events/EventOverOutHandler";
+export 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();
+        this._overOutHandler = new EventOverOutHandler();
+        this._fallbackVisualization = new 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: 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 = 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 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(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({
+                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(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;
+    }
+}
+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());
+};