以前專案中用到了尋路，就寫了個A*尋路的演算法類，感覺還不錯，這裡分享出來。

A*演算法的原理網上有很多，這裡只簡單說一下我這個演算法的邏輯：

*我的這個演算法裡面沒有關閉列表，因為我會根據地圖資料建立一個對應的節點資料的陣列，每個節點資料記錄自己當前的狀態，是開啟還是關閉的。節點資料只有在尋找周圍點被找到的時候才會建立並放到陣列中，這樣在每次新增節點時，只要在陣列中取出對應位置的節點資料，就能知道節點是開啟的還是關閉的或者還沒有被新增，不用去遍歷open和close列表。

*開放列表直接使用List來儲存，為了使列表保持有序，每次新增節點時直接把節點按照從小到大的順序插入到對應位置。這裡可以使用其它資料結構或者排序演算法來進行優化。

*路徑可以行進的方向使用一個數組來表示:

//附近的格子 4方向
    int[,] nearArray = new int[,]{
        {0, 1},
        {1, 0},
        {0, -1},
        {-1, 0},
    };

    //附近的格子 8方向
    int[,] nearArray= new int[,]{
        {0, 1},   
        {1, 1},   
        {1, 0},   
        {1, -1},  
        {0, -1},  
        {-1, -1}, 
        {-1, 0},  
        {-1, 1}   
    };
 

這裡可以修改成任意個方向和距離，我只對1個距離以內的移動進行過測試。其它距離不能保證正確性。

*G和H值的計算可以使用曼哈頓距離或者歐式距離，曼哈頓距離效率上會更高。

    float GetNodeG(MapNode parent,MapNode node){
        //曼哈頓距離
        float dis = Mathf.Abs(parent.p.x - node.p.x) + Mathf.Abs(parent.p.y - node.p.y);
        //歐式距離
        //float dis = Vector2.Distance(parent.p, node.p);
        return parent.g + dis;
    }

    float GetNodeH( MapNode node)
    {
        //曼哈頓距離
        return Mathf.Abs(endPosition.x - node.p.x) + Mathf.Abs(endPosition.y - node.p.y);
        //歐式距離
        //return Vector2.Distance(endPosition,node.p);
    }
 

最終的結果只有在4方向時表現上會有些許不同：

左圖為曼哈頓距離的結果，右圖為歐式距離的結果，雖然移動距離是一樣的，但是很明顯歐式距離更符合我們的習慣。

*使用方式:

呼叫AStar類的StratAStar方法即可

    /// <summary>
    /// 開始尋路
    /// </summary>
    /// <returns>路徑點資料，從起始點到結束點路徑的有序vector陣列.</returns>
    /// <param name="map">地圖資料 二維陣列，0為可移動路徑，1為不可移動路徑.</param>
    /// <param name="startPosition">開始位置.</param>
    /// <param name="endPosition">結束位置.</param>
    public List<Vector2> StratAStar(int[,] map,Vector2 startPosition,Vector2 endPosition)

*示例:

定義一個二維資料作為我們的地圖資料:

int[,] map = 
    { 
        {0,0,0,0,0,0,0,0,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,1,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,0,0,0,0},
        {0,0,0,0,0,0,0,0,0,0,0,0,0,0}
    };

設定起始和結束位置:

        Vector2 startPosition = new Vector2(5,6);
        Vector2 endPosition = new Vector2(8, 12);

建立AStar類並呼叫開始方法:

        AStar astar = new AStar();
        List<Vector2> path = astar.StratAStar(map,startPosition,endPosition);

看下效果:

下面使用隨機陣列：

int[, ] map = new int[mapWidth,mapHight];

設定起始點和結束點，然後隨機向陣列中填充資料

        Vector2 startPosition = new Vector2(Random.Range(0, mapWidth),Random.Range(0, mapHight));
        Vector2 endPosition = new Vector2(Random.Range(0, mapWidth), Random.Range(0, mapHight));

        for (int i = 0; i < mapWidth;i ++){
            for (int j = 0; j < mapHight; j++)
            {
                //如果是起點或者終點 跳過
                if((i == (int)startPosition.x && j == (int)startPosition.y) ||
                   (i == (int)endPosition.x && j == (int)endPosition.x) ){
                    continue;
                }
                if (Random.Range(0f, 1f) < 0.2f){
                    map[i, j] = 1;
                }
            }
        }

看下效果:

完整的AStar類:

using System.Collections.Generic;
using UnityEngine;

public class AStar
{
    //節點
    private class MapNode{
        //節點狀態 
        public enum enNodeState{
            normal,//待機
            open,//開啟
            close //關閉
        }

        public MapNode parent = null;//父節點
        public float g, h, f;
        public Vector2 p;//位置
        public enNodeState state = enNodeState.normal;
    }

    //附近的格子 8方向
    int[,] nearArray= new int[,]{
        {0, 1},   
        {1, 1},   
        {1, 0},   
        {1, -1},  
        {0, -1},  
        {-1, -1}, 
        {-1, 0},  
        {-1, 1}   
    };
    //附近的格子 4方向
    //int[,] nearArray = new int[,]{
    //    {0, 1},
    //    {1, 0},
    //    {0, -1},
    //    {-1, 0},
    //};
    Vector2 startPosition, endPosition;//起始點和結束點

    //開放列表，在插入時根據MapNode的f值進行排序，即優先佇列
    List<MapNode> openList = new List<MapNode>();

    //所有點
    MapNode[,] mapList;

    //向開放列表中加入節點，這裡需要進行排序
    void PushNode(MapNode node)
    {
        node.state = MapNode.enNodeState.open;
        for (int i = 0; i < openList.Count; i++){
            if (openList[i].f > node.f){
                openList.Insert(i,node);
                return;
            }
        }
        openList.Add(node);
    }

    //建立節點時即對節點進行估價
    MapNode CreateNode(Vector2 p,MapNode parent){
        MapNode node = new MapNode();
        node.parent = parent;
        node.p = p;

        //f = g+h
        //g和h直接使用曼哈頓距離
        //--------g------
        if(parent != null){
            node.g = GetNodeG(parent,node);
        }else {
            node.g = 0;
        }

        //--------h------
        node.h =GetNodeH(node);

        //--------f------
        node.f = node.g + node.h;

        //建立的節點加入到節點列表中
        mapList[(int)node.p.x,(int)node.p.y] = node;

        return node;
    }

    float GetNodeG(MapNode parent,MapNode node){
        //曼哈頓距離
        //float dis = Mathf.Abs(parent.p.x - node.p.x) + Mathf.Abs(parent.p.y - node.p.y);
        //歐式距離
        float dis = Vector2.Distance(parent.p, node.p);
        return parent.g + dis;
    }

    float GetNodeH( MapNode node)
    {
        //曼哈頓距離
        //return Mathf.Abs(endPosition.x - node.p.x) + Mathf.Abs(endPosition.y - node.p.y);
        //歐式距離
        return Vector2.Distance(endPosition,node.p);
    }

    /// <summary>
    /// 開始尋路
    /// </summary>
    /// <returns>路徑點資料，從起始點到結束點路徑的有序vector陣列.</returns>
    /// <param name="map">地圖資料 二維陣列，0為可移動路徑，1為不可移動路徑.</param>
    /// <param name="startPosition">開始位置.</param>
    /// <param name="endPosition">結束位置.</param>
    public List<Vector2> StratAStar(int[,] map,Vector2 startPosition,Vector2 endPosition){

        mapList = new MapNode[map.GetLength(0),map.GetLength(1)];

        //附近可移動點的數量
        int nearcount = nearArray.GetLength(0);

        this.startPosition = startPosition;
        this.endPosition = endPosition;

        //起始點加入開啟列表
        MapNode startNode = CreateNode(startPosition,null);
        PushNode(startNode);

        MapNode endNode = null;//目標節點

        //開始尋找路徑
        while(openList.Count > 0){
            //取出開啟列表中f值最低的節點，由於我們在向開啟列表中新增節點時已經進行了排序，所以這裡直接取第0個值即可
            MapNode node = openList[0];
            //如果node為目標點則結束尋找
            if(node.p.x == endPosition.x && node.p.y == endPosition.y){
                endNode = node;
                break;
            }

            //設定為關閉狀態並從開啟列表中移除
            node.state = MapNode.enNodeState.close;
            openList.RemoveAt(0);

            //當前點座標
            //相鄰格子加入到開啟列表
            for (int i = 0; i < nearcount; i ++){
                Vector2 nearPosition = node.p - new Vector2(nearArray[i,0], nearArray[i,1]);

                //位置是否超出範圍
                if((nearPosition.x < 0 || nearPosition.x >= map.GetLength(0)) ||
                   (nearPosition.y < 0 || nearPosition.y >= map.GetLength(1))){
                    continue;
                }
                //該位置是否可以移動
                if(map[(int)nearPosition.x,(int)nearPosition.y] != 0){
                    continue;
                }

                //是否已經建立過這個點
                MapNode nearNode = mapList[(int)nearPosition.x, (int)nearPosition.y];
                if(nearNode != null){
                    //該節點已經建立過

                    //節點是否關閉
                    if(nearNode.state == MapNode.enNodeState.close){
                        continue;
                    }

                    //重新計算g
                    float newg = GetNodeG(node, nearNode);
                    if(newg < nearNode.g){
                        nearNode.parent = node;
                        nearNode.g = newg;
                        nearNode.f = nearNode.g + nearNode.h;

                        Debug.Log("==" + openList.Count);
                        //重新對開放列表排序
                        openList.Remove(nearNode);
                        Debug.Log(openList.Count);
                    }else{
                        continue;
                    }
                }else{
                    //建立節點
                    nearNode = CreateNode(nearPosition, node);
                }

                PushNode(nearNode);
            }
        }

        //路徑資料
        List<Vector2> ret = new List<Vector2>();

        if (endNode == null)
        {
            Debug.Log("no path!");
            return ret;
        }

        //將路徑儲存到陣列中
        while(endNode.parent != null){
            ret.Insert(0,endNode.p);
            endNode = endNode.parent;
        }

        return ret;
    }
}