mudlet-map-renderer 1.0.0 → 1.1.0

package/demo/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "paths": {
-      "@src": ["../src/index.ts"],
-      "@src/*": ["../src/*"]
-    }
-  },
-  "include": ["./**/*.ts", "./**/*.tsx", "../src/types/**/*.ts"]
-}

package/src/ExitRenderer.ts

@@ -1,275 +0,0 @@
-import Exit, {longToShort} from "./reader/Exit";
-import MapReader from "./reader/MapReader";
-import Konva from "konva";
-import {Settings} from "./Renderer";
-import {movePoint} from "./directions";
-
-const Colors = {
-    OPEN_DOOR: 'rgb(10, 155, 10)',
-    CLOSED_DOOR: 'rgb(226, 205, 59)',
-    LOCKED_DOOR: 'rgb(155, 10, 10)'
-}
-
-const dirNumbers: Record<number, MapData.direction> = {
-    1: "north",
-    2: "northeast",
-    3: "northwest",
-    4: "east",
-    5: "west",
-    6: "south",
-    7: "southeast",
-    8: "southwest",
-    9: "up",
-    10: "down",
-    11: "in",
-    12: "out",
-};
-
-const innerExits: MapData.direction[] = ["up", "down", "in", "out"];
-
-function getDoorColor(doorType: 1 | 2 | 3) {
-    switch (doorType) {
-        case 1:
-            return Colors.OPEN_DOOR
-        case 2:
-            return Colors.CLOSED_DOOR
-        default:
-            return Colors.LOCKED_DOOR
-    }
-}
-
-export default class ExitRenderer {
-
-    private mapReader: MapReader;
-
-    constructor(mapReader: MapReader) {
-        this.mapReader = mapReader;
-    }
-
-    render(exit: Exit) {
-        if (exit.aDir && exit.bDir) {
-            return this.renderTwoWayExit(exit);
-        } else {
-            return this.renderOneWayExit(exit);
-        }
-    }
-
-    private renderTwoWayExit(exit: Exit) {
-        const sourceRoom = this.mapReader.getRoom(exit.a)
-        const targetRoom = this.mapReader.getRoom(exit.b);
-
-        if (!sourceRoom || !targetRoom || !exit.aDir || !exit.bDir) {
-            return;
-        }
-
-        const exitRender = new Konva.Group();
-
-        const points = []
-        points.push(...Object.values(movePoint(sourceRoom.x, sourceRoom.y, exit.aDir, Settings.roomSize / 2)));
-        points.push(...Object.values(movePoint(targetRoom.x, targetRoom.y, exit.bDir, Settings.roomSize / 2)));
-
-        if (sourceRoom.doors[longToShort[exit.aDir]] || targetRoom.doors[longToShort[exit.bDir]]) {
-            const door = this.renderDoor(points, sourceRoom.doors[longToShort[exit.aDir]] ?? targetRoom.doors[longToShort[exit.bDir]])
-            exitRender.add(door);
-        }
-
-        const link = new Konva.Line({
-            points,
-            stroke: Settings.lineColor,
-            strokeWidth: 0.025,
-        });
-        exitRender.add(link);
-
-        return exitRender;
-    }
-
-    private renderOneWayExit(exit: Exit) {
-        const sourceRoom = exit.aDir ? this.mapReader.getRoom(exit.a) : this.mapReader.getRoom(exit.b)
-        const targetRoom = exit.aDir ? this.mapReader.getRoom(exit.b) : this.mapReader.getRoom(exit.a)
-        const dir = exit.aDir ? exit.aDir : exit.bDir;
-
-        if (!sourceRoom || !targetRoom) {
-            return;
-        }
-
-        if (sourceRoom.area != targetRoom.area && dir) {
-            return this.renderAreaExit(sourceRoom, dir);
-        }
-
-        let targetPoint = {x: targetRoom.x, y: targetRoom.y};
-        if (targetRoom.area !== sourceRoom.area || targetRoom.z !== sourceRoom.z) {
-            targetPoint = movePoint(sourceRoom.x, sourceRoom.y, dir, Settings.roomSize / 2);
-        }
-
-        const startPoint = movePoint(sourceRoom.x, sourceRoom.y, dir, 0.3);
-
-        const middlePointX = startPoint.x - (startPoint.x - targetPoint.x) / 2;
-        const middlePointY = startPoint.y - (startPoint.y - targetPoint.y) / 2;
-
-        const group = new Konva.Group();
-        const points = []
-        points.push(...Object.values(movePoint(sourceRoom.x, sourceRoom.y, dir, Settings.roomSize / 2)));
-        points.push(targetPoint.x, targetPoint.y);
-        const link = new Konva.Line({
-            points,
-            stroke: Settings.lineColor,
-            strokeWidth: 0.025,
-            dashEnabled: true,
-            dash: [0.1, 0.05],
-        });
-        group.add(link)
-
-        const arrow = new Konva.Arrow({
-            points: [points[0], points[1], middlePointX, middlePointY],
-            pointerLength: 0.5,
-            pointerWidth: 0.35,
-            strokeWidth: 0.035,
-            stroke: Settings.lineColor,
-            fill: '#FF0000',
-            dashEnabled: true,
-            dash: [0.1, 0.05],
-        })
-
-        group.add(arrow)
-
-        return group;
-    }
-
-    renderAreaExit(room: MapData.Room, dir: MapData.direction) {
-        const start = movePoint(room.x, room.y, dir, Settings.roomSize / 2)
-        const end = movePoint(room.x, room.y, dir, Settings.roomSize * 1.5)
-        return new Konva.Arrow({
-            points: [start.x, start.y, end.x, end.y],
-            pointerLength: 0.3,
-            pointerWidth: 0.3,
-            strokeWidth: 0.035,
-            stroke: this.mapReader.getColorValue(room.env),
-            fill: this.mapReader.getColorValue(room.env),
-        })
-    }
-
-    renderSpecialExits(room: MapData.Room) {
-        return Object.entries(room.customLines).map(([_, line]) => {
-            const points = [room.x, room.y]
-            line.points.reduce((acc, point) => {
-                acc.push(point.x, -point.y);
-                return acc;
-            }, points)
-
-            const construct = line.attributes.arrow ? Konva.Arrow : Konva.Line;
-            const lineRender = new construct({
-                points: points,
-                strokeWidth: .025,
-                stroke: `rgb(${line.attributes.color.r}, ${line.attributes.color.g}, ${line.attributes.color.b})`,
-                fill: `rgb(${line.attributes.color.r}, ${line.attributes.color.g} , ${line.attributes.color.b})`,
-                pointerLength: 0.3,
-                pointerWidth: 0.2,
-
-            })
-
-            let style = line.attributes.style;
-            if (style === "dot line") {
-                lineRender.dash([0.05, 0.05])
-                lineRender.dashOffset(0.1)
-            } else if (style === "dash line") {
-                lineRender.dash([0.4, 0.2])
-            } else if (style === "solid line") {
-            } else if (style !== undefined) {
-                console.log("Brak opisu stylu: " + style);
-            }
-
-            return lineRender;
-        })
-    }
-
-    renderStubs(room: MapData.Room) {
-        return room.stubs.map(stub => {
-            const direction = dirNumbers[stub];
-            const start = movePoint(room.x, room.y, direction, Settings.roomSize / 2)
-            const end = movePoint(room.x, room.y, direction, Settings.roomSize / 2 + 0.5)
-            const points = [start.x, start.y, end.x, end.y]
-            return new Konva.Line({
-                points,
-                stroke: Settings.lineColor,
-                strokeWidth: 0.025,
-            });
-        })
-    }
-
-    renderInnerExits(room: MapData.Room) {
-        return innerExits.map(exit => {
-            if (room.exits[exit]) {
-                const render = new Konva.Group();
-                const triangle = new Konva.RegularPolygon({
-                    x: room.x,
-                    y: room.y,
-                    sides: 3,
-                    fill: this.mapReader.getSymbolColor(room.env, 0.6),
-                    stroke: this.mapReader.getSymbolColor(room.env),
-                    strokeWidth: 0.025,
-                    radius: Settings.roomSize / 5,
-                    scaleX: 1.4,
-                    scaleY: 0.8
-                })
-                render.add(triangle);
-
-                let doorType = room.doors[exit];
-                if (doorType !== undefined) {
-                    switch (doorType) {
-                        case 1:
-                            triangle.stroke(Colors.OPEN_DOOR)
-                            break;
-                        case 2:
-                            triangle.stroke(Colors.CLOSED_DOOR);
-                            break;
-                        default:
-                            triangle.stroke(Colors.LOCKED_DOOR);
-                    }
-                }
-
-                switch (exit) {
-                    case "up":
-                        triangle.position(movePoint(room.x, room.y, "south", Settings.roomSize / 4));
-                        break;
-                    case "down":
-                        triangle.rotation(180);
-                        triangle.position(movePoint(room.x, room.y, "north", Settings.roomSize / 4));
-                        break;
-                    case "in":
-                        const inRender = triangle.clone()
-                        inRender.rotation(-90);
-                        inRender.position(movePoint(room.x, room.y, "east", Settings.roomSize / 4));
-                        render.add(inRender);
-                        triangle.rotation(90);
-                        triangle.position(movePoint(room.x, room.y, "west", Settings.roomSize / 4));
-                        break;
-                    case "out":
-                        const outRender = triangle.clone()
-                        outRender.rotation(90);
-                        outRender.position(movePoint(room.x, room.y, "east", Settings.roomSize / 4));
-                        render.add(outRender);
-                        triangle.rotation(-90);
-                        triangle.position(movePoint(room.x, room.y, "west", Settings.roomSize / 4));
-                        break;
-                }
-                return render
-            }
-        }).filter(e => e !== undefined)
-    }
-
-    renderDoor(points: number[], type: 1 | 2 | 3) {
-        const point = {
-            x: points[0] + (points[2] - points[0]) / 2,
-            y: points[1] + (points[3] - points[1]) / 2,
-        }
-        return new Konva.Rect({
-            x: point.x - Settings.roomSize / 4,
-            y: point.y - Settings.roomSize / 4,
-            width: Settings.roomSize / 2,
-            height: Settings.roomSize / 2,
-            stroke: getDoorColor(type),
-            strokeWidth: 0.025
-        })
-    }
-
-}

