[Unity算法]A星寻路(一)：基础版本

参考链接：

https://www.cnblogs.com/yangyxd/articles/5447889.html

一.原理

1.将场景简化，分割为一个个正方形格子，这些格子称之为节点(node)，从一个节点到另一个节点的距离称之为代价(cost)。一个节点与水平/垂直方向的相邻节点的代价是1，与对角节点的代价是1.4。这里引用公式f = g + h，f表示该节点的总代价，g表示该节点与上一路径节点的代价，h表示该节点与目标节点的代价。

2.需要两个列表，开启列表(openList)和关闭列表(closeList)。开启列表用来记录需要考虑的节点，关闭列表用来记录不会再考虑的节点。

3.在开启列表中添加起始节点。

4.在开启列表中找到总代价最低的节点，然后从开启列表中移除该节点，从关闭列表中添加该节点，把与该节点相邻的可通行的节点添加到开启列表，并且更新这些节点的代价。

5.循环第四步，如果当前节点等于目标节点，则退出循环。

二.实现

FindWayNode.cs

 using UnityEngine;

 public class FindWayNode {

     public bool isObstacle;//是否是障碍物
     public Vector3 scenePos;//场景位置
     public int x, y;//坐标

     public int gCost;//与起始点的距离
     public int hCost;//与目标点的距离
     public int fCost {
         get { return gCost + hCost; }
     }//总距离

     public FindWayNode parentNode;//父节点

     public FindWayNode(bool isObstacle, Vector3 scenePos, int x, int y)
     {
         this.isObstacle = isObstacle;
         this.scenePos = scenePos;
         this.x = x;
         this.y = y;
     }
 }

FindWayGrid.cs

 using System.Collections.Generic;
 using UnityEngine;

 public class FindWayGrid {

     public int width;//格子水平方向个数
     public int height;//格子垂直方向个数
     public float nodeLength;//格子长度

     private FindWayNode[,] findWayNodes;//格子数组
     private float halfNodeLength;//格子长度的一半
     private Vector3 startPos;//场景坐标起点

     public FindWayGrid(int width, int height, float nodeLength = 1f)
     {
         this.width = width;
         this.height = height;
         this.nodeLength = nodeLength;

         findWayNodes = new FindWayNode[width, height];
         halfNodeLength = nodeLength / ;
         startPos = new Vector3(-width /  * nodeLength + halfNodeLength, , -height /  * nodeLength + halfNodeLength);

         for (int x = ; x < width; x++)
         {
             for (int y = ; y < height; y++)
             {
                 Vector3 pos = CoordinateToScenePos(x, y);
                 findWayNodes[x, y] = new FindWayNode(false, pos, x, y);
             }
         }
     }

     //坐标转场景坐标
     public Vector3 CoordinateToScenePos(int x, int y)
     {
         Vector3 pos = new Vector3(startPos.x + x * nodeLength, startPos.y, startPos.z + y * nodeLength);
         return pos;
     }

     //根据场景坐标获取节点
     public FindWayNode GetNode(Vector3 pos)
     {
         int x = (int)(Mathf.RoundToInt(pos.x - startPos.x) / nodeLength);
         int y = (int)(Mathf.RoundToInt(pos.z - startPos.z) / nodeLength);
         x = Mathf.Clamp(x, , width - );
         y = Mathf.Clamp(y, , height - );
         return GetNode(x, y);
     }

     //根据坐标获取节点
     public FindWayNode GetNode(int x, int y)
     {
         return findWayNodes[x, y];
     }

     //获取相邻节点列表
     public List<FindWayNode> GetNearbyNodeList(FindWayNode node)
     {
         List<FindWayNode> list = new List<FindWayNode>();
         for (int i = -; i <= ; i++)
         {
             for (int j = -; j <= ; j++)
             {
                 if (i ==  && j == )
                 {
                     continue;
                 }
                 int x = node.x + i;
                 int y = node.y + j;
                 if (x >=  && x < width && y >=  && y < height)
                 {
                     list.Add(findWayNodes[x, y]);
                 }
             }
         }
         return list;
     }

     //获取两个节点之间的距离
     int GetDistance(FindWayNode nodeA, FindWayNode nodeB)
     {
         int countX = Mathf.Abs(nodeA.x - nodeB.x);
         int countY = Mathf.Abs(nodeA.y - nodeB.y);
         if (countX > countY)
         {
             return  * countY +  * (countX - countY);
         }
         else
         {
             return  * countX +  * (countY - countX);
         }
     }

     //找出起点到终点的最短路径
     public List<FindWayNode> FindWay(Vector3 startPos, Vector3 endPos)
     {
         FindWayNode startNode = GetNode(startPos);
         FindWayNode endNode = GetNode(endPos);

         List<FindWayNode> openList = new List<FindWayNode>();
         List<FindWayNode> closeList = new List<FindWayNode>();
         openList.Add(startNode);

         while (openList.Count > )
         {
             FindWayNode nowNode = openList[];

             //选择花费最低的
             for (int i = ; i < openList.Count; i++)
             {
                 if (openList[i].fCost <= nowNode.fCost &&
                     openList[i].hCost < nowNode.hCost)
                 {
                     nowNode = openList[i];
                 }
             }

             openList.Remove(nowNode);
             closeList.Add(nowNode);

             //找到目标节点
             if (nowNode == endNode)
             {
                 return GeneratePath(startNode, endNode);
             }

             List<FindWayNode> nearbyNodeList = GetNearbyNodeList(nowNode);
             for (int i = ; i < nearbyNodeList.Count; i++)
             {
                 FindWayNode node = nearbyNodeList[i];
                 //如果是墙或者已经在关闭列表中
                 if (node.isObstacle || closeList.Contains(node))
                 {
                     continue;
                 }
                 //计算当前相邻节点与开始节点的距离
                 int gCost = nowNode.gCost + GetDistance(nowNode, node);
                 //如果距离更小，或者原来不在打开列表
                 if (gCost < node.gCost || !openList.Contains(node))
                 {
                     //更新与开始节点的距离
                     node.gCost = gCost;
                     //更新与结束节点的距离
                     node.hCost = GetDistance(node, endNode);
                     //更新父节点为当前选定的节点
                     node.parentNode = nowNode;
                     //加入到打开列表
                     if (!openList.Contains(node))
                     {
                         openList.Add(node);
                     }
                 }
             }
         }

         return null;
     }

     //生成路径
     public List<FindWayNode> GeneratePath(FindWayNode startNode, FindWayNode endNode)
     {
         List<FindWayNode> nodeList = new List<FindWayNode>();
         if (endNode != null)
         {
             FindWayNode tempNode = endNode;
             while (tempNode != startNode)
             {
                 nodeList.Add(tempNode);
                 tempNode = tempNode.parentNode;
             }
             nodeList.Reverse();//反转路径
         }
         return nodeList;
     }
 }

