@esengine/pathfinding 1.0.1 → 1.0.2

package/src/AI/Pathfinding/AStar/AStarPathfinder.ts

@@ -1,244 +0,0 @@
-import { IVector2, Vector2Utils } from '../../../Types/IVector2';
-import { IAstarGraph } from './IAstarGraph';
-import { PriorityQueue, IPriorityQueueNode } from '../../../Utils/PriorityQueue';
-
-/**
- * A*算法节点
- */
-class AStarNode implements IPriorityQueueNode {
-    public node: IVector2;
-    public priority: number = 0;
-    public gCost: number = 0;
-    public hCost: number = 0;
-    public parent: AStarNode | null = null;
-    public hash: number = 0; // 缓存哈希值，避免重复计算
-
-    constructor(node: IVector2, gCost: number = 0, hCost: number = 0, parent: AStarNode | null = null) {
-        this.node = node;
-        this.gCost = gCost;
-        this.hCost = hCost;
-        this.priority = gCost + hCost;
-        this.parent = parent;
-        this.hash = Vector2Utils.toHash(node); // 预计算哈希值
-    }
-
-    updateCosts(gCost: number, hCost: number, parent: AStarNode | null = null): void {
-        this.gCost = gCost;
-        this.hCost = hCost;
-        this.priority = gCost + hCost;
-        this.parent = parent;
-    }
-
-    updateNode(node: IVector2, gCost: number = 0, hCost: number = 0, parent: AStarNode | null = null): void {
-        this.node = node;
-        this.gCost = gCost;
-        this.hCost = hCost;
-        this.priority = gCost + hCost;
-        this.parent = parent;
-        this.hash = Vector2Utils.toHash(node); // 更新哈希值
-    }
-
-    reset(): void {
-        this.node = null as any;
-        this.priority = 0;
-        this.gCost = 0;
-        this.hCost = 0;
-        this.parent = null;
-        this.hash = 0;
-    }
-}
-
-export class AStarPathfinder {
-    private static _nodePool: AStarNode[] = [];
-    private static _tempPath: IVector2[] = [];
-    
-    /**
-     * 从对象池获取节点
-     */
-    private static _getNode(node: IVector2, gCost: number = 0, hCost: number = 0, parent: AStarNode | null = null): AStarNode {
-        let astarNode = this._nodePool.pop();
-        if (!astarNode) {
-            astarNode = new AStarNode(node, gCost, hCost, parent);
-        } else {
-            astarNode.updateNode(node, gCost, hCost, parent);
-        }
-        return astarNode;
-    }
-
-    /**
-     * 回收节点到对象池
-     */
-    private static _recycleNode(node: AStarNode): void {
-        if (this._nodePool.length < 1000) { // 限制池大小
-            node.reset();
-            this._nodePool.push(node);
-        }
-    }
-
-    /**
-     * 使用A*算法搜索路径
-     * @param graph 图对象
-     * @param start 起始节点
-     * @param goal 目标节点
-     * @returns 搜索结果
-     */
-    static search<T extends IVector2>(
-        graph: IAstarGraph<T>, 
-        start: T, 
-        goal: T
-    ): { found: boolean; goalNode?: AStarNode } {
-        const openSet = new PriorityQueue<AStarNode>();
-        const closedSet = new Set<number>(); // 使用数值哈希
-        const openSetMap = new Map<number, AStarNode>(); // 使用数值哈希
-
-        const startHash = Vector2Utils.toHash(start);
-        const goalHash = Vector2Utils.toHash(goal);
-
-        if (startHash === goalHash) {
-            return { found: true, goalNode: this._getNode(start, 0, 0) };
-        }
-        const startNode = this._getNode(start, 0, graph.heuristic(start, goal));
-        openSet.enqueue(startNode);
-        openSetMap.set(startHash, startNode);
-
-        let goalNode: AStarNode | undefined;
-
-        while (!openSet.isEmpty) {
-            const current = openSet.dequeue()!;
-            const currentHash = current.hash;
-
-            openSetMap.delete(currentHash);
-
-            if (currentHash === goalHash) {
-                goalNode = current;
-                break;
-            }
-
-            closedSet.add(currentHash);
-            for (const neighbor of graph.getNeighbors(current.node as T)) {
-                const neighborHash = Vector2Utils.toHash(neighbor);
-
-                if (closedSet.has(neighborHash)) {
-                    continue;
-                }
-
-                const tentativeGScore = current.gCost + graph.cost(current.node as T, neighbor);
-                const existingNode = openSetMap.get(neighborHash);
-                
-                if (existingNode) {
-                    if (tentativeGScore < existingNode.gCost) {
-                        const hCost = existingNode.hCost;
-                        existingNode.updateCosts(tentativeGScore, hCost, current);
-                    }
-                } else {
-                    const hCost = graph.heuristic(neighbor, goal);
-                    const neighborNode = this._getNode(neighbor, tentativeGScore, hCost, current);
-                    openSet.enqueue(neighborNode);
-                    openSetMap.set(neighborHash, neighborNode);
-                }
-            }
-
-            if (current !== goalNode) {
-                this._recycleNode(current);
-            }
-        }
-        while (!openSet.isEmpty) {
-            const node = openSet.dequeue()!;
-            if (node !== goalNode) {
-                this._recycleNode(node);
-            }
-        }
-
-        return { found: !!goalNode, goalNode };
-    }
-
-    /**
-     * 搜索并返回完整路径
-     * @param graph 图对象
-     * @param start 起始节点
-     * @param goal 目标节点
-     * @returns 路径数组，如果没找到则返回空数组
-     */
-    static searchPath<T extends IVector2>(
-        graph: IAstarGraph<T>, 
-        start: T, 
-        goal: T
-    ): T[] {
-        const result = this.search(graph, start, goal);
-        
-        if (!result.found || !result.goalNode) {
-            return [];
-        }
-
-        return this.reconstructPathFromNode(result.goalNode, start);
-    }
-
-    /**
-     * 从目标节点重构路径
-     * @param goalNode 目标节点
-     * @param start 起始节点
-     * @returns 完整路径
-     */
-    private static reconstructPathFromNode<T extends IVector2>(
-        goalNode: AStarNode, 
-        start: T
-    ): T[] {
-        this._tempPath.length = 0;
-        
-        let current: AStarNode | null = goalNode;
-        const startHash = Vector2Utils.toHash(start);
-
-        while (current) {
-            this._tempPath.unshift(current.node as T);
-            
-            const currentHash = current.hash;
-            const parent = current.parent;
-            
-            if (currentHash !== startHash) {
-                this._recycleNode(current);
-            }
-            
-            current = parent;
-        }
-        return [...this._tempPath] as T[];
-    }
-
-    /**
-     * 检查路径是否存在
-     * @param graph 图对象
-     * @param start 起始节点
-     * @param goal 目标节点
-     * @returns 是否存在路径
-     */
-    static hasPath<T extends IVector2>(
-        graph: IAstarGraph<T>, 
-        start: T, 
-        goal: T
-    ): boolean {
-        const result = this.search(graph, start, goal);
-        
-        if (result.goalNode) {
-            this._recycleNode(result.goalNode);
-        }
-        
-        return result.found;
-    }
-
-    /**
-     * 清理对象池（可选调用，用于内存管理）
-     */
-    static clearPool(): void {
-        this._nodePool.length = 0;
-        this._tempPath.length = 0;
-    }
-
-    /**
-     * 获取对象池统计信息
-     */
-    static getPoolStats(): { poolSize: number; maxPoolSize: number } {
-        return {
-            poolSize: this._nodePool.length,
-            maxPoolSize: 1000
-        };
-    }
-} 

