Unity3D 打造3D Astar寻路系统详解

在游戏开发中，寻路系统是一个非常重要的功能，它可以让游戏中的角色自动寻找最短路径到达目的地。在本文中，我们将详细介绍如何使用Unity3D打造一个3D Astar寻路系统。

对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！

Astar算法是一种常用的寻路算法，它通过将地图网格化并使用启发式搜索来找到最短路径。在Unity3D中，我们可以通过编写脚本来实现Astar寻路系统。下面我们将详细介绍如何实现这一功能。

首先，我们需要创建一个地图网格来表示游戏场景。我们可以使用Unity3D中的Tilemap工具来创建一个2D地图，然后将其转换为3D地图。在网格上，我们需要标记出障碍物的位置，这样Astar算法才能正确计算路径。

接下来，我们需要编写一个脚本来实现Astar寻路算法。我们可以创建一个名为Astar.cs的脚本，并将其挂载到一个空物体上。在脚本中，我们需要定义一个Node类来表示地图中的每个节点。Node类需要包含节点的位置、父节点、G值、H值和F值等属性。G值表示起点到当前节点的移动代价，H值表示当前节点到终点的估算代价，F值为G值和H值的和。

接着，我们需要实现Astar算法的核心逻辑。在Astar脚本中，我们可以定义一个OpenList和一个ClosedList来存储待处理的节点和已处理的节点。我们可以使用一个循环来不断从OpenList中取出F值最小的节点，并将其加入ClosedList。然后，我们需要计算当前节点的邻居节点，并更新其G值、H值和F值。最后，我们需要递归地搜索路径，直到找到终点或者OpenList为空。

在搜索完成后，我们可以通过遍历ClosedList来获取最短路径。我们可以从终点开始，沿着每个节点的父节点回溯，直到到达起点。这样就可以得到从起点到终点的最短路径了。

最后，我们需要在游戏中显示路径。我们可以在Unity3D中创建一个角色物体，并编写一个脚本来控制其移动。在脚本中，我们可以将Astar脚本挂载到角色物体上，并调用其方法来计算路径。然后，我们可以在游戏中显示路径，让角色按照路径移动。

通过以上步骤，我们就可以在Unity3D中打造一个3D Astar寻路系统了。这个系统可以帮助游戏中的角色自动寻找最短路径到达目的地，提升游戏的体验。

以下是一个简单的实现Astar算法的示例代码：

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

public class Node
{
    public Vector3 position;
    public Node parent;
    public float gCost;
    public float hCost;
    public float fCost
    {
        get { return gCost + hCost; }
    }

    public Node(Vector3 _pos)
    {
        position = _pos;
    }
}

public class Astar : MonoBehaviour
{
    public Transform startNode;
    public Transform endNode;
    public LayerMask obstacleMask;
    public float nodeRadius;

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

    private void Start()
    {
        FindPath(startNode.position, endNode.position);
    }

    private void FindPath(Vector3 startPos, Vector3 targetPos)
    {
        Node startNode = new Node(startPos);
        Node targetNode = new Node(targetPos);

        openList.Add(startNode);

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

            for (int i = 1; i < openList.Count; i++)
            {
                if (openList[i].fCost < currentNode.fCost || openList[i].fCost == currentNode.fCost && openList[i].hCost < currentNode.hCost)
                {
                    currentNode = openList[i];
                }
            }

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

            if (currentNode == targetNode)
            {
                RetracePath(startNode, targetNode);
                return;
            }

            foreach (Node neighbour in GetNeighbours(currentNode))
            {
                if (!closedList.Contains(neighbour))
                {
                    float newCostToNeighbour = currentNode.gCost + GetDistance(currentNode, neighbour);
                    if (newCostToNeighbour < neighbour.gCost || !openList.Contains(neighbour))
                    {
                        neighbour.gCost = newCostToNeighbour;
                        neighbour.hCost = GetDistance(neighbour, targetNode);
                        neighbour.parent = currentNode;

                        if (!openList.Contains(neighbour))
                        {
                            openList.Add(neighbour);
                        }
                    }
                }
            }
        }
    }

    private List<Node> GetNeighbours(Node node)
    {
        List<Node> neighbours = new List<Node>();

        Vector3[] directions = new Vector3[]
        {
            new Vector3(1, 0, 0),
            new Vector3(-1, 0, 0),
            new Vector3(0, 1, 0),
            new Vector3(0, -1, 0),
            new Vector3(1, 1, 0),
            new Vector3(-1, -1, 0),
            new Vector3(1, -1, 0),
            new Vector3(-1, 1, 0)
        };

        foreach (Vector3 dir in directions)
        {
            Vector3 neighbourPos = node.position + dir * nodeRadius;
            if (!Physics.CheckSphere(neighbourPos, nodeRadius, obstacleMask))
            {
                neighbours.Add(new Node(neighbourPos));
            }
        }

        return neighbours;
    }

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

        while (currentNode != startNode)
        {
            path.Add(currentNode);
            currentNode = currentNode.parent;
        }

        path.Reverse();

        foreach (Node node in path)
        {
            Debug.Log(node.position);
        }
    }

    private float GetDistance(Node nodeA, Node nodeB)
    {
        float dstX = Mathf.Abs(nodeA.position.x - nodeB.position.x);
        float dstY = Mathf.Abs(nodeA.position.y - nodeB.position.y);
        float dstZ = Mathf.Abs(nodeA.position.z - nodeB.position.z);

        if (dstX > dstY)
        {
            return 14 * dstY + 10 * (dstX - dstY) + 10 * dstZ;
        }
        return 14 * dstX + 10 * (dstY - dstX) + 10 * dstZ;
    }
}

以上代码实现了一个简单的Astar寻路算法。我们可以在Unity3D中创建一个空物体，并将该脚本挂载到空物体上。然后，我们可以设置起点和终点，并在游戏运行时调用FindPath方法来计算路径。最后，我们可以在RetracePath方法中获取路径并在控制台输出。这样就实现了一个简单的3D Astar寻路系统。

总结一下，Unity3D是一个非常强大的游戏开发引擎，可以帮助我们实现各种功能，包括寻路系统。通过使用Astar算法，我们可以实现一个高效的寻路系统，让游戏中的角色可以自动寻找最短路径到达目的地。希望本文对你有所帮助，谢谢阅读！