@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/events/EventManagerNode.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventManagerNode = void 0;
+class EventManagerNode {
+    get minX() {
+        if (this._rectangle == null)
+            throw new Error("Rectangle wasn't set");
+        return this._rectangle.x;
+    }
+    get maxX() {
+        if (this._rectangle == null)
+            throw new Error("Rectangle wasn't set");
+        return this._rectangle.x + this._rectangle.width;
+    }
+    get minY() {
+        if (this._rectangle == null)
+            throw new Error("Rectangle wasn't set");
+        return this._rectangle.y;
+    }
+    get maxY() {
+        if (this._rectangle == null)
+            throw new Error("Rectangle wasn't set");
+        return this._rectangle.y + this._rectangle.height;
+    }
+    constructor(target, _bush) {
+        this.target = target;
+        this._bush = _bush;
+        this._subscription = target.getRectangleObservable().subscribe((value) => {
+            // avoid updating for no reason as it lowers FPS in more than half
+            const current = this._rectangle;
+            if ((current === null || current === void 0 ? void 0 : current.height) != (value === null || value === void 0 ? void 0 : value.height) ||
+                (current === null || current === void 0 ? void 0 : current.width) != (value === null || value === void 0 ? void 0 : value.width) ||
+                (current === null || current === void 0 ? void 0 : current.x) != (value === null || value === void 0 ? void 0 : value.x) ||
+                (current === null || current === void 0 ? void 0 : current.y) != (value === null || value === void 0 ? void 0 : value.y)) {
+                this._updateRectangle(value);
+            }
+        });
+    }
+    destroy() {
+        if (this._rectangle != null) {
+            this._bush.remove(this);
+        }
+        this._subscription.unsubscribe();
+    }
+    _updateRectangle(rectangle) {
+        if (this._rectangle != null) {
+            this._bush.remove(this);
+        }
+        this._rectangle = rectangle;
+        if (rectangle != null) {
+            this._bush.insert(this);
+        }
+    }
+}
+exports.EventManagerNode = EventManagerNode;

package/dist/objects/events/EventOverOutHandler.d.ts

@@ -0,0 +1,24 @@
+import { HitSpriteEventMap } from "../hitdetection/HitSprite";
+import { EventEmitter } from "./EventEmitter";
+import { IEventManagerEvent } from "./interfaces/IEventManagerEvent";
+type EventOverOutCallback = (event: IEventManagerEvent) => void;
+export declare class EventOverOutHandler {
+    private _eventEmitters;
+    private _overElements;
+    private _hover;
+    private _onOverCallback;
+    private _onOutCallback;
+    private _timeout;
+    private _targetChanged;
+    get onOver(): EventOverOutCallback | undefined;
+    set onOver(value: EventOverOutCallback | undefined);
+    get onOut(): EventOverOutCallback | undefined;
+    set onOut(value: EventOverOutCallback | undefined);
+    register(emitter: EventEmitter<HitSpriteEventMap>): void;
+    remove(emitter: EventEmitter<HitSpriteEventMap>): void;
+    private _onOver;
+    private _onOut;
+    private _onTargetChanged;
+    private _update;
+}
+export {};

