A*和Dijkstra算法在unity寻路中的应用

最新推荐文章于 2024-02-21 16:46:08 发布

helloworld_hust

最新推荐文章于 2024-02-21 16:46:08 发布

阅读量374

点赞数

文章标签： unity 算法游戏引擎

本文链接：https://blog.csdn.net/helloworld_hust/article/details/127886932

版权

引入

A*和Dijstra算法都是寻路常用的算法，A*和Dijkstra算法可以说是极为相似了，只是拓展结点时选取的方式不同，因为A*在寻路中使用得更多，所以我将着重讲解A*寻路，最后将两者不同之处进行对比。

Astar核心脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Astar : MonoBehaviour
{
    private GridNodes gridNodes;

    private Node startNode;
    private Node targetNode;

    private int gridWidth;
    private int gridHeight;

    private List<Node> openNodeList;    //当前选中Node周围的8个点,开放表
    private HashSet<Node> closedNodeList;   //所有被选中的点，关闭表

    private void Start()
    {
        gridNodes = GetComponent<FSM>().parameter.nodes;
    }
    public GridNodes BiuldPath(Vector2Int startPos, Vector2Int endPos)
    {
        GenerateGridNodes(startPos, endPos);

        //查找最短路径
        return FindShortestPath();
    }

    /// <summary>
    /// 构建网格节点信息，初始化两个列表
    /// </summary>
    /// <param name="startPos">起点</param>
    /// <param name="endPos">终点</param>
    /// <returns></returns>
    private void GenerateGridNodes(Vector2Int startPos, Vector2Int endPos)
    {
        MapManager.instance.GetGridDimensions(out Vector2Int gridDimensions);
        //根据瓦片地图范围构建网格移动节点范围数组
        gridNodes = new GridNodes(gridDimensions.x, gridDimensions.y);
        gridWidth = gridDimensions.x;
        gridHeight = gridDimensions.y;

        openNodeList = new List<Node>();

        closedNodeList = new HashSet<Node>();

        //gridNodes的范围是从0,0开始所以需要减去原点坐标得到实际位置
        startNode = gridNodes.GetGridNode(startPos.x, startPos.y);
        targetNode = gridNodes.GetGridNode(endPos.x, endPos.y);

        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                if (MapManager.instance.isObstacles[x, y])
                {
                    gridNodes.SetObstacle(x, y);
                }
            }
        }
    }

    public GridNodes FindShortestPath()
    {
        openNodeList.Add(startNode);
        Node currentNode;
        while(openNodeList.Count > 0)
        {
            //currentNode = FindOpenFLeastNode();
            currentNode = FindMinNode();
            openNodeList.Remove(currentNode);
            closedNodeList.Add(currentNode);
            EvaluateNeighbourNodes(currentNode);
            if(closedNodeList.Contains(targetNode))
            {
                return gridNodes;
            }
        }
        return null;
    }

    /// <summary>
    /// 评估周围8个点，并生成对应消耗值
    /// </summary>
    /// <param name="currentNode"></param>
    private void EvaluateNeighbourNodes(Node currentNode)
    {
        Vector2Int currentNodePos = currentNode.gridPosition;
        Node validNeighbourNode;

        for (int x = -1; x <= 1; x++)
        {
            for (int y = -1; y <= 1; y++)
            {
                if (x == 0 && y == 0)
                    continue;

                validNeighbourNode = GetValidNeighbourNode(currentNodePos.x + x, currentNodePos.y + y);

                if (validNeighbourNode != null)
                {
                    if (!openNodeList.Contains(validNeighbourNode))
                    {
                        validNeighbourNode.gCost = currentNode.gCost + GetDistance(currentNode, validNeighbourNode);
                        validNeighbourNode.hCost = GetDistance(validNeighbourNode, targetNode);
                        //链接父节点
                        validNeighbourNode.parentNode = currentNode;
                        openNodeList.Add(validNeighbourNode);
                    }
                }
            }
        }
    }


    /// <summary>
    /// 找到有效的Node,非障碍，非已选择
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    private Node GetValidNeighbourNode(int x, int y)
    {
        if (x >= gridWidth || y >= gridHeight || x < 0 || y < 0)
            return null;

        Node neighbourNode = gridNodes.GetGridNode(x, y);

        if (neighbourNode.isObstacle || closedNodeList.Contains(neighbourNode))
            return null;
        else
            return neighbourNode;
    }


    /// <summary>
    /// 求HCost，以下是其中一种启发函数
    /// </summary>
    /// <param name="nodeA"></param>
    /// <param name="nodeB"></param>
    /// <returns>14的倍数+10的倍数</returns>
    private int GetDistance(Node nodeA, Node nodeB)
    {
        int xDistance = Mathf.Abs(nodeA.gridPosition.x - nodeB.gridPosition.x);
        int yDistance = Mathf.Abs(nodeA.gridPosition.y - nodeB.gridPosition.y);

        if (xDistance > yDistance)
        {
            return 14 * yDistance + 10 * (xDistance - yDistance);
        }
        return 14 * xDistance + 10 * (yDistance - xDistance);
    }
    /// <summary>
    /// 找到开放列表中F最小的那一项
    /// </summary>
    /// <returns></returns>
    private Node FindOpenFLeastNode()
    {
        Node node = openNodeList[0];
        for(int i = 1; i< openNodeList.Count; i++)
        {
            if(openNodeList[i].FCost < node.FCost)
            {
                node = openNodeList[i];
            }
        }
        return node;
    }
}

