@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/objects/furniture/visualization/AnimatedFurnitureVisualization.js

@@ -0,0 +1,210 @@
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export class AnimatedFurnitureVisualization extends FurnitureVisualization {
+    constructor() {
+        super();
+        this._animationQueue = [];
+        this._sprites = new Set();
+        this._disableTransitions = false;
+        this._frame = 0;
+        this._changeAnimationCount = 0;
+        this._lastFramePlayedMap = new Map();
+        this._refreshFurniture = false;
+        this._refreshFurniture = true;
+    }
+    get animationId() {
+        if (this._overrideAnimation != null) {
+            return this._overrideAnimation;
+        }
+        return this._currentAnimationId;
+    }
+    set animationId(value) {
+        this._overrideAnimation = value;
+        this._refreshFurniture = true;
+    }
+    get modifier() {
+        return this._modifier;
+    }
+    set modifier(value) {
+        this._modifier = value;
+        this._updateFurniture();
+    }
+    setView(view) {
+        super.setView(view);
+        this._currentTargetAnimationId = undefined;
+        this._currentDirection = undefined;
+        this._currentAnimationId = undefined;
+    }
+    setCurrentAnimation(newAnimation) {
+        this._animationQueueStartFrame = undefined;
+        // Skip the transitions of the initial animation change.
+        this._animationQueue = this._getAnimationList(this.view.getVisualizationData(), newAnimation);
+        this._disableTransitions = this._changeAnimationCount === 0;
+        this._changeAnimationCount++;
+        this._update();
+    }
+    updateAnimation(animation) {
+        this._updateAnimation(this._currentTargetAnimationId, animation);
+    }
+    updateDirection(direction) {
+        if (this._currentDirection === direction)
+            return;
+        this._currentDirection = direction;
+        this._updateFurniture();
+    }
+    isLastFramePlayedForLayer(layerIndex) {
+        var _a;
+        return (_a = this._lastFramePlayedMap.get(layerIndex)) !== null && _a !== void 0 ? _a : false;
+    }
+    destroy() {
+        // Do nothing
+    }
+    update() {
+        if (this._currentDirection == null)
+            return;
+        this.view.setDisplayDirection(this._currentDirection);
+        this.view.updateDisplay();
+        this._update();
+    }
+    updateFrame(frame) {
+        if (this._refreshFurniture) {
+            this._refreshFurniture = false;
+            this._updateFurniture();
+        }
+        if (this._animationQueueStartFrame == null) {
+            this._animationQueueStartFrame = frame;
+        }
+        if (this._animationQueue.length > 0) {
+            const progress = this._getCurrentProgress(frame);
+            let frameCounter = 0;
+            let animationId;
+            let animationFrameCount;
+            for (let i = 0; i < this._animationQueue.length; i++) {
+                const animation = this._animationQueue[i];
+                frameCounter += animation.frameCount;
+                if (progress < frameCounter) {
+                    animationId = animation.id;
+                    animationFrameCount = animation.frameCount;
+                    break;
+                }
+            }
+            if (animationId == null ||
+                animationFrameCount == null ||
+                this._disableTransitions) {
+                const animation = this._animationQueue[this._animationQueue.length - 1];
+                animationId = animation.id;
+                animationFrameCount = animation.frameCount;
+            }
+            this._setAnimation(animationId);
+            this._animationFrameCount = animationFrameCount;
+            this._frame = progress;
+        }
+        this._update(true);
+    }
+    isAnimated(animation = "0") {
+        var _a;
+        if (!this.mounted)
+            return true;
+        const data = this.view.getVisualizationData();
+        const animationId = Number(animation);
+        if (Number.isNaN(animationId))
+            return true;
+        if (data.getTransitionForAnimation(64, animationId) != null)
+            return true;
+        const frameCount = (_a = data.getFrameCount(64, animationId)) !== null && _a !== void 0 ? _a : 1;
+        return frameCount > 1;
+    }
+    _getCurrentProgress(frame) {
+        if (this._animationQueueStartFrame == null) {
+            return 0;
+        }
+        return frame - this._animationQueueStartFrame;
+    }
+    _setAnimation(animation) {
+        if (this._currentAnimationId === animation)
+            return;
+        this._currentAnimationId = animation;
+        this._updateFurniture();
+    }
+    _updateLayers() {
+        if (this.modifier != null) {
+            const modifier = this.modifier;
+            this.view.getLayers().forEach((layer) => modifier(layer));
+        }
+    }
+    _updateFurniture() {
+        var _a;
+        var _b;
+        if (!this.mounted)
+            return;
+        this.view.setDisplayDirection((_b = this._currentDirection) !== null && _b !== void 0 ? _b : 0);
+        this.view.setDisplayAnimation((_a = this.animationId) === null || _a === void 0 ? void 0 : _a.toString());
+        this.view.updateDisplay();
+        this._updateLayers();
+        this._update();
+    }
+    _update(skipLayerUpdate = false) {
+        var _a;
+        const frameCount = (_a = this._animationFrameCount) !== null && _a !== void 0 ? _a : 1;
+        this.view.getLayers().forEach((part) => {
+            if (this.modifier != null) {
+                part = this.modifier(part);
+            }
+            const frameProgress = this._frame % frameCount;
+            // Each layer cycles through its own frame sequence independently, like
+            // the official client. The global frame count only bounds the animation
+            // as a whole — layers with a shorter sequence (or a different
+            // frameRepeat) wrap around instead of freezing on their last frame.
+            let frameIndex = Math.floor(frameProgress / part.frameRepeat);
+            if (part.assetCount > 0) {
+                frameIndex = frameIndex % part.assetCount;
+            }
+            else {
+                frameIndex = 0;
+            }
+            if (frameProgress === frameCount - 1) {
+                this._lastFramePlayedMap.set(part.layerIndex, true);
+            }
+            else {
+                this._lastFramePlayedMap.set(part.layerIndex, false);
+            }
+            part.setCurrentFrameIndex(frameIndex);
+        });
+    }
+    _getAnimationList(data, target) {
+        const animations = [];
+        const handleAnimation = (id) => {
+            var _a;
+            const transition = data.getTransitionForAnimation(64, id);
+            if (transition != null) {
+                handleAnimation(transition.id);
+            }
+            const animation = data.getAnimation(64, id);
+            const frameCount = (_a = data.getFrameCount(64, id)) !== null && _a !== void 0 ? _a : 1;
+            if (animation != null) {
+                animations.push({ id: animation.id, frameCount });
+            }
+        };
+        handleAnimation(target);
+        if (animations.length === 0) {
+            return [{ id: 0, frameCount: 1 }];
+        }
+        return animations;
+    }
+    _updateAnimation(oldAnimation, newAnimation) {
+        this._currentTargetAnimationId = newAnimation;
+        if (newAnimation == null) {
+            this.setCurrentAnimation(0);
+        }
+        else if (oldAnimation == newAnimation) {
+            // Do nothing
+        }
+        else if (oldAnimation != newAnimation) {
+            this.setCurrentAnimation(Number(newAnimation));
+        }
+    }
+}
+const getAssetsCount = (part) => {
+    if (part.assets == null)
+        return 1;
+    return part.assets.length;
+};

