unity使用深度优先搜索算法自动生成随机迷宫

unity使用深度优先搜索算法自动生成随机迷宫

关键词：unity C# 随机生成迷宫 深度优先搜索算法 迷宫算法

最近有空，研究了一下深度优先搜索算法，并做成一个生成迷宫的例子。

参考的是：

https://en.wikipedia.org/wiki/Maze_generation_algorithm

以下是效果图。

话不多说，代码直接贴在下面。

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

public class WorldBehaviour : MonoBehaviour
{
    public struct MapPointState
    {
        public int x;
        public int y;

        public bool isVisit;
        public int state;

        public List<int> direction;

        public MapPointState(int x, int y, bool isVisit, int state)
        {
            this.x = x;
            this.y = y;
            this.isVisit = isVisit;
            this.state = state;
            direction = new List<int>();
        }
    }

    public RectTransform mainCanvas;
    public Image image;

    public int worldWidth;
    public int worldHeight;

    private Image[,] pathImages;

    private MapPointState[,] mapPointStates;

    private Queue<MapPointState> mapQueue;

    private Stack<MapPointState> pathStack;

    private int currentVisits;

    private bool isReadyStop;
    private Coroutine coroutine;
    // Use this for initialization
    void Start()
    {
        pathImages = new Image[worldHeight, worldWidth];
        mapQueue = new Queue<MapPointState>();

        coroutine = StartCoroutine(WaitAndShow());

        CreateAllPath();
        InitDepthFirstSearch();
        StartDepthFirstSearch();
    }
    /// <summary>
    /// 初始化
    /// </summary>
    private void InitDepthFirstSearch()
    {
        mapPointStates = new MapPointState[worldHeight, worldWidth];
        pathStack = new Stack<MapPointState>();

        int[] a = { 0, 1, 2, 3 };//0Up 1Down 2Left 3Right

        for (int i = 0; i < worldWidth; i++)
        {
            for (int j = 0; j < worldHeight; j++)
            {
                mapPointStates[i, j] = new MapPointState(i, j, false, 0);
                mapPointStates[i, j].direction.AddRange(a);
            }
        }
    }
    /// <summary>
    /// 开始
    /// </summary>
    private void StartDepthFirstSearch()
    {
        DepthFirstSearch(Random.Range(0, worldHeight), Random.Range(0, worldWidth), -1);

        print(currentVisits);
        isReadyStop = true;
    }
    /// <summary>
    /// 搜索
    /// </summary>
    /// <param name="x">当前所在x</param>
    /// <param name="y">当前所在y</param>
    /// <param name="direction">来时的方向</param>
    private void DepthFirstSearch(int x, int y, int direction)//抽象坐标轴x↑y→
    {
        //若超过边界
        if (x < 0 || x >= worldHeight || y < 0 || y >= worldWidth)
        {
            if (pathStack.Count > 0)
                DepthFirstSearch(pathStack.Peek().x, pathStack.Peek().y, -1);
            return;
        }
        //若剩余方向为0
        if (mapPointStates[x, y].direction.Count == 0)
        {
            if (pathStack.Contains(mapPointStates[x, y]))
            {
                pathStack.Pop();
                mapPointStates[x, y].isVisit = true;
                mapQueue.Enqueue(mapPointStates[x, y]);
            }
            if (pathStack.Count > 0)
                DepthFirstSearch(pathStack.Peek().x, pathStack.Peek().y, -1);
            return;
        }
        //移除来时方向
        if (mapPointStates[x, y].direction.Contains(direction))
        {
            mapPointStates[x, y].direction.Remove(direction);
        }

        currentVisits++;

        //随机下一个方向
        int nextDirection = mapPointStates[x, y].direction[Random.Range(0, mapPointStates[x, y].direction.Count)];
        mapPointStates[x, y].direction.Remove(nextDirection);

        int newX = -1, newY = -1;

        ProcessNextPosition(x, y, nextDirection, ref newX, ref newY);

        //搜索下一个方向
        if (newX != -1 && newY != -1)
        {
            AddNewPointInMap(x, y);

            switch (nextDirection)
            {
                case 0:
                    nextDirection = 1;
                    break;
                case 1:
                    nextDirection = 0;
                    break;
                case 2:
                    nextDirection = 3;
                    break;
                case 3:
                    nextDirection = 2;
                    break;
            }

            DepthFirstSearch(newX, newY, nextDirection);

            return;
        }
        //回溯
        if (mapPointStates[x, y].direction.Count > 0)
        {
            DepthFirstSearch(x, y, -1);
        }
        else if (pathStack.Count > 0)
        {
            DepthFirstSearch(pathStack.Peek().x, pathStack.Peek().y, -1);
        }
    }
    /// <summary>
    /// 计算下一个坐标
    /// </summary>
    /// <param name="x">当前x</param>
    /// <param name="y">当前y</param>
    /// <param name="nextDirection">下一个方向</param>
    /// <param name="newX">新x</param>
    /// <param name="newY">新y</param>
    private void ProcessNextPosition(int x, int y, int nextDirection, ref int newX, ref int newY)
    {
        switch (nextDirection)
        {
            case 0:
                if (x + 1 < worldHeight && mapPointStates[x + 1, y].state != 1)
                {
                    if ((y - 1 >= 0 && mapPointStates[x + 1, y - 1].state == 1) || (y + 1 < worldWidth && mapPointStates[x + 1, y + 1].state == 1))
                    {
                        break;
                    }

                    if (x + 2 < worldHeight && mapPointStates[x + 2, y].state == 1)
                    {
                        AddNewPointInMap(x, y);
                        break;
                    }

                    newX = x + 1;
                    newY = y;
                }
                break;
            case 1:
                if (x - 1 >= 0 && mapPointStates[x - 1, y].state != 1)
                {
                    if ((y - 1 >= 0 && mapPointStates[x - 1, y - 1].state == 1) || (y + 1 < worldWidth && mapPointStates[x - 1, y + 1].state == 1))
                    {
                        break;
                    }

                    if (x - 2 >= 0 && mapPointStates[x - 2, y].state == 1)
                    {
                        AddNewPointInMap(x, y);
                        break;
                    }

                    newX = x - 1;
                    newY = y;
                }
                break;
            case 2:
                if (y - 1 >= 0 && mapPointStates[x, y - 1].state != 1)
                {
                    if ((x + 1 < worldHeight && mapPointStates[x + 1, y - 1].state == 1) || (x - 1 >= 0 && mapPointStates[x - 1, y - 1].state == 1))
                    {
                        break;
                    }

                    if (y - 2 >= 0 && mapPointStates[x, y - 2].state == 1)
                    {
                        AddNewPointInMap(x, y);
                        break;
                    }

                    newX = x;
                    newY = y - 1;
                }
                break;
            case 3:
                if (y + 1 < worldWidth && mapPointStates[x, y + 1].state != 1)
                {
                    if ((x + 1 < worldHeight && mapPointStates[x + 1, y + 1].state == 1) || (x - 1 >= 0 && mapPointStates[x - 1, y + 1].state == 1))
                    {
                        break;
                    }

                    if (y + 2 < worldWidth && mapPointStates[x, y + 2].state == 1)
                    {
                        AddNewPointInMap(x, y);
                        break;
                    }

                    newX = x;
                    newY = y + 1;
                }
                break;
        }
    }

