寻路算法 之 A*寻路

A*寻路是游戏设计使用比较频繁的寻路算法，主要原理是将平面划分为多个网格，来进行目标查找。

图例说明：

目标：

                                                            

                                           

开始搜索：

启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。
估价函数：从当前节点移动到目标节点的预估费用；这个估计就是启发式的。在寻路问题和迷宫问题中，我们通常用曼哈顿（manhattan）估价函数预估费用。
A*算法的特点：A*算法在理论上是时间最优的，但是也有缺点：它的空间增长是指数级别的。(优化：二叉堆)

在A*寻路算法中，我们通过从点A开始，检查相邻方格的方式，向外扩展直到找到目标。

开启列表：待检查方格的集合列表，寻找周围可以达到的点，加入到此表中，并保存中心点为父节点
关闭列表：列表中保存不需要再次检查的方格

                                               

路径评分：

G-与起始点的距离
H-与目标点的距离
F的值是G和H的和。F,G和H的评分被写在每个方格里。
正如在紧挨起始格右侧的方格所表示的，F被打印中间，G在左上角，H则在右上角。

选择路径中经过哪个方格的关键是 这个等式：F = G + H

                                                                                    

                                                           

开始搜索：

                                                          

1，把起始格添加到开启列表。     

                                                               
2，寻找起点周围所有可到达或者可通过的方格，把他们加入开启列表。

                                                             
3，从开启列表中删除点A，把它加     入到一个“关闭列表”，列表中保存所有不需要再次检查的方格。

                                                              
4，把当前格子从开启列表中删除，然后添 加到关闭列表中。

                                                            
5，检查所有相邻格子。跳过那些已经在关  闭列表中的或者不可通过的，把他们添加进开启列表，把选中的方格作为新的方格的父节点。

6，如果某个相邻格已经在开启列表里了，检查现在的这条路径G值是否会更低一些。如果新的G值更低，那就把相邻方格的父节点改为目前选中的方格，重新计算F和G的值。

起始格下方格子的父节点已经和前面不同的。之前它的G值是，并且指向右上方的格子。现在它的G值是，指向它上方的格子。这在寻路过程中的某处发生，当应用新路径时，G值经过检查变得低了－于是父节点被重新指定，G和F值被重新计算。

步骤总结：

1，把起始格添加到开启列表。
2，重复如下的工作：
a) 寻找开启列表中F值最低的格子。我们称它为当前格。
b) 把它切换到关闭列表。
c) 对相邻的格中的每一个
* 如果它不可通过或者已经在关闭列表中，略过它。反之如下。
* 如果它不在开启列表中，把它添加进去。把当前格作为这一格的父节点。记录
这一格的F,G,和H值。
* 如果它已经在开启列表中，用G值为参考检查新的路径是否更好。更低的G值
意味着更好的路径。如果是这样，就把这一格的父节点改成当前格，并且重新计算这一格的
G和F值。
d) 停止，当你
* 把目标格添加进了关闭列表，这时候路径被找到
* 没有找到目标格，开启列表已经空了。这时候，路径不存在。
3.保存路径。从目标格开始，沿着每一格的父节点移动直到回到起始格。

算法实现：

开启集合
关闭集合
添加起始点到开始集合中
循环如下步骤：
当前点=开启集合中最小F_Cost的点
将当前点移出开启集合中
将当前点添加到关闭集合中
如果当前点是目标点，结束查询
遍历当前点的每个相邻点
如果相邻点不能访问或者相邻点在关闭集合中，跳过此相邻点
如果新路径到相邻点的距离更短，或者相邻点不在开启集合中
重新设置F_Cost
重新设置其父节点为当前点
如果相邻点不在开启集合中
添加相邻点到开启集合中

具体代码：

Node 类：

	using UnityEngine;
	using System.Collections;
	
	public class Node {
	    //能否行走
	    public bool _canWalk;
	    //世界坐标
	    public Vector3 _worldPos;
	    //位置
	    public int _gridX, _gridY;
	    //与目标节点和开始节点的距离
	    public int gCost;
	    public int hCost;
		//总距离
	    public int fCost
	    {
	        get { return gCost + hCost; }
	    }
	    //父节点
	    public Node parent;
	
	    //构造函数
	    public Node(bool canwalk,Vector3 position,int x,int y)
	    {
	        _canWalk = canwalk;
	        _worldPos = position;
	        _gridX = x;
	        _gridY = y;
	    }
	}

Grid类：

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

public class Grid : MonoBehaviour
{

    //节点
    private Node[,] grid;

    public Vector2 gridSize;
    public float nodeRadius;
    private float nodeDiameter;
    public LayerMask whatLayer;
    //玩家
    public Transform player;


    public List<Node> path = new List<Node>();
    public int gridCntX, gridCntY;

    // Use this for initialization
    void Start()
    {
        //初始化数据
        nodeDiameter = nodeRadius * 2;
        gridCntX = Mathf.RoundToInt(gridSize.x / nodeDiameter);
        gridCntY = Mathf.RoundToInt(gridSize.y / nodeDiameter);
        grid = new Node[gridCntX, gridCntY];
        CreateGrid();

    }
    //创建grid 
    private void CreateGrid()
    {
        Vector3 startPoint = transform.position - gridSize.x / 2 * Vector3.right - Vector3
            .forward * gridSize.y / 2;

        for (int i = 0; i < gridCntX; i++)
            for (int j = 0; j < gridCntY; j++)
            {
                Vector3 worldPoint = startPoint + Vector3.right * (i * nodeDiameter + nodeRadius) + Vector3.forward * (j * nodeDiameter + nodeRadius);
                bool walkable = !Physics.CheckSphere(worldPoint, nodeRadius, whatLayer);
                grid[i, j] = new Node(walkable, worldPoint, i, j);
            }
        Vector3 endPos = transform.position - gridSize.x / 2 * Vector3.right;
    }