package/dist-esm/objects/furniture/visualization/BasicFurnitureVisualization.js

@@ -0,0 +1,50 @@
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export class StaticFurnitureVisualization extends FurnitureVisualization {
+    constructor() {
+        super(...arguments);
+        this._sprites = [];
+        this._refreshFurniture = false;
+    }
+    setView(view) {
+        super.setView(view);
+        this._update();
+    }
+    updateDirection(direction) {
+        if (this._currentDirection === direction)
+            return;
+        this._currentDirection = direction;
+        this._update();
+    }
+    updateAnimation(animation) {
+        if (this._animationId === animation)
+            return;
+        this._animationId = animation;
+        this._update();
+    }
+    updateFrame() {
+        if (!this.mounted)
+            return;
+        if (this._refreshFurniture) {
+            this._refreshFurniture = false;
+            this._update();
+        }
+    }
+    update() {
+        this._update();
+    }
+    destroy() {
+        // Do nothing
+    }
+    _update() {
+        if (this._currentDirection == null)
+            return;
+        this.view.setDisplayAnimation(this._animationId);
+        this.view.setDisplayDirection(this._currentDirection);
+        this.view.updateDisplay();
+        this.view.getLayers().forEach((layer) => layer.setCurrentFrameIndex(0));
+    }
+}
+/**
+ * @deprecated Use `StaticFurnitureVisualization`
+ */
+export const BasicFurnitureVisualization = StaticFurnitureVisualization;

package/dist-esm/objects/furniture/visualization/FurnitureBottleVisualization.js