package/src/PathFinder.ts

@@ -1,93 +0,0 @@
-import Graph from "node-dijkstra";
-import MapReader from "./reader/MapReader";
-
-const exitNumberToDirection: Record<number, MapData.direction> = {
-    1: "north",
-    2: "northeast",
-    3: "northwest",
-    4: "east",
-    5: "west",
-    6: "south",
-    7: "southeast",
-    8: "southwest",
-    9: "up",
-    10: "down",
-    11: "in",
-    12: "out",
-};
-
-type GraphDefinition = Record<string, Record<string, number>>;
-
-export default class PathFinder {
-
-    private readonly mapReader: MapReader;
-    private readonly graph: Graph;
-    private readonly cache = new Map<string, Array<number> | null>();
-
-    constructor(mapReader: MapReader) {
-        this.mapReader = mapReader;
-        this.graph = this.buildGraph();
-    }
-
-    private buildGraph(): Graph {
-        const graphDefinition: GraphDefinition = {};
-        this.mapReader.getRooms().forEach(room => {
-            const connections: Record<string, number> = {};
-
-            const lockedDirections = new Set(
-                (room.exitLocks ?? [])
-                    .map(lockId => exitNumberToDirection[lockId])
-                    .filter((direction): direction is MapData.direction => Boolean(direction))
-            );
-
-            const lockedSpecialTargets = new Set(room.mSpecialExitLocks ?? []);
-
-            Object.entries(room.exits ?? {}).forEach(([direction, targetRoomId]) => {
-                if (lockedDirections.has(direction as MapData.direction)) {
-                    return;
-                }
-                if (this.mapReader.getRoom(targetRoomId)) {
-                    connections[targetRoomId.toString()] = 1;
-                }
-            });
-
-            Object.values(room.specialExits ?? {}).forEach(targetRoomId => {
-                if (lockedSpecialTargets.has(targetRoomId)) {
-                    return;
-                }
-                if (this.mapReader.getRoom(targetRoomId)) {
-                    connections[targetRoomId.toString()] = 1;
-                }
-            });
-
-            graphDefinition[room.id.toString()] = connections;
-        });
-
-        return new Graph(graphDefinition);
-    }
-
-    findPath(from: number, to: number): Array<number> | null {
-        const cacheKey = `${from}->${to}`;
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey)!;
-        }
-
-        if (from === to) {
-            const result = this.mapReader.getRoom(from) ? [from] : null;
-            this.cache.set(cacheKey, result);
-            return result;
-        }
-
-        if (!this.mapReader.getRoom(from) || !this.mapReader.getRoom(to)) {
-            this.cache.set(cacheKey, null);
-            return null;
-        }
-
-        const path = this.graph.path(from.toString(), to.toString());
-        const nodes = Array.isArray(path) ? path : path?.path;
-        const result = nodes ? nodes.map((id: string) => Number(id)) : null;
-        this.cache.set(cacheKey, result);
-        return result;
-    }
-}
-

