Unity学习笔记--快速入门实现A*算法寻路
一、要实现的功能：
- 在场景中自动生成cube阵列，并随机20%的生成为“障碍”红色cube；
- 建立节点类；
- 建立节点管理类（实现A*的主要逻辑）
- 进行操作，可以用鼠标点击选择起始点与结束点。
最终实现以下效果：
二、A算法原理：
这篇是csdn上点击量很高的一个，而且里面讲解的很详细，算是通俗易懂：
A*算法详解（个人认为最透彻的一个）
结合Unity实现的视频（本文的核心代码也是根据此学习的）：
Unity中实现A星寻路算法
三、代码实现：
这里首先介绍核心与难点代码，并在最后附上所有代码，A节点与管理器类不需要继承MonoBehaviour。 - 创建节点类：
1.1 创建节点的枚举类型，将其归类为可以走的地方：Walk与不可走的地方Stop：
public enum E_Node_Type
{
Walk,//可以走的地方
Stop,//不能走的地方
}
1.2 每个节点都应包含的信息：x、y坐标，f=g+h评价函数，类型（Walk/Stop)，节点类中建立构造函数：
public AStarNode(int x,int y,E_Node_Type type)
{
this.x = x;
this.y = y;
this.type = type;
}
- A星管理器：
2.1 A*管理器命名为AStarManager，首先应建立类的单例：
//定义私有变量用来存储类的实例对象
private static AStarManager instance;
//定义公有方法提供一个全局访问点
public static AStarManager Instance
{
get //类的实例是只读的，所以只有get没有set
{
if (instance==null)
{
instance = new AStarManager();
}
return instance;
}
}
上面的单例是为了保证管理类只有一个实例，且为只读的。
2.2 建立一个方法，输入为开始、结束节点，返回的是寻找到的节点列表，方法的架构如下：
//1. 首先判断传入的两个点是否合法(假设传入的点就是整数) 是不是阻挡
//2. 如果不合法，应直接返回null，意味着不能寻路
//3. 应当得到起点和终点对应的节点
//4. 把开始点放入关闭列表中
//5. 从起点开始找周围的点并放入开启列表中
//6. 左上-上-右上-左-右-左下-下-右下
//7. 判断这些点是否是边界，是否是阻挡，是否已经在开启或者关闭别表中，如果都不是，则放进开启列表中；
//8. 选出开启列表中寻路消耗最小的点
//9. 放入关闭列表中，然后从开启列表中删除
//10. 如果这个点已经是终点了，那么得到最终的结果返回出去
//11. 如果这个点不是终点，那么继续寻路。
2.3 节点的搜寻状态：
判断某一个节点是否合法，然后再判断是否已经存在与当前的开启列表与关闭列表中，存储这个节点的父节点，并计算这个节点的代价函数：f=g+h;
其中h用的是欧几里得计算方法：忽略障碍时当前点距离终点的水平+垂直距离：
private void FindNearlyNodeToOPenList(int x, int y,float g,AStarNode father,AStarNode end)
{
if (x<0||x>=mapW||y<0||y>=mapH)
return;
AStarNode node = nodes[x, y];
if (node==null||
node.type==E_Node_Type.Stop||
closeList.Contains(node)||
openList.Contains(node))
return;
//计算f值
node.father = father;
node.g = father.g + g;
node.h = Mathf.Abs(end.x - node.x) + Mathf.Abs(end.y - node.y);
node.f = node.g + node.h;
openList.Add(node);
}
记得最后要把这个点存入开启列表中；
2.4 使用list.sort( )进行降序排列：
private int SortOpenList(AStarNode a, AStarNode b)
{
if (a.f>b.f)
return 1;
else
return -1;
}
openList.Sort(SortOpenList);
重新排列后的OpenList[0]就是我们代价最先的点，作为下一个start再次循环；
- TestAstar的作用：
3.1 定义网格(地图)的长宽属性；
3.2 在场景中生成Cube网格，给每个网格命名，并存储到节点中；
3.3 获取鼠标事件，选中起点选中终点，改变颜色；
三、附上完整代码：
使用中记得将最后的TestAstar赋给我们的摄像机（也可其他物体），要是看的不全，摄像机调整下位置即可；
- AStarNode类：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// - AStarManager类：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class AStarManager
{
//定义类的单例：
//定义私有变量用来存储类的实例对象
private static AStarManager instance;
//定义公有方法提供一个全局访问点
public static AStarManager Instance
{
get //类的实例是只读的，所以只有get没有set
{
if (instance==null)
{
instance = new AStarManager();
}
return instance;
}
}
//地图的宽、高尺寸：
public int mapW;
public int mapH;
//二维数组作为存储地图相关所有节点的对象容器
public AStarNode[,] nodes;
//开启列表
private List<AStarNode> openList=new List<AStarNode>();
//关闭列表
private List<AStarNode> closeList=new List<AStarNode>();
public void InitMapInfo(int w, int h)
{
//声明容器可以装多少个节点
nodes = new AStarNode[w, h];
//根据宽高，创建节点
//声明节点，装进去
this.mapW = w;
this.mapH = h;
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
AStarNode node = new AStarNode(i, j, Random.Range(0, 100) <25 ? E_Node_Type.Stop : E_Node_Type.Walk);
nodes[i, j] = node;
}
}
}
public List<AStarNode> FindPath(Vector2 startPos,Vector2 endPos)
{
//1. 首先判断传入的两个点是否合法(假设传入的点就是整数) 是不是阻挡
//2. 如果不合法，应直接返回null，意味着不能寻路
//3. 应当得到起点和终点对应的节点
//4. 把开始点放入关闭列表中
//5. 从起点开始找周围的点并放入开启列表中
//6. 左上-上-右上-左-右-左下-下-右下
//7. 判断这些点是否是边界，是否是阻挡，是否已经在开启或者关闭别表中，如果都不是，则放进开启列表中；
//8. 选出开启列表中寻路消耗最小的点
//9. 放入关闭列表中，然后从开启列表中删除
//10. 如果这个点已经是终点了，那么得到最终的结果返回出去
//11. 如果这个点不是终点，那么继续寻路。
//首先判断起始点是否超出边界
if (startPos.x < 0 || startPos.x >= mapW ||
startPos.y < 0 || startPos.y >= mapH ||
endPos.x < 0 || endPos.x >= mapW ||
endPos.y < 0 || endPos.y >= mapH)
{
Debug.Log("开始或结束点在地图外");
return null;
}
AStarNode start = nodes[(int)startPos.x, (int)startPos.y];
AStarNode end = nodes[(int)endPos.x, (int)endPos.y];
if (start.type == E_Node_Type.Stop || end.type == E_Node_Type.Stop)
{
Debug.Log("开始或结束点为阻挡");
return null;
}
closeList.Clear();
openList.Clear();
start.father = null;
start.f = 0;
start.g = 0;
start.h = 0;
closeList.Add(start);
while (true)
{
FindNearlyNodeToOPenList(start.x - 1, start.y - 1, 1.4f, start, end);
FindNearlyNodeToOPenList(start.x, start.y - 1, 1f, start, end);
FindNearlyNodeToOPenList(start.x + 1, start.y - 1, 1.4f, start, end);
FindNearlyNodeToOPenList(start.x - 1, start.y, 1f, start, end);
FindNearlyNodeToOPenList(start.x + 1, start.y, 1f, start, end);
FindNearlyNodeToOPenList(start.x - 1, start.y + 1, 1.4f, start, end);
FindNearlyNodeToOPenList(start.x, start.y + 1, 1f, start, end);
FindNearlyNodeToOPenList(start.x + 1, start.y + 1, 1.4f, start, end);
if (openList.Count == 0)
{
Debug.Log("死路");
return null;
}
openList.Sort(SortOpenList);
closeList.Add(openList[0]);
//找到的这个点又变成新的起点
start = openList[0];
openList.RemoveAt(0);
if (start == end)
{
List<AStarNode> path = new List<AStarNode>();
path.Add(end);
while (end.father != null)
{
path.Add(end.father);
end = end.father;
}
path.Reverse();//顺序反转
return path;
}
}
}
private int SortOpenList(AStarNode a, AStarNode b)
{
if (a.f>b.f)
return 1;
else
return -1;
}
/// - TestAStar类：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class TestAStar : MonoBehaviour
{
public int beginX=3;
public int beginY=5;
//偏移位置
public int offsetX=2;
public int offsetY=-2;
//地图格子的宽与高
public int mapW=5;
public int mapH=5;
//开始点，给他一个为负的坐标点
private Vector2 beginPos = Vector2.right * -1;
List<AStarNode> list;
private Dictionary<string, GameObject> cubes = new Dictionary<string, GameObject>();
// Start is called before the first frame update
void Start()
{
AStarManager.Instance.InitMapInfo(mapW, mapH);
for (int i = 0; i < mapW; ++i)
{
for (int j = 0; j < mapH; ++j)
{
GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cube);
obj.transform.position = new Vector3(beginX + i * offsetX, beginY + j * offsetY, 0);
obj.name = i + "_" + j;//起个名字
cubes.Add(obj.name,obj);
AStarNode node = AStarManager.Instance.nodes[i, j];
if (node.type==E_Node_Type.Stop)
{
obj.GetComponent<MeshRenderer>().material.color = Color.red;
}
}
}
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
RaycastHit info;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray,out info,1000))
{
if (beginPos==Vector2.right*-1)
{
//清理上一次路径
if (list != null)
{
for (int i = 0; i < list.Count; ++i)
{
cubes[list[i].x + "_" + list[i].y].GetComponent<MeshRenderer>().material.color = Color.white;
}
}
string[] strs = info.collider.gameObject.name.Split('_');
//得到行列位置，就是开始点的位置
beginPos = new Vector2(int.Parse(strs[0]), int.Parse(strs[1]));
//将起点改为黄色
info.collider.gameObject.GetComponent<MeshRenderer>().material.color = Color.yellow;
}
else
{
//得到终点
string[] strs = info.collider.gameObject.name.Split('_');
Vector2 endPos = new Vector2(int.Parse(strs[0]), int.Parse(strs[1]));
//寻路
list = AStarManager.Instance.FindPath(beginPos,endPos);
if (list!=null)
{
for (int i = 0; i < list.Count; ++i)
{
cubes[list[i].x + "_" + list[i].y].GetComponent<MeshRenderer>().material.color = Color.green;
}
}
beginPos = Vector2.right * -1;
}
}
}
}
}