[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 / 2;
        startPos = new Vector3(-width / 2 * nodeLength + halfNodeLength, 0, -height / 2 * nodeLength + halfNodeLength);

        for (int x = 0; x < width; x++)
        {
            for (int y = 0; 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, 0, width - 1);
        y = Mathf.Clamp(y, 0, height - 1);
        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 = -1; i <= 1; i++)
        {
            for (int j = -1; j <= 1; j++)
            {
                if (i == 0 && j == 0)
                {
                    continue;
                }
                int x = node.x + i;
                int y = node.y + j;
                if (x >= 0 && x < width && y >= 0 && 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 14 * countY + 10 * (countX - countY);
        }
        else
        {
            return 14 * countX + 10 * (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 > 0)
        {
            FindWayNode nowNode = openList[0];

            //选择花费最低的
            for (int i = 0; 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 = 0; 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 = 0; 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 / 2;

        for (int x = 0; x < width; x++)
        {
            for (int y = 0; 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变量进行拖拽赋值即可。效果如下：