如何在pathfinding3d.js中的两个远程节点之间构造一条路径？

Question

要在pathfinding3d.js中创建路径，我们必须添加所有节点及其邻居。

var nodes = [
    new PF.Node(0,0,0),
    new PF.Node(1,0,0),
    new PF.Node(2,0,0),
];
nodes[0].neighbors.push(nodes[1]);
nodes[1].neighbors.push(nodes[0],nodes[2]);
nodes[2].neighbors.push(nodes[1]);
var finder = new PF.AStarFinder();
var path = finder.findPath(nodes[0], nodes[2], nodes);

问题是，如果我想要创建一个大型的三维节点网格，创建一个路径，我需要在每个节点中推送邻居来创建路径。还有别的办法吗？我可以通过添加起始节点和目标节点从一个点到另一个遥远的点创建路径吗？例如createPath(节点(1，2，3)，节点(4，5，6)以及它们之间的路径创建路径。或者还有比这更合适的解决方案？

Answer 1

我已经找到了解决办法。首先，我创建了三个函数来帮助我创建布局，使所有节点连接起来，然后，使用pathfinding3d.js来计算它需要连接的节点，根据所提出的连接节点，只连接必要的节点。以下是功能：

function create3DLayout(x, y, z) {
    let layout = new Array(x);
    for (let i = 0; i < x; i++) {
        layout[i] = new Array(y);
        for (let j = 0; j < y; j++) {
            layout[i][j] = new Array(z);
            for (let k = 0; k < z; k++) {
                layout[i][j][k] = new PF.Node(i, j, k);
            }
        }
    }
    return layout;
}

function createAllWalkable(layout) {
    for (let i = 0; i < layout.length; i++) {
        for (let j = 0; j < layout[i].length; j++) {
            for (let k = 0; k < layout[i][j].length; k++) {

                let mInit = (i + -1 >= 0) ? -1 : 0;
                let mEnd = (i + 1 < layout.length) ? 1 : 0;

                for (let m = mInit; m <= mEnd; m++) {

                    let nInit = (j + -1 >= 0) ? -1 : 0;
                    let nEnd = (j + 1 < layout[i].length) ? 1 : 0;

                    for (let n = nInit; n <= nEnd; n++) {

                        let oInit = (k + -1 >= 0) ? -1 : 0;
                        let oEnd = (k + 1 < layout[i][j].length) ? 1 : 0;

                        for (let o = oInit; o <= oEnd; o++) {

                            let xt = m + i;
                            let yt = n + j;
                            let zt = o + k;

                            if (layout[xt][yt][zt] != layout[i][j][k]) {
                                layout[i][j][k].neighbors.push(layout[xt][yt][zt]);
                            }
                        }
                    }
                }
            }
        }
    }
}

function createWalkablePath(layout, nodeStart, nodeEnd) {
    // Create building
    let walkablelayout = create3DLayout(layout.length, layout[0].length, layout[0][0].length);

    // Create path to every corner of building
    createAllWalkable(walkablelayout);

    let startPath = walkablelayout[nodeStart.x][nodeStart.y][nodeStart.z];
    let endPath = walkablelayout[nodeEnd.x][nodeEnd.y][nodeEnd.z];

    let explorer = new PF.AStarFinder();
    let exploredPath = explorer.findPath(startPath, endPath, walkablelayout);

    for (let i = 0; i < exploredPath.length - 1; i++) {
        layout[exploredPath[i][0]][exploredPath[i][1]][exploredPath[i][2]].neighbors.push(layout[exploredPath[i + 1][0]][exploredPath[i + 1][1]][exploredPath[i + 1][2]]);
        layout[exploredPath[i + 1][0]][exploredPath[i + 1][1]][exploredPath[i + 1][2]].neighbors.push(layout[exploredPath[i][0]][exploredPath[i][1]][exploredPath[i][2]]);
    }

}

然后，我将进行计算：

var nodes = create3DLayout(26, 26, 3);

        createWalkablePath(nodes, nodes[7][14][0], nodes[9][17][0]);
        createWalkablePath(nodes, nodes[0][0][0], nodes[25][25][2]);
        createWalkablePath(nodes, nodes[0][25][0], nodes[9][17][0]);
        createWalkablePath(nodes, nodes[1][15][1], nodes[9][17][0]);
        createWalkablePath(nodes, nodes[20][25][1], nodes[9][17][0]);

        // Create finder
        var finder = new PF.AStarFinder();

        // origin
        var startNode = nodes[14][14][2];
        console.log(startNode);

        // Destination
        var endNode = nodes[17][17][2];
        console.log(endNode);

        var path;

        // Find path
        path = finder.findPath(startNode, endNode, nodes);
        console.log(path);

希望这对面临同样问题的人有所帮助。