理解A*寻路算法具体过程

A*寻路

using UnityEngine;
using System.Collections;

public class Node {

public float radium; // 半径
public int x, y; // 下标
public float gCost = 0, hCost = 0, fCost = 0;   // 估价值
public Node parent;  // 父节点
public bool canWalk;// 能否行走，是否有障碍物
public Vector3 worldPos;// 世界坐标

public Node(int x, int y, bool canWalk, Vector3 worldPos)
{// 初始化变量
this.x = x;
this.y = y;
this.canWalk = canWalk;
this.worldPos = worldPos;
}

}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class Grid : MonoBehaviour
{
public float gridSize;// 网格大小
public float nodeRadius;// 每一个小格子的半径
float nodeDia;// 小格子的直径
int countX, countY;// 水平格子数量和垂直格子数量
Node[,] grid;// 网格
public LayerMask obsLayer;// 障碍物所在层
public List<Node> paths;// 最终可行路径
public void Start()
{// 初始化变量
nodeDia = nodeRadius * 2;
countX = Mathf.CeilToInt(gridSize / nodeDia);
countY = countX;
grid = new Node[countX, countY];
initGrid();
}

/// <summary>
/// 初始化网格矩阵
/// </summary>
private void initGrid()
{
Vector3 startPos = transform.position - new Vector3(gridSize / 2, 0, gridSize / 2);
for (int i = 0; i < countX; i++)
{
for (int j = 0; j < countY; j++)
{
// 获取小方格的世界坐标点
Vector3 pos = startPos + new Vector3(i * nodeDia + nodeRadius, 0, j * nodeDia + nodeRadius);
// 判断小方格周围是否有障碍物
bool canWalk = !Physics.CheckSphere(pos, nodeRadius, obsLayer);
Node node = new Node(i, j, canWalk, pos);
grid[i, j] = node;
}
}
}

public void OnDrawGizmos()
{
//Gizmos.DrawCube(transform.position, new Vector3(gridSize, 1, gridSize));
// 绘制网格矩阵
if (grid != null)
{
for (int i = 0; i < countX; i++)
{
for (int j = 0; j < countY; j++)
{
if (grid[i, j].canWalk)
{// 如果可以行走，绘制为绿色或白色
if(i>countX/2 && j>countY/2 || i<countX/2 && j<countY/2){
Gizmos.color = Color.green;
}
else Gizmos.color = Color.white;

}
else Gizmos.color = Color.red;// 如果不可以行走，绘制为红色
Gizmos.DrawCube(grid[i,j].worldPos, new Vector3(nodeDia - 0.2f, 0.2f, nodeDia - 0.2f));
}
}
}
// 绘制最终路径网格
if(paths!=null && paths.Count>0){
Gizmos.color = Color.cyan;
foreach (var item in paths)
{
Gizmos.DrawCube(item.worldPos, new Vector3(nodeDia - 0.2f, 0.2f, nodeDia - 0.2f));

}

}

}

/// <summary>
/// 通过世界坐标点，获取对应网格的坐标值
/// </summary>
/// <param name="pos"></param>
/// <returns></returns>
public Node GetNodeByPos(Vector3 pos) {
Vector3 reaPos = pos - transform.position;//相对坐标位置
//Debug.Log("reaPosl" + reaPos);
float percentX = (reaPos.x + gridSize / 2) / gridSize;
float percentY = (reaPos.z + gridSize / 2) / gridSize;
int X = Mathf.CeilToInt(countX * percentX)-1;
int Y = Mathf.CeilToInt(countY * percentY)-1;
if (grid != null)
{
return grid[X, Y];
}
else return null;
}

/// <summary>
/// 通过一个格子，根据九宫格，获取周围8个相邻格子
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public List<Node> GetNeighborNodes(Node node)
{
List<Node> nodeList = new List<Node>();
int x = node.x;
int y = node.y;
for (int i = -1; i <=1; i++)
{
for (int j = -1; j <= 1; j++)
{
if(x+i>=0 && y+j>=0&& x+i<countX && y+j<countY){
nodeList.Add(grid[x + i, y + j]);
}
}
}

return nodeList;
}

}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class Paths : MonoBehaviour
{
float cost1;// 相邻两个格子的水平估价
float cost2;//相邻两个格子的对角线估价
Grid grid;
bool isMove = false;
int index = 0;
Vector3 des;
public Transform moveTarget;//移动对象
public static Paths Instance;//创建单例

public void Awake()
{
Instance = this;
}

void Start()
{

grid = GetComponent<Grid>();
cost1 = grid.nodeRadius * 2;
cost2 = Mathf.Sqrt(grid.nodeRadius * 2 * grid.nodeRadius * 2 * 2);//对角线
//setDis(enemy.position);
}
// Update is called once per frame
void Update()
{

}

//设置寻路目标点
public  void setDis(Vector3 destination)
{
findPath(moveTarget.position, destination);

}

//停止寻路
public void StopDis() {
grid.paths = null;
}

/// <summary>
/// 获取从起始点到终点的最近路程
/// </summary>
/// <param name="beginPos">起始点</param>
/// <param name="destination">终点</param>
private  void findPath(Vector3 beginPos, Vector3 destination)
{
List<Node> openList = new List<Node>();//创建开启列表
List<Node> closeList = new List<Node>();//创建关闭列表

Node beginNode = grid.GetNodeByPos(beginPos);
Node EndNode = grid.GetNodeByPos(destination);
Node currentNode = beginNode;//将当前节点保存到开启列表
openList.Add(currentNode);
while (currentNode != EndNode)
{
if (openList.Count <= 0) { break; }

currentNode = openList[0];

//从开启列表寻找估价最小的节点
for (int i = 0; i < openList.Count; i++)
{

if (openList[i].fCost < currentNode.fCost || (openList[i].fCost == currentNode.fCost && openList[i].hCost < currentNode.hCost))
{
currentNode = openList[i];
}
}

closeList.Add(currentNode);//将当前节点添加到关闭列表
openList.Remove(currentNode);//将当前节点从开启列表移出
if (currentNode == EndNode)
{//如果寻路到达终点，生成最终路径
grid.paths = GeneratePath(beginNode, EndNode);
return;
}
//获取当前节点周围8个点，如果它们不在关闭集合并且可以行走，计算它们的估价，并添加到开启集合

List<Node> neiborList = grid.GetNeighborNodes(currentNode);
foreach (Node item in neiborList)
{
float gCost = GetNodesCost(item, currentNode) + currentNode.gCost;
float hCost = GetNodesCost(item, EndNode);

if (item == null || closeList.Contains(item) || !item.canWalk)
{
continue;
}
//如果已经保存在开启集合，计算新的g估价大于原先估价，更新其估计和父节点
if (openList.Contains(item))
{
if (gCost < item.gCost)
{
item.gCost = gCost;
item.parent = currentNode;
}
}
else
{
item.gCost = gCost;
item.hCost = hCost;
item.parent = currentNode;
openList.Add(item);

}
}

}
}

/// <summary>
/// 生成最终路径
/// </summary>
/// <param name="beginNode">起始节点</param>
/// <param name="EndNode">终止节点</param>
/// <returns></returns>
private List<Node> GeneratePath(Node beginNode, Node EndNode)
{//通过寻找父节点的方式，生成从终点到起始点的路径，然后将集合取反，生成最终路径
List<Node> path = new List<Node>();
Node temp = EndNode;
while (temp != beginNode)
{
path.Add(temp);
temp = temp.parent;
}
path.Reverse();//取反
return path;
}

/// <summary>
/// 获取两个节点之间的估价值
/// </summary>
/// <param name="item"></param>
/// <param name="currentNode"></param>
/// <returns></returns>
private float GetNodesCost(Node item, Node currentNode)
{
//计算节点坐标水平和垂直的差值
int offsetX = Mathf.Abs(item.x - currentNode.x);
int offsetY = Mathf.Abs(item.y - currentNode.y);
float dis;
//让小的差值乘于对角线估价，大的差值与小的差值的差乘于水平估价
if (offsetX >= offsetY)
{
dis = offsetY * cost2 + (offsetX - offsetY) * cost1;
}
else
{
dis = offsetX * cost2 + (offsetY - offsetX) * cost1;
}
return dis;
}

}