package/dist/objects/events/EventOverOutHandler.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventOverOutHandler = void 0;
+class EventOverOutHandler {
+    constructor() {
+        this._eventEmitters = new Map();
+        this._overElements = new Set();
+        this._hover = false;
+        this._targetChanged = false;
+        this._onOver = (emitter, event) => {
+            this._overElements.add(emitter);
+            this._update(event);
+        };
+        this._onOut = (emitter, event) => {
+            this._overElements.delete(emitter);
+            this._update(event);
+        };
+        this._onTargetChanged = (emitter, event) => {
+            this._overElements.delete(emitter);
+            this._targetChanged = true;
+            this._update(event);
+        };
+    }
+    get onOver() {
+        return this._onOverCallback;
+    }
+    set onOver(value) {
+        this._onOverCallback = value;
+    }
+    get onOut() {
+        return this._onOutCallback;
+    }
+    set onOut(value) {
+        this._onOutCallback = value;
+    }
+    register(emitter) {
+        if (this._eventEmitters.has(emitter))
+            return;
+        this._eventEmitters.set(emitter, new RegisteredOverOutHandler(emitter, this._onOver, this._onOut, this._onTargetChanged));
+    }
+    remove(emitter) {
+        const handler = this._eventEmitters.get(emitter);
+        if (handler == null)
+            return;
+        this._eventEmitters.delete(emitter);
+        this._overElements.delete(emitter);
+        handler.destroy();
+    }
+    _update(event) {
+        if (this._overElements.size > 0 && !this._hover) {
+            this._hover = true;
+            if (!this._targetChanged) {
+                this.onOver && this.onOver(event);
+            }
+            this._targetChanged = false;
+        }
+        if (this._overElements.size < 1 && this._hover) {
+            this._hover = false;
+            if (!this._targetChanged) {
+                this.onOut && this.onOut(event);
+            }
+        }
+    }
+}
+exports.EventOverOutHandler = EventOverOutHandler;
+class RegisteredOverOutHandler {
+    constructor(emitter, onOver, onOut, onTargetChanged) {
+        this.emitter = emitter;
+        this.onOver = onOver;
+        this.onOut = onOut;
+        this.onTargetChanged = onTargetChanged;
+        this._handlePointerOut = (event) => {
+            this.onOut(this.emitter, event);
+        };
+        this._handlePointerOver = (event) => {
+            this.onOver(this.emitter, event);
+        };
+        this._handlePointerTargetChanged = (event) => {
+            this.onTargetChanged(this.emitter, event);
+        };
+        emitter.addEventListener("pointerout", this._handlePointerOut);
+        emitter.addEventListener("pointerover", this._handlePointerOver);
+        emitter.addEventListener("pointertargetchanged", this._handlePointerTargetChanged);
+    }
+    destroy() {
+        this.emitter.removeEventListener("pointerout", this._handlePointerOut);
+        this.emitter.removeEventListener("pointerover", this._handlePointerOver);
+        this.emitter.removeEventListener("pointertargetchanged", this._handlePointerTargetChanged);
+    }
+}

package/dist/objects/events/interfaces/IEventGroup.d.ts

@@ -0,0 +1,7 @@
+export interface IEventGroup {
+    getEventGroupIdentifier(): EventGroupIdentifier;
+}
+export type EventGroupIdentifier = typeof FURNITURE | typeof AVATAR | typeof TILE_CURSOR;
+export declare const FURNITURE: unique symbol;
+export declare const AVATAR: unique symbol;
+export declare const TILE_CURSOR: unique symbol;

package/dist/objects/events/interfaces/IEventGroup.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TILE_CURSOR = exports.AVATAR = exports.FURNITURE = void 0;
+exports.FURNITURE = Symbol("FURNITURE");
+exports.AVATAR = Symbol("AVATAR");
+exports.TILE_CURSOR = Symbol("TILE_CURSOR");

package/dist/objects/events/interfaces/IEventHandler.d.ts

@@ -0,0 +1,9 @@
+import { IEventManagerEvent } from "./IEventManagerEvent";
+export interface IEventHandler {
+    triggerClick(event: IEventManagerEvent): void;
+    triggerPointerDown(event: IEventManagerEvent): void;
+    triggerPointerUp(event: IEventManagerEvent): void;
+    triggerPointerOver(event: IEventManagerEvent): void;
+    triggerPointerOut(event: IEventManagerEvent): void;
+    triggerPointerTargetChanged(event: IEventManagerEvent): void;
+}

package/dist/objects/events/interfaces/IEventHandler.js

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

