游戏AI实现-寻路算法（BFS）

news2024/12/21 0:59:05

广度优先搜索算法（英语：Breadth-first search，缩写：BFS），又译作宽度优先搜索，或横向优先搜索，是一种图形搜索算法。

寻路地图搭建：

游戏AI实现-寻路地图搭建-CSDN博客

算法过程：遍历方向为从竖直向上沿顺时针方向

1.首先将开始节点加入到队列中。注：黄色代表已检测。

2.从队列中取出第一个节点，检测是否为目标点。

如果是则返回目标点终止算法，否则，遍历变量v相邻的子节点，将它的子节点，加入到队列中。

------------------------------->

3.重复步骤2，直到找到目标点。

代码实现：

算法实现类：

public class BFS : FindPathAlgorithm
{
    public BFS(int[,] mapData, int xCount, int zCount) : base(mapData, xCount, zCount) { }

    public override List<Vector2Int> FindPath(Vector2Int startPos, Vector2Int goalPos)
    {
        DataNode dataNode = this.BFSFind(startPos, goalPos);
        if(dataNode == null)
        {
            Debug.LogError("寻路有误，请检查参数是否正确");
            return null;
        }
        //Utils.DisplayData(path);
        return Utils.GetPath(dataNode);
    }

    DataNode BFSFind(Vector2Int startPos, Vector2Int goalPos)
    {
        //存储要检测的点
        Queue<DataNode> frontier = new Queue<DataNode>();
        //存储已经检测的点
        List<Vector2Int> reached = new List<Vector2Int>();

        frontier.Enqueue(new DataNode(startPos, null));
        reached.Add(startPos);

        while (frontier.Count > 0)
        {
            DataNode currentNode = frontier.Dequeue();
            if (currentNode.pos == goalPos)
            {
                return new DataNode(goalPos, currentNode.parent);
            }
            List<Vector2Int> neighbors = GetNeighbors(currentNode.pos, reached);
            foreach (Vector2Int p in neighbors)
            {
                if (this.mapData[p.y,p.x] != 1)
                {
                    frontier.Enqueue(new DataNode(p, currentNode));
                }
                //增加已检测点
                reached.Add(p);
            }
        }
        return null;
    }

    List<Vector2Int> GetNeighbors(Vector2Int current, List<Vector2Int> reached)
    {
        List<Vector2Int> neighbors = new List<Vector2Int>();
        for (int i = 0; i < Utils.pointDir.Count; i++)
        {
            Vector2Int neighbor = current + Utils.pointDir[i];
            if (this.IsCanAdd(neighbor, reached))
            {
                neighbors.Add(neighbor);
            }
        }
        return neighbors;
    }

    bool IsCanAdd(Vector2Int current, List<Vector2Int> reached)
    {
        if (reached.Contains(current))
            return false;
        if (current.x >= 0 && current.y >= 0 && current.x < xCount && current.y < zCount)
            return true;
        return false;
    }
}

结果：