mudlet-map-renderer 0.0.25 → 0.1.0-konva

package/map-fragment/reader/Area.js

@@ -1,74 +0,0 @@
-class Area {
-    constructor(areaId, areaName, rooms, labels, zIndex, levels) {
-        this.areaId = parseInt(areaId);
-        this.areaName = areaName;
-        this.rooms = [];
-        this.labels = labels;
-        rooms.forEach(element => this.rooms[element.id] = element)
-        this.levels = levels;
-        this.zIndex = zIndex;
-    }
-
-    getAreaBounds(full = false) {
-        if (this.bounds === undefined) {
-            let minX = 9999999999;
-            let minY = 9999999999;
-            let maxX = -9999999999;
-            let maxY = -9999999999;
-            this.rooms.forEach((room) => {
-                if (!full && room.z !== this.zIndex) {
-                    return;
-                }
-                minX = Math.min(minX, room.x);
-                minY = Math.min(minY, room.y);
-                maxX = Math.max(maxX, room.x);
-                maxY = Math.max(maxY, room.y);
-            });
-            this.labels.forEach((label) => {
-                if (!full && label.Z !== this.zIndex) {
-                    return;
-                }
-                minX = Math.min(minX, label.X);
-                minY = Math.min(minY, label.Y);
-                maxX = Math.max(maxX, label.X + label.Width);
-                maxY = Math.max(maxY, label.Y + label.Height);
-            });
-            this.bounds = { minX: minX, minY: minY, maxX: maxX, maxY: maxY };
-        }
-
-        return this.bounds;
-    }
-
-    getRoomById(id) {
-        return this.rooms[id];
-    }
-
-    getLevels() {
-        return this.levels;
-    }
-
-    getZIndex() {
-        return this.zIndex;
-    }
-
-    limit(id, padding) {
-        let room = this.rooms[id];
-        let limits = {
-            xMin: room.x - padding,
-            xMax: room.x + padding,
-            yMin: room.y - padding,
-            yMax: room.y + padding,
-        }
-
-        let onScreen = this.rooms.filter(room => limits.xMin < room.x && limits.xMax > room.x && limits.yMin < room.y && limits.yMax > room.y).map(item => item.id)
-
-        return new Area(this.areaId, this.areaName,
-             this.rooms.filter(room => onScreen.includes(room.id) || Object.values(room.exits).filter(val => onScreen.includes(val)).length > 0), 
-             this.labels.filter(label => limits.xMin < label.X && limits.xMax > label.X && limits.yMin < label.Y && limits.yMax > label.Y),
-             this.zIndex, this.levels);   
-    }
-}
-
-module.exports = {
-    Area: Area,
-};

package/map-fragment/reader/MapReader.js

@@ -1,89 +0,0 @@
-let Area = require("./Area").Area;
-
-class MapReader {
-    constructor(data, colors) {
-        this.mapDataIndex = {};
-        this.roomIndex = {};
-        this.data = data;
-        this.data.sort(function (areaElement1, areaElement2) {
-            if (areaElement1.areaName < areaElement2.areaName) {
-                return -1;
-            }
-            if (areaElement1.areaName > areaElement2.areaName) {
-                return 1;
-            }
-            return 0;
-        });
-        data.forEach((value, index) => {
-            this.mapDataIndex[value.areaId] = index;
-            value.rooms.forEach((room) => {
-                room.areaId = value.areaId;
-                this.roomIndex[room.id] = room;
-            });
-        });
-        this.colors = {};
-        colors.forEach((element) => {
-            this.colors[parseInt(element.envId)] = element.colors;
-        });
-        this.colors.default = [255, 255, 255];
-    }
-
-    getAreas() {
-        return this.data;
-    }
-
-    getArea(areaId, zIndex, limits) {
-        let area = this.data[this.mapDataIndex[areaId]];
-        let levels = new Set();
-        let candidateArea = new Area(
-            areaId,
-            area.areaName,
-            area.rooms.filter((room) => {
-                levels.add(parseInt(room.z));
-                let isWithinBounds = true;
-                if (limits) {
-                    isWithinBounds = limits.xMin < room.x && limits.xMax > room.x && limits.yMin < room.y && limits.yMax > room.y;
-                }
-                return isWithinBounds;
-            }),
-            area.labels.filter((label) => {
-                let isWithinBounds = true;
-                if (limits) {
-                    isWithinBounds = limits.xMin < label.X && limits.xMax > label.X && limits.yMin < label.Y && limits.yMax > label.Y;
-                }
-                return isWithinBounds;
-            }),
-            zIndex,
-            levels
-        );
-        if (area.rooms.length > 0 && !levels.has(zIndex)) {
-            candidateArea = this.getArea(areaId, levels.values().next().value);
-        }
-        return candidateArea;
-    }
-
-    getAreaProperties(areaId) {
-        return this.data[this.mapDataIndex[areaId]];
-    }
-
-    getAreaByRoomId(id, limits) {
-        let room = this.getRoomById(id);
-        if (room === undefined) {
-            return;
-        }
-        return this.getArea(room.areaId, room.z, limits);
-    }
-
-    getColors() {
-        return this.colors;
-    }
-
-    getRoomById(id) {
-        return this.roomIndex[id];
-    }
-
-}
-
-module.exports = {
-    MapReader
-};

package/map-fragment/reader/PathFinder.js

@@ -1,26 +0,0 @@
-const { MapReader } = require("./MapReader");
-const Graph = require("node-dijkstra")
-
-class PathFinder {
-
-    /**
-     * 
-     * @param {MapReader} reader 
-     */
-    constructor(reader) {
-        this.route = new Graph();
-        reader.getAreas().forEach(area => area.rooms.forEach(room => {
-            let exits = Object.values(room.exits).concat(Object.values(room.specialExits)).map(item => [item, room.weight ?? 1]);
-            this.route.addNode(room.id.toString(), Object.fromEntries(exits))
-        }))
-    }
-
-    path(from, to) {
-        return this.route.path(from.toString(), to.toString())
-    }
-
-}
-
-module.exports = {
-    PathFinder
-}