roguelike地牢生成算法

文章原地址

上一个地图生成算法，这一次是一个地牢的生成算法，是一个国外的人写的算法，用dart语言写，我把它改成了unity-c#。

原作者博客地址：Rooms and Mazes: A Procedural Dungeon Generator

当然，我看英文很吃力，好不容易找了一篇翻译后的文章，分享给英语不太好的人。

一个翻译后的版本：房间和迷宫：一个地牢生成算法

然后原作者的算法代码地址（dart）：github

算法的原理请看原文地址或者翻译地址，那里有各种动态演示图，讲解的也很清楚，代码可以看原作者的代码，因为我没有学过dart，改写c#的过程很有可能有错误，请见谅！

原作者的代码用到了第三方的一个库，github地址，可以参考这个看原作者代码。

c#代码：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using System.Threading;

class Directions{
    public static Vector2 none = new Vector2 (0,0);
    public static Vector2 up = new Vector2 (0,1);
    public static Vector2 down = new Vector2 (0,-1);
    public static Vector2 left = new Vector2 (-1,0);
    public static Vector2 right = new Vector2 (1,0);

    public static Vector2[] all = {up,down,left,right};

}

//确保地图的长宽是奇数
public class generateDungeon2 : MonoBehaviour {
    //尝试生成房间的数量
    public int numRoomTries = 50;
    //在已经连接的房间和走廊中再次连接的机会，使得地牢不完美
    public int extraConnectorChance = 20;
    //控制生成房间的大小
    public int roomExtraSize = 0;
    //控制迷宫的曲折程度
    public int windingPercent = 0; 
    public int width = 51;
    public int height = 51;
    public GameObject wall, floor,connect;

    private Transform mapParent;
    //生成的有效房间
    private List<Rect> rooms;
    //正被雕刻的区域的索引。(每个房间一个索引，每个不连通的迷宫一个索引，在连通之前)
    private int currentRegion = 0;
    //原文https://github.com/munificent/piecemeal Array2D
    //改成int[,]
    private int[,] _regions;
    private Tiles[,] map;

    void Start () {
        rooms = new List<Rect> ();
        map = new Tiles[width,height];
        _regions = new int[width,height];
        mapParent = GameObject.FindGameObjectWithTag ("mapParent").transform;
        Generate ();
    }

    void Update () {
        if (Input.GetKeyDown (KeyCode.Q)) {
            Generate ();
        }
    }

    public void Generate(){
        if (width % 2 == 0 || height % 2 == 0) {
            Debug.Log ("地图长宽不能为偶数");
            return;
        }
        InitMap ();
        AddRooms ();
        FillMaze ();
        ConnectRegions ();
        RemoveDeadEnds ();
        InstanceMap ();
    }


    /*
     *生成房间
     *1.随机房间（随机大小，奇数）
     *2.查看是否重叠，否则加入房间数组
     */
    private void AddRooms(){
        for (int i = 0; i < numRoomTries; i++) {
            //确保房间长宽为奇数
            int size = Random.Range(1,3+roomExtraSize)*2+1;
            int rectangularity = Random.Range (0, 1 + size / 2) * 2;
            int w = size, h = size;
            if (0 == Random.Range (0, 1)) {
                w += rectangularity;
            } else {
                h += rectangularity;
            }
            int x = Random.Range (0, (width - w) / 2) * 2 + 1;
            int y = Random.Range (0, (height - h) / 2) * 2 + 1;
            Rect room = new Rect (x,y,w,h);
            //判断房间是否和已存在的重叠
            bool overlaps = false;
            foreach (Rect r in rooms) {
                if(room.Overlaps(r)){
                    overlaps = true;
                    break;
                }
            }
            //如果重叠，抛弃该房间
            if (overlaps)
                continue;
            //如果不重叠，把房间放入rooms中
            rooms.Add(room);
            //设置新房间索引
            StartRegion();

            for (int j = x; j < x + w; j++) {
                for (int k = y; k < y + h; k++) {
                    Carve (new Vector2 (k, j));
                }
            }
        }
    }