@@ -0,0 +1,61 @@
+import { AnimatedFurnitureVisualization } from "./AnimatedFurnitureVisualization";
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export class FurnitureBottleVisualization extends FurnitureVisualization {
+    constructor() {
+        super(...arguments);
+        this._base = new AnimatedFurnitureVisualization();
+        this._stateQueue = [];
+        this._running = false;
+    }
+    isAnimated() {
+        return true;
+    }
+    destroy() {
+        this._base.destroy();
+    }
+    update() {
+        this._base.update();
+    }
+    setView(view) {
+        super.setView(view);
+        this._base.setView(view);
+    }
+    updateFrame(frame) {
+        if (this._stateQueue.length > 0 &&
+            this._base.isLastFramePlayedForLayer(0)) {
+            const nextAnimation = this._stateQueue.shift();
+            if (nextAnimation != null) {
+                this._base.setCurrentAnimation(nextAnimation);
+            }
+        }
+        this._base.updateFrame(frame);
+    }
+    updateDirection(direction) {
+        this._base.updateDirection(direction);
+    }
+    updateAnimation(animation) {
+        if (animation === FurnitureBottleVisualization.ANIMATION_ID_ROLL.toString()) {
+            if (!this._running) {
+                this._running = true;
+                this._stateQueue.push(FurnitureBottleVisualization.ANIMATION_ID_ROLL);
+                return;
+            }
+        }
+        const animationNumber = Number(animation);
+        // Animation between 0 and 7 is the final value of the bottle. This directly translates to its direction.
+        if (animationNumber >= 0 && animationNumber <= 7) {
+            if (this._running) {
+                this._running = false;
+                this._stateQueue.push(FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW1);
+                this._stateQueue.push(FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW2 +
+                    animationNumber);
+                this._stateQueue.push(animationNumber);
+                return;
+            }
+            this._base.updateAnimation(animation);
+        }
+    }
+}
+FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW1 = 20;
+FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW2 = 9;
+FurnitureBottleVisualization.ANIMATION_ID_ROLL = -1;

package/dist-esm/objects/furniture/visualization/FurnitureGuildCustomizedVisualization.js

@@ -0,0 +1,83 @@
+import { getIntFromHex } from "../../../util/getIntFromHex";
+import { AnimatedFurnitureVisualization } from "./AnimatedFurnitureVisualization";
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export class FurnitureGuildCustomizedVisualization extends FurnitureVisualization {
+    constructor(options = {}) {
+        super();
+        this._base = new AnimatedFurnitureVisualization();
+        this._refreshModifier = false;
+        this.primaryColor = this._normalizeColor(options.primaryColor);
+        this.secondaryColor = this._normalizeColor(options.secondaryColor);
+    }
+    get primaryColor() {
+        return this._primaryColor;
+    }
+    set primaryColor(value) {
+        this._primaryColor = value;
+        this._refreshModifier = true;
+    }
+    get secondaryColor() {
+        return this._secondaryColor;
+    }
+    set secondaryColor(value) {
+        this._secondaryColor = value;
+        this._refreshModifier = true;
+    }
+    isAnimated() {
+        return true;
+    }
+    update() {
+        this._base.update();
+    }
+    setView(view) {
+        super.setView(view);
+        this._base.setView(view);
+    }
+    destroy() {
+        this._base.destroy();
+    }
+    updateFrame(frame) {
+        if (this._refreshModifier) {
+            this._refreshModifier = false;
+            this._updateModifier();
+        }
+        this._base.updateFrame(frame);
+    }
+    updateDirection(direction) {
+        this._base.updateDirection(direction);
+    }
+    updateAnimation(animation) {
+        this._base.updateAnimation(animation);
+    }
+    _updateModifier() {
+        this._base.modifier = (part) => {
+            return this._modifyPart(part);
+        };
+    }
+    _normalizeColor(color) {
+        if (color == null || color.length === 0) {
+            return undefined;
+        }
+        if (color[0] === "#") {
+            return color.slice(1);
+        }
+        return color;
+    }
+    _modifyPart(part) {
+        switch (part.tag) {
+            case FurnitureGuildCustomizedVisualization.PRIMARY_COLOR_TAG:
+                if (this._primaryColor != null) {
+                    part.setColor(getIntFromHex(this._primaryColor));
+                }
+                break;
+            case FurnitureGuildCustomizedVisualization.SECONDARY_COLOR_TAG:
+                if (this._secondaryColor != null) {
+                    part.setColor(getIntFromHex(this._secondaryColor));
+                }
+                break;
+        }
+        return part;
+    }
+}
+FurnitureGuildCustomizedVisualization.PRIMARY_COLOR_TAG = "COLOR1";
+FurnitureGuildCustomizedVisualization.SECONDARY_COLOR_TAG = "COLOR2";

