A*寻路算法简单实现

寻路算法有很多种，其中最常用的是A*算法。以下是一个简单的实现示例：

1. 创建一个二维网格来表示地图，并用不同的值表示不同的区域类型，比如墙壁、地板和障碍物。

2. 定义一个节点类来表示网格中的每个单元，包括其位置、父节点、G值和H值。

3. 实现A*算法来寻找最优路径：

   • 创建一个开放列表和一个关闭列表，用于保存待访问的节点和已访问的节点。
   • 将起始节点添加到开放列表中。
   • 重复以下步骤，直到找到目标节点或者开放列表为空：
     • 从开放列表中选择一个节点，称为当前节点。
     • 如果当前节点是目标节点，路径已找到，跳出循环。
     • 将当前节点从开放列表中移除，并添加到关闭列表中。
     • 对当前节点的邻居进行遍历：
       • 如果邻居节点不可通行或者已在关闭列表中，忽略它。
       • 如果邻居节点不在开放列表中，将它添加到开放列表中，并计算它的G值、H值和F值。
       • 如果邻居节点已在开放列表中，计算从当前节点经由邻居节点到达目标节点的G值，并比较它与邻居节点原有的G值：
         • 如果新的G值更小，则更新邻居节点的父节点为当前节点，并更新它的G值和F值。

4. 当A*算法结束时，通过回溯父节点的方式从目标节点到起始节点，即可得到最优路径。

以下是一个使用A*算法寻找最优路径的示例代码：

public List<Vector2Int> FindPath(Vector2Int start, Vector2Int target)
{
    Node startNode = new Node(start, null, 0, 0);
    Node targetNode = new Node(target, null, 0, 0);

    List<Node> openList = new List<Node>();
    List<Node> closedList = new List<Node>();

    openList.Add(startNode);

    while (openList.Count > 0)
    {
        Node current = openList[0];

        for (int i = 1; i < openList.Count; i++)
        {
            if (openList[i].F < current.F || (openList[i].F == current.F && openList[i].H < current.H))
            {
                current = openList[i];
            }
        }

        openList.Remove(current);
        closedList.Add(current);

        if (current.Equals(targetNode))
        {
            return RetracePath(startNode, current);
        }

        foreach (Vector2Int neighborPos in GetNeighborPositions(current.position))
        {
            Node neighbor = new Node(neighborPos, current, current.G + 1, CalculateH(neighborPos, target));

            if (!IsValidPosition(neighborPos) || IsBlocked(neighborPos) || closedList.Contains(neighbor))
            {
                continue;
            }

            if (!openList.Contains(neighbor))
            {
                openList.Add(neighbor);
            }
            else
            {
                int newG = current.G + 1;
                if (newG < neighbor.G)
                {
                    neighbor.parent = current;
                    neighbor.G = newG;
                }
            }
        }
    }

    return null; // 如果找不到路径，返回空路径
}

private List<Vector2Int> RetracePath(Node startNode, Node endNode)
{
    List<Vector2Int> path = new List<Vector2Int>();
    Node current = endNode;

    while (!current.Equals(startNode))
    {
        path.Add(current.position);
        current = current.parent;
    }

    path.Reverse();
    return path;
}

// 根据具体需求实现以下辅助函数：
// - GetNeighborPositions: 获取一个节点的所有相邻位置
// - CalculateH: 计算从一个位置到目标位置的启发式评估值
// - IsValidPosition: 判断一个位置是否在地图范围内
// - IsBlocked: 判断一个位置是否为障碍物

以上是一个基本的A*算法寻找最优路径的示例。你可以根据具体需求和游戏引擎的特性进行相应的调整和扩展。

希望这个解答对你有所帮助！