引入
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值距离绝对值
欧几里得距离:
两点之间的直线距离
切比雪夫距离:
见上方代码块