    /*
     * 填充迷宫(洪水填充)
     * 
     */ 
    private void FillMaze(){
        //0处为墙
        for (int x = 1; x < width; x += 2) {
            for (int y = 1; y < height; y += 2) {
                Vector2 pos = new Vector2 (x,y);
                //if (map [pos] == Tiles.Wall) {
                if (map [x,y] == Tiles.Wall) {
                    GrowMaze (pos);
                }
            }
        }
    }

    /*
     * 生成迷宫
     */ 
    private void GrowMaze(Vector2 start){
        List<Vector2> cells = new List<Vector2> ();
        Vector2 lastDir = Directions.none;
        StartRegion ();
        //cells添加之前需要变成Floor
        Carve (start);
        cells.Add (start);
        while (cells != null && cells.Count != 0) {
            Vector2 cell = cells [cells.Count - 1];
            //可以扩展的方向的集合
            List<Vector2> unmadeCells = new List<Vector2> ();
            //加入能扩展迷宫的方向
            foreach (Vector2 dir in Directions.all) {
                if (CanCarve (cell, dir)) {
                    unmadeCells.Add (dir);
                }
            }
            if (unmadeCells != null && unmadeCells.Count != 0) {
                Vector2 dir;
                //得到扩展方向 windingPercent用来控制是否为原方向
                if (unmadeCells.Contains (lastDir) && Random.Range (0, 100) > windingPercent) {
                    dir = lastDir;
                } else {
                    dir = unmadeCells [Random.Range (0, unmadeCells.Count - 1)];
                }

                Carve (cell + dir);
                Carve (cell + dir * 2);
                //添加第二个单元
                cells.Add (cell + dir * 2);
                lastDir = dir;
            } else {
                //没有相邻可以雕刻的单元，就删除
                cells.Remove (cells[cells.Count - 1]);
                //置空路径
                lastDir = Directions.none;
            }

        }
    }

    /*
     * 连通房间和迷宫
     */ 
    private void ConnectRegions(){
        //找到区域所有可连接的空间墙wall
        Dictionary<Vector2,List<int>> connectorRegions = new Dictionary<Vector2, List<int>> ();
        for (int i = 1; i < width - 1; i++) {
            for (int j = 1; j < height - 1; j++) {
                //不是墙的跳过
                if (map [i, j] != Tiles.Wall)
                    continue;
                List<int> regions = new List<int> ();
                foreach (Vector2 dir in Directions.all) {
                    int region = _regions [i + (int)dir.x, j + (int)dir.y];
                    //如果周围不是墙（墙的索引为regions的初始值为0）
                    //去重
                    if (region != 0 && !regions.Contains(region))
                        regions.Add (region);
                }
                //如果这个墙没有连接一个以上的区域，那就不是一个连接点
                if (regions.Count < 2)
                    continue;
                connectorRegions [new Vector2 (i, j)] = regions;
                //标志连接点
                //SetConnectCube(i,j);
            }
        }
        //所有连接点
        List<Vector2> connectors = connectorRegions.Keys.ToList<Vector2>();
        //跟踪哪些区域已合并。将区域索引映射为它已合并的区域索引。
        List<int> merged = new List<int>();
        List<int> openRegions = new List<int> ();
        for (int i = 0; i <= currentRegion; i++) {
            merged.Add (i);
            openRegions.Add (i);
        }
        //使区域连接最终只剩下一个
        while (openRegions.Count > 1) {
            //随机选择一个连接点
            Vector2 connector = connectors[Random.Range(0,connectors.Count-1)];
            //连接
            AddJunction(connector);
            //合并连接区域我们将选择第一个区域（任意）和
            //将所有其他区域映射到其索引。
            //connectorRegions[connector]
            List<int> regions = connectorRegions[connector];
            for (int i = 0; i < regions.Count; i++) {
                regions[i] = merged[regions[i]];
            }
            int dest = regions[0];
            regions.RemoveAt (0);
            List<int> sources = regions;
            //合并所有受影响的区域
            for(int i=0;i<currentRegion;i++){
                if (sources.Contains (merged [i])) {
                    merged [i] = dest;
                }
            }
            //移除已经连接的区域
            foreach (int s in sources) {
                openRegions.RemoveAll (value => (value==s));
            }
            connectors.RemoveAll (index=>IsRemove(merged,connectorRegions,connector,index));
        }
    }
        

