@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist-esm/assets/WsproomAssetBundle.js

@@ -0,0 +1,79 @@
+import ByteBuffer from "bytebuffer";
+export class WsproomAssetBundle {
+    constructor(files = []) {
+        this._files = new Map();
+        this._blobs = new Map();
+        this._strings = new Map();
+        files.forEach((file) => this._files.set(file.fileName, file.buffer));
+    }
+    get files() {
+        return Array.from(this._files.entries());
+    }
+    static async fromUrl(url) {
+        const response = await fetch(url);
+        if (response.status >= 400)
+            throw new Error(`Failed to load: ${url} - ${response.status}`);
+        const buffer = await response.arrayBuffer();
+        return WsproomAssetBundle.fromBuffer(buffer);
+    }
+    static fromBuffer(buffer) {
+        const byteBuffer = ByteBuffer.wrap(buffer);
+        const readFile = () => {
+            const fileNameLength = byteBuffer.readUint16();
+            const fileName = byteBuffer.readString(fileNameLength);
+            const fileLength = byteBuffer.readUint32();
+            const buffer = byteBuffer.readBytes(fileLength);
+            return {
+                fileName,
+                buffer: buffer.toArrayBuffer(),
+            };
+        };
+        const version = byteBuffer.readByte();
+        const fileCount = byteBuffer.readUint16();
+        const files = [];
+        for (let i = 0; i < fileCount; i++) {
+            const file = readFile();
+            files.push(file);
+        }
+        return new WsproomAssetBundle(files);
+    }
+    addFile(fileName, buffer) {
+        this._files.set(fileName, buffer);
+    }
+    toBuffer() {
+        const byteBuffer = new ByteBuffer();
+        byteBuffer.writeByte(WsproomAssetBundle.VERSION);
+        byteBuffer.writeUint16(this._files.size);
+        this._files.forEach((buffer, key) => {
+            byteBuffer.writeUint16(key.length);
+            byteBuffer.writeString(key);
+            byteBuffer.writeUint32(buffer.byteLength);
+            byteBuffer.append(buffer);
+        });
+        return byteBuffer.flip().toBuffer();
+    }
+    async getBlob(name) {
+        const current = this._blobs.get(name);
+        if (current != null)
+            return current;
+        const buffer = this._files.get(name);
+        if (buffer == null)
+            throw new Error(`Couldn't find ${name}.`);
+        const blob = new Blob([buffer]);
+        this._blobs.set(name, blob);
+        return blob;
+    }
+    async getString(name) {
+        const current = this._strings.get(name);
+        if (current != null)
+            return current;
+        const buffer = this._files.get(name);
+        if (buffer == null)
+            throw new Error(`Couldn't find ${name}.`);
+        const encoder = new TextDecoder();
+        const string = encoder.decode(buffer);
+        this._strings.set(name, string);
+        return string;
+    }
+}
+WsproomAssetBundle.VERSION = 1;

package/dist-esm/data/XmlData.js

@@ -0,0 +1,11 @@
+export class XmlData {
+    constructor(xml) {
+        this.document = new DOMParser().parseFromString(xml, "text/xml");
+    }
+    querySelectorAll(query) {
+        return Array.from(this.document.querySelectorAll(query));
+    }
+    querySelector(query) {
+        return this.document.querySelector(query);
+    }
+}

package/dist-esm/index.js

@@ -0,0 +1,33 @@
+export { RoomObject } from "./objects/RoomObject";
+export { Avatar } from "./objects/avatar/Avatar";
+export { FloorFurniture } from "./objects/furniture/FloorFurniture";
+export { HighlightFilter } from "./objects/furniture/filter/HighlightFilter";
+export { ActiveWiredFilter } from "./objects/furniture/filter/ActiveWiredFilter";
+export { WallFurniture } from "./objects/furniture/WallFurniture";
+export { Room } from "./objects/room/Room";
+export { RoomCamera } from "./objects/room/RoomCamera";
+export { Pathfinding } from "./objects/room/Pathfinding";
+export { loadRoomTexture } from "./util/loadRoomTexture";
+export { parseTileMapString } from "./util/parseTileMapString";
+export { hasWallTiles } from "./util/tilemap/hasWallTiles";
+export { FurnitureData } from "./objects/furniture/FurnitureData";
+export { FurnitureHelper } from "./objects/furniture/FurnitureHelper";
+export { Wsproom } from "./objects/Wsproom";
+export { Landscape, getLandscapeItemPosition, } from "./objects/room/Landscape";
+export { AnimationTicker } from "./objects/animation/AnimationTicker";
+export { FurnitureLoader } from "./objects/furniture/FurnitureLoader";
+export { AvatarLoader } from "./objects/avatar/AvatarLoader";
+export { AvatarAction } from "./objects/avatar/enum/AvatarAction";
+export { FurnitureRoomVisualization } from "./objects/furniture/FurnitureRoomVisualization";
+export { BaseFurniture } from "./objects/furniture/BaseFurniture";
+export { BaseAvatar } from "./objects/avatar/BaseAvatar";
+export { AnimatedFurnitureVisualization } from "./objects/furniture/visualization/AnimatedFurnitureVisualization";
+export { FurnitureGuildCustomizedVisualization } from "./objects/furniture/visualization/FurnitureGuildCustomizedVisualization";
+export { StaticFurnitureVisualization, BasicFurnitureVisualization, } from "./objects/furniture/visualization/BasicFurnitureVisualization";
+export { FurnitureBottleVisualization } from "./objects/furniture/visualization/FurnitureBottleVisualization";
+export { FurnitureVisualization } from "./objects/furniture/visualization/FurnitureVisualization";
+export { WallLeft } from "./objects/room/parts/WallLeft";
+export { WallRight } from "./objects/room/parts/WallRight";
+export { RoomModelVisualization } from "./objects/room/RoomModelVisualization";
+export { TileMapEditorLayer } from "./objects/room/TileMapEditorLayer";
+export { AVATAR, TILE_CURSOR, FURNITURE, } from "./objects/events/interfaces/IEventGroup";

package/dist-esm/interfaces/IAnimationTicker.js

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

package/dist-esm/interfaces/IAvatarLoader.js

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

package/dist-esm/interfaces/IConfiguration.js

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

package/dist-esm/interfaces/IFurnitureData.js

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

package/dist-esm/interfaces/IFurnitureLoader.js

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

package/dist-esm/interfaces/IHitDetection.js

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

package/dist-esm/interfaces/IRoomContext.js

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

package/dist-esm/interfaces/IRoomGeometry.js

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

package/dist-esm/interfaces/IRoomObject.js

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

package/dist-esm/interfaces/IRoomObjectContainer.js

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

package/dist-esm/interfaces/IRoomVisualization.js

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

package/dist-esm/interfaces/ITextureable.js

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

package/dist-esm/interfaces/ITileMap.js

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

package/dist-esm/objects/RoomObject.js

@@ -0,0 +1,65 @@
+export 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;
+    }
+}

package/dist-esm/objects/Wsproom.js

@@ -0,0 +1,49 @@
+import { AnimationTicker } from "./animation/AnimationTicker";
+import { AvatarLoader } from "./avatar/AvatarLoader";
+import { FurnitureLoader } from "./furniture/FurnitureLoader";
+import { FurnitureData } from "./furniture/FurnitureData";
+import * as PIXI from "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];
+    }
+};
+export 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.create(resourcePath);
+        const _avatarLoader = avatarLoader !== null && avatarLoader !== void 0 ? avatarLoader : AvatarLoader.createForAssetBundle(resourcePath);
+        const _furnitureLoader = furnitureLoader !== null && furnitureLoader !== void 0 ? furnitureLoader : 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.create(application);
+                const realDependencies = {
+                    animationTicker: _animationTicker,
+                    avatarLoader: _avatarLoader,
+                    furnitureLoader: _furnitureLoader,
+                    configuration: _configuration,
+                    furnitureData: _furnitureData,
+                    application,
+                };
+                return new Wsproom(realDependencies);
+            },
+        };
+    }
+}

package/dist-esm/objects/animation/AnimationTicker.js

@@ -0,0 +1,33 @@
+const ANIM_FPS = 24;
+const TARGET_FPS = 60;
+export 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));
+    }
+}

package/dist-esm/objects/animation/ObjectAnimation.js

@@ -0,0 +1,89 @@
+export 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;
+    }
+}