Unity3D之迷宫寻路_A*最短路径寻路

A*寻路相信很多人都听说过，也是比较基本的一种算法，具体概念我就不多说了，网上查找一下一大堆，我直接贴上我的A*应用方法，以下是地图：

接下来是地图数组：

using UnityEngine;
using System.Collections;

public static class MapsArray {

    public static int[,] MazeItem = new int[15, 10]   //初始化迷宫
		{
			{1,1,1,1,1,1,1,1,1,1},
			{1,0,1,1,1,0,0,0,1,1},
			{1,0,0,1,1,0,1,0,1,1},
			{1,0,0,0,0,0,1,0,1,1},
			{1,1,0,1,0,1,1,0,1,1},
			{1,1,0,1,0,0,0,0,1,1},
			{1,0,0,0,1,1,1,0,1,1},
			{1,1,0,0,0,0,0,0,1,1},
			{1,1,0,1,1,1,0,0,0,1},
			{1,1,0,0,1,1,1,0,1,1},
            {1,1,1,0,0,0,0,0,1,1},
            {1,1,1,1,0,0,1,0,1,1},
            {1,0,0,0,0,1,1,0,0,1},
            {1,0,1,1,1,0,1,1,0,1},
            {1,1,1,1,1,1,1,1,1,1}
		};
}

接下来是A*算法的使用代码：

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

public enum Grids3DType {
    Normal,
    Obstacle,
    Start,
    End
}

public class Grids_3D : IComparable
{
    public int x;
    public int y;
    public int G;
    public int F;
    public int H;
    public Grids_3D fatherMode;
    public Grids3DType gridsType;
    public int CompareTo(object obj)
    {
        Grids_3D grid = (Grids_3D)obj;
        if (this.F < grid.F)
            return -1;
        else if (this.F > grid.F)
            return 1;
        return 0;
    }
}

public class AStart_3D : MonoBehaviour {

    private int[,] MazeItem;   // 迷宫数组
    private GameObject npc;

    private const int xStart = 1;
    private const int yStart = 1;
    private const int xEnd = 8;
    private const int yEnd = 8;
    private bool noroad = false;    // 没有路
    private Grids_3D[,] map;        //
    private Vector3 target = Vector3.zero;      // 当前要前往的目标点

    private float speed = 4;           // 小球移动速度
    ArrayList openList;                 // 开放列表
    ArrayList closeList;                // 关闭列表
    private List<Vector3> path;         // 存储要移动的路径
    private int n = 0;                  // 当前已经移动的路点
	// Use this for initialization
	void Start () {
        MazeItem = MapsArray.MazeItem;  // 初始化迷宫数组
        openList = new ArrayList();
        closeList = new ArrayList();
        path = new List<Vector3>();

        StartCoroutine(CreateMap());
	}

    void Update()
    {
        if (target != Vector3.zero)
        {
            if (path.Count > 0)
            {
                npc.transform.position = Vector3.MoveTowards(npc.transform.position, target, Time.deltaTime * speed);
                if (npc.transform.position == target) {
                    target = GetTarget();
                }
            }
        }
    }

    // 创建地图
    IEnumerator CreateMap()
    {
        GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        yield return cube;
        for (int i = 0; i < MazeItem.GetLength(0); i++)
        {
            for (int j = 0; j < MazeItem.GetLength(1); j++)
            {
                if (MazeItem[i, j] == 1)
                {
                    Instantiate(cube, new Vector3(i, j, 0), Quaternion.identity);
                }
            }
        }

        // 起始点标记
        GameObject start = Instantiate(cube, new Vector3(xStart, yStart, 0), Quaternion.identity) as GameObject;
        start.transform.localScale = Vector3.one * 0.3f;
        start.renderer.material.color = Color.grey;
        GameObject end = Instantiate(cube, new Vector3(xEnd, yEnd, 0), Quaternion.identity) as GameObject;
        end.transform.localScale = Vector3.one * 0.3f;
        end.renderer.material.color = Color.blue;
        yield return new WaitForEndOfFrame();
        StartCoroutine(CreateNPC());
    }