    /*
     * 简化迷宫
     */ 
    private void RemoveDeadEnds(){
        bool done = false;
        while (!done) {
            done = true;
            for (int i = 1; i < width - 1; i++) {
                for (int j = 1; j < height - 1; j++) {
                    if (map [i, j] == Tiles.Wall)
                        continue;
                    int exists = 0;
                    foreach (Vector2 dir in Directions.all) {
                        if (map [i + (int)dir.x, j + (int)dir.y] != Tiles.Wall) {
                            exists++;
                        }
                    }
                    //如果exists==1则是三面环墙
                    if (exists != 1) {
                        continue;
                    }
                    done = false;
                    _regions [i, j] = 0;//变成墙
                    map [i, j] = Tiles.Wall;
                }
            }
        }
    }

    /*
     *保存区域索引
     * 
     */ 
    private void StartRegion() {
        currentRegion++;
    }

    /*
     * 雕塑点，设置这个点的类型,默认地板
     * 
     */ 
    private void Carve(Vector2 pos,Tiles type=Tiles.Floor) {
        int x = (int)pos.x, y = (int)pos.y;
        map [x, y] = Tiles.Floor;
        _regions [x,y] = currentRegion;
    }

    //dir是方向
    private bool CanCarve(Vector2 pos,Vector2 dir){
        Vector2 temp = pos + 3*dir;
        int x = (int)temp.x, y = (int)temp.y;
        //判断是否超过边界
        if (x < 0 || x > width || y < 0 || y > height) {
            return false;
        }
        //需要判断方向第二个单元的原因是cells中需要添加下一个cell
        //所以下一个cell要变为Floor,然后需要判断是否第二个单元是否为墙
        //如果不为墙，则第一个cell被变为Floor为，和第二个单元就连通了，不可行
        //判断第二个单元主要用来判断不能＆其他房间或走廊（regions）连通
        temp = pos + 2 * dir;
        x = (int)temp.x;
        y = (int)temp.y;
        //是墙则能雕刻迷宫
        return map [x, y] == Tiles.Wall;
    }

    private void AddJunction(Vector2 pos){
        map [(int)pos.x, (int)pos.y] = Tiles.Floor;
    }

    /*
     * 删除不需要的连接点
     */ 
    private bool IsRemove(List<int> merged,Dictionary<Vector2,List<int>> ConnectRegions,Vector2 connector,Vector2 pos){
        //不让连接器相连（包括斜向相连）
        if((connector-pos).SqrMagnitude() < 2){
            return true;
        }
        List<int> temp = ConnectRegions[pos];
        for(int i=0;i<temp.Count;i++){
            temp[i] = merged[temp[i]];
        }
        HashSet<int> set = new HashSet<int>(temp);
        //判断连接点是否和两个区域相邻，不然移除
        if(set.Count>1){
            return false;
        }
        //增加连接，使得地图连接不是单连通的
        if(Random.Range(0,extraConnectorChance)==0) AddJunction(pos);
        return true;
    }

    private void SetConnectCube(int i,int j){
        GameObject go = Instantiate (connect, new Vector3 (i, j, 1), Quaternion.identity) as GameObject;
        go.transform.SetParent (mapParent);
        go.layer = LayerMask.NameToLayer ("wall");
    }

    /*
     * 地图全部初始化为墙
     * 
     */ 
    private void InitMap(){
        for (int x = 0; x < width; x ++) {
            for (int y = 0; y < height; y ++) {
                map [x, y] = Tiles.Wall;
            }
        }
    }

    private void InstanceMap (){
        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                if (map [i, j] == Tiles.Floor) {
                    GameObject go = Instantiate (floor, new Vector3 (i, j, 1), Quaternion.identity) as GameObject;
                    go.transform.SetParent (mapParent);
                    //设置层级
                    go.layer = LayerMask.NameToLayer ("floor");
                } else if (map [i, j] == Tiles.Wall) {
                    GameObject go = Instantiate (wall, new Vector3 (i, j, 1), Quaternion.identity) as GameObject;
                    go.transform.SetParent (mapParent);
                    go.layer = LayerMask.NameToLayer ("wall");
                }
            }
        }
    }

}

效果图：

这个是一开始的生成房间的效果图：

下图是对地图空白部分进行迷宫填充：


下图是对迷宫进行连接点计算：

下图是对地图的区域进行连接：

最后是对地图中的死胡同进行消除：