Unity3D AStar地图编辑与寻路测试详解

前言

A星算法是一种常用的寻路算法，能够帮助游戏对象在地图中找到最短路径。本文将详细介绍如何在Unity3D中使用A算法进行地图编辑和寻路测试。

对啦！这里有个游戏开发交流小组里面聚集了一帮热爱学习游戏的零基础小白，也有一些正在从事游戏开发的技术大佬，欢迎你来交流学习。

一、地图编辑

首先我们需要创建一个地图，可以使用Unity3D中的Tilemap功能来快速创建地图。在Unity3D中创建一个Tilemap，然后在Tile Palette中选择合适的地图块进行绘制。可以使用不同的地图块来表示不同的地形，比如墙壁、草地、水域等。在地图编辑中，我们需要定义每个地图块的通行能力，比如墙壁是不可通行的，草地是可通行的。

接下来我们需要将地图转换为一个二维数组，用来表示地图中每个位置的通行能力。可以使用一个二维数组来表示地图，其中1表示可通行，0表示不可通行。在Unity3D中可以使用Tilemap.GetTile来获取每个位置的地图块，然后根据地图块的类型来确定通行能力。

二、A*算法实现

在地图编辑完成后，我们可以使用A算法来进行寻路。A算法是一种启发式搜索算法，通过估计每个位置到目标位置的代价来选择最优路径。在Unity3D中实现A*算法需要定义一个Node类来表示地图中的每个位置，包括位置坐标、父节点、启发函数值等。然后我们需要定义一个OpenList和ClosedList来保存已经访问过的节点和待访问的节点。

A*算法的核心是计算每个节点的启发函数值，然后选择最小的启发函数值的节点进行扩展。在扩展节点时，需要考虑周围的邻居节点，计算它们的启发函数值并将其加入OpenList中。直到找到目标节点或者OpenList为空时算法结束。

三、代码实现

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

using System.Collections.Generic;
using UnityEngine;

public class AStar : MonoBehaviour
{
    private List<Node> OpenList = new List<Node>();
    private List<Node> ClosedList = new List<Node>();

    public List<Node> FindPath(Vector2Int start, Vector2Int end)
    {
        Node startNode = new Node(start);
        Node endNode = new Node(end);

        OpenList.Add(startNode);

        while (OpenList.Count > 0)
        {
            Node currentNode = GetLowestFNode(OpenList);
            OpenList.Remove(currentNode);
            ClosedList.Add(currentNode);

            if (currentNode.Equals(endNode))
            {
                return CalculatePath(startNode, currentNode);
            }

            List<Node> neighbors = GetNeighbors(currentNode);
            foreach (Node neighbor in neighbors)
            {
                if (ClosedList.Contains(neighbor))
                {
                    continue;
                }

                int newG = currentNode.G + 1;
                if (newG < neighbor.G || !OpenList.Contains(neighbor))
                {
                    neighbor.G = newG;
                    neighbor.H = CalculateH(neighbor, endNode);
                    neighbor.Parent = currentNode;

                    if (!OpenList.Contains(neighbor))
                    {
                        OpenList.Add(neighbor);
                    }
                }
            }
        }

        return null;
    }

    private Node GetLowestFNode(List<Node> nodes)
    {
        Node lowestNode = nodes[0];
        foreach (Node node in nodes)
        {
            if (node.F < lowestNode.F)
            {
                lowestNode = node;
            }
        }
        return lowestNode;
    }

    private List<Node> GetNeighbors(Node node)
    {
        List<Node> neighbors = new List<Node>();
        // TODO: Add code to get neighbors of current node
        return neighbors;
    }

    private int CalculateH(Node node, Node endNode)
    {
        return Mathf.Abs(node.Position.x - endNode.Position.x) + Mathf.Abs(node.Position.y - endNode.Position.y);
    }

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

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

        path.Reverse();
        return path;
    }
}

public class Node
{
    public Vector2Int Position;
    public int G;
    public int H;
    public Node Parent;

    public int F
    {
        get { return G + H; }
    }

    public Node(Vector2Int position)
    {
        Position = position;
    }

    public override bool Equals(object obj)
    {
        Node other = obj as Node;
        if (other == null)
        {
            return false;
        }
        return Position.Equals(other.Position);
    }

    public override int GetHashCode()
    {
        return Position.GetHashCode();
    }
}

在上面的代码中，我们定义了一个AStar类来实现A*算法，其中包括FindPath方法用来寻找路径，GetLowestFNode方法用来获取OpenList中最小的F值节点，GetNeighbors方法用来获取当前节点的邻居节点，CalculateH方法用来计算启发函数值，CalculatePath方法用来计算最终路径。同时我们还定义了一个Node类来表示地图中的每个位置。

四、测试

最后我们可以在Unity3D中测试A*算法的效果。在场景中放置一个角色和一个目标点，然后调用AStar类的FindPath方法来获取路径。通过将路径上的位置连接起来，可以看到角色按照最短路径移动到目标点。