package/src/AI/Pathfinding/AStar/AstarGridGraph.ts

@@ -1,183 +0,0 @@
-import { IVector2, Vector2Utils } from '../../../Types/IVector2';
-import { IAstarGraph } from './IAstarGraph';
-import { AStarPathfinder } from './AStarPathfinder';
-
-/**
- * 基本静态网格图与A*一起使用
- * 将walls添加到walls数组，并将加权节点添加到weightedNodes数组
- */
-export class AstarGridGraph implements IAstarGraph<IVector2> {
-    public dirs: IVector2[] = [
-        Vector2Utils.create(1, 0),
-        Vector2Utils.create(0, -1),
-        Vector2Utils.create(-1, 0),
-        Vector2Utils.create(0, 1)
-    ];
-
-    public walls: IVector2[] = [];
-    public weightedNodes: IVector2[] = [];
-    public defaultWeight: number = 1;
-    public weightedNodeWeight = 5;
-
-    private _width: number;
-    private _height: number;
-    private _neighbors: IVector2[] = new Array(4);
-    
-    private _wallsSet: Set<number> = new Set();
-    private _weightedNodesSet: Set<number> = new Set();
-    private _wallsDirty: boolean = true;
-    private _weightedNodesDirty: boolean = true;
-
-    constructor(width: number, height: number) {
-        this._width = width;
-        this._height = height;
-    }
-
-    /**
-     * 添加障碍物
-     */
-    addWall(wall: IVector2): void {
-        this.walls.push(wall);
-        this._wallsDirty = true;
-    }
-
-    /**
-     * 批量添加障碍物
-     */
-    addWalls(walls: IVector2[]): void {
-        this.walls.push(...walls);
-        this._wallsDirty = true;
-    }
-
-    /**
-     * 清空障碍物
-     */
-    clearWalls(): void {
-        this.walls.length = 0;
-        this._wallsSet.clear();
-        this._wallsDirty = false;
-    }
-
-    /**
-     * 添加加权节点
-     */
-    addWeightedNode(node: IVector2): void {
-        this.weightedNodes.push(node);
-        this._weightedNodesDirty = true;
-    }
-
-    /**
-     * 批量添加加权节点
-     */
-    addWeightedNodes(nodes: IVector2[]): void {
-        this.weightedNodes.push(...nodes);
-        this._weightedNodesDirty = true;
-    }
-
-    /**
-     * 清空加权节点
-     */
-    clearWeightedNodes(): void {
-        this.weightedNodes.length = 0;
-        this._weightedNodesSet.clear();
-        this._weightedNodesDirty = false;
-    }
-
-    /**
-     * 更新内部哈希集合
-     */
-    private _updateHashSets(): void {
-        if (this._wallsDirty) {
-            this._wallsSet.clear();
-            for (const wall of this.walls) {
-                this._wallsSet.add(Vector2Utils.toHash(wall));
-            }
-            this._wallsDirty = false;
-        }
-
-        if (this._weightedNodesDirty) {
-            this._weightedNodesSet.clear();
-            for (const node of this.weightedNodes) {
-                this._weightedNodesSet.add(Vector2Utils.toHash(node));
-            }
-            this._weightedNodesDirty = false;
-        }
-    }
-
-    /**
-     * 确保节点在网格图的边界内
-     * @param node
-     */
-    public isNodeInBounds(node: IVector2): boolean {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    }
-
-    /**
-     * 检查节点是否可以通过。walls是不可逾越的。
-     * @param node
-     */
-    public isNodePassable(node: IVector2): boolean {
-        this._updateHashSets();
-        return !this._wallsSet.has(Vector2Utils.toHash(node));
-    }
-
-    /**
-     * 检查是否存在路径
-     * @param start 起始位置
-     * @param goal 目标位置
-     */
-    public search(start: IVector2, goal: IVector2): boolean {
-        return AStarPathfinder.hasPath(this, start, goal);
-    }
-
-    /**
-     * 搜索并返回完整路径
-     * @param start 起始位置
-     * @param goal 目标位置
-     */
-    public searchPath(start: IVector2, goal: IVector2): IVector2[] {
-        return AStarPathfinder.searchPath(this, start, goal);
-    }
-
-    public getNeighbors(node: IVector2): IVector2[] {
-        this._neighbors.length = 0;
-
-        for (const dir of this.dirs) {
-            const next = Vector2Utils.add(node, dir);
-            if (this.isNodeInBounds(next) && this.isNodePassable(next)) {
-                this._neighbors.push(next);
-            }
-        }
-
-        return this._neighbors;
-    }
-
-    public cost(from: IVector2, to: IVector2): number {
-        this._updateHashSets();
-        return this._weightedNodesSet.has(Vector2Utils.toHash(to)) ? this.weightedNodeWeight : this.defaultWeight;
-    }
-
-    public heuristic(node: IVector2, goal: IVector2): number {
-        return Vector2Utils.manhattanDistance(node, goal);
-    }
-
-    /**
-     * 获取统计信息
-     */
-    public getStats(): { 
-        walls: number; 
-        weightedNodes: number; 
-        gridSize: string;
-        wallsSetSize: number;
-        weightedNodesSetSize: number;
-    } {
-        this._updateHashSets();
-        return {
-            walls: this.walls.length,
-            weightedNodes: this.weightedNodes.length,
-            gridSize: `${this._width}x${this._height}`,
-            wallsSetSize: this._wallsSet.size,
-            weightedNodesSetSize: this._weightedNodesSet.size
-        };
-    }
-}