    /// <summary>
    /// 增加新点进地图
    /// </summary>
    /// <param name="x"></param>
    /// <param name="y"></param>
    private void AddNewPointInMap(int x, int y)
    {
        mapPointStates[x, y].state = 1;

        if (!mapQueue.Contains(mapPointStates[x, y]))
        {
            mapQueue.Enqueue(mapPointStates[x, y]);
        }

        if (!pathStack.Contains(mapPointStates[x, y]))
        {
            pathStack.Push(mapPointStates[x, y]);
        }
    }
    /// <summary>
    /// 创建所有路径
    /// </summary>
    private void CreateAllPath()
    {
        for (int i = 0; i < worldHeight; i++)
        {
            for (int j = 0; j < worldWidth; j++)
            {
                pathImages[i, j] = Instantiate(image, new Vector3(i * 32, j * 32, 0), Quaternion.identity, mainCanvas);
            }
        }
    }
    /// <summary>
    /// 设置路径颜色
    /// </summary>
    /// <param name="mapPointState"></param>
    private void SetPathColor(MapPointState mapPointState)
    {
        if (mapPointState.isVisit)
            pathImages[mapPointState.x, mapPointState.y].color = new Color(0, 1, 0, 1);
        else
            pathImages[mapPointState.x, mapPointState.y].color = new Color(1, 1, 1, 1);
    }
    /// <summary>
    /// 等待显示
    /// </summary>
    /// <returns></returns>
    private IEnumerator WaitAndShow()
    {
        while (true)
        {
            yield return new WaitForSeconds(0.1f);

            if (mapQueue.Count > 0)
            {
                SetPathColor(mapQueue.Peek());
                mapQueue.Dequeue();
            }

            if (isReadyStop && mapQueue.Count == 0)
            {
                print("End");
                StopCoroutine(coroutine);
            }
        }
    }
}

另附上工程文件：

https://files.cnblogs.com/files/JinT-Hwang/NewUnityProject1.7z

欢迎交流指教:)