    // 创建NPC
    IEnumerator CreateNPC()
    {
        GameObject npc_Prefab = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        yield return npc_Prefab;
        if (MazeItem[1, 1] == 0)
        {
            npc = Instantiate(npc_Prefab, new Vector3(1, 1, 0), Quaternion.identity) as GameObject;
            npc.renderer.material.color = Color.red;
            target = npc.transform.position;        // 设置初始点
        }
        yield return new WaitForEndOfFrame();
        StartCoroutine(Pathing());

    }

    // 开始寻路
    IEnumerator Pathing() {
        InitMap();           // 初始化地图, 标记地图起点、终点、障碍物
        yield return new WaitForEndOfFrame();
        while (!noroad)        // 如果不是没有路，就继续寻路
        {
            Pathing_OneStep();
        }
    }

    // 初始化地图, 标记地图起点、终点、障碍物
    void InitMap() {

        map = new Grids_3D[MazeItem.GetLength(0), MazeItem.GetLength(1)];
        for (int i = 0; i < MazeItem.GetLength(0); i++)
        {
            for (int j = 0; j < MazeItem.GetLength(1); j++)
            {
                map[i, j] = new Grids_3D();
                map[i, j].x = i;
                map[i, j].y = j;
                if (MazeItem[i, j] == 0)
                {
                    map[i, j].gridsType = Grids3DType.Normal;
                }
                else {
                    map[i, j].gridsType = Grids3DType.Obstacle;
                }
            }
        }

        map[xStart, yStart].gridsType = Grids3DType.Start;
        map[xStart, yStart].H = ManHattan(xEnd, yEnd);
        map[xEnd, yEnd].gridsType = Grids3DType.End;

        openList.Add(map[xStart, yStart]);
    }

    //曼哈顿算法，求H的值
    int ManHattan(int x, int y) {
        return (int)(Mathf.Abs(x - xEnd) + Mathf.Abs(y - yEnd)) * 10;
    }

    // 进行一步寻路计算获取最短路径
    void Pathing_OneStep() {
        // 如果开放列表为0，则返回，并标记为没有路
        if (openList.Count == 0) {
            noroad = true;
            return;
        }
        Grids_3D grid = (Grids_3D)openList[0];
        // 如果到达终点，则回溯获取路径，并返回没有路
        if (grid.gridsType == Grids3DType.End) {
            ShowFatherNode(grid);          // 通过父节点回溯
            noroad = true;
            return;
        }

        for (int i = -1; i <= 1; i++)
        {
            for (int j = -1; j <= 1; j++)
            {
                if (!(i == 0 && j == 0) && ((i == 0 && j != 0) || (j == 0 && i != 0)))
                {
                    int x = grid.x + i;
                    int y = grid.y + j;

                    if (x >= 0 && x < MazeItem.GetLength(0) && y >= 0 && y < MazeItem.GetLength(1)
                        && !closeList.Contains(map[x, y])
                        && map[x, y].gridsType != Grids3DType.Obstacle) {
                        int g = grid.G + (int)(Mathf.Sqrt(Mathf.Abs(i) + Mathf.Abs(j)) * 10);
                        if (map[x, y].G == 0 || g < map[x, y].G) {
                            map[x, y].G = g;
                        }

                        map[x, y].H = ManHattan(x, y);
                        map[x, y].F = map[x, y].G + map[x, y].H;
                        map[x, y].fatherMode = grid;

                        if (!openList.Contains(map[x, y])) {
                            openList.Add(map[x, y]);
                        }

                        openList.Sort();
                    }

                }
            }
        }
        closeList.Add(grid);
        openList.Remove(grid);
    }

    // 通过回溯找到最短路径
    void ShowFatherNode(Grids_3D grid)
    {
        if (grid.fatherMode != null)
        {
            Vector3 point = new Vector3(grid.x, grid.y, 0);
            path.Add(point);
            ShowFatherNode(grid.fatherMode);
        }
    }

    // 获取路径
    Vector3 GetTarget() {
        Vector3 point = npc.transform.position;
        if (path.Count > 0 && n < path.Count)
        {
           point = path[path.Count - n - 1];
           n++;
        }
        return point;
    }
}