@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,25 @@
+import { HitSprite } from "../hitdetection/HitSprite";
+export declare class FurnitureSprite extends HitSprite {
+    private _baseX;
+    private _baseY;
+    private _baseZIndex;
+    private _offsetX;
+    private _offsetY;
+    private _offsetZIndex;
+    private _assetName;
+    get offsetX(): number;
+    set offsetX(value: number);
+    get offsetY(): number;
+    set offsetY(value: number);
+    get offsetZIndex(): number;
+    set offsetZIndex(value: number);
+    get baseX(): number;
+    set baseX(value: number);
+    get baseY(): number;
+    set baseY(value: number);
+    get baseZIndex(): number;
+    set baseZIndex(value: number);
+    get assetName(): string | undefined;
+    set assetName(value: string | undefined);
+    private _update;
+}

package/dist/objects/furniture/FurnitureSprite.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureSprite = void 0;
+const HitSprite_1 = require("../hitdetection/HitSprite");
+class FurnitureSprite extends HitSprite_1.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;
+    }
+}
+exports.FurnitureSprite = FurnitureSprite;

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

@@ -0,0 +1,66 @@
+import * as PIXI from "pixi.js";
+import { EventOverOutHandler } from "../events/EventOverOutHandler";
+import { EventGroupIdentifier, IEventGroup } from "../events/interfaces/IEventGroup";
+import { IEventManager } from "../events/interfaces/IEventManager";
+import { ClickHandler } from "../hitdetection/ClickHandler";
+import { IFurnitureVisualizationData } from "./data/interfaces/IFurnitureVisualizationData";
+import { FurnitureSprite } from "./FurnitureSprite";
+import { IFurnitureVisualizationLayer, IFurnitureVisualizationView } from "./IFurnitureVisualizationView";
+import { LoadFurniResult } from "./util/loadFurni";
+import { IConfiguration } from "../../interfaces/IConfiguration";
+export declare class FurnitureVisualizationView implements IFurnitureVisualizationView, IBaseFurniture, IEventGroup {
+    private _eventManager;
+    private _clickHandler;
+    private _overOutHandler;
+    private _container;
+    private _furniture;
+    private _configuration;
+    private _direction;
+    private _animation;
+    private _cache;
+    private _layers;
+    private _x;
+    private _y;
+    private _zIndex;
+    private _alpha;
+    private _highlight;
+    private _activeWired;
+    get activeWired(): boolean;
+    set activeWired(value: boolean);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get zIndex(): number;
+    set zIndex(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get highlight(): string | boolean;
+    set highlight(value: string | boolean);
+    constructor(_eventManager: IEventManager, _clickHandler: ClickHandler, _overOutHandler: EventOverOutHandler, _container: PIXI.Container, _furniture: LoadFurniResult, _configuration?: IConfiguration);
+    get configuration(): IConfiguration;
+    getEventGroupIdentifier(): EventGroupIdentifier;
+    getLayers(): IFurnitureVisualizationLayer[];
+    getVisualizationData(): IFurnitureVisualizationData;
+    setDisplayAnimation(animation?: string): void;
+    setDisplayDirection(direction: number): void;
+    updateLayers(): void;
+    updateDisplay(): void;
+    destroy(): void;
+    /**
+     * Sprites of the furni's `_mask` asset. A window ships its own mask (see the
+     * `*_<direction>_mask` asset), and the landscape uses it to know which part of
+     * the wall the glass opens up — without registering it the wall has no mask
+     * at all and gets clipped away entirely.
+     */
+    getMaskSprites(): FurnitureSprite[];
+    private _getDrawDefinition;
+}
+export interface IBaseFurniture {
+    x: number;
+    y: number;
+    zIndex: number;
+    alpha: number;
+    highlight: boolean | string;
+    activeWired: boolean;
+}

package/dist/objects/furniture/FurnitureVisualizationView.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureVisualizationView = void 0;
+const IEventGroup_1 = require("../events/interfaces/IEventGroup");
+const HighlightFilter_1 = require("./filter/HighlightFilter");
+const ActiveWiredFilter_1 = require("./filter/ActiveWiredFilter");
+const FurnitureSprite_1 = require("./FurnitureSprite");
+const activeWiredFilter = new ActiveWiredFilter_1.ActiveWiredFilter();
+const DEFAULT_HIGHLIGHT_FILTERS = {
+    default: new HighlightFilter_1.HighlightFilter(0x7dabab, 0xffffff, 1),
+    primary: new HighlightFilter_1.HighlightFilter(0xb8d45a, 0xffffff, 1),
+    secondary: new HighlightFilter_1.HighlightFilter(0x727dd9, 0xffffff, 1),
+};
+class FurnitureVisualizationView {
+    get activeWired() {
+        return this._activeWired;
+    }
+    set activeWired(value) {
+        this._activeWired = value;
+    }
+    get x() {
+        if (this._x == null)
+            throw new Error("x not set");
+        return this._x;
+    }
+    set x(value) {
+        this._x = value;
+    }
+    get y() {
+        if (this._y == null)
+            throw new Error("y not set");
+        return this._y;
+    }
+    set y(value) {
+        this._y = value;
+    }
+    get zIndex() {
+        if (this._zIndex == null)
+            throw new Error("zIndex not set");
+        return this._zIndex;
+    }
+    set zIndex(value) {
+        this._zIndex = value;
+    }
+    get alpha() {
+        if (this._alpha == null)
+            throw new Error("alpha not set");
+        return this._alpha;
+    }
+    set alpha(value) {
+        this._alpha = value;
+    }
+    get highlight() {
+        if (this._highlight == null)
+            throw new Error("highlight not set");
+        return this._highlight;
+    }
+    set highlight(value) {
+        this._highlight = value;
+    }
+    constructor(_eventManager, _clickHandler, _overOutHandler, _container, _furniture, _configuration = {}) {
+        this._eventManager = _eventManager;
+        this._clickHandler = _clickHandler;
+        this._overOutHandler = _overOutHandler;
+        this._container = _container;
+        this._furniture = _furniture;
+        this._configuration = _configuration;
+        this._cache = new Map();
+        this._activeWired = false;
+    }
+    get configuration() {
+        return this._configuration;
+    }
+    getEventGroupIdentifier() {
+        return IEventGroup_1.FURNITURE;
+    }
+    getLayers() {
+        if (this._layers == null)
+            throw new Error("Layers not set yet. Call `updateDisplay` before accessing the layers.");
+        return this._layers;
+    }
+    getVisualizationData() {
+        return this._furniture.visualizationData;
+    }
+    setDisplayAnimation(animation) {
+        if (this._animation !== animation) {
+            this._cache.clear();
+        }
+        this._animation = animation;
+    }
+    setDisplayDirection(direction) {
+        this._direction = direction;
+    }
+    updateLayers() {
+        var _a;
+        (_a = this._layers) === null || _a === void 0 ? void 0 : _a.forEach((layer) => {
+            layer.x = this.x;
+            layer.y = this.y;
+            layer.zIndex = this.zIndex;
+            layer.alpha = this.alpha;
+            layer.highlight = this.highlight;
+            layer.activeWired = this.activeWired;
+            layer.update();
+        });
+    }
+    updateDisplay() {
+        var _a;
+        if (this._direction == null)
+            throw new Error("Direction was not set");
+        const direction = this._direction;
+        const animation = this._animation;
+        (_a = this._layers) === null || _a === void 0 ? void 0 : _a.forEach((layer) => layer.destroy());
+        this._layers = this._getDrawDefinition(direction, animation).parts.map((part) => new FurnitureVisualizationLayer(this, this._container, part, this._eventManager, this._clickHandler, this._overOutHandler, (id) => this._furniture.getTexture(id)));
+        this.updateLayers();
+    }
+    destroy() {
+        var _a;
+        (_a = this._layers) === null || _a === void 0 ? void 0 : _a.forEach((layer) => layer.destroy());
+    }
+    /**
+     * Sprites of the furni's `_mask` asset. A window ships its own mask (see the
+     * `*_<direction>_mask` asset), and the landscape uses it to know which part of
+     * the wall the glass opens up — without registering it the wall has no mask
+     * at all and gets clipped away entirely.
+     */
+    getMaskSprites() {
+        var _a;
+        return ((_a = this._layers) !== null && _a !== void 0 ? _a : [])
+            .filter((layer) => layer.isMask)
+            .flatMap((layer) => layer.getSprites());
+    }
+    _getDrawDefinition(direction, animation) {
+        animation = animation !== null && animation !== void 0 ? animation : "undefined";
+        const key = `${direction}_${animation}`;
+        const current = this._cache.get(key);
+        if (current != null)
+            return current;
+        const definition = this._furniture.getDrawDefinition(direction, animation);
+        this._cache.set(key, definition);
+        return definition;
+    }
+}
+exports.FurnitureVisualizationView = FurnitureVisualizationView;
+class FurnitureVisualizationLayer {
+    get highlight() {
+        if (this._highlight == null)
+            throw new Error("highlight not set");
+        return this._highlight;
+    }
+    set highlight(value) {
+        if (value === this._highlight)
+            return;
+        this._highlight = value;
+        this._spritesChanged = true;
+    }
+    get activeWired() {
+        var _a;
+        return (_a = this._activeWired) !== null && _a !== void 0 ? _a : false;
+    }
+    set activeWired(value) {
+        if (value === this._activeWired)
+            return;
+        this._activeWired = value;
+        this._spritesChanged = true;
+    }
+    get alpha() {
+        if (this._alpha == null)
+            throw new Error("alpha not set");
+        return this._alpha;
+    }
+    set alpha(value) {
+        if (value === this._alpha)
+            return;
+        this._alpha = value;
+        this._spritesChanged = true;
+    }
+    get x() {
+        if (this._x == null)
+            throw new Error("x not set");
+        return this._x;
+    }
+    set x(value) {
+        if (value === this._x)
+            return;
+        this._x = value;
+        this._spritePositionChanged = true;
+    }
+    get y() {
+        if (this._y == null)
+            throw new Error("y not set");
+        return this._y;
+    }
+    set y(value) {
+        if (this._y === value)
+            return;
+        this._y = value;
+        this._spritePositionChanged = true;
+    }
+    get zIndex() {
+        if (this._zIndex == null)
+            throw new Error("zIndex not set");
+        return this._zIndex;
+    }
+    set zIndex(value) {
+        if (this._zIndex === value)
+            return;
+        this._zIndex = value;
+        this._spritePositionChanged = true;
+    }
+    get tag() {
+        var _a;
+        return (_a = this._part.layer) === null || _a === void 0 ? void 0 : _a.tag;
+    }
+    get z() {
+        var _a;
+        return (_a = this._part.z) !== null && _a !== void 0 ? _a : 0;
+    }
+    get ink() {
+        var _a;
+        return (_a = this._part.layer) === null || _a === void 0 ? void 0 : _a.ink;
+    }
+    get isMask() {
+        return this._part.mask === true;
+    }
+    getSprites() {
+        return Array.from(this._sprites.values());
+    }
+    constructor(_parent, _container, _part, _eventManager, _clickHandler, _overOutHandler, _getTexture) {
+        this._parent = _parent;
+        this._container = _container;
+        this._part = _part;
+        this._eventManager = _eventManager;
+        this._clickHandler = _clickHandler;
+        this._overOutHandler = _overOutHandler;
+        this._getTexture = _getTexture;
+        this._sprites = new Map();
+        this._maskSprites = new Set();
+        this._spritePositionChanged = false;
+        this._spritesChanged = false;
+        this._frameIndex = 0;
+        this._allSpritesMounted = false;
+        this._mountedSprites = new Set();
+        this.frameRepeat = _part.frameRepeat;
+        this.layerIndex = _part.layerIndex;
+        this.assetCount = _part.assets.length;
+    }
+    setColor(color) {
+        if (this._color === color)
+            return;
+        this._color = color;
+        this._spritesChanged = true;
+    }
+    setCurrentFrameIndex(value) {
+        if (this._appliedFrameIndex === value)
+            return;
+        this._appliedFrameIndex = value;
+        const previousFrameIndex = this._frameIndex;
+        this._frameIndex = value;
+        const previousFrame = this._getSprite(previousFrameIndex);
+        if (previousFrame != null) {
+            this._setSpriteVisible(previousFrame, false);
+        }
+        const newFrame = this._getSprite(this._frameIndex);
+        if (newFrame != null) {
+            this._setSpriteVisible(newFrame, true);
+            this._addSprite(newFrame);
+            if (this._color != null) {
+                newFrame.tint = this._color;
+            }
+        }
+    }
+    update() {
+        if (!this._allSpritesMounted) {
+            this._allSpritesMounted = true;
+            this._mountAllSprites();
+        }
+        if (this._spritePositionChanged) {
+            this._spritePositionChanged = false;
+            this._updateSpritesPosition();
+        }
+        if (this._spritesChanged) {
+            this._spritesChanged = false;
+            this._destroySprites();
+            this._updateSprites();
+        }
+    }
+    destroy() {
+        this._destroySprites();
+    }
+    _updateSpritePosition(sprite) {
+        sprite.baseX = this.x;
+        sprite.baseY = this.y;
+        sprite.baseZIndex = this.zIndex;
+    }
+    _addSprite(sprite) {
+        // A mask asset is a black silhouette: it only ever gets drawn by the room,
+        // as the mask that cuts a wall open. Off the wall there is no such mask, so
+        // keeping it in the furni's own tree is what paints it black.
+        if (this._maskSprites.has(sprite))
+            return;
+        if (this._mountedSprites.has(sprite))
+            return;
+        this._mountedSprites.add(sprite);
+        this._container.addChild(sprite);
+        this._overOutHandler.register(sprite.events);
+    }
+    _destroySprites() {
+        this._sprites.forEach((sprite) => {
+            this._container.removeChild(sprite);
+            this._overOutHandler.remove(sprite.events);
+            sprite.destroy();
+        });
+        this._sprites = new Map();
+        this._mountedSprites = new Set();
+        this._maskSprites = new Set();
+        this._appliedFrameIndex = undefined;
+    }
+    _setSpriteVisible(sprite, visible) {
+        if (visible) {
+            sprite.ignore = false;
+            sprite.visible = true;
+        }
+        else {
+            sprite.ignore = true;
+            sprite.visible = false;
+        }
+    }
+    // Mounts every frame's sprite (hidden) up front. Layers are processed in
+    // draw order, so this pins the container insertion order to the layer
+    // order. With lazy mounting, sprites of equal zIndex were stacked by
+    // whichever layer created a new frame sprite last, making upper layers
+    // (e.g. the "b" overlay of wired selectors) intermittently disappear
+    // behind lower ones.
+    _mountAllSprites() {
+        for (let i = 0; i < this.assetCount; i++) {
+            const sprite = this._getSprite(i);
+            if (sprite != null)
+                this._addSprite(sprite);
+        }
+    }
+    _updateSprites() {
+        this._mountAllSprites();
+        const frameIndex = this._frameIndex;
+        const sprite = this._getSprite(frameIndex);
+        this._sprites.forEach((sprite) => this._setSpriteVisible(sprite, false));
+        if (sprite != null) {
+            this._addSprite(sprite);
+            this._setSpriteVisible(sprite, true);
+        }
+    }
+    _updateSpritesPosition() {
+        this._sprites.forEach((sprite) => {
+            this._updateSpritePosition(sprite);
+        });
+    }
+    _getSpriteInfo(frameIndex) {
+        const asset = this._part.assets[frameIndex];
+        if (asset == null)
+            return;
+        const texture = this._getTexture(getAssetTextureName(asset));
+        return {
+            asset,
+            texture,
+        };
+    }
+    _getSprite(frameIndex) {
+        var _a, _b, _c, _d;
+        const current = this._sprites.get(frameIndex);
+        if (current != null) {
+            return current;
+        }
+        const spriteInfo = this._getSpriteInfo(frameIndex);
+        if (spriteInfo == null)
+            return;
+        const { z, layer, shadow, mask, tint } = this._part;
+        const { asset, texture } = spriteInfo;
+        const zIndex = z !== null && z !== void 0 ? z : 0;
+        const sprite = new FurnitureSprite_1.FurnitureSprite({
+            eventManager: this._eventManager,
+            mirrored: asset.flipH,
+            tag: layer === null || layer === void 0 ? void 0 : layer.tag,
+            group: this._parent,
+        });
+        if (mask)
+            this._maskSprites.add(sprite);
+        const ignoreMouse = (layer === null || layer === void 0 ? void 0 : layer.ignoreMouse) != null && layer.ignoreMouse;
+        sprite.ignoreMouse = ignoreMouse;
+        sprite.events.addEventListener("click", (event) => {
+            this._clickHandler.handleClick(event);
+        });
+        sprite.events.addEventListener("pointerup", (event) => {
+            this._clickHandler.handlePointerUp(event);
+        });
+        sprite.events.addEventListener("pointerdown", (event) => {
+            this._clickHandler.handlePointerDown(event);
+        });
+        sprite.hitTexture = texture;
+        // Apply asset styling
+        const highlight = this._highlight /* && layer?.ink == null */ && !shadow && !mask;
+        const configuration = this._parent.configuration;
+        const custom = configuration.highlightFilters;
+        const wiredFilter = (_a = configuration.activeWiredFilter) !== null && _a !== void 0 ? _a : activeWiredFilter;
+        if (highlight) {
+            const key = typeof this._highlight === 'string' ? this._highlight : 'default';
+            const filter = (_d = (_c = (_b = custom === null || custom === void 0 ? void 0 : custom[key]) !== null && _b !== void 0 ? _b : DEFAULT_HIGHLIGHT_FILTERS[key]) !== null && _c !== void 0 ? _c : custom === null || custom === void 0 ? void 0 : custom.default) !== null && _d !== void 0 ? _d : DEFAULT_HIGHLIGHT_FILTERS.default;
+            sprite.filters = this._activeWired ? [filter, wiredFilter] : [filter];
+        }
+        else if (this._activeWired && !shadow && !mask) {
+            sprite.filters = [wiredFilter];
+        }
+        else {
+            sprite.filters = [];
+        }
+        const scaleX = asset.flipH ? -1 : 1;
+        const offsetX = +(32 - asset.x * scaleX);
+        const offsetY = -asset.y + 16;
+        sprite.offsetX = offsetX;
+        sprite.offsetY = offsetY;
+        sprite.offsetZIndex = zIndex;
+        sprite.baseX = this.x;
+        sprite.baseY = this.y;
+        sprite.baseZIndex = this.zIndex;
+        if (shadow) {
+            sprite.baseZIndex = this.zIndex;
+            sprite.offsetZIndex = -this.zIndex;
+        }
+        if (tint != null) {
+            sprite.tint = parseInt(tint, 16);
+        }
+        const alpha = this._getAlpha({
+            baseAlpha: this.alpha,
+            layerAlpha: layer === null || layer === void 0 ? void 0 : layer.alpha,
+        });
+        if (layer != null) {
+            if (layer.ink != null) {
+                if (this.highlight) {
+                    sprite.visible = false;
+                }
+                sprite.blendMode = inkToBlendMode(layer.ink);
+            }
+        }
+        if (shadow) {
+            if (this.highlight) {
+                sprite.visible = false;
+                sprite.alpha = 0;
+            }
+            else {
+                sprite.visible = true;
+                sprite.alpha = alpha / 5;
+            }
+        }
+        else {
+            sprite.visible = true;
+            sprite.alpha = alpha;
+        }
+        if (mask) {
+            sprite.tint = 0xffffff;
+        }
+        if (this._color != null) {
+            sprite.tint = this._color;
+        }
+        this._setSpriteVisible(sprite, false);
+        this._sprites.set(frameIndex, sprite);
+        this._overOutHandler.register(sprite.events);
+        return sprite;
+    }
+    _getAlpha({ layerAlpha, baseAlpha, }) {
+        if (layerAlpha != null)
+            return (layerAlpha / 255) * baseAlpha;
+        return baseAlpha;
+    }
+}
+const getAssetTextureName = (asset) => { var _a; return (_a = asset.source) !== null && _a !== void 0 ? _a : asset.name; };
+const inkToBlendMode = (ink) => {
+    if (ink === "ADD" || ink === "33" || Number(ink) === 33)
+        return "add";
+    if (ink === "SCREEN" || Number(ink) === 3)
+        return "screen";
+    if (ink === "MULTIPLY")
+        return "multiply";
+    return "normal";
+};

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

@@ -0,0 +1,26 @@
+import { FurnitureId } from "../../interfaces/IFurnitureData";
+import { FurnitureExtraData } from "./FurnitureExtraData";
+import { IFurnitureVisualization } from "./IFurnitureVisualization";
+import { IFurnitureEventHandlers } from "./util/IFurnitureEventHandlers";
+export interface IFurniture extends IFurnitureEventHandlers {
+    id: FurnitureId | undefined;
+    type: string | undefined;
+    roomX: number;
+    roomY: number;
+    roomZ: number;
+    direction: number;
+    animation: string | undefined;
+    highlight: boolean | string | undefined;
+    activeWired: boolean | undefined;
+    placementType: "wall" | "floor";
+    alpha: number;
+    extradata: Promise<FurnitureExtraData>;
+    validDirections: Promise<number[]>;
+    visualization: IFurnitureVisualization;
+}
+export interface IFurnitureExtended extends IFurniture {
+    rotate: () => Promise<void>;
+}
+export type IFurnitureBehavior<T extends IFurniture = IFurniture> = {
+    setParent(furniture: T): void;
+};

package/dist/objects/furniture/IFurniture.js

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

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

@@ -0,0 +1,12 @@
+import { HitTexture } from "../hitdetection/HitTexture";
+import { IFurnitureAssetsData } from "./data/interfaces/IFurnitureAssetsData";
+import { IFurnitureIndexData } from "./data/interfaces/IFurnitureIndexData";
+import { IFurnitureLogicData } from "./data/interfaces/IFurnitureLogicData";
+import { IFurnitureVisualizationData } from "./data/interfaces/IFurnitureVisualizationData";
+export interface IFurnitureAssetBundle {
+    getAssets(): Promise<IFurnitureAssetsData>;
+    getVisualization(): Promise<IFurnitureVisualizationData>;
+    getTexture(name: string): Promise<HitTexture>;
+    getIndex(): Promise<IFurnitureIndexData>;
+    getLogic(): Promise<IFurnitureLogicData>;
+}

package/dist/objects/furniture/IFurnitureAssetBundle.js

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