package/dist/objects/events/interfaces/IEventHittable.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from "rxjs";
+import { Rectangle } from "../../room/IRoomRectangle";
+import { IEventGroup } from "./IEventGroup";
+export interface IEventHittable {
+    getGroup(): IEventGroup;
+    getRectangleObservable(): Observable<Rectangle | undefined>;
+    getEventZOrder(): number;
+    hits(x: number, y: number): void;
+}

package/dist/objects/events/interfaces/IEventHittable.js

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

package/dist/objects/events/interfaces/IEventManager.d.ts

@@ -0,0 +1,8 @@
+import type { Matrix } from "pixi.js";
+import { IEventManagerNode } from "./IEventManagerNode";
+import { IEventTarget } from "./IEventTarget";
+export interface IEventManager {
+    register(target: IEventTarget): IEventManagerNode;
+    remove(target: IEventTarget): void;
+    getCoordinateRootMatrix?(): Matrix | undefined;
+}

package/dist/objects/events/interfaces/IEventManager.js

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

package/dist/objects/events/interfaces/IEventManagerEvent.d.ts

@@ -0,0 +1,11 @@
+import { FederatedPointerEvent } from "pixi.js";
+import { EventGroupIdentifier } from "./IEventGroup";
+export interface IEventManagerEvent {
+    tag?: string;
+    mouseEvent: FederatedPointerEvent["nativeEvent"];
+    interactionEvent: FederatedPointerEvent;
+    stopPropagation(): void;
+    skip(...identifiers: EventGroupIdentifierParam[]): void;
+    skipExcept(...identifiers: EventGroupIdentifierParam[]): void;
+}
+export type EventGroupIdentifierParam = EventGroupIdentifierParam[] | EventGroupIdentifier;

package/dist/objects/events/interfaces/IEventManagerEvent.js

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

package/dist/objects/events/interfaces/IEventManagerNode.d.ts

@@ -0,0 +1,3 @@
+export interface IEventManagerNode {
+    destroy(): void;
+}

package/dist/objects/events/interfaces/IEventManagerNode.js

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

package/dist/objects/events/interfaces/IEventTarget.d.ts

@@ -0,0 +1,4 @@
+import { IEventHandler } from "./IEventHandler";
+import { IEventHittable } from "./IEventHittable";
+export interface IEventTarget extends IEventHittable, IEventHandler {
+}

package/dist/objects/events/interfaces/IEventTarget.js

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

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