package/dist-esm/objects/furniture/visualization/FurnitureVisualization.js

@@ -0,0 +1,20 @@
+export class FurnitureVisualization {
+    get view() {
+        if (this._view == null)
+            throw new Error("No view mounted");
+        return this._view;
+    }
+    get previousView() {
+        return this._previousView;
+    }
+    get mounted() {
+        return this._view != null;
+    }
+    setView(view) {
+        this._previousView = this._view;
+        this._view = view;
+    }
+    isAnimated(animation = "0") {
+        return false;
+    }
+}

package/dist-esm/objects/hitdetection/ClickHandler.js

@@ -0,0 +1,75 @@
+export class ClickHandler {
+    constructor() {
+        this._map = new Map();
+    }
+    get onClick() {
+        return this._onClick;
+    }
+    set onClick(value) {
+        this._onClick = value;
+    }
+    get onDoubleClick() {
+        return this._onDoubleClick;
+    }
+    set onDoubleClick(value) {
+        this._onDoubleClick = value;
+    }
+    get onPointerDown() {
+        return this._onPointerDown;
+    }
+    set onPointerDown(value) {
+        this._onPointerDown = value;
+    }
+    get onPointerUp() {
+        return this._onPointerUp;
+    }
+    set onPointerUp(value) {
+        this._onPointerUp = value;
+    }
+    handleClick(event) {
+        if (this._doubleClickInfo == null) {
+            this.onClick && this.onClick(event);
+            if (this.onDoubleClick != null) {
+                this._startDoubleClick(event);
+            }
+        }
+        else {
+            event.stopPropagation();
+            this._performDoubleClick(event);
+        }
+    }
+    handlePointerDown(event) {
+        this.onPointerDown && this.onPointerDown(event);
+    }
+    handlePointerUp(event) {
+        this.onPointerUp && this.onPointerUp(event);
+    }
+    _performDoubleClick(event) {
+        if (this._doubleClickInfo == null)
+            return;
+        this.onDoubleClick &&
+            this.onDoubleClick(this._doubleClickInfo.initialEvent);
+        setTimeout(() => {
+            this._resetDoubleClick();
+        });
+    }
+    _resetDoubleClick() {
+        if (this._doubleClickInfo == null)
+            return;
+        clearTimeout(this._doubleClickInfo.timeout);
+        this._doubleClickInfo = undefined;
+    }
+    _startDoubleClick(event) {
+        this._doubleClickInfo = {
+            initialEvent: event,
+            timeout: window.setTimeout(() => this._resetDoubleClick(), 350),
+        };
+    }
+    reset() {
+        if (this._doubleClickInfo != null) {
+            clearTimeout(this._doubleClickInfo.timeout);
+            this._doubleClickInfo = undefined;
+        }
+        this._map.clear();
+    }
+}

package/dist-esm/objects/hitdetection/HitSprite.js

