Question

我正在构建一个需要正确寻路的Flash游戏。我使用了this tutorial中的伪代码和对角启发式算法。我没有密切关注他们的代码。该语言是ActionScript 3，我也使用flashpunk库。

我目前的问题是该程序正在生成一条显然不是最短路径的路径。以下是显示问题的屏幕截图：

enter image description here

灰色块不可遍历，绿色块标记已“访问”的节点，蓝色块显示算法生成的路径。

尽管我试图使对角线成本更高（1.414），但对角线旅行成本似乎等于非对角线旅行成本。

这是整体算法实现。

function solveMaze() {

    // intitialize starting node
    startingNode.g = 0;
    startingNode.h = diagonalHeuristic(startingNode, destinationNode);
    startingNode.f = startingNode.g + startingNode.h;

    // Loop until destination node has been reached.
    while (currentNode != destinationNode) {

        if (openNodes.length == 0) {
            return null;
        }

        // set lowest cost node in openNode list to current node
        currentNode = lowestCostInArray(openNodes);

        //remove current node from openList
        openNodes.splice(openNodes.indexOf(currentNode), 1);

        //find 8 nodes adjacent to current node
        connectedNodes = findConnectedNodes(currentNode);

        //for each adjacent node,
        for each (var n:Node in connectedNodes) {
            // if node is not in open list AND its not in closed list AND its traversable
            if ((openNodes.indexOf(n) == -1) && (closedNodes.indexOf(n) == -1) && n.traversable) {

                // Calculate g and h values for the adjacent node and add the adjacent node to the open list
                // also set the current node as the parent of the adjacent node

                if ((n.mapX != currentNode.mapX) && (n.mapY != currentNode.mapY)) {
                    cost = 1.414; 
                } else {
                    cost = 1;
                }
                if(n.g> currentNode.g + cost){
                n.g = currentNode.g + cost;
                n.f=calculateCostOfNode(n);
                n.parentNode =currentNode;
                openNodes.push(n);
               }
            }
        }
        // turn current node into grass to indicate its been traversed
        currentNode.setType("walked_path");

        //var temp2:TextEntity = new TextEntity(n.h.toFixed(1).toString(), 32 * currentNode.mapX, 32 * currentNode.mapY);
        //add(temp2);

        // add current node to closed list
        closedNodes.push(currentNode);
    }

    // create a path from the destination node back to the starting node by following each parent node
    var tempNode:Node = destinationNode.parentNode;

    tempNode.setType("path2"); // blue blocks
    while(tempNode != startingNode){
        tempNode = tempNode.parentNode;
        tempNode.setType("path2");

    }
}

这些是使用的辅助函数：

function findConnectedNodes(inputNode:Node):Array {
    var outputArray:Array=[];

    // obtain all nodes that are either 1 unit away or 1.4 units away.
    for each (var n:Node in listOfNodes){
        if ((diagonalHeuristic(inputNode, n) == 1)||(diagonalHeuristic(inputNode, n) == 1.4) {
            outputArray.push(n);
        }
    }
    return outputArray;
}

public static function diagonalHeuristic(node:Node, destinationNode:Node, cost:Number = 1.0, diagonalCost:Number = 1.4):Number {
    var dx:Number = Math.abs(node.mapX - destinationNode.mapX);
    var dy:Number = Math.abs(node.mapY - destinationNode.mapY);

    if (dx > dy) {
        return diagonalCost * dy + (dx - dy);
    }else {
        return diagonalCost * dx + (dy - dx);
    }       
}

function lowestCostInArray(inputArray:Array):Node {
    var tempNode:Node = inputArray[0];
    for each (var n:Node in inputArray) {
        if (n.f < tempNode.f) {
            tempNode = n;
        }
    }
    return tempNode;
}

如果有帮助，我可以提供项目源代码。

Answer 1

我看到一些潜在的错误。

您可能会在此处覆盖值：
```
        n.g = currentNode.g + cost;
        n.f=calculateCostOfNode(n);
        n.parentNode =currentNode;
        openNodes.push(n);
```
应该是：
```
     if n.g > currentNode.g + cost:
        n.g = currentNode.g + cost;
        n.f=calculateCostOfNode(n);
        n.parentNode =currentNode;
        if n not already in openNodes:
            openNodes.push(n);
```
将n.g设置为非常大的值，或者您可以执行if n not in the open set or n.g > currentNode.g + cost之类的检查。

您应该从现在的位置删除支票if ((openNodes.indexOf(n) == -1)并将其放在我说的位置。如果新的g费用更高，您应该更新它，即使它在打开的列表中。您只需更新一个节点一次。如果您首先检查对角线，则会完全忽略侧面步骤。

这可能是问题所在：通过忽略打开列表中的邻居，您只需更新一次成本。只要它们不在关闭列表中，就可以更新它们的成本。
我不确定这是否是一个有效的问题，但我认为你在启发式函数中使用1.414稍稍玩火。启发式函数必须是可接受的，这意味着它永远不应高估成本。如果遇到一些浮点问题，可能会高估。我会安全地使用1.4作为启发式，使用1.414作为对角相邻节点之间的实际成本。

我的A * pathfinding实现不会产生最短路径

1 个答案: