基于Unity的A星算法实现

  本篇实现的A星算法是基于贪婪优先算法实现的，由于贪婪优先算法得到的是次优路径，因此我们增加一个当前节点到起始节点的一个路径开销分量来提升路径的质量，筛选最优路径。具体实现如下：

节点类的编写

  节点主要用来存储当前节点在地图中的位置信息，如：行号，列号、父节点、到起始节点的路径开销量g，到目标节点的路径开销量h，总的开销量；并包含计算g和h的方法；具体实现代码如下：

/// <summary>
/// 节点类
/// </summary>
public class ANode : System.IComparable
{
    /// <summary>
    /// 行
    /// </summary>
    public int Row { get; set; }
    /// <summary>
    /// 列
    /// </summary>
    public int Col { get; set; }

    /// <summary>
    /// 父节点
    /// </summary>
    public ANode parent = null;
    /// <summary>
    /// 相邻节点
    /// </summary>
    public List<ANode> adjacent = new List<ANode>();
    /// <summary>
    /// 曼哈顿距离
    /// </summary>
    public int h = 0;

    public int g = 0;

    public int f = 0;

    public void H(ANode endNode)
    {
        h = Mathf.Abs(endNode.Row - Row) + Mathf.Abs(endNode.Col - Col);

        f = g + h;
    }

    /// <summary>
    /// 清除
    /// </summary>
    public void Clear()
    {
        parent = null;
        h = 0;
        g = 0;
        f = 0;
    }

    public int CompareTo(object obj)
    {
        ANode node = obj as ANode;

        if (f - node.f < 0)
            return -1;
        else if (f - node.f == 0)
            return 0;
        else
            return 1;
    }
}

地图存储

  地图存储与贪婪算法中的思路一样，代码逻辑一样，只是把节点变量换一下即可，这里不在描述，代码大家自行实现。

寻路算法实现

  寻路算法与贪婪优先算法的实现相比只是增加了一个与起点的开销分量计算，然后根据f值来判断最优路径，具体实现代码如下：

public class AStarAlgorithm
{
    private ANode startNode;
    private ANode destNode;

    private List<ANode> openSet = new List<ANode>();
    private List<ANode> closedSet = new List<ANode>();

    private AMap map;

    /// <summary>
    /// 初始化地图
    /// </summary>
    /// <param name="map"></param>
    public AStarAlgorithm(AMap map)
    {
        this.map = map;
    }

    /// <summary>
    /// 查找开放式集合中H值最小的节点
    /// </summary>
    /// <returns></returns>
    private ANode FindLowest()
    {
        openSet.Sort();
        return openSet[0];
    }

    /// <summary>
    /// 将节点的相邻节点添加到开放集合中
    /// </summary>
    /// <param name="node"></param>
    private void AddAdjacent(ANode node)
    {
        for (int i = 0; i < node.adjacent.Count; i++)
        {
            if (closedSet.Contains(node.adjacent[i]))
                continue;
            int newG = node.g + Mathf.Abs(node.Row - node.adjacent[i].Row) + Mathf.Abs(node.Col - node.adjacent[i].Col);
                
            if(newG < node.adjacent[i].g || !openSet.Contains(node.adjacent[i]))
            {
                node.adjacent[i].parent = node;
                node.adjacent[i].g = newG;
                node.adjacent[i].H(destNode);
                if (!openSet.Contains(node.adjacent[i]))
                    openSet.Add(node.adjacent[i]);
            }
        }
    }

    /// <summary>
    /// 更新地图
    /// </summary>
    /// <param name="map"></param>
    public void UpdateMap(AMap map)
    {
        this.map = map;
    }

    public void Start(ANode startNode, ANode endNode)
    {
        openSet.Clear();
        closedSet.Clear();

        openSet.Add(startNode);
        destNode = endNode;
        this.startNode = startNode;

        for (int i = 0; i < map.aNodes.Length; i++)
        {
            map.aNodes[i].Clear();
        }
    }

    public Stack<ANode> Find()
    {
        Stack<ANode> path = new Stack<ANode>();

        ANode currNode = openSet[0];

        while (currNode != destNode)
        {              
            if (openSet.Count == 0)
                break;

            currNode = FindLowest();
            openSet.Remove(currNode);
            closedSet.Add(currNode);

            AddAdjacent(currNode);
        }

        if (currNode == destNode)
        {
            ANode node = destNode;
            while (node != null)
            {
                path.Push(node);
                node = node.parent;
            }
        }
        else
            return null;

        return path;
    }
}

对于节点类的优化可以继承贪婪优先算法的节点类，这样便于维护修改。

Unity实现效果如下

[https://github.com/FredLyu/FredLyu.github.io/tree/master/基于Unity的A星算法实现-md/A星算法效果.png]

完整工程仓库地址：A星算法
个人博客地址：基于Unity的A星算法实现

---

参考

《游戏编程算法与技巧》