    // Update is called once per frame
    void Update()
    {
    }
    /*
          根据位置获取node节点   
   */
    public Node getFromPosition(Vector3 postition)
    {
        float percentX = (postition.x + gridSize.x / 2) / gridSize.x;
        float percentY = (postition.z + gridSize.y / 2) / gridSize.y;
        //确保在0和1之间
        percentX = Mathf.Clamp01(percentX);
        percentY = Mathf.Clamp01(percentY);
        int x = Mathf.RoundToInt((gridCntX - 1) * percentX);
        int y = Mathf.RoundToInt((gridCntY - 1) * percentY);

        return grid[x, y];
    }
    //调用函数，进行初始化
    void OnDrawGizmos()
    {
        Gizmos.DrawWireCube(transform.position, new Vector3(gridSize.x, 1, gridSize.y));
        if (grid == null)
            return;
        Node playerNode = getFromPosition(player.position);
        //遍历
        foreach (var node in grid)
        {
            Gizmos.color = node._canWalk ? Color.white : Color.red;
            Gizmos.DrawCube(node._worldPos, Vector3.one * (nodeDiameter - .1f));
        }
        //遍历路径
        if (path != null)
        {
            foreach (var node in path)
            {
                Gizmos.color = Color.black;
                Gizmos.DrawCube(node._worldPos, Vector3.one * (nodeDiameter - .1f));
            }
        }
        //绘制玩家颜色
        if (playerNode != null && playerNode._canWalk)
        {
            Gizmos.color = Color.cyan;
            Gizmos.DrawCube(playerNode._worldPos, Vector3.one * (nodeDiameter - .1f));
        }


    }

    /*
     * 
        获取节点周围的八个节点
     
     */
    public List<Node> getNeibourhood(Node node)
    {
        List<Node> neibourhood = new List<Node>();

        for (int i = -1; i <= 1; i++)
        {
            for (int j = -1; j <= 1; j++)
            {
                if (i == 0 && j == 0)
                    continue;
                int tempX = node._gridX + i;

                int tempY = node._gridY + j;
                if (tempX < gridCntX && tempX > 0 && tempY > 0 && tempY < gridCntY)
                {
                    neibourhood.Add(grid[tempX, tempY]);
                }
            }

        }
        return neibourhood;

    }
}

FindPath 类，也是核心类：

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

public class FindPath : MonoBehaviour
{
    //添加玩家和目标点

    public Transform player, endPoint;
    private Grid _grid;
    // Use this for initialization
   //初始化grid
    void Start()
    {
        _grid = GetComponent<Grid>();
    }

    // Update is called once per frame
    //调用获取路径的函数
    void Update()
    {
        findingPath(player.position, endPoint.position);
    }
    //发现路径
    void findingPath(Vector3 startPos, Vector3 endPos)
    {
        //开始节点和结束节点
        Node startNode = _grid.getFromPosition(startPos);
        Node endNode = _grid.getFromPosition(endPos);
        //开启列表和关闭列表
        List<Node> openSet = new List<Node>();
        HashSet<Node> closeSet = new HashSet<Node>();
        //添加到开启列表
        openSet.Add(startNode);
        while (openSet.Count > 0)
        {
            //获取第一个几点
            Node currentNode = openSet[0];
            //遍历所有在开启列表中的节点
            for (int i = 0; i < openSet.Count; i++)
            {
                //判断是否满足条件
                if (openSet[i].fCost < currentNode.fCost || openSet[i].fCost == currentNode.fCost
                    && openSet[i].hCost < currentNode.hCost)
                {
                    currentNode = openSet[i];
                }
            }
            //从开启列表移除
            openSet.Remove(currentNode);
           //添加到关闭列表
            closeSet.Add(currentNode);
            //如果当前节点是目标节点，完成查找
            if (currentNode == endNode)
            {
                //获取路径
                generatePath(startNode,endNode);
                return;
            }
            //根据当前节点判断周围的节点
            foreach (var node in _grid.getNeibourhood(currentNode))
            {
                if (!node._canWalk || closeSet.Contains(node))
                    continue;

                int newCost = currentNode.gCost + getDistanceNodes(currentNode, node);
                //判断fCost,并更新fCost
                if (newCost < node.gCost || !openSet.Contains(node))
                {
                    node.gCost = newCost;
                    node.hCost = getDistanceNodes(node, endNode);
                    node.parent = currentNode;
                    if (!openSet.Contains(node))
                    {
                        openSet.Add(node);
                    }
                }
            }
        }
    }
    //生成路径
    private void generatePath(Node startNode, Node endNode)
    {
        List<Node> path = new List<Node>();

        Node temp = endNode;
        while (temp != startNode)
        {
            path.Add(temp);
            temp = temp.parent;
        }
        //翻转
        path.Reverse();
        _grid.path=path;
    }

    //获取距离
    int getDistanceNodes(Node a, Node b)
    {
        int cntX = Mathf.Abs(a._gridX - b._gridX);
        int cntY = Mathf.Abs(a._gridY - b._gridY);
        //判断横优先还是竖优先
        if (cntX > cntY)
        {
            return 14 * cntY + 10 * (cntX - cntY);
        }
        else
        {
            return 14 * cntX + 10 * (cntY - cntX);
        }
    }
}

资源下载地址：http://download.csdn.net/detail/u012251421/8341159