@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/interfaces/IFurnitureLoader.d.ts

@@ -0,0 +1,13 @@
+import { LoadFurniResult } from "../objects/furniture/util/loadFurni";
+import { FurnitureId } from "./IFurnitureData";
+export interface IFurnitureLoader {
+    loadFurni(type: FurnitureFetch): Promise<LoadFurniResult>;
+}
+export type FurnitureFetch = {
+    kind: "id";
+    id: FurnitureId;
+    placementType: "wall" | "floor";
+} | {
+    kind: "type";
+    type: string;
+};

package/dist/interfaces/IFurnitureLoader.js

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

package/dist/interfaces/IHitDetection.js

@@ -0,0 +1 @@
+"use strict";

package/dist/interfaces/IRoomContext.d.ts

@@ -0,0 +1,26 @@
+import { IEventManager } from "../objects/events/interfaces/IEventManager";
+import { ILandscapeContainer } from "../objects/room/ILandscapeContainer";
+import { Room } from "../objects/room/Room";
+import { IAnimationTicker } from "./IAnimationTicker";
+import { IAvatarLoader } from "./IAvatarLoader";
+import { IConfiguration } from "./IConfiguration";
+import { IFurnitureLoader } from "./IFurnitureLoader";
+import { IRoomGeometry } from "./IRoomGeometry";
+import { IRoomObjectContainer } from "./IRoomObjectContainer";
+import { IRoomVisualization } from "./IRoomVisualization";
+import { ITileMap } from "./ITileMap";
+import type * as PIXI from "pixi.js";
+export interface IRoomContext {
+    geometry: IRoomGeometry;
+    furnitureLoader: IFurnitureLoader;
+    avatarLoader: IAvatarLoader;
+    animationTicker: IAnimationTicker;
+    visualization: IRoomVisualization;
+    roomObjectContainer: IRoomObjectContainer;
+    configuration: IConfiguration;
+    tilemap: ITileMap;
+    landscapeContainer: ILandscapeContainer;
+    application: PIXI.Application;
+    room: Room;
+    eventManager: IEventManager;
+}

package/dist/interfaces/IRoomContext.js

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

package/dist/interfaces/IRoomGeometry.d.ts

@@ -0,0 +1,6 @@
+export interface IRoomGeometry {
+    getPosition(roomX: number, roomY: number, roomZ: number): {
+        x: number;
+        y: number;
+    };
+}

package/dist/interfaces/IRoomGeometry.js

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

package/dist/interfaces/IRoomObject.d.ts

@@ -0,0 +1,5 @@
+import { IRoomContext } from "./IRoomContext";
+export interface IRoomObject {
+    setParent(room: IRoomContext): void;
+    destroy(): void;
+}

package/dist/interfaces/IRoomObject.js

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

package/dist/interfaces/IRoomObjectContainer.d.ts

@@ -0,0 +1,5 @@
+import { IRoomObject } from "./IRoomObject";
+export interface IRoomObjectContainer {
+    addRoomObject(roomObject: IRoomObject): void;
+    removeRoomObject(roomObject: IRoomObject): void;
+}

package/dist/interfaces/IRoomObjectContainer.js

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

package/dist/interfaces/IRoomVisualization.d.ts

@@ -0,0 +1,25 @@
+import { IRoomPart } from "../objects/room/parts/IRoomPart";
+import { RoomLandscapeMaskSprite } from "../objects/room/RoomLandscapeMaskSprite";
+import type * as PIXI from "pixi.js";
+export interface IRoomVisualization {
+    container: PIXI.Container;
+    behindWallContainer: PIXI.Container;
+    landscapeContainer: PIXI.Container;
+    floorContainer: PIXI.Container;
+    wallContainer: PIXI.Container;
+    addPart(part: IRoomPart): PartNode;
+    addMask(id: string, element: PIXI.Sprite): MaskNode;
+}
+export type MaskNode = {
+    sprite: PIXI.Sprite;
+    update: () => void;
+    remove: () => void;
+};
+export type PartNode = {
+    remove: () => void;
+};
+export type RoomVisualizationMeta = {
+    masks: Map<string, RoomLandscapeMaskSprite>;
+    wallHeight: number;
+    wallHeightWithZ: number;
+};

package/dist/interfaces/IRoomVisualization.js

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

package/dist/interfaces/ITextureable.d.ts

@@ -0,0 +1,5 @@
+import * as PIXI from "pixi.js";
+export interface ITexturable {
+    texture: PIXI.Texture | undefined;
+    color: string | undefined;
+}

