@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/room/Pathfinding.js

@@ -0,0 +1,241 @@
+"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.Pathfinding = void 0;
+const __1 = require("../../");
+const EasyStar = __importStar(require("easystarjs"));
+class Pathfinding {
+    constructor(room, tilemap, furnitureData) {
+        this.grid = [];
+        this.furniGrid = [];
+        this.room = room;
+        this.furnitureData = furnitureData;
+        this.baseGrid = tilemap.map((row) => row.map((type) => (type !== "x" ? Number(type) : -1)));
+        this.calculateFurnisFilledSpace();
+        this.locateDoor();
+    }
+    locateDoor() {
+        this.baseGrid.forEach((row, i) => {
+            if (row[3] === 0) {
+                this.door = {
+                    roomX: 3,
+                    roomY: i,
+                    roomZ: 0
+                };
+            }
+        });
+    }
+    calculateFurnisFilledSpace() {
+        let grid = this.clone(this.baseGrid);
+        let furniGrid = this.resetFurniGrid();
+        const sub = async (roomObject) => {
+            if (roomObject instanceof __1.Avatar) {
+                return;
+            }
+            // ignore wall placements
+            if (roomObject.placementType === 'wall') {
+                return;
+            }
+            const info = await this.furnitureData.getInfoForFurniture(roomObject);
+            // !info.canlayon && !info.cansiton && 
+            if (info && !info.canstandon) {
+                this.calculateFilledSpace(roomObject, info, grid, furniGrid);
+            }
+        };
+        // update navmesh at the end, so meanwhile the existing one can be used/its never empty
+        return Promise.all(Array.from(this.room.roomObjects.values()).map(sub)).then(() => {
+            this.grid = grid;
+            this.furniGrid = furniGrid;
+        });
+    }
+    calculateFilledSpace(roomObject, info, grid, furniGrid) {
+        let dimensions = {
+            x: 0,
+            y: 0,
+        };
+        switch (info.defaultdir) {
+            case 0: // up
+            case 4: // down
+                dimensions.x = info.xdim;
+                dimensions.y = info.ydim;
+                break;
+            default:
+                dimensions.x = info.ydim;
+                dimensions.y = info.xdim;
+                break;
+        }
+        switch (roomObject.direction) {
+            case 0: // up
+            case 4: // down
+                for (let y = 0; y < dimensions.y; y++) {
+                    for (let x = 0; x < dimensions.x; x++) {
+                        this.addToGrid(roomObject.roomX + x, roomObject.roomY + y, roomObject, info, grid, furniGrid);
+                    }
+                }
+                break;
+            default:
+                for (let y = 0; y < dimensions.x; y++) {
+                    for (let x = 0; x < dimensions.y; x++) {
+                        this.addToGrid(roomObject.roomX + x, roomObject.roomY + y, roomObject, info, grid, furniGrid);
+                    }
+                }
+                break;
+        }
+    }
+    resetFurniGrid() {
+        let furniGrid = [];
+        this.baseGrid.forEach((entries, y) => {
+            furniGrid[y] = [];
+            entries.forEach((useless, x) => {
+                furniGrid[y][x] = [];
+            });
+        });
+        return furniGrid;
+    }
+    addToGrid(x, y, roomObject, info, grid, furniGrid) {
+        grid[y][x] = this.determineNegativeMesh(info);
+        furniGrid[y][x].push({
+            roomObject,
+            info
+        });
+    }
+    determineNegativeMesh(info) {
+        if (info.canlayon) {
+            return -2;
+        }
+        if (info.cansiton) {
+            return -3;
+        }
+        if (info.canstandon) {
+            return -4;
+        }
+        return -1;
+    }
+    getFurnisOnTile(position) {
+        return this.furniGrid[position.roomY][position.roomX];
+    }
+    findPath(origin, target) {
+        return new Promise((resolve) => {
+            const easystar = new EasyStar.js();
+            let grid = this.grid;
+            // if the target position is a sofa or a bed
+            // set it as navigable so a path can be traced
+            if (this.grid[target.roomY][target.roomX] < -1) {
+                grid = this.clone(this.grid);
+                grid[target.roomY][target.roomX] = 0;
+            }
+            easystar.setGrid(grid);
+            easystar.setAcceptableTiles([1, 0]);
+            //easystar.enableDiagonals();
+            easystar.findPath(origin.roomX, origin.roomY, target.roomX, target.roomY, (result) => {
+                let currentPosition = {
+                    x: origin.roomX,
+                    y: origin.roomY,
+                };
+                const path = [];
+                if (!result) {
+                    resolve(path);
+                    return;
+                }
+                result.forEach((position, index) => {
+                    if (index === 0)
+                        return;
+                    const direction = this.getAvatarDirectionFromDiff(position.x - currentPosition.x, position.y - currentPosition.y);
+                    const tile = this.room.getTileAtPosition(position.x, position.y);
+                    if (tile != null) {
+                        const getHeight = () => {
+                            if (tile.type === "tile")
+                                return tile.z;
+                            if (tile.type === "stairs")
+                                return tile.z + 0.5;
+                            return 0;
+                        };
+                        path.push({
+                            roomX: position.x,
+                            roomY: position.y,
+                            roomZ: getHeight(),
+                            direction,
+                        });
+                        currentPosition = {
+                            x: position.x,
+                            y: position.y,
+                        };
+                    }
+                });
+                resolve(path);
+            });
+            easystar.calculate();
+        });
+    }
+    clone(grid) {
+        return JSON.parse(JSON.stringify(grid));
+    }
+    getAvatarDirectionFromDiff(diffX, diffY) {
+        const signX = Math.sign(diffX);
+        const signY = Math.sign(diffY);
+        switch (signX) {
+            case -1:
+                switch (signY) {
+                    case -1:
+                        return 7;
+                    case 0:
+                        return 6;
+                    case 1:
+                        return 5;
+                }
+                break;
+            case 0:
+                switch (signY) {
+                    case -1:
+                        return 0;
+                    case 1:
+                        return 4;
+                }
+                break;
+            case 1:
+                switch (signY) {
+                    case -1:
+                        return 1;
+                    case 0:
+                        return 2;
+                    case 1:
+                        return 3;
+                }
+                break;
+        }
+        throw "Invalid direction set " + [diffX, diffY].join(",");
+    }
+}
+exports.Pathfinding = Pathfinding;