@@ -0,0 +1,152 @@
+import * as PIXI from "pixi.js";
+import { IFurnitureEventHandlers } from "./util/IFurnitureEventHandlers";
+import { MaskNode } from "../../interfaces/IRoomVisualization";
+import { FurnitureFetch, IFurnitureLoader } from "../../interfaces/IFurnitureLoader";
+import { IAnimationTicker } from "../../interfaces/IAnimationTicker";
+import { IConfiguration } from "../../interfaces/IConfiguration";
+import { IRoomContext } from "../../interfaces/IRoomContext";
+import { Wsproom } from "../Wsproom";
+import { IFurnitureVisualization } from "./IFurnitureVisualization";
+import { IEventManager } from "../events/interfaces/IEventManager";
+import { EventGroupIdentifier, IEventGroup } from "../events/interfaces/IEventGroup";
+type MaskIdGetter = (direction: number) => string | undefined;
+export type SpriteWithStaticOffset = {
+    x: number;
+    y: number;
+    sprite: PIXI.Sprite;
+    zIndex?: number;
+};
+interface BaseFurnitureDependencies {
+    placeholder: PIXI.Texture | undefined;
+    visualization: IFurnitureRoomVisualization;
+    animationTicker: IAnimationTicker;
+    furnitureLoader: IFurnitureLoader;
+    application?: PIXI.Application;
+    eventManager: IEventManager;
+    configuration?: IConfiguration;
+}
+export interface BaseFurnitureProps {
+    type: FurnitureFetch;
+    direction: number;
+    animation: string | undefined;
+    getMaskId?: MaskIdGetter;
+    onLoad?: () => void;
+}
+export declare class BaseFurniture implements IFurnitureEventHandlers, IEventGroup {
+    private _sprites;
+    private _loadFurniResult;
+    private _x;
+    private _y;
+    private _zIndex;
+    private _direction;
+    private _animation;
+    private _type;
+    private _unknownTexture;
+    private _unknownSprite;
+    private _clickHandler;
+    private _overOutHandler;
+    private _loadFurniResultPromise;
+    private _validDirections;
+    private _resolveLoadFurniResult;
+    private _rejectLoadFurniResult;
+    private _view;
+    private _visualization;
+    private _fallbackVisualization;
+    private _refreshPosition;
+    private _refreshFurniture;
+    private _refreshZIndex;
+    private _highlight;
+    private _activeWired;
+    private _alpha;
+    private _destroyed;
+    private _maskNodes;
+    private _maskSprites;
+    private _cancelTicker;
+    private _getMaskId;
+    private _onLoad;
+    private _dependencies?;
+    constructor({ type, direction, animation, getMaskId, dependencies, onLoad, }: {
+        dependencies?: BaseFurnitureDependencies;
+    } & BaseFurnitureProps);
+    static fromRoomContext(context: IRoomContext, props: BaseFurnitureProps): BaseFurniture;
+    static fromWsproom(wsproom: Wsproom, container: PIXI.Container, props: BaseFurnitureProps): BaseFurniture;
+    get dependencies(): BaseFurnitureDependencies;
+    set dependencies(value: BaseFurnitureDependencies);
+    get visualization(): IFurnitureVisualization;
+    set visualization(value: IFurnitureVisualization);
+    get mounted(): boolean;
+    get height(): Promise<number | undefined>;
+    set height(value: Promise<number | undefined>);
+    /**
+     * Tile footprint of the furniture, in room tiles.
+     */
+    get dimensions(): Promise<{
+        x: number;
+        y: number;
+    } | undefined>;
+    get extradata(): Promise<import("./FurnitureExtraData").FurnitureExtraData>;
+    get validDirections(): Promise<number[]>;
+    get validAnimations(): Promise<number[]>;
+    get highlight(): string | boolean;
+    set highlight(value: string | boolean);
+    get activeWired(): boolean;
+    set activeWired(value: boolean);
+    get alpha(): number;
+    set alpha(value: number);
+    get onClick(): import("../hitdetection/HitSprite").HitEventHandler | undefined;
+    set onClick(value: import("../hitdetection/HitSprite").HitEventHandler | undefined);
+    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 onPointerOut(): ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined;
+    set onPointerOut(value: ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined);
+    get onPointerOver(): ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined;
+    set onPointerOver(value: ((event: import("../events/interfaces/IEventManagerEvent").IEventManagerEvent) => void) | undefined);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get zIndex(): number;
+    set zIndex(value: number);
+    get direction(): number;
+    set direction(value: number);
+    rotate(): Promise<void>;
+    get animation(): string;
+    set animation(value: string);
+    get maskId(): MaskIdGetter;
+    set maskId(value: MaskIdGetter);
+    getEventGroupIdentifier(): EventGroupIdentifier;
+    destroy(): void;
+    private static _dirtyFurniture;
+    private static _flushScheduled;
+    private static _flushDirty;
+    private _scheduleTicker;
+    private _onTicker;
+    private _updateDirection;
+    private _updateSprites;
+    private _updateZIndex;
+    private _updatePosition;
+    private _updateFurniture;
+    private _updateUnknown;
+    private _createNewView;
+    private _updateFurnitureSprites;
+    /**
+     * 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.
+     */
+    private _updateMasks;
+    private _destroySprites;
+    private _loadFurniture;
+    private _handleAnimationChange;
+    private _getAlpha;
+    onLoad: (() => void) | undefined;
+}
+export interface IFurnitureRoomVisualization {
+    container: PIXI.Container;
+    addMask(maskId: string, element: PIXI.Container): MaskNode;
+}
+export {};