@@ -0,0 +1,186 @@
+import * as PIXI from "pixi.js";
+import { BehaviorSubject } from "rxjs";
+import { EventEmitter } from "../events/EventEmitter";
+export class HitSprite extends PIXI.Sprite {
+    get events() {
+        return this._eventEmitter;
+    }
+    constructor({ eventManager, mirrored = false, getHitmap, tag, group, }) {
+        super();
+        this._ignore = false;
+        this._ignoreMouse = false;
+        this._rectangleSubject = new BehaviorSubject(undefined);
+        this._eventEmitter = new EventEmitter();
+        this._emitRectangle = () => {
+            var _a, _b;
+            let width = this.texture.width;
+            let height = this.texture.height;
+            let x = this.worldTransform.tx - (this._mirrored ? width : 0);
+            let y = this.worldTransform.ty;
+            const m = (_b = (_a = this._eventManager).getCoordinateRootMatrix) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (m != null) {
+                x = (x - m.tx) / m.a;
+                y = (y - m.ty) / m.d;
+            }
+            const last = this._lastRect;
+            if (last != null &&
+                last.x === x &&
+                last.y === y &&
+                last.width === width &&
+                last.height === height) {
+                return;
+            }
+            this._lastRect = { x, y, width, height };
+            this._rectangleSubject.next(this._lastRect);
+        };
+        this._group = group;
+        this._mirrored = mirrored;
+        this._getHitmap = getHitmap;
+        this._tag = tag;
+        this.mirrored = this._mirrored;
+        this._eventManager = eventManager;
+        this.onRender = this._emitRectangle;
+        eventManager.register(this);
+    }
+    getGroup() {
+        return this._group;
+    }
+    getRectangleObservable() {
+        return this._rectangleSubject;
+    }
+    getEventZOrder() {
+        return this.zIndex;
+    }
+    triggerPointerTargetChanged(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointertargetchanged", event);
+    }
+    triggerClick(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("click", event);
+        event.stopPropagation();
+    }
+    triggerPointerDown(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerdown", event);
+    }
+    triggerPointerUp(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerup", event);
+    }
+    triggerPointerOver(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerover", event);
+    }
+    triggerPointerOut(event) {
+        event.tag = this._tag;
+        this._eventEmitter.trigger("pointerout", event);
+    }
+    createDebugSprite() {
+        if (this._hitTexture == null)
+            return;
+        const hitMap = this._hitTexture.getHitMap();
+        if (hitMap == null)
+            return;
+        const sprite = new PIXI.TilingSprite({
+            texture: PIXI.Texture.WHITE,
+            width: this._hitTexture.texture.width,
+            height: this._hitTexture.texture.height,
+        });
+        sprite.alpha = 0.1;
+        sprite.x = this.getGlobalPosition().x;
+        sprite.y = this.getGlobalPosition().y;
+        return sprite;
+    }
+    get ignoreMouse() {
+        return this._ignoreMouse;
+    }
+    set ignoreMouse(value) {
+        this._ignoreMouse = value;
+    }
+    get group() {
+        return this._group;
+    }
+    get ignore() {
+        return this._ignore;
+    }
+    set ignore(value) {
+        this._ignore = value;
+    }
+    get mirrored() {
+        return this._mirrored;
+    }
+    set mirrored(value) {
+        this._mirrored = value;
+        this.scale.x = this._mirrored ? -1 : 1;
+    }
+    get hitTexture() {
+        return this._hitTexture;
+    }
+    set hitTexture(value) {
+        if (value != null) {
+            this.texture = value.texture;
+            this._hitTexture = value;
+            this._getHitmap = () => (x, y, transform) => value.hits(x, y, transform, {
+                mirrorHorizonally: this._mirrored,
+            });
+        }
+    }
+    getHitDetectionZIndex() {
+        return this.zIndex;
+    }
+    destroy() {
+        super.destroy();
+        this._eventManager.remove(this);
+    }
+    getHitBox() {
+        const pos = this.getGlobalPosition();
+        const { x: scaleX, y: scaleY } = this._getGlobalScale();
+        const width = this.texture.width * scaleX;
+        const height = this.texture.height * scaleY;
+        if (this._mirrored) {
+            return {
+                x: pos.x - width,
+                y: pos.y,
+                width,
+                height,
+            };
+        }
+        return {
+            x: pos.x,
+            y: pos.y,
+            width,
+            height,
+        };
+    }
+    _getGlobalScale() {
+        const transform = this.worldTransform;
+        return {
+            x: Math.sqrt(transform.a * transform.a + transform.b * transform.b) || 1,
+            y: Math.sqrt(transform.c * transform.c + transform.d * transform.d) || 1,
+        };
+    }
+    hits(x, y) {
+        if (this._getHitmap == null)
+            return false;
+        if (this.ignore)
+            return false;
+        if (this.ignoreMouse)
+            return false;
+        const hitBox = this.getHitBox();
+        const inBoundsX = hitBox.x <= x && x <= hitBox.x + hitBox.width;
+        const inBoundsY = hitBox.y <= y && y <= hitBox.y + hitBox.height;
+        if (inBoundsX && inBoundsY) {
+            const hits = this._getHitmap();
+            const pos = this.getGlobalPosition();
+            const scale = this._getGlobalScale();
+            return hits(x, y, {
+                x: pos.x,
+                y: pos.y,
+                scaleX: scale.x,
+                scaleY: scale.y,
+            });
+        }
+        return false;
+    }
+}