@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,478 @@
+import { FURNITURE, } from "../events/interfaces/IEventGroup";
+import { HighlightFilter } from "./filter/HighlightFilter";
+import { ActiveWiredFilter } from "./filter/ActiveWiredFilter";
+import { FurnitureSprite } from "./FurnitureSprite";
+const activeWiredFilter = new ActiveWiredFilter();
+const DEFAULT_HIGHLIGHT_FILTERS = {
+    default: new HighlightFilter(0x7dabab, 0xffffff, 1),
+    primary: new HighlightFilter(0xb8d45a, 0xffffff, 1),
+    secondary: new HighlightFilter(0x727dd9, 0xffffff, 1),
+};
+export 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 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;
+    }
+}
+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({
+            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-esm/objects/furniture/IFurniture.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,52 @@
+import * as PIXI from "pixi.js";
+import { HitTexture } from "../hitdetection/HitTexture";
+import { JsonFurnitureAssetsData } from "./data/JsonFurnitureAssetsData";
+import { JsonFurnitureVisualizationData } from "./data/JsonFurnitureVisualizationData";
+import { JsonFurnitureLogicData } from "./data/JsonFurnitureLogicData";
+export class JsonFurnitureAssetBundle {
+    constructor(_assetBundle) {
+        this._assetBundle = _assetBundle;
+        this._data = this._load();
+    }
+    async getLogic() {
+        const { logic } = await this._data;
+        return logic;
+    }
+    async getAssets() {
+        const { assets } = await this._data;
+        return assets;
+    }
+    async getVisualization() {
+        const { visualization } = await this._data;
+        return visualization;
+    }
+    async getTexture(name) {
+        const { spritesheet } = await this._data;
+        return HitTexture.fromSpriteSheet(spritesheet, name);
+    }
+    async getIndex() {
+        const { index } = await this._data;
+        return index;
+    }
+    async _load() {
+        const json = JSON.parse(await this._assetBundle.getString("index.json"));
+        const blob = await this._assetBundle.getBlob("spritesheet.png");
+        const baseTextureImage = await createImageBitmap(blob, {
+            premultiplyAlpha: "none",
+            colorSpaceConversion: "none",
+        });
+        const texture = PIXI.Texture.from(baseTextureImage);
+        texture.source.scaleMode = "nearest";
+        texture.source.antialias = false;
+        texture.source.autoGenerateMipmaps = false;
+        const spritesheet = new PIXI.Spritesheet(texture, json.spritesheet);
+        await spritesheet.parse();
+        return {
+            assets: new JsonFurnitureAssetsData(json.assets),
+            visualization: new JsonFurnitureVisualizationData(json.visualization),
+            index: json.index,
+            spritesheet,
+            logic: new JsonFurnitureLogicData(json.logic),
+        };
+    }
+}