@grafloria/element 0.3.18 → 0.3.20

package/src/libs/engine/src/routing/algorithms/AStarRouter.js

@@ -0,0 +1,331 @@
+"use strict";
+// AStarRouter.ts - A* Pathfinding Algorithm Implementation (Phase 4.2)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AStarRouter = exports.AStarHeuristic = void 0;
+/**
+ * Heuristic functions for A* algorithm
+ */
+var AStarHeuristic;
+(function (AStarHeuristic) {
+    /** Manhattan distance (L1 norm) - best for grid-based movement */
+    AStarHeuristic["MANHATTAN"] = "manhattan";
+    /** Euclidean distance (L2 norm) - best for free movement */
+    AStarHeuristic["EUCLIDEAN"] = "euclidean";
+    /** Diagonal distance (Chebyshev/L∞ norm) - best for 8-directional movement */
+    AStarHeuristic["DIAGONAL"] = "diagonal";
+})(AStarHeuristic || (exports.AStarHeuristic = AStarHeuristic = {}));
+/**
+ * Min-heap priority queue for A* open set
+ */
+class PriorityQueue {
+    constructor() {
+        this.heap = [];
+    }
+    push(node) {
+        this.heap.push(node);
+        this.bubbleUp(this.heap.length - 1);
+    }
+    pop() {
+        if (this.heap.length === 0)
+            return undefined;
+        if (this.heap.length === 1)
+            return this.heap.pop();
+        const result = this.heap[0];
+        this.heap[0] = this.heap.pop();
+        this.bubbleDown(0);
+        return result;
+    }
+    isEmpty() {
+        return this.heap.length === 0;
+    }
+    bubbleUp(index) {
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            if (this.heap[index].f >= this.heap[parentIndex].f)
+                break;
+            [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
+            index = parentIndex;
+        }
+    }
+    bubbleDown(index) {
+        while (true) {
+            let minIndex = index;
+            const leftChild = 2 * index + 1;
+            const rightChild = 2 * index + 2;
+            if (leftChild < this.heap.length && this.heap[leftChild].f < this.heap[minIndex].f) {
+                minIndex = leftChild;
+            }
+            if (rightChild < this.heap.length && this.heap[rightChild].f < this.heap[minIndex].f) {
+                minIndex = rightChild;
+            }
+            if (minIndex === index)
+                break;
+            [this.heap[index], this.heap[minIndex]] = [this.heap[minIndex], this.heap[index]];
+            index = minIndex;
+        }
+    }
+}
+/**
+ * A* Pathfinding Router
+ */
+class AStarRouter {
+    constructor(obstacleMap, options = {}) {
+        var _a, _b, _c, _d, _e, _f;
+        this.obstacleMap = obstacleMap;
+        this.options = {
+            heuristic: (_a = options.heuristic) !== null && _a !== void 0 ? _a : AStarHeuristic.MANHATTAN,
+            allowDiagonal: (_b = options.allowDiagonal) !== null && _b !== void 0 ? _b : true,
+            gridSize: (_c = options.gridSize) !== null && _c !== void 0 ? _c : 5,
+            smoothing: (_d = options.smoothing) !== null && _d !== void 0 ? _d : true,
+            obstacleMargin: (_e = options.obstacleMargin) !== null && _e !== void 0 ? _e : 5,
+            maxIterations: (_f = options.maxIterations) !== null && _f !== void 0 ? _f : 10000,
+        };
+    }
+    /**
+     * Get algorithm name
+     */
+    getName() {
+        return 'a-star';
+    }
+    /**
+     * Find path from start to end using A* algorithm
+     */
+    route(start, end) {
+        // Early exit if start equals end
+        if (this.pointsEqual(start, end)) {
+            return [start];
+        }
+        // Snap points to grid
+        const gridStart = this.snapToGrid(start);
+        const gridEnd = this.snapToGrid(end);
+        // If points snap to the same grid cell, return direct path
+        if (this.pointsEqual(gridStart, gridEnd)) {
+            return [start, end];
+        }
+        // Run A* algorithm
+        const path = this.findPath(gridStart, gridEnd);
+        if (path.length === 0) {
+            return [];
+        }
+        // Replace first and last points with original coordinates
+        path[0] = start;
+        path[path.length - 1] = end;
+        // Apply path smoothing if enabled
+        if (this.options.smoothing) {
+            return this.smoothPath(path);
+        }
+        return path;
+    }
+    /**
+     * Core A* pathfinding algorithm
+     */
+    findPath(start, end) {
+        const openSet = new PriorityQueue();
+        const closedSet = new Set();
+        const gScores = new Map();
+        // Initialize start node
+        const startNode = {
+            point: start,
+            g: 0,
+            h: this.heuristic(start, end),
+            f: this.heuristic(start, end),
+            parent: null,
+        };
+        openSet.push(startNode);
+        gScores.set(this.pointKey(start), 0);
+        let iterations = 0;
+        while (!openSet.isEmpty() && iterations < this.options.maxIterations) {
+            iterations++;
+            const current = openSet.pop();
+            const currentKey = this.pointKey(current.point);
+            // Check if we reached the goal
+            if (this.pointsEqual(current.point, end)) {
+                return this.reconstructPath(current);
+            }
+            closedSet.add(currentKey);
+            // Explore neighbors
+            const neighbors = this.getNeighbors(current.point);
+            for (const neighbor of neighbors) {
+                const neighborKey = this.pointKey(neighbor);
+                // Skip if in closed set
+                if (closedSet.has(neighborKey))
+                    continue;
+                // Skip if collides with obstacle
+                if (this.collidesWithObstacle(neighbor))
+                    continue;
+                // Calculate tentative g score
+                const tentativeG = current.g + this.distance(current.point, neighbor);
+                // Check if this is a better path
+                const existingG = gScores.get(neighborKey);
+                if (existingG !== undefined && tentativeG >= existingG) {
+                    continue;
+                }
+                // This is the best path so far
+                gScores.set(neighborKey, tentativeG);
+                const neighborNode = {
+                    point: neighbor,
+                    g: tentativeG,
+                    h: this.heuristic(neighbor, end),
+                    f: tentativeG + this.heuristic(neighbor, end),
+                    parent: current,
+                };
+                openSet.push(neighborNode);
+            }
+        }
+        // No path found
+        return [];
+    }
+    /**
+     * Reconstruct path from end node
+     */
+    reconstructPath(node) {
+        const path = [];
+        let current = node;
+        while (current !== null) {
+            path.unshift(current.point);
+            current = current.parent;
+        }
+        return path;
+    }
+    /**
+     * Get neighbors of a point
+     */
+    getNeighbors(point) {
+        const { gridSize } = this.options;
+        const neighbors = [];
+        // 4-directional movement (orthogonal)
+        const orthogonal = [
+            { x: point.x + gridSize, y: point.y }, // Right
+            { x: point.x - gridSize, y: point.y }, // Left
+            { x: point.x, y: point.y + gridSize }, // Down
+            { x: point.x, y: point.y - gridSize }, // Up
+        ];
+        neighbors.push(...orthogonal);
+        // 8-directional movement (diagonal)
+        if (this.options.allowDiagonal) {
+            const diagonal = [
+                { x: point.x + gridSize, y: point.y + gridSize }, // Down-right
+                { x: point.x - gridSize, y: point.y + gridSize }, // Down-left
+                { x: point.x + gridSize, y: point.y - gridSize }, // Up-right
+                { x: point.x - gridSize, y: point.y - gridSize }, // Up-left
+            ];
+            neighbors.push(...diagonal);
+        }
+        return neighbors;
+    }
+    /**
+     * Calculate heuristic distance
+     */
+    heuristic(a, b) {
+        const dx = Math.abs(b.x - a.x);
+        const dy = Math.abs(b.y - a.y);
+        switch (this.options.heuristic) {
+            case AStarHeuristic.MANHATTAN:
+                return dx + dy;
+            case AStarHeuristic.EUCLIDEAN:
+                return Math.sqrt(dx * dx + dy * dy);
+            case AStarHeuristic.DIAGONAL:
+                // Chebyshev distance
+                return Math.max(dx, dy);
+            default:
+                return dx + dy;
+        }
+    }
+    /**
+     * Calculate actual distance between two points
+     */
+    distance(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    /**
+     * Check if point collides with obstacle (including margin)
+     */
+    collidesWithObstacle(point) {
+        const margin = this.options.obstacleMargin;
+        // Query obstacles in region around point
+        const obstacles = this.obstacleMap.queryRegion({
+            x: point.x - margin,
+            y: point.y - margin,
+            width: margin * 2,
+            height: margin * 2,
+        });
+        for (const obstacle of obstacles) {
+            // Check if point is within obstacle bounds + margin
+            if (point.x >= obstacle.x - margin &&
+                point.x <= obstacle.x + obstacle.width + margin &&
+                point.y >= obstacle.y - margin &&
+                point.y <= obstacle.y + obstacle.height + margin) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Smooth path by removing unnecessary waypoints
+     */
+    smoothPath(path) {
+        if (path.length <= 2)
+            return path;
+        const smoothed = [path[0]];
+        let currentIndex = 0;
+        while (currentIndex < path.length - 1) {
+            // Try to find the farthest point we can reach directly
+            let farthestIndex = currentIndex + 1;
+            for (let i = path.length - 1; i > currentIndex + 1; i--) {
+                if (this.hasLineOfSight(path[currentIndex], path[i])) {
+                    farthestIndex = i;
+                    break;
+                }
+            }
+            smoothed.push(path[farthestIndex]);
+            currentIndex = farthestIndex;
+        }
+        return smoothed;
+    }
+    /**
+     * Check if there's a clear line of sight between two points
+     */
+    hasLineOfSight(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        const steps = Math.ceil(distance / this.options.gridSize);
+        for (let i = 1; i < steps; i++) {
+            const t = i / steps;
+            const point = {
+                x: a.x + dx * t,
+                y: a.y + dy * t,
+            };
+            if (this.collidesWithObstacle(point)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Snap point to grid
+     */
+    snapToGrid(point) {
+        const { gridSize } = this.options;
+        return {
+            x: Math.round(point.x / gridSize) * gridSize,
+            y: Math.round(point.y / gridSize) * gridSize,
+        };
+    }
+    /**
+     * Create unique key for point
+     */
+    pointKey(point) {
+        return `${point.x},${point.y}`;
+    }
+    /**
+     * Check if two points are equal
+     */
+    pointsEqual(a, b) {
+        return a.x === b.x && a.y === b.y;
+    }
+}
+exports.AStarRouter = AStarRouter;
+//# sourceMappingURL=AStarRouter.js.map

package/src/libs/engine/src/routing/algorithms/DijkstraRouter.d.ts

@@ -0,0 +1,74 @@
+import type { Point } from '../../types';
+import type { ObstacleMap } from '../ObstacleMap';
+/**
+ * Configuration options for Dijkstra router
+ */
+export interface DijkstraOptions {
+    /** Allow diagonal movement (default: true) */
+    allowDiagonal?: boolean;
+    /** Grid size for discretization (default: 5) */
+    gridSize?: number;
+    /** Enable path smoothing (default: true) */
+    smoothing?: boolean;
+    /** Margin around obstacles (default: 5) */
+    obstacleMargin?: number;
+    /** Maximum iterations before giving up (default: 10000) */
+    maxIterations?: number;
+}
+/**
+ * Dijkstra's Shortest Path Router
+ * Guarantees shortest path but may be slower than A* for long distances
+ */
+export declare class DijkstraRouter {
+    private obstacleMap;
+    private options;
+    constructor(obstacleMap: ObstacleMap, options?: DijkstraOptions);
+    /**
+     * Get algorithm name
+     */
+    getName(): string;
+    /**
+     * Find shortest path from start to end using Dijkstra's algorithm
+     */
+    route(start: Point, end: Point): Point[];
+    /**
+     * Core Dijkstra's shortest path algorithm
+     */
+    private findPath;
+    /**
+     * Reconstruct path from end node
+     */
+    private reconstructPath;
+    /**
+     * Get neighbors of a point
+     */
+    private getNeighbors;
+    /**
+     * Calculate distance between two points
+     */
+    private distance;
+    /**
+     * Check if point collides with obstacle (including margin)
+     */
+    private collidesWithObstacle;
+    /**
+     * Smooth path by removing unnecessary waypoints
+     */
+    private smoothPath;
+    /**
+     * Check if there's a clear line of sight between two points
+     */
+    private hasLineOfSight;
+    /**
+     * Snap point to grid
+     */
+    private snapToGrid;
+    /**
+     * Create unique key for point
+     */
+    private pointKey;
+    /**
+     * Check if two points are equal
+     */
+    private pointsEqual;
+}

package/src/libs/engine/src/routing/algorithms/DijkstraRouter.js

@@ -0,0 +1,297 @@
+"use strict";
+// DijkstraRouter.ts - Dijkstra's Shortest Path Algorithm (Phase 4.3)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DijkstraRouter = void 0;
+/**
+ * Min-heap priority queue for Dijkstra
+ */
+class PriorityQueue {
+    constructor() {
+        this.heap = [];
+    }
+    push(node) {
+        this.heap.push(node);
+        this.bubbleUp(this.heap.length - 1);
+    }
+    pop() {
+        if (this.heap.length === 0)
+            return undefined;
+        if (this.heap.length === 1)
+            return this.heap.pop();
+        const result = this.heap[0];
+        this.heap[0] = this.heap.pop();
+        this.bubbleDown(0);
+        return result;
+    }
+    isEmpty() {
+        return this.heap.length === 0;
+    }
+    bubbleUp(index) {
+        while (index > 0) {
+            const parentIndex = Math.floor((index - 1) / 2);
+            if (this.heap[index].distance >= this.heap[parentIndex].distance)
+                break;
+            [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
+            index = parentIndex;
+        }
+    }
+    bubbleDown(index) {
+        while (true) {
+            let minIndex = index;
+            const leftChild = 2 * index + 1;
+            const rightChild = 2 * index + 2;
+            if (leftChild < this.heap.length && this.heap[leftChild].distance < this.heap[minIndex].distance) {
+                minIndex = leftChild;
+            }
+            if (rightChild < this.heap.length && this.heap[rightChild].distance < this.heap[minIndex].distance) {
+                minIndex = rightChild;
+            }
+            if (minIndex === index)
+                break;
+            [this.heap[index], this.heap[minIndex]] = [this.heap[minIndex], this.heap[index]];
+            index = minIndex;
+        }
+    }
+}
+/**
+ * Dijkstra's Shortest Path Router
+ * Guarantees shortest path but may be slower than A* for long distances
+ */
+class DijkstraRouter {
+    constructor(obstacleMap, options = {}) {
+        var _a, _b, _c, _d, _e;
+        this.obstacleMap = obstacleMap;
+        this.options = {
+            allowDiagonal: (_a = options.allowDiagonal) !== null && _a !== void 0 ? _a : true,
+            gridSize: (_b = options.gridSize) !== null && _b !== void 0 ? _b : 5,
+            smoothing: (_c = options.smoothing) !== null && _c !== void 0 ? _c : true,
+            obstacleMargin: (_d = options.obstacleMargin) !== null && _d !== void 0 ? _d : 5,
+            maxIterations: (_e = options.maxIterations) !== null && _e !== void 0 ? _e : 10000,
+        };
+    }
+    /**
+     * Get algorithm name
+     */
+    getName() {
+        return 'dijkstra';
+    }
+    /**
+     * Find shortest path from start to end using Dijkstra's algorithm
+     */
+    route(start, end) {
+        // Early exit if start equals end
+        if (this.pointsEqual(start, end)) {
+            return [start];
+        }
+        // Snap points to grid
+        const gridStart = this.snapToGrid(start);
+        const gridEnd = this.snapToGrid(end);
+        // If points snap to the same grid cell, return direct path
+        if (this.pointsEqual(gridStart, gridEnd)) {
+            return [start, end];
+        }
+        // Run Dijkstra's algorithm
+        const path = this.findPath(gridStart, gridEnd);
+        if (path.length === 0) {
+            return [];
+        }
+        // Replace first and last points with original coordinates
+        path[0] = start;
+        path[path.length - 1] = end;
+        // Apply path smoothing if enabled
+        if (this.options.smoothing) {
+            return this.smoothPath(path);
+        }
+        return path;
+    }
+    /**
+     * Core Dijkstra's shortest path algorithm
+     */
+    findPath(start, end) {
+        const openSet = new PriorityQueue();
+        const closedSet = new Set();
+        const distances = new Map();
+        // Initialize start node
+        const startNode = {
+            point: start,
+            distance: 0,
+            parent: null,
+        };
+        openSet.push(startNode);
+        distances.set(this.pointKey(start), 0);
+        let iterations = 0;
+        while (!openSet.isEmpty() && iterations < this.options.maxIterations) {
+            iterations++;
+            const current = openSet.pop();
+            const currentKey = this.pointKey(current.point);
+            // Check if we reached the goal
+            if (this.pointsEqual(current.point, end)) {
+                return this.reconstructPath(current);
+            }
+            closedSet.add(currentKey);
+            // Explore neighbors
+            const neighbors = this.getNeighbors(current.point);
+            for (const neighbor of neighbors) {
+                const neighborKey = this.pointKey(neighbor);
+                // Skip if in closed set
+                if (closedSet.has(neighborKey))
+                    continue;
+                // Skip if collides with obstacle
+                if (this.collidesWithObstacle(neighbor))
+                    continue;
+                // Calculate tentative distance
+                const tentativeDistance = current.distance + this.distance(current.point, neighbor);
+                // Check if this is a better path
+                const existingDistance = distances.get(neighborKey);
+                if (existingDistance !== undefined && tentativeDistance >= existingDistance) {
+                    continue;
+                }
+                // This is the best path so far
+                distances.set(neighborKey, tentativeDistance);
+                const neighborNode = {
+                    point: neighbor,
+                    distance: tentativeDistance,
+                    parent: current,
+                };
+                openSet.push(neighborNode);
+            }
+        }
+        // No path found
+        return [];
+    }
+    /**
+     * Reconstruct path from end node
+     */
+    reconstructPath(node) {
+        const path = [];
+        let current = node;
+        while (current !== null) {
+            path.unshift(current.point);
+            current = current.parent;
+        }
+        return path;
+    }
+    /**
+     * Get neighbors of a point
+     */
+    getNeighbors(point) {
+        const { gridSize } = this.options;
+        const neighbors = [];
+        // 4-directional movement (orthogonal)
+        const orthogonal = [
+            { x: point.x + gridSize, y: point.y }, // Right
+            { x: point.x - gridSize, y: point.y }, // Left
+            { x: point.x, y: point.y + gridSize }, // Down
+            { x: point.x, y: point.y - gridSize }, // Up
+        ];
+        neighbors.push(...orthogonal);
+        // 8-directional movement (diagonal)
+        if (this.options.allowDiagonal) {
+            const diagonal = [
+                { x: point.x + gridSize, y: point.y + gridSize }, // Down-right
+                { x: point.x - gridSize, y: point.y + gridSize }, // Down-left
+                { x: point.x + gridSize, y: point.y - gridSize }, // Up-right
+                { x: point.x - gridSize, y: point.y - gridSize }, // Up-left
+            ];
+            neighbors.push(...diagonal);
+        }
+        return neighbors;
+    }
+    /**
+     * Calculate distance between two points
+     */
+    distance(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+    /**
+     * Check if point collides with obstacle (including margin)
+     */
+    collidesWithObstacle(point) {
+        const margin = this.options.obstacleMargin;
+        // Query obstacles in region around point
+        const obstacles = this.obstacleMap.queryRegion({
+            x: point.x - margin,
+            y: point.y - margin,
+            width: margin * 2,
+            height: margin * 2,
+        });
+        for (const obstacle of obstacles) {
+            // Check if point is within obstacle bounds + margin
+            if (point.x >= obstacle.x - margin &&
+                point.x <= obstacle.x + obstacle.width + margin &&
+                point.y >= obstacle.y - margin &&
+                point.y <= obstacle.y + obstacle.height + margin) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Smooth path by removing unnecessary waypoints
+     */
+    smoothPath(path) {
+        if (path.length <= 2)
+            return path;
+        const smoothed = [path[0]];
+        let currentIndex = 0;
+        while (currentIndex < path.length - 1) {
+            // Try to find the farthest point we can reach directly
+            let farthestIndex = currentIndex + 1;
+            for (let i = path.length - 1; i > currentIndex + 1; i--) {
+                if (this.hasLineOfSight(path[currentIndex], path[i])) {
+                    farthestIndex = i;
+                    break;
+                }
+            }
+            smoothed.push(path[farthestIndex]);
+            currentIndex = farthestIndex;
+        }
+        return smoothed;
+    }
+    /**
+     * Check if there's a clear line of sight between two points
+     */
+    hasLineOfSight(a, b) {
+        const dx = b.x - a.x;
+        const dy = b.y - a.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        const steps = Math.ceil(distance / this.options.gridSize);
+        for (let i = 1; i < steps; i++) {
+            const t = i / steps;
+            const point = {
+                x: a.x + dx * t,
+                y: a.y + dy * t,
+            };
+            if (this.collidesWithObstacle(point)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Snap point to grid
+     */
+    snapToGrid(point) {
+        const { gridSize } = this.options;
+        return {
+            x: Math.round(point.x / gridSize) * gridSize,
+            y: Math.round(point.y / gridSize) * gridSize,
+        };
+    }
+    /**
+     * Create unique key for point
+     */
+    pointKey(point) {
+        return `${point.x},${point.y}`;
+    }
+    /**
+     * Check if two points are equal
+     */
+    pointsEqual(a, b) {
+        return a.x === b.x && a.y === b.y;
+    }
+}
+exports.DijkstraRouter = DijkstraRouter;
+//# sourceMappingURL=DijkstraRouter.js.map