分块解析

初始化地图信息，根据自己的需要构建网格信息，因为A*是基于图的算法

 private void GenerateGridNodes(Vector2Int startPos, Vector2Int endPos)
    {
        MapManager.instance.GetGridDimensions(out Vector2Int gridDimensions);
        //根据瓦片地图范围构建网格移动节点范围数组
        gridNodes = new GridNodes(gridDimensions.x, gridDimensions.y);
        gridWidth = gridDimensions.x;
        gridHeight = gridDimensions.y;

        openNodeList = new List<Node>();

        closedNodeList = new HashSet<Node>();

        //gridNodes的范围是从0,0开始所以需要减去原点坐标得到实际位置
        startNode = gridNodes.GetGridNode(startPos.x, startPos.y);
        targetNode = gridNodes.GetGridNode(endPos.x, endPos.y);

        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                if (MapManager.instance.isObstacles[x, y])
                {
                    gridNodes.SetObstacle(x, y);
                }
            }
        }

A*算法核心函数

只要开放列表中还有结点并且关闭列表中不包括终点，就继续拓展路径

流程是：找到当前最佳结点(A*和Dijkstra区别)、开放列表移除当前最佳结点、关闭列表加入当前最佳结点、根据当前最佳结点拓展相邻符合结点

 public GridNodes FindShortestPath()
    {
        openNodeList.Add(startNode);
        Node currentNode;
        while(openNodeList.Count > 0)
        {
            //currentNode = FindOpenFLeastNode();
            currentNode = FindMinNode();
            openNodeList.Remove(currentNode);
            closedNodeList.Add(currentNode);
            EvaluateNeighbourNodes(currentNode);
            if(closedNodeList.Contains(targetNode))
            {
                return gridNodes;
            }
        }
        return null;
    }

流程函数详解

找到当前最佳结点(A*和Dijkstra区别)

A*是考虑到了终点的，所以不会去拓展偏差很大的点，但是Dijkstra就会一层一层的外扩，直到找到终点(有一种盲目性)

  private Node FindOpenFLeastNode()//A*找到FCost最小的
    {
        Node node = openNodeList[0];
        for(int i = 1; i< openNodeList.Count; i++)
        {
            if(openNodeList[i].FCost < node.FCost)
            {
                node = openNodeList[i];
            }
        }
        return node;
    }
   private Node FindMinNode()//Dijkstra是找到GCost值最小的
    {
        if (openNodeList == null || openNodeList.Count == 0) return null;
        openNodeList.Sort((x, y) => x.gCost.CompareTo(y.gCost));
        return openNodeList[0];
    }

根据当前最佳结点拓展相邻符合结点

我们规定的是八个方向都可以走，所以遍历八个点，但我们需要筛掉一部分不满足的点(见下方第二段代码块)，我们筛掉了出界、障碍、关闭列表中的点

筛选完之后，假如开放列表中也不存在该点，那么就可以计算他的g，h，f值了，将其父节点设置为当前结点，并且归入开放列表中

 private void EvaluateNeighbourNodes(Node currentNode)
    {
        Vector2Int currentNodePos = currentNode.gridPosition;
        Node validNeighbourNode;

        for (int x = -1; x <= 1; x++)
        {
            for (int y = -1; y <= 1; y++)
            {
                if (x == 0 && y == 0)
                    continue;

                validNeighbourNode = GetValidNeighbourNode(currentNodePos.x + x, currentNodePos.y + y);

                if (validNeighbourNode != null)
                {
                    if (!openNodeList.Contains(validNeighbourNode))
                    {
                        validNeighbourNode.gCost = currentNode.gCost + GetDistance(currentNode, validNeighbourNode);
                        validNeighbourNode.hCost = GetDistance(validNeighbourNode, targetNode);
                        //链接父节点
                        validNeighbourNode.parentNode = currentNode;
                        openNodeList.Add(validNeighbourNode);
                    }
                }
            }
        }
    }

private Node GetValidNeighbourNode(int x, int y)
    {
        if (x >= gridWidth || y >= gridHeight || x < 0 || y < 0)
            return null;

        Node neighbourNode = gridNodes.GetGridNode(x, y);

        if (neighbourNode.isObstacle || closedNodeList.Contains(neighbourNode))
            return null;
        else
            return neighbourNode;
    }

启发函数

启发函数对A*算法的效率是至关重要的，比如Dijkstra算法中，其实就可以看成h(n) = 0，换句话说，启发函数为h(n) = 0时，A*就可以退化成Dijkstra算法，启发函数为g(n) = 0时，A*就可以退化成贪婪最佳优先算法(GBFS)，接下来我们将要介绍几种启发算法，例子中使用的是对角线距离(切比雪夫距离)

private int GetDistance(Node nodeA, Node nodeB)
    {
        int xDistance = Mathf.Abs(nodeA.gridPosition.x - nodeB.gridPosition.x);
        int yDistance = Mathf.Abs(nodeA.gridPosition.y - nodeB.gridPosition.y);

        if (xDistance > yDistance)
        {
            return 14 * yDistance + 10 * (xDistance - yDistance);
        }
        return 14 * xDistance + 10 * (yDistance - xDistance);
    }

曼哈顿距离：

当前点与目标点的x值距离绝对值加y值距离绝对值

欧几里得距离：

两点之间的直线距离

切比雪夫距离：

见上方代码块