简单AStar寻路2D示例
A*寻路
牢记A*寻路的核心
F(n) = G(n) + H(n)
G(n): 从起始位置到n位置所需的实际消耗
H(n): 从n位置到目标位置的预计消耗
所以F(n)就是从起始位置经过n位置到目标位置的路径总消耗
A*寻路的过程就是不断找最小F(n)的过程
A*寻路流程
1.加入“开启列表”
先将起点作为当前检查点加入“开启列表”，“开启列表”是一个等待检查方格的列表，起点格子是最开始的检查点
2.检查周围
将当前检查点周围可到达的点加入“开启列表”，并设置它们的"父节点"为当前的检查点，并且计算出这些点的G(n)、H(n)、F(n)值
如果周围的点已经有在“开启列表” 中，则我们需要对比新旧路径的G值，如果新路径的G值更小，则使用新路径，需要更新“父节点”
如果是障碍物，则忽略
3.移入“关闭列表”
将这个检查点从“开启列表”移到“关闭列表”，"关闭列表"中存放的都是不需要再次检查的格子点
4.继续找直到找不到或者找到为止
再从“开启列表”中找出F值最小的格子，然后从上述的第1步开始重复继续，直到找到的F值最小的格子为终点或者“开启列表”中没有格子了，即为结束
几点注意点
- H(n)预计消耗的计算的准确度非常重要
由于G(n)是已经走过的路，所需的消耗是明确的，只有H(n)是预计的，预计的越准，我们就能越快的找到目标位置，减少计算量，也能更贴近最短路径 - A*寻路的结果并不一定是最短
由于H(n)是预计的消耗，这个预计的消耗可能会出现与实际情况相差较大的情况，这个时候寻路结果可能不是最短的
纸上得来终觉浅，绝知此事要躬行
简单做了个示例演示A*寻路的过程，以辅助理解
地图随机生成指定数量的障碍物，随机指定起始位置和终点位置
Game视图 Esc重置地图 Space 执行一步寻路步骤
白色：未检查过的格子
黑色：障碍物
黄色：在“开启列表”中的格子
灰色：在“关闭列表”中的格子
红色：目标格子
绿色：当前正在检查的格子
绿色链：最终的寻路结果
格子左上角：G值
格子右上角：H值
格子左下角：F值
格子右下角：坐标
箭头：指向寻路过程中的父格子
这里随机两次寻路过程来看下：
看下最终的寻路图
代码
完整工程：
Unity版本：2020.3.10
AStarGrid
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class AStarGrid
{
public int X { get; set; } //坐标X
public int Y { get; set; } //坐标Y
public float F { get { return G + H; } }
public float G { get; set; }
public float H { get; set; }
public bool IsObstacle { get; set; }
public AStarGrid ParentGrid { get; set; }
public AStarGrid(int x, int y)
{
this.X = x;
this.Y = y;
}
public void Reset()
{
G = 0;
H = 0;
IsObstacle = false;
ParentGrid = null;
}
}
AStarMap
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class AStarMap
{
AStarGrid[,] map;
int mapWidth;
int mapHeight;
//开启列表
Dictionary<int, AStarGrid> openList = new Dictionary<int, AStarGrid>();
//关闭列表
Dictionary<int, AStarGrid> closeList = new Dictionary<int, AStarGrid>();
public AStarMap(int mapWidth, int mapHeight)
{
this.mapWidth = mapWidth;
this.mapHeight = mapHeight;
map = new AStarGrid[mapWidth, mapHeight];
for (int w = 0; w < mapWidth; w++)
{
for (int h = 0; h < mapHeight; h++)
{
map[w, h] = new AStarGrid(w, h);
}
}
}
public void SetObstacle(int x, int y, bool isObstacle)
{
map[x, y].IsObstacle = isObstacle;
}
public AStarGrid GetGrid(int x, int y)
{
return map[x, y];
}
/// 寻路是否完成
public bool DoFindPathStep()
{
if (pathCurrentGrid == null || pathCurrentGrid == pathTargetGrid)
return true;
AddAroundGridToOpenList(pathCurrentGrid, pathTargetGrid);
MoveGridToCloseFromOpen(pathCurrentGrid);
pathCurrentGrid = FindMinFGrid();
if (pathCurrentGrid == null)
return true;
if (pathCurrentGrid == pathTargetGrid)
{
while (pathCurrentGrid != null)
{
pathResult.Add(pathCurrentGrid);
pathCurrentGrid = pathCurrentGrid.ParentGrid;
}
return true;
}
return false;
}
public List<AStarGrid> GetPathResult()
{
return pathResult;
}
public bool IsCurrentCheckGrid(AStarGrid grid)
{
return grid == pathCurrentGrid;
}
public bool IsTargetGrid(AStarGrid grid)
{
return grid == pathTargetGrid;
}
#endregion
public bool IsInOpenList(AStarGrid grid)
{
return openList.ContainsKey(GetGridIndex(grid));
}
public bool IsInCloseList(AStarGrid grid)
{
return closeList.ContainsKey(GetGridIndex(grid));
}
void AddToOpenList(AStarGrid grid, AStarGrid parentGrid, AStarGrid targetGrid)
{
int index = GetGridIndex(grid);
if (openList.ContainsKey(index))
{
float newG = ComputeG(grid, parentGrid);
if (newG < grid.G)
{
grid.ParentGrid = parentGrid;
grid.G = newG;
}
}
else
{
openList.Add(index, grid);
grid.ParentGrid = parentGrid;
UpdateGridGH(grid, targetGrid);
}
}
int GetGridIndex(AStarGrid grid)
{
return grid.Y * mapWidth + grid.X;
}
int GetGridIndex(int x, int y)
{
return y * mapWidth + x;
}
void AddAroundGridToOpenList(AStarGrid grid, AStarGrid targetGrid)
{
int cx, cy;
AStarGrid g;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
cx = grid.X + x;
cy = grid.Y + y;
if (cx >= 0 && cx < mapWidth && cy >= 0 && cy < mapHeight)
{
g = map[cx, cy]; if (!g.IsObstacle && !closeList.ContainsKey(GetGridIndex(g)))
{
AddToOpenList(g, grid, targetGrid);
}
}
}
}
}
void MoveGridToCloseFromOpen(AStarGrid grid)
{
int index = GetGridIndex(grid);
openList.Remove(index);
if (!closeList.ContainsKey(index))
{
closeList.Add(index, grid);
}
}
void UpdateGridGH(AStarGrid grid, AStarGrid targetGrid)
{
var parentGrid = grid.ParentGrid;
grid.G = ComputeG(grid, parentGrid);
grid.H = Mathf.Sqrt((float)((targetGrid.X - grid.X) * (targetGrid.X - grid.X) + (targetGrid.Y - grid.Y) * (targetGrid.Y - grid.Y)));
}
float ComputeG(AStarGrid grid, AStarGrid parentGrid)
{
float g = 0;
if (parentGrid != null)
{
g = parentGrid.G + Mathf.Sqrt((float)((parentGrid.X - grid.X) * (parentGrid.X - grid.X) + (parentGrid.Y - grid.Y) * (parentGrid.Y - grid.Y)));
}
return g;
}
AStarGrid FindMinFGrid()
{
AStarGrid minFGrid = null;
foreach (var grid in openList.Values)
{
if (minFGrid == null)
{
minFGrid = grid;
}
else
{
if (grid.F < minFGrid.F)
{
minFGrid = grid;
}
}
}
return minFGrid;
}
}
GridCtrl
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class GridCtrl : MonoBehaviour
{
public Text txtF;
public Text txtG;
public Text txtH;
public Text txtCoordinate;
public RectTransform directionObj;
public Image bg;
AStarMap map;
AStarGrid grid;
public void SetGrid(AStarGrid grid, AStarMap map)
{
this.map = map;
this.grid = grid;
var rect = (transform as RectTransform).rect;
transform.position = new Vector3((rect.width + 5) * grid.X , (rect.height + 5) * grid.Y + 5, 0);
}
public void UpdateShow()
{
txtF.text = grid.F.ToString("f2");
txtG.text = grid.G.ToString("f2");
txtH.text = grid.H.ToString("f2");
txtCoordinate.text = string.Format("({0},{1})", grid.X, grid.Y);
if (grid.ParentGrid != null)
{
Vector2 parentGridDir = new Vector2(grid.ParentGrid.X - grid.X, grid.ParentGrid.Y - grid.Y);
float angle = Vector2.SignedAngle(parentGridDir, new Vector2(1, 0));
directionObj.rotation = Quaternion.Euler(0, 0, -angle);
directionObj.gameObject.SetActive(true);
}
else
{
directionObj.gameObject.SetActive(false);
}
if(grid.IsObstacle)
{
bg.color = Color.black;
}
else if(map.IsCurrentCheckGrid(grid))
{
bg.color = Color.green;
}
else if(map.IsTargetGrid(grid))
{
bg.color = Color.red;
}
else if(map.IsInOpenList(grid))
{
bg.color = Color.yellow;
}
else if(map.IsInCloseList(grid))
{
bg.color = Color.grey;
}
else
{
bg.color = Color.white;
}
}
public void SetBgColor(Color color)
{
bg.color = color;
}
}
AStarMapGenerator
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class AStarMapGenerator : MonoBehaviour
{
public int mapWidth = 5;
public int mapHeight = 5;
public GameObject GridPrefab;
public Vector2 startGrid;
public Vector2 targetGrid;
public bool isRandomMap;
public int randomObstacleCount;
public Vector2[] obstacles;
GridCtrl[,] gridCtrlMap;
AStarMap map;
void Start()
{
GenerateMap();
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
DoPathFindStep();
}
if (Input.GetKeyDown(KeyCode.Escape))
{
ResetMap();
}
}
public void GenerateMap()
{
map = new AStarMap(mapWidth, mapHeight);
gridCtrlMap = new GridCtrl[mapWidth, mapHeight];
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
var grid = map.GetGrid(x, y);
var gridCtrl = GameObject.Instantiate<GameObject>(GridPrefab, transform).GetComponent<GridCtrl>();
gridCtrl.SetGrid(grid, map);
gridCtrlMap[x, y] = gridCtrl;
}
}
InitMap();
}
void ResetMap()
{
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
var grid = map.GetGrid(x, y);
grid.Reset();
}
}
InitMap();
}
void InitMap()
{
if (isRandomMap)
{
int obsCount = 0;
int rx, ry;
while (obsCount < randomObstacleCount)
{
rx = Random.Range(0, mapWidth);
ry = Random.Range(0, mapHeight);
if (!map.GetGrid(rx, ry).IsObstacle)
{
map.SetObstacle(rx, ry, true);
obsCount++;
}
}
AStarGrid sGrid, tGrid;
while (true)
{
rx = Random.Range(0, mapWidth);
ry = Random.Range(0, mapHeight);
if (!map.GetGrid(rx, ry).IsObstacle)
{
sGrid = map.GetGrid(rx, ry);
break;
}
}
while (true)
{
rx = Random.Range(0, mapWidth);
ry = Random.Range(0, mapHeight);
tGrid = map.GetGrid(rx, ry);
if (!tGrid.IsObstacle && tGrid != sGrid)
{
break;
}
}
map.SetFindPath(sGrid.X, sGrid.Y, tGrid.X, tGrid.Y);
Debug.Log(sGrid.X + " " + sGrid.Y + " " + tGrid.X + " " + tGrid.Y);
}
else
{
for (int i = 0; i < obstacles.Length; i++)
{
map.SetObstacle((int)obstacles[i].x, (int)obstacles[i].y, true);
}
map.SetFindPath((int)startGrid.x, (int)startGrid.y, (int)targetGrid.x, (int)targetGrid.y);
}
UpdateShow();
}
void DoPathFindStep()
{
bool isComplete = map.DoFindPathStep();
UpdateShow();
if (isComplete)
{
var path = map.GetPathResult();
if (path.Count > 0)
{
foreach (var grid in path)
{
gridCtrlMap[grid.X, grid.Y].SetBgColor(Color.green);
}
}
}
}
void UpdateShow()
{
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
gridCtrlMap[x, y].UpdateShow();
}
}
}
}