TestFindWay.cs

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

 public class TestFindWay : MonoBehaviour {

     public Transform startTra;//起点tra
     public Transform endTra;//终点tra
     public Transform floorTra;//地板tra

     public GameObject obstacleGridPrefab;//障碍物格子
     public GameObject pathGridPrefab;//路径格子
     public LayerMask obstacleLayer;//障碍物所在的层

     private FindWayGrid findWayGrid;

     private GameObject obstacleRootGo;//障碍物格子的父go
     private GameObject pathRootGo;//路径格子的父go
     private List<GameObject> pathGridGoList;//路径格子go列表

     void Start ()
     {
         MeshFilter meshFilter = floorTra.GetComponent<MeshFilter>();
         int width = Mathf.CeilToInt(meshFilter.mesh.bounds.size.x) * (int)floorTra.localScale.x;
         int height = Mathf.CeilToInt(meshFilter.mesh.bounds.size.z) * (int)floorTra.localScale.z;

         findWayGrid = new FindWayGrid(width, height);

         obstacleRootGo = new GameObject("ObstacleRoot");
         pathRootGo = new GameObject("PathRoot");
         pathGridGoList = new List<GameObject>();

         ShowObstacle();
     }

     void Update ()
     {
         List<FindWayNode> nodeList = findWayGrid.FindWay(startTra.position, endTra.position);
         if (nodeList != null)
         {
             ShowPath(nodeList);
         }
     }

     //展示路径
     public void ShowPath(List<FindWayNode> list)
     {
         for (int i = ; i < list.Count; i++)
         {
             if (i < pathGridGoList.Count)
             {
                 pathGridGoList[i].transform.position = list[i].scenePos;
                 pathGridGoList[i].SetActive(true);
             }
             else
             {
                 GameObject go = Instantiate(pathGridPrefab);
                 go.transform.SetParent(pathRootGo.transform);
                 go.transform.position = list[i].scenePos;
                 pathGridGoList.Add(go);
             }
         }

         for (int i = list.Count; i < pathGridGoList.Count; i++)
         {
             pathGridGoList[i].SetActive(false);
         }
     }

     //展示障碍物
     public void ShowObstacle()
     {
         int width = findWayGrid.width;
         int height = findWayGrid.height;
         float halfNodeLength = findWayGrid.nodeLength / ;

         for (int x = ; x < width; x++)
         {
             for (int y = ; y < height; y++)
             {
                 FindWayNode node = findWayGrid.GetNode(x, y);
                 bool isObstacle = Physics.CheckSphere(node.scenePos, halfNodeLength, obstacleLayer);
                 if (isObstacle)
                 {
                     GameObject go = GameObject.Instantiate(obstacleGridPrefab, node.scenePos, Quaternion.identity) as GameObject;
                     go.transform.SetParent(obstacleRootGo.transform);
                 }
                 node.isObstacle = isObstacle;
             }
         }
     }
 }

三.使用

把TestFindWay.cs挂上，然后对public变量进行拖拽赋值即可。效果如下：