package/src/AI/Pathfinding/AStar/IAstarGraph.ts

@@ -1,30 +0,0 @@
-import { IVector2 } from '../../../Types/IVector2';
-
-/**
- * A*算法图接口
- * @template T 节点类型，通常是实现了IVector2的类型
- */
-export interface IAstarGraph<T extends IVector2> {
-    /**
-     * 获取指定节点的邻居节点
-     * @param node 当前节点
-     * @returns 邻居节点数组
-     */
-    getNeighbors(node: T): T[];
-
-    /**
-     * 计算从一个节点到另一个节点的移动成本
-     * @param from 起始节点
-     * @param to 目标节点
-     * @returns 移动成本
-     */
-    cost(from: T, to: T): number;
-
-    /**
-     * 计算启发式函数值（估算从当前节点到目标的成本）
-     * @param node 当前节点
-     * @param goal 目标节点
-     * @returns 启发式成本
-     */
-    heuristic(node: T, goal: T): number;
-}

package/src/AI/Pathfinding/BreadthFirst/BreadthFirstPathfinder.ts

@@ -1,109 +0,0 @@
-import { IVector2, Vector2Utils } from '../../../Types/IVector2';
-import { IUnweightedGraph } from './IUnweightedGraph';
-
-/**
- * 广度优先搜索算法实现
- * 适用于无权图，保证找到最短路径（步数最少）
- */
-export class BreadthFirstPathfinder {
-    /**
-     * 使用广度优先搜索算法搜索路径
-     * @param graph 图对象
-     * @param start 起始节点
-     * @param goal 目标节点
-     * @param cameFrom 可选的路径记录Map
-     * @returns 是否找到路径
-     */
-    static search<T extends IVector2>(
-        graph: IUnweightedGraph<T>, 
-        start: T, 
-        goal: T, 
-        cameFrom?: Map<number, T>
-    ): boolean {
-        const frontier: T[] = [];
-        const visited = new Set<number>();
-        const pathMap = cameFrom || new Map<number, T>();
-
-        const startHash = Vector2Utils.toHash(start);
-        const goalHash = Vector2Utils.toHash(goal);
-
-        if (startHash === goalHash) {
-            return true;
-        }
-
-        frontier.push(start);
-        visited.add(startHash);
-
-        while (frontier.length > 0) {
-            const current = frontier.shift()!;
-            const currentHash = Vector2Utils.toHash(current);
-
-            if (currentHash === goalHash) {
-                return true;
-            }
-
-            for (const neighbor of graph.getNeighbors(current)) {
-                const neighborHash = Vector2Utils.toHash(neighbor);
-
-                if (visited.has(neighborHash)) {
-                    continue;
-                }
-
-                visited.add(neighborHash);
-                pathMap.set(neighborHash, current);
-                frontier.push(neighbor);
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * 搜索并返回完整路径
-     * @param graph 图对象
-     * @param start 起始节点
-     * @param goal 目标节点
-     * @returns 路径数组，如果没找到则返回空数组
-     */
-    static searchPath<T extends IVector2>(
-        graph: IUnweightedGraph<T>, 
-        start: T, 
-        goal: T
-    ): T[] {
-        const cameFrom = new Map<number, T>();
-        
-        if (this.search(graph, start, goal, cameFrom)) {
-            return this.reconstructPath(cameFrom, start, goal);
-        }
-        
-        return [];
-    }
-
-    /**
-     * 重构路径
-     * @param cameFrom 路径记录Map
-     * @param start 起始节点
-     * @param goal 目标节点
-     * @returns 完整路径
-     */
-    static reconstructPath<T extends IVector2>(
-        cameFrom: Map<number, T>, 
-        start: T, 
-        goal: T
-    ): T[] {
-        const path: T[] = [];
-        let current = goal;
-        const startHash = Vector2Utils.toHash(start);
-
-        while (Vector2Utils.toHash(current) !== startHash) {
-            path.unshift(current);
-            const currentHash = Vector2Utils.toHash(current);
-            const parent = cameFrom.get(currentHash);
-            if (!parent) break;
-            current = parent;
-        }
-        
-        path.unshift(start);
-        return path;
-    }
-}

package/src/AI/Pathfinding/BreadthFirst/IUnweightedGraph.ts

@@ -1,14 +0,0 @@
-import { IVector2 } from '../../../Types/IVector2';
-
-/**
- * 无权图接口，用于广度优先搜索
- * @template T 节点类型，通常是实现了IVector2的类型
- */
-export interface IUnweightedGraph<T extends IVector2> {
-    /**
-     * 获取指定节点的邻居节点
-     * @param node 当前节点
-     * @returns 邻居节点数组
-     */
-    getNeighbors(node: T): T[];
-}

package/src/AI/Pathfinding/BreadthFirst/UnweightedGraph.ts

@@ -1,29 +0,0 @@
-import { IVector2 } from '../../../Types/IVector2';
-import { IUnweightedGraph } from './IUnweightedGraph';
-
-/**
- * 一个未加权图的基本实现。所有的边都被缓存。这种类型的图最适合于非基于网格的图。
- * 作为边添加的任何节点都必须在边字典中有一个条目作为键。
- */
-export class UnweightedGraph<T extends IVector2> implements IUnweightedGraph<T> {
-    public edges: Map<T, T[]> = new Map<T, T[]>();
-
-    /**
-     * 为指定节点添加边
-     * @param node 节点
-     * @param neighbors 邻居节点数组
-     */
-    addEdgesForNode(node: T, neighbors: T[]): this {
-        this.edges.set(node, neighbors);
-        return this;
-    }
-
-    /**
-     * 获取指定节点的邻居节点
-     * @param node 节点
-     * @returns 邻居节点数组
-     */
-    getNeighbors(node: T): T[] {
-        return this.edges.get(node) || [];
-    }
-}

package/src/AI/Pathfinding/BreadthFirst/UnweightedGridGraph.ts

@@ -1,81 +0,0 @@
-import { IVector2, Vector2Utils } from '../../../Types/IVector2';
-import { IUnweightedGraph } from './IUnweightedGraph';
-import { BreadthFirstPathfinder } from './BreadthFirstPathfinder';
-
-/**
- * 基本的无权网格图，用于广度优先搜索
- * 适用于简单的网格寻路，如迷宫、推箱子等游戏
- */
-export class UnweightedGridGraph implements IUnweightedGraph<IVector2> {
-    private static readonly CARDINAL_DIRS: IVector2[] = [
-        Vector2Utils.create(1, 0),
-        Vector2Utils.create(0, -1),
-        Vector2Utils.create(-1, 0),
-        Vector2Utils.create(0, 1)
-    ];
-
-    private static readonly COMPASS_DIRS: IVector2[] = [
-        Vector2Utils.create(1, 0),
-        Vector2Utils.create(1, -1),
-        Vector2Utils.create(0, -1),
-        Vector2Utils.create(-1, -1),
-        Vector2Utils.create(-1, 0),
-        Vector2Utils.create(-1, 1),
-        Vector2Utils.create(0, 1),
-        Vector2Utils.create(1, 1),
-    ];
-
-    public walls: IVector2[] = [];
-
-    private _width: number;
-    private _height: number;
-    private _dirs: IVector2[];
-    private _neighbors: IVector2[] = [];
-
-    constructor(width: number, height: number, allowDiagonalSearch: boolean = false) {
-        this._width = width;
-        this._height = height;
-        this._dirs = allowDiagonalSearch ? UnweightedGridGraph.COMPASS_DIRS : UnweightedGridGraph.CARDINAL_DIRS;
-    }
-
-    public isNodeInBounds(node: IVector2): boolean {
-        return 0 <= node.x && node.x < this._width && 0 <= node.y && node.y < this._height;
-    }
-
-    public isNodePassable(node: IVector2): boolean {
-        return !this.walls.find(wall => Vector2Utils.equals(wall, node));
-    }
-
-    public getNeighbors(node: IVector2): IVector2[] {
-        this._neighbors.length = 0;
-
-        for (const dir of this._dirs) {
-            const next = Vector2Utils.add(node, dir);
-            if (this.isNodeInBounds(next) && this.isNodePassable(next)) {
-                this._neighbors.push(next);
-            }
-        }
-
-        return this._neighbors;
-    }
-
-    /**
-     * 搜索路径的便捷方法
-     * @param start 起始位置
-     * @param goal 目标位置
-     * @returns 路径数组，如果没找到则返回空数组
-     */
-    public searchPath(start: IVector2, goal: IVector2): IVector2[] {
-        return BreadthFirstPathfinder.searchPath(this, start, goal);
-    }
-
-    /**
-     * 检查是否存在路径
-     * @param start 起始位置
-     * @param goal 目标位置
-     * @returns 是否存在路径
-     */
-    public hasPath(start: IVector2, goal: IVector2): boolean {
-        return BreadthFirstPathfinder.search(this, start, goal);
-    }
-}