package/dist/interfaces/ITextureable.js

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

package/dist/interfaces/ITileMap.d.ts

@@ -0,0 +1,5 @@
+import { ParsedTileType } from "../util/parseTileMap";
+export interface ITileMap {
+    getTileAtPosition(roomX: number, roomY: number): ParsedTileType | undefined;
+    getParsedTileTypes(): ParsedTileType[][];
+}

package/dist/interfaces/ITileMap.js

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

package/dist/objects/RoomObject.d.ts

@@ -0,0 +1,24 @@
+import { IRoomContext } from "../interfaces/IRoomContext";
+import { IRoomObject } from "../interfaces/IRoomObject";
+export declare abstract class RoomObject implements IRoomObject {
+    private _context;
+    private _isDestroyed;
+    setParent(room: IRoomContext): void;
+    destroy(): void;
+    protected getRoomContext(): IRoomContext;
+    abstract destroyed(): void;
+    abstract registered(): void;
+    protected get mounted(): boolean;
+    protected get room(): import("..").Room;
+    protected get configuration(): import("../interfaces/IConfiguration").IConfiguration;
+    protected get furnitureLoader(): import("../interfaces/IFurnitureLoader").IFurnitureLoader;
+    protected get animationTicker(): import("../interfaces/IAnimationTicker").IAnimationTicker;
+    protected get roomVisualization(): import("../interfaces/IRoomVisualization").IRoomVisualization;
+    protected get geometry(): import("../interfaces/IRoomGeometry").IRoomGeometry;
+    protected get roomObjectContainer(): import("../interfaces/IRoomObjectContainer").IRoomObjectContainer;
+    protected get avatarLoader(): import("../interfaces/IAvatarLoader").IAvatarLoader;
+    protected get eventManager(): import("./events/interfaces/IEventManager").IEventManager;
+    protected get tilemap(): import("../interfaces/ITileMap").ITileMap;
+    protected get landscapeContainer(): import("./room/ILandscapeContainer").ILandscapeContainer;
+    protected get application(): import("pixi.js").Application<import("pixi.js").Renderer>;
+}

package/dist/objects/RoomObject.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomObject = void 0;
+class RoomObject {
+    constructor() {
+        this._isDestroyed = false;
+    }
+    setParent(room) {
+        if (this._context != null)
+            throw new Error("RoomObject already provided with a context.");
+        this._isDestroyed = false;
+        this._context = room;
+        this.registered();
+    }
+    destroy() {
+        if (this._isDestroyed)
+            return;
+        // Important: set isDestroyed to true so this doesn't infinite loop.
+        this._isDestroyed = true;
+        this.roomObjectContainer.removeRoomObject(this);
+        this._context = undefined;
+        this.destroyed();
+    }
+    getRoomContext() {
+        if (this._context == null)
+            throw new Error("Invalid context");
+        return this._context;
+    }
+    get mounted() {
+        return this._context != null;
+    }
+    get room() {
+        return this.getRoomContext().room;
+    }
+    get configuration() {
+        return this.getRoomContext().configuration;
+    }
+    get furnitureLoader() {
+        return this.getRoomContext().furnitureLoader;
+    }
+    get animationTicker() {
+        return this.getRoomContext().animationTicker;
+    }
+    get roomVisualization() {
+        return this.getRoomContext().visualization;
+    }
+    get geometry() {
+        return this.getRoomContext().geometry;
+    }
+    get roomObjectContainer() {
+        return this.getRoomContext().roomObjectContainer;
+    }
+    get avatarLoader() {
+        return this.getRoomContext().avatarLoader;
+    }
+    get eventManager() {
+        return this.getRoomContext().eventManager;
+    }
+    get tilemap() {
+        return this.getRoomContext().tilemap;
+    }
+    get landscapeContainer() {
+        return this.getRoomContext().landscapeContainer;
+    }
+    get application() {
+        return this.getRoomContext().application;
+    }
+}
+exports.RoomObject = RoomObject;

package/dist/objects/Wsproom.d.ts

@@ -0,0 +1,22 @@
+import { Dependencies } from "./room/Room";
+import * as PIXI from "pixi.js";
+export declare class Wsproom {
+    readonly dependencies: Dependencies;
+    constructor(dependencies: Dependencies);
+    /**
+     * Create a wsproom instance
+     */
+    static create(options: {
+        resourcePath?: string;
+        application: PIXI.Application;
+    } & Partial<Dependencies>): Wsproom;
+    /**
+     * Create a shared wsproom instance. This is useful if you have multiple
+     * `PIXI.Application` which all share the same wsproom dependencies.
+     */
+    static createShared({ resourcePath, configuration, animationTicker, avatarLoader, furnitureData, furnitureLoader, }: {
+        resourcePath?: string;
+    } & Partial<Dependencies>): {
+        for: (application: PIXI.Application) => Wsproom;
+    };
+}

package/dist/objects/Wsproom.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wsproom = void 0;
+const AnimationTicker_1 = require("./animation/AnimationTicker");
+const AvatarLoader_1 = require("./avatar/AvatarLoader");
+const FurnitureLoader_1 = require("./furniture/FurnitureLoader");
+const FurnitureData_1 = require("./furniture/FurnitureData");
+const PIXI = __importStar(require("pixi.js"));
+PIXI.TextureSource.defaultOptions.scaleMode = "nearest";
+const patchAdditiveBlendForTransparentCanvas = (application) => {
+    var _a;
+    const state = application.renderer.state;
+    if (((_a = state === null || state === void 0 ? void 0 : state.blendModesMap) === null || _a === void 0 ? void 0 : _a.add) != null) {
+        state.blendModesMap.add = [1, 1, 0, 1];
+    }
+};
+class Wsproom {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    /**
+     * Create a wsproom instance
+     */
+    static create(options) {
+        return this.createShared(options).for(options.application);
+    }
+    /**
+     * Create a shared wsproom instance. This is useful if you have multiple
+     * `PIXI.Application` which all share the same wsproom dependencies.
+     */
+    static createShared({ resourcePath, configuration, animationTicker, avatarLoader, furnitureData, furnitureLoader, }) {
+        const _furnitureData = furnitureData !== null && furnitureData !== void 0 ? furnitureData : FurnitureData_1.FurnitureData.create(resourcePath);
+        const _avatarLoader = avatarLoader !== null && avatarLoader !== void 0 ? avatarLoader : AvatarLoader_1.AvatarLoader.createForAssetBundle(resourcePath);
+        const _furnitureLoader = furnitureLoader !== null && furnitureLoader !== void 0 ? furnitureLoader : FurnitureLoader_1.FurnitureLoader.createForJson(_furnitureData, resourcePath);
+        const _configuration = configuration !== null && configuration !== void 0 ? configuration : {};
+        return {
+            for: (application) => {
+                patchAdditiveBlendForTransparentCanvas(application);
+                const _animationTicker = animationTicker !== null && animationTicker !== void 0 ? animationTicker : AnimationTicker_1.AnimationTicker.create(application);
+                const realDependencies = {
+                    animationTicker: _animationTicker,
+                    avatarLoader: _avatarLoader,
+                    furnitureLoader: _furnitureLoader,
+                    configuration: _configuration,
+                    furnitureData: _furnitureData,
+                    application,
+                };
+                return new Wsproom(realDependencies);
+            },
+        };
+    }
+}
+exports.Wsproom = Wsproom;

package/dist/objects/animation/AnimationTicker.d.ts

@@ -0,0 +1,13 @@
+import { IAnimationTicker } from "../../interfaces/IAnimationTicker";
+import type * as PIXI from "pixi.js";
+export declare class AnimationTicker implements IAnimationTicker {
+    private _frame;
+    private _idCounter;
+    private _subscriptions;
+    constructor(application: PIXI.Application);
+    static create(application: PIXI.Application): AnimationTicker;
+    subscribe(cb: (frame: number, accurateFrame: number) => void): () => void;
+    current(): number;
+    private _getNormalizedFrame;
+    private _increment;
+}

package/dist/objects/animation/AnimationTicker.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimationTicker = void 0;
+const ANIM_FPS = 24;
+const TARGET_FPS = 60;
+class AnimationTicker {
+    constructor(application) {
+        this._frame = 0;
+        this._idCounter = 0;
+        this._subscriptions = new Map();
+        application.ticker.maxFPS = TARGET_FPS;
+        application.ticker.minFPS = ANIM_FPS;
+        application.ticker.add(() => this._increment());
+    }
+    static create(application) {
+        return new AnimationTicker(application);
+    }
+    subscribe(cb) {
+        const id = this._idCounter++;
+        this._subscriptions.set(id, cb);
+        return () => this._subscriptions.delete(id);
+    }
+    current() {
+        return this._getNormalizedFrame(this._frame).rounded;
+    }
+    _getNormalizedFrame(frame) {
+        const factor = ANIM_FPS / TARGET_FPS;
+        const calculatedFrame = frame * factor;
+        return { rounded: Math.floor(calculatedFrame), pure: calculatedFrame };
+    }
+    _increment() {
+        this._frame += 1;
+        const data = this._getNormalizedFrame(this._frame);
+        this._subscriptions.forEach((cb) => cb(data.rounded, data.pure));
+    }
+}
+exports.AnimationTicker = AnimationTicker;

package/dist/objects/animation/ObjectAnimation.d.ts

@@ -0,0 +1,36 @@
+import { IAnimationTicker } from "../../interfaces/IAnimationTicker";
+import { RoomPosition } from "../../types/RoomPosition";
+export declare class ObjectAnimation<T> {
+    private _animationTicker;
+    private _callbacks;
+    private _duration;
+    private _current;
+    private _diff;
+    private _start;
+    private _enqueued;
+    private _nextPosition;
+    private _finishCurrent;
+    private _destroyed;
+    private _cancelTicker;
+    constructor(_animationTicker: IAnimationTicker, _callbacks: {
+        onUpdatePosition: (position: RoomPosition, data: T) => void;
+        onStart: (data: T) => void;
+        onStop: (data: T) => void;
+    }, _duration?: number);
+    clear(): RoomPosition | undefined;
+    /**
+     * Drops the running interpolation and everything queued behind it, so the
+     * object can be placed somewhere else without gliding there first.
+     */
+    stop(): void;
+    destroy(): void;
+    move(currentPos: {
+        roomX: number;
+        roomY: number;
+        roomZ: number;
+    }, newPos: {
+        roomX: number;
+        roomY: number;
+        roomZ: number;
+    }, data: T): void;
+}

package/dist/objects/animation/ObjectAnimation.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectAnimation = void 0;
+class ObjectAnimation {
+    constructor(_animationTicker, _callbacks, _duration = 500) {
+        this._animationTicker = _animationTicker;
+        this._callbacks = _callbacks;
+        this._duration = _duration;
+        this._start = 0;
+        this._enqueued = [];
+        this._destroyed = false;
+    }
+    clear() {
+        this._enqueued = [];
+        return this._nextPosition;
+    }
+    /**
+     * Drops the running interpolation and everything queued behind it, so the
+     * object can be placed somewhere else without gliding there first.
+     */
+    stop() {
+        var _a;
+        this._enqueued = [];
+        this._finishCurrent = undefined;
+        this._current = undefined;
+        this._diff = undefined;
+        (_a = this._cancelTicker) === null || _a === void 0 ? void 0 : _a.call(this);
+        this._cancelTicker = undefined;
+    }
+    destroy() {
+        this._destroyed = true;
+        if (this._cancelTicker != null) {
+            this._cancelTicker();
+        }
+    }
+    move(currentPos, newPos, data) {
+        if (this._finishCurrent != null) {
+            this._finishCurrent();
+            this._finishCurrent = undefined;
+        }
+        this._callbacks.onStart(data);
+        this._current = currentPos;
+        this._diff = {
+            roomX: newPos.roomX - currentPos.roomX,
+            roomY: newPos.roomY - currentPos.roomY,
+            roomZ: newPos.roomZ - currentPos.roomZ,
+        };
+        this._nextPosition = newPos;
+        this._start = performance.now();
+        const handleFinish = () => {
+            this._diff = undefined;
+            this._current = undefined;
+            const next = this._enqueued.shift();
+            if (next != null) {
+                this.move(next.currentPosition, next.newPosition, next.data);
+            }
+            else {
+                this._callbacks.onStop(data);
+            }
+            cancel();
+        };
+        this._finishCurrent = handleFinish;
+        this._callbacks.onUpdatePosition({
+            roomX: this._current.roomX,
+            roomY: this._current.roomY,
+            roomZ: this._current.roomZ,
+        }, data);
+        const cancel = this._animationTicker.subscribe(() => {
+            if (this._destroyed)
+                return;
+            const timeDiff = performance.now() - this._start;
+            let factor = timeDiff / this._duration;
+            const current = this._current;
+            const diff = this._diff;
+            if (factor > 1) {
+                factor = 1;
+            }
+            if (current != null && diff != null) {
+                this._callbacks.onUpdatePosition({
+                    roomX: current.roomX + diff.roomX * factor,
+                    roomY: current.roomY + diff.roomY * factor,
+                    roomZ: current.roomZ + diff.roomZ * factor,
+                }, data);
+            }
+            if (factor >= 1) {
+                handleFinish();
+                return;
+            }
+        });
+        this._cancelTicker = cancel;
+    }
+}
+exports.ObjectAnimation = ObjectAnimation;