package/src/PathRenderer.ts

@@ -1,129 +0,0 @@
-import Konva from "konva";
-import MapReader from "./reader/MapReader";
-import {Settings} from "./Renderer";
-import {movePoint, PlanarDirection, planarDirections, oppositeDirections} from "./directions";
-
-export default class PathRenderer {
-    private readonly mapReader: MapReader;
-    private readonly overlayLayer: Konva.Layer;
-    private paths: Konva.Line[] = [];
-
-    constructor(mapReader: MapReader, overlayLayer: Konva.Layer) {
-        this.mapReader = mapReader;
-        this.overlayLayer = overlayLayer;
-    }
-
-    renderPath(locations: number[], currentArea?: number, currentZIndex?: number) {
-        if (currentArea === undefined || currentZIndex === undefined) {
-            return;
-        }
-
-        const rooms = locations
-            .map(location => this.mapReader.getRoom(location))
-            .filter((room): room is MapData.Room => room !== undefined);
-
-        const segments: number[][] = [];
-        let currentSegment: number[] | null = null;
-
-        const finalizeSegment = () => {
-            if (!currentSegment) {
-                return;
-            }
-            if (currentSegment.length < 4) {
-                segments.pop();
-            }
-            currentSegment = null;
-        };
-
-        const ensureSegment = () => {
-            if (!currentSegment) {
-                currentSegment = [];
-                segments.push(currentSegment);
-            }
-            return currentSegment;
-        };
-
-        rooms.forEach((room, index) => {
-            if (!this.isRoomVisible(room, currentArea, currentZIndex)) {
-                return;
-            }
-
-            const previousRoom = index > 0 ? rooms[index - 1] : undefined;
-            const nextRoom = index < rooms.length - 1 ? rooms[index + 1] : undefined;
-            const previousVisible = this.isRoomVisible(previousRoom, currentArea, currentZIndex);
-
-            if (!previousVisible) {
-                finalizeSegment();
-                const segment = ensureSegment();
-                if (previousRoom) {
-                    const directionToPrevious = this.getDirectionTowards(room, previousRoom);
-                    if (directionToPrevious) {
-                        const startPoint = movePoint(room.x, room.y, directionToPrevious, Settings.roomSize);
-                        segment.push(startPoint.x, startPoint.y);
-                    }
-                }
-            } else {
-                ensureSegment();
-            }
-
-            currentSegment?.push(room.x, room.y);
-
-            const nextVisible = this.isRoomVisible(nextRoom, currentArea, currentZIndex);
-            if (!nextVisible && nextRoom) {
-                const directionToNext = this.getDirectionTowards(room, nextRoom);
-                if (directionToNext) {
-                    const endPoint = movePoint(room.x, room.y, directionToNext, Settings.roomSize);
-                    currentSegment?.push(endPoint.x, endPoint.y);
-                }
-                finalizeSegment();
-            }
-        });
-
-        finalizeSegment();
-
-        const paths = segments
-            .filter(points => points.length >= 4)
-            .map(points => new Konva.Line({
-                points,
-                stroke: 'green',
-                strokeWidth: 0.1
-            }));
-
-        paths.forEach(path => {
-            this.overlayLayer.add(path);
-            this.paths.push(path);
-        });
-
-        return paths[0];
-    }
-
-    clearPaths() {
-        this.paths.forEach(path => {
-            path.destroy();
-        });
-        this.paths = [];
-    }
-
-    private isRoomVisible(room: MapData.Room | undefined, currentArea: number | undefined, currentZIndex: number | undefined) {
-        if (!room) {
-            return false;
-        }
-        return room.area === currentArea && room.z === currentZIndex;
-    }
-
-    private getDirectionTowards(from: MapData.Room, to: MapData.Room): PlanarDirection | undefined {
-        for (const direction of planarDirections) {
-            if (from.exits[direction] === to.id) {
-                return direction;
-            }
-        }
-
-        for (const direction of planarDirections) {
-            if (to.exits[direction] === from.id) {
-                return oppositeDirections[direction];
-            }
-        }
-
-        return undefined;
-    }
-}