package/dist/objects/room/Room.d.ts

@@ -0,0 +1,182 @@
+import * as PIXI from "pixi.js";
+import { IAnimationTicker } from "../../interfaces/IAnimationTicker";
+import { IAvatarLoader } from "../../interfaces/IAvatarLoader";
+import { IConfiguration } from "../../interfaces/IConfiguration";
+import { IFurnitureData } from "../../interfaces/IFurnitureData";
+import { IFurnitureLoader } from "../../interfaces/IFurnitureLoader";
+import { IRoomGeometry } from "../../interfaces/IRoomGeometry";
+import { IRoomObject } from "../../interfaces/IRoomObject";
+import { IRoomObjectContainer } from "../../interfaces/IRoomObjectContainer";
+import { RoomPosition } from "../../types/RoomPosition";
+import { WallPosition } from "../../types/WallPosition";
+import { TileType } from "../../types/TileType";
+import { ParsedTileType } from "../../util/parseTileMap";
+import { Wsproom } from "../Wsproom";
+import { ITileMap } from "../../interfaces/ITileMap";
+import { RoomModelVisualization } from "./RoomModelVisualization";
+import { EventManager } from "../events/EventManager";
+import { FederatedPointerEvent } from "pixi.js";
+import { IEventManagerEvent } from "../events/interfaces/IEventManagerEvent";
+export interface Dependencies {
+    animationTicker: IAnimationTicker;
+    avatarLoader: IAvatarLoader;
+    furnitureLoader: IFurnitureLoader;
+    configuration: IConfiguration;
+    furnitureData?: IFurnitureData;
+    application: PIXI.Application;
+}
+type TileMap = TileType[][] | string;
+interface CreateOptions {
+    /**
+     * A tilemap string or 2d-array. This should have the following format
+     * ```
+     * xxxx  <- Upper padding
+     * x000  <- Tiles
+     * x000
+     * x000
+     *
+     * |
+     * |
+     * Side padding
+     * ```
+     */
+    tilemap: TileMap;
+}
+export declare class Room extends PIXI.Container implements IRoomGeometry, IRoomObjectContainer, ITileMap {
+    readonly application: PIXI.Application;
+    private _roomObjectContainer;
+    private _visualization;
+    private _animationTicker;
+    private _avatarLoader;
+    private _furnitureLoader;
+    private _eventManager;
+    private _configuration;
+    private _wallTexture;
+    private _floorTexture;
+    private _wallColor;
+    private _floorColor;
+    private _currentWallTexture;
+    private _onTileClick;
+    private _application;
+    private _activeTileSubject;
+    private _activeTileSubscription;
+    private _activeWallSubject;
+    private _activeWallSubscription;
+    private _tileClickSubscription;
+    get onActiveTileChange(): import("rxjs").Observable<RoomPosition>;
+    get onActiveWallChange(): import("rxjs").Observable<WallPosition | undefined>;
+    constructor({ animationTicker, avatarLoader, furnitureLoader, tilemap, configuration, application, }: {
+        tilemap: TileMap;
+    } & Dependencies);
+    /**
+     * The room exposes its own subjects, so a visualization swap (changeTileMap)
+     * stays invisible to whoever subscribed to the room.
+     */
+    private _resubscribeVisualization;
+    /**
+     * Creates a new room.
+     * @param wsproom A wsproom instance
+     * @param options Room creation options
+     */
+    static create(wsproom: Wsproom, { tilemap }: CreateOptions): Room;
+    /**
+     * Room objects which are attached to the room.
+     */
+    get roomObjects(): ReadonlySet<IRoomObject>;
+    /**
+     * When set to true, hides the walls
+     */
+    get hideWalls(): boolean;
+    set hideWalls(value: boolean);
+    /**
+     * When set to true, hide the floor. This will also hide the walls.
+     */
+    get hideFloor(): boolean;
+    set hideFloor(value: boolean);
+    get hideTileCursor(): boolean;
+    set hideTileCursor(value: boolean);
+    /**
+     * Height of the walls in the room.
+     */
+    get wallHeight(): number;
+    set wallHeight(value: number);
+    /**
+     * Height of the tile
+     */
+    get tileHeight(): number;
+    set tileHeight(value: number);
+    /**
+     * Depth of the wall
+     */
+    get wallDepth(): number;
+    set wallDepth(value: number);
+    /**
+     * A callback which is called with the tile position when a tile is clicked.
+     */
+    get onTileClick(): ((position: RoomPosition, event: IEventManagerEvent) => void) | undefined;
+    set onTileClick(value: ((position: RoomPosition, event: IEventManagerEvent) => void) | undefined);
+    /**
+     * Texture of the wall.
+     */
+    get wallTexture(): Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined;
+    set wallTexture(value: Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined);
+    /**
+     * Texture of the floor.
+     */
+    get floorTexture(): Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined;
+    set floorTexture(value: Promise<PIXI.Texture<PIXI.TextureSource<any>>> | PIXI.Texture<PIXI.TextureSource<any>> | undefined);
+    /**
+     * Color of the wall.
+     */
+    get wallColor(): string | undefined;
+    set wallColor(value: string | undefined);
+    /**
+     * Color of the floor.
+     */
+    get floorColor(): string | undefined;
+    set floorColor(value: string | undefined);
+    /**
+     * Height of the room.
+     */
+    get roomHeight(): number;
+    /**
+     * Width of the room.
+     */
+    get roomWidth(): number;
+    get visualization(): RoomModelVisualization;
+    get eventManager(): EventManager;
+    changeTileMap(tileMap: TileType[][]): void;
+    getParsedTileTypes(): ParsedTileType[][];
+    getTileMap(): TileType[][];
+    getWallOffsets(): {
+        x: number;
+        y: number;
+    };
+    setTileAt(x: number, y: number, type: TileType): void;
+    resizeTileMap(cols: number, rows: number): void;
+    getTileMapString(): string;
+    /**
+     * Adds and registers a room object to a room.
+     * @param object The room object to attach
+     */
+    addRoomObject(object: IRoomObject): void;
+    /**
+     * Removes and destroys a room object from the room.
+     * @param object The room object to remove
+     */
+    removeRoomObject(object: IRoomObject): void;
+    getPosition(roomX: number, roomY: number, roomZ: number): {
+        x: number;
+        y: number;
+    };
+    getTileAtPosition(roomX: number, roomY: number): ParsedTileType | undefined;
+    destroy(): void;
+    set onBackgroundClick(value: ((event: FederatedPointerEvent) => void) | undefined);
+    private _getObjectPositionWithOffset;
+    private _loadWallTextures;
+    private _loadFloorTextures;
+    private _updateWallColor;
+    private _updateTileColor;
+    private _getWallColor;
+}
+export {};