[MM] 随机生成迷宫地牢

最新推荐文章于 2024-05-03 11:45:27 发布
最新推荐文章于 2024-05-03 11:45:27 发布
阅读量555 收藏 2
点赞数
分类专栏： module
// Author: FreeKnight 2014-09-02
#include "stdafx.h"
#include <iostream>
#include <string>
#include <random>
#include <cassert>
 
/*
简单逻辑流程描述：
将整个地图填满土
在地图中间挖一个房间出来
选中某一房间（如果有多个的话）的墙壁
确定要修建某种新元素
查看从选中的墙延伸出去是否有足够的空间承载新的元素
如果有的话继续，不然就返回第 3 步
从选中的墙处增加新的元素
返回第 3 步，直到地牢建设完成
在地图的随机点上安排上楼和下楼的楼梯
最后，放进去怪兽和物品
*/
//-------------------------------------------------------------------------------
// 暂时支持的最大的地图块个数
#define MAX_TILES_NUM    10000
 
// 房间的大小
#define MAX_ROOM_WIDTH   8
#define MAX_ROOM_HEIGHT  8
#define MIN_ROOM_WIDTH   4
#define MIN_ROOM_HEIGHT  4
 
// 房间和走廊的合计最大个数
#define DEFAULT_FEATURE_NUM  1000
 
// 尝试生成房间和走廊的测试次数（即步长）
#define MAX_TRY_TIMES    1000
 
// 默认创建房间的概率（100-该值则为创建走廊的概率）
#define DEFAULT_CREATE_ROOM_CHANCE   70
 
// 走廊长度
#define MIN_CORRIDOR_LEN     3
#define MAX_CORRIDOR_LEN     6
//-------------------------------------------------------------------------------
// 格子块
enum class Tile
{
     Unused,  // 没用的格子（土块）
     DirtWall,    // 墙壁
     DirtFloor,   // 房间地板
     Corridor,    // 走廊
     Door,    // 房门
     UpStairs,    // 入口
     DownStairs  // 出口
};
//-------------------------------------------------------------------------------
// 朝向
enum class Direction
{
     North,   // 北
     South,   // 南
     East,    // 东
     West,    // 西
};
//-------------------------------------------------------------------------------
class Map
{
public :
 
     Map():
         xSize(0), ySize(0),
         data() { }
 
     // 构造函数，全屏填土
     Map( int x, int y, Tile value = Tile::Unused):
         xSize(x), ySize(y),
         data(x * y, value) { }
 
     // 填充某块类型
     void SetCell( int x, int y, Tile celltype)
     {
         assert (IsXInBounds(x));
         assert (IsYInBounds(y));
 
         data[x + xSize * y] = celltype;
     }
 
     // 获取某块类型
     Tile GetCell( int x, int y) const
     {
         assert (IsXInBounds(x));
         assert (IsYInBounds(y));
 
         return data[x + xSize * y];
     }
 
     // 设置一块区域为指定类型块
     void SetCells( int xStart, int yStart, int xEnd, int yEnd, Tile cellType)
     {
         assert (IsXInBounds(xStart) && IsXInBounds(xEnd));
         assert (IsYInBounds(yStart) && IsYInBounds(yEnd));
 
         assert (xStart <= xEnd);
         assert (yStart <= yEnd);
 
         for ( auto y = yStart; y != yEnd + 1; ++y)
         {
             for ( auto x = xStart; x != xEnd + 1; ++x)
             {
                 SetCell(x, y, cellType);
             }
         }
     }
 
     // 判断一块是否在有效范围内
     bool IsXInBounds( int x) const
     {
         return x >= 0 && x < xSize;
     }
 
     // 判断一块是否在有效范围内
     bool IsYInBounds( int y) const
     {
         return y >= 0 && y < ySize;
     }
 
     // 判断一个区域是否已被使用过
     bool IsAreaUnused( int xStart, int yStart, int xEnd, int yEnd)
     {
         assert (IsXInBounds(xStart) && IsXInBounds(xEnd));
         assert (IsYInBounds(yStart) && IsYInBounds(yEnd));
 
         assert (xStart <= xEnd);
         assert (yStart <= yEnd);
 
         for ( auto y = yStart; y != yEnd + 1; ++y)
         {
             for ( auto x = xStart; x != xEnd + 1; ++x)
             {
                 if (GetCell(x, y) != Tile::Unused)
                 {
                     return false ;
                 }
             }
         }
 
         return true ;
     }
 
     // 判断一个地图块周围是否临接某种地图块
     bool IsAdjacent( int x, int y, Tile tile)
     {
         assert (IsXInBounds(x - 1) && IsXInBounds(x + 1));
         assert (IsYInBounds(y - 1) && IsYInBounds(y + 1));
 
         return (GetCell(x - 1, y) == tile || GetCell(x + 1, y) == tile ||
             GetCell(x, y - 1) == tile || GetCell(x, y + 1) == tile);
     }
 
     // 输出地图
     void Print() const
     {
         for ( auto y = 0; y != ySize; y++)
         {
             for ( auto x = 0; x != xSize; x++)
             {
                 switch (GetCell(x, y))
                 {
                 case Tile::Unused:
                     std::cout << " " ;
                     break ;
                 case Tile::DirtWall:
                     std::cout << "#" ;
                     break ;
                 case Tile::DirtFloor:
                     std::cout << "_" ;
                     break ;
                 case Tile::Corridor:
                     std::cout << "." ;
                     break ;
                 case Tile::Door:
                     std::cout << "+" ;
                     break ;
                 case Tile::UpStairs:
                     std::cout << "<" ;
                     break ;
                 case Tile::DownStairs:
                     std::cout << ">" ;
                     break ;
                 };
             }
 
             std::cout << std::endl;
         }
 
         std::cout << std::endl;
     }
 
private :
     // 地图总宽高
     int xSize, ySize;
     // 全部地图块数据
     std::vector<Tile> data;
};
//-------------------------------------------------------------------------------
class DungeonGenerator
{
public :
     int m_nSeed;     // 随机数种子
     int m_nXSize, m_nYSize;  // 地图最大宽高
     int m_nMaxFeatures;  // 房间和走廊的最大个数
     int m_nChanceRoom;   // 创建房间的概率【0,100】
     int m_nChanceCorridor;   // 创建走廊的概率【0,100】 该概率+创建房间的概率应当 = 100
 
     typedef std::mt19937 RngT;
public :
     DungeonGenerator( int XSize, int YSize ):
         m_nSeed(std::random_device()()),
         m_nXSize( XSize ), m_nYSize( YSize ),
         m_nMaxFeatures( DEFAULT_FEATURE_NUM ),
         m_nChanceRoom( DEFAULT_CREATE_ROOM_CHANCE )
     {
         m_nChanceCorridor = 100 - m_nChanceRoom;
     }
 
     Map Generate()
     {
         assert ( m_nMaxFeatures > 0 && m_nMaxFeatures <= DEFAULT_FEATURE_NUM);
         assert ( m_nXSize > 3 );
         assert ( m_nYSize > 3 );
 
         auto rng = RngT(m_nSeed);
         // step1: 满地图填土
         auto map = Map(m_nXSize, m_nYSize, Tile::Unused);
 
         MakeDungeon(map, rng);
 
         return map;
     }
 
private :
     // 获取随机int
     int GetRandomInt(RngT& rng, int min, int max) const
     {
         return std::uniform_int_distribution< int >(min, max)(rng);
     }
 
     // 获取随机方向
     Direction GetRandomDirection(RngT& rng) const
     {
         return Direction(std::uniform_int_distribution< int >( static_cast < int >(Direction::North), static_cast < int >(Direction::West) )(rng));
     }
 
     // 创建走廊
     bool MakeCorridor(Map& map, RngT& rng, int x, int y, int maxLength, Direction direction) const
     {
         assert (x >= 0 && x < m_nXSize);
         assert (y >= 0 && y < m_nYSize);
 
         assert (maxLength > 0 && maxLength <= std::max(m_nXSize, m_nYSize));
 
         // 设置走廊长度
         auto length = GetRandomInt(rng, MIN_CORRIDOR_LEN, maxLength);
 
         auto xStart = x;
         auto yStart = y;
 
         auto xEnd = x;
         auto yEnd = y;
 
         if (direction == Direction::North)
             yStart = y - length;
         else if (direction == Direction::East)
             xEnd = x + length;
         else if (direction == Direction::South)
             yEnd = y + length;
         else if (direction == Direction::West)
             xStart = x - length;
 
         // 检查整个走廊是否在地图内
         if (!map.IsXInBounds(xStart) || !map.IsXInBounds(xEnd) || !map.IsYInBounds(yStart) || !map.IsYInBounds(yEnd))
             return false ;
 
         // 检查走廊区域是否有被占用
         if (!map.IsAreaUnused(xStart, yStart, xEnd, yEnd))
             return false ;
 
         map.SetCells(xStart, yStart, xEnd, yEnd, Tile::Corridor);
 
         return true ;
     }
 
     // 创造房间
     bool MakeRoom(Map& map, RngT& rng, int x, int y, int xMaxLength, int yMaxLength, Direction direction) const
     {
         assert ( xMaxLength >= MIN_ROOM_WIDTH );
         assert ( yMaxLength >= MIN_ROOM_HEIGHT );
 
         // 创建的房间最小是4 * 4，随机出房间大小
         auto xLength = GetRandomInt(rng, MIN_ROOM_WIDTH, xMaxLength);
         auto yLength = GetRandomInt(rng, MIN_ROOM_HEIGHT, yMaxLength);
 
         auto xStart = x;
         auto yStart = y;
         auto xEnd = x;
         auto yEnd = y;
 
         // 根据房间朝向随机出房间起始和终结位置
         if (direction == Direction::North)
         {
             yStart = y - yLength;
             xStart = x - xLength / 2;
             xEnd = x + (xLength + 1) / 2;
         }
         else if (direction == Direction::East)
         {
             yStart = y - yLength / 2;
             yEnd = y + (yLength + 1) / 2;
             xEnd = x + xLength;
         }
         else if (direction == Direction::South)
         {
             yEnd = y + yLength;
             xStart = x - xLength / 2;
             xEnd = x + (xLength + 1) / 2;
         }
         else if (direction == Direction::West)
         {
             yStart = y - yLength / 2;
             yEnd = y + (yLength + 1) / 2;
             xStart = x - xLength;
         }
 
         // 要保证生成的房间一定四个点都在地图中
         if (!map.IsXInBounds(xStart) || !map.IsXInBounds(xEnd) || !map.IsYInBounds(yStart) || !map.IsYInBounds(yEnd))
             return false ;
 
         // 要保证房间所占用土地未被其他地占用
         if (!map.IsAreaUnused(xStart, yStart, xEnd, yEnd))
             return false ;
 
         // 周围种墙
         map.SetCells(xStart, yStart, xEnd, yEnd, Tile::DirtWall);
         // 房间内铺地板
         map.SetCells(xStart + 1, yStart + 1, xEnd - 1, yEnd - 1, Tile::DirtFloor);
 
         return true ;
     }
 
 
     // 创建一个房间或者走廊
     bool MakeRoomOrCorridor(Map& map, RngT& rng, int x, int y, int xmod, int ymod, Direction direction) const
     {
         //  随机选择创建类型（房间或者走廊）
         auto chance = GetRandomInt(rng, 0, 100);
 
         if (chance <= m_nChanceRoom)
         {
             // 创建房间
             if (MakeRoom(map, rng, x + xmod, y + ymod, MAX_ROOM_WIDTH, MAX_ROOM_HEIGHT, direction))
             {
                 // 当前位置设置门
                 map.SetCell(x, y, Tile::Door);
 
                 // 删除门旁边的墙壁，改建为墙壁
                 map.SetCell(x + xmod, y + ymod, Tile::DirtFloor);
 
                 return true ;
             }
 
             return false ;
         }
         else
         {
             // 创建走廊
             if (MakeCorridor(map, rng, x + xmod, y + ymod, MAX_CORRIDOR_LEN, direction))
             {
                 // 当前位置设置门
                 map.SetCell(x, y, Tile::Door);
 
                 return true ;
             }
 
             return false ;
         }
     }
 
 
     // 对全地图进行随机处理生成房间和走廊
     bool MakeRandomFeature(Map& map, RngT& rng) const
     {
         for ( auto tries = 0 ; tries != MAX_TRY_TIMES; ++tries)
         {
             // 获取一个有意义的地形格
             int x = GetRandomInt(rng, 1, m_nXSize - 2);
             int y = GetRandomInt(rng, 1, m_nYSize - 2);
 
             // 获取一个随机墙壁 或者 走廊
             if (map.GetCell(x, y) != Tile::DirtWall && map.GetCell(x, y) != Tile::Corridor)
                 continue ;
 
             // 保证该墙壁和走廊不临接门
             if (map.IsAdjacent(x, y, Tile::Door))
                 continue ;
 
             // 找个临接墙壁或者走廊的格子 创建新房间或者走廊
             if (map.GetCell(x, y+1) == Tile::DirtFloor || map.GetCell(x, y+1) == Tile::Corridor)
             {
                 if (MakeRoomOrCorridor(map, rng, x, y, 0, -1, Direction::North))
                     return true ;
             }
             else if (map.GetCell(x-1, y) == Tile::DirtFloor || map.GetCell(x-1, y) == Tile::Corridor)
             {
                 if (MakeRoomOrCorridor(map, rng, x, y, 1, 0, Direction::East))
                     return true ;
             }
             else if (map.GetCell(x, y-1) == Tile::DirtFloor || map.GetCell(x, y-1) == Tile::Corridor)
             {
                 if (MakeRoomOrCorridor(map, rng, x, y, 0, 1, Direction::South))
                     return true ;
             }
             else if (map.GetCell(x+1, y) == Tile::DirtFloor || map.GetCell(x+1, y) == Tile::Corridor)
             {
                 if (MakeRoomOrCorridor(map, rng, x, y, -1, 0, Direction::West))
                     return true ;
             }
         }
 
         return false ;
     }
 
     // 随机制作出入口
     bool MakeRandomStairs(Map& map, RngT& rng, Tile tile) const
     {
         auto tries = 0;
         auto maxTries = MAX_TILES_NUM;
 
         for ( ; tries != maxTries; ++tries)
         {
             // 随机获取一个非边缘的点
             int x = GetRandomInt(rng, 1, m_nXSize - 2);
             int y = GetRandomInt(rng, 1, m_nYSize - 2);
 
             // 如果周围没有地板并且没有走廊（通路）的话，直接放弃
             if (!map.IsAdjacent(x, y, Tile::DirtFloor) && !map.IsAdjacent(x, y, Tile::Corridor))
                 continue ;
 
             // 周围不允许有门
             if (map.IsAdjacent(x, y, Tile::Door))
                 continue ;
 
             map.SetCell(x, y, tile);
 
             return true ;
         }
 
         return false ;
     }
 
     // 随机生成地牢
     bool MakeDungeon(Map& map, RngT& rng) const
     {
         // step2 : 在正中间创建一个房间
         MakeRoom(map, rng, m_nXSize / 2, m_nYSize / 2, MAX_ROOM_WIDTH, MAX_ROOM_HEIGHT, GetRandomDirection(rng));
 
         for ( auto features = 1; features != m_nMaxFeatures; ++features)
         {
             if (!MakeRandomFeature(map, rng))
             {
                 std::cout << "生成地牢已满。（当前房间和走廊个数为： " << features << "）." << std::endl;
                 break ;
             }
         }
 
         // 创建随机入口点
         if (!MakeRandomStairs(map, rng, Tile::UpStairs))
             std::cout << "创建入口点失败！" << std::endl;
 
         // 创建随机出口点
         if (!MakeRandomStairs(map, rng, Tile::DownStairs))
             std::cout << "创建出口点失败！" << std::endl;
 
         return true ;
     }
};
 
 
#include <windows.h>
void ResetConsoleSize()
{
     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
     // 获取标准输出设备句柄
     CONSOLE_SCREEN_BUFFER_INFO bInfo;   // 窗口缓冲区信息
     GetConsoleScreenBufferInfo(hOut, &bInfo );
     COORD size = {1000, 800};
     SetConsoleScreenBufferSize(hOut,size);  // 重新设置缓冲区大小
     SMALL_RECT rc = {0,0, 1000-1, 800-1};   // 重置窗口位置和大小
     SetConsoleWindowInfo(hOut, true ,&rc);
}
void FlushReadme()
{
     std::cout<< "=================================" << std::endl;
     std::cout<< " < 表示入口 " << std::endl;
     std::cout<< " > 表示出口 " << std::endl;
     std::cout<< " _ 下划线表示地板 " << std::endl;
     std::cout<< " # 表示墙壁 " << std::endl;
     std::cout<< " . 点表示走廊 " << std::endl;
     std::cout<< " + 表示门 " << std::endl;
     std::cout<< "纯黑表示啥都没有，是障碍" << std::endl;
     std::cout<< "=================================" << std::endl;
}
 
int main()
{
     ResetConsoleSize();
     FlushReadme();
 
     DungeonGenerator* pGenerator = new DungeonGenerator( 150, 50 );
     if ( pGenerator == NULL )
         return -1;
     auto map = pGenerator->Generate();
     map.Print();
 
     int n;
     std::cin >> n;
}
生为红颜
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity随机方向的代码_unity3d随机地牢生成代码
weixin_33240229的博客
01-14 578
做完了以后我又想了一下，发现其实根本不需要这么麻烦，果然demo里的代码对我的思路影响还是有点大。demo里的c++代码为了展示地牢的墙壁，在二维数组中加上了wall这个东西表示墙壁。事实上用unity来做的话，只需要考虑地板的位置，然后根据邻接的地板有没有东西来判断是否生成墙壁即可。首先用一个枚举类型代表地牢迷宫中的各个元素：public enumTile{Default,DirtFloor,/...
随机地牢设计 - Random Dungeon Design
08-20
一篇英文的关于随机地牢(Dungeon)迷宫的设计
（原创 untiy） 随机地牢生成算法（一）
weixin_30883311的博客
03-06 588
转载注明出处：http://www.cnblogs.com/m-f-s/p/6509135.html 根据http://www.gamelook.com.cn/2015/12/239245 翻译整理 进行实现： 我最终在unity里面随机出的地牢，因为我不需要走廊所以就没有做： 生成房间 首先，你要生成一些宽和高不同的房间，随机地放在一个圈内。TKdev的...
Rot.js 随机地牢，迷宫地图生成
weixin_41604051的博客
02-10 1018
js 随机地图生成插件
unity3d随机地牢生成代码
aiwanliao4788的博客
12-14 719
现在也是处于失业状态，碰巧看到个面试题是要用unity生成个随机地牢，就把做题过程中的思路和代码记录一下吧。 做完了以后我又想了一下，发现其实根本不需要这么麻烦，果然demo里的代码对我的思路影响还是有点大。demo里的c++代码为了展示地牢的墙壁，在二维数组中加上了wall这个东西表示墙壁。事实上用unity来做的话，只需要考虑地板的位置，然后根据邻接的地板有没有东西来判断是否生...
C++实现随机生成迷宫地牢
09-03
主要介绍了C++实现随机生成迷宫地牢的相关资料及代码分享，推荐给大家，有需要的小伙伴可以参考下。
地牢生成器
02-15
在IT行业中，地牢生成器通常指的是用于创建地下城或者迷宫结构的游戏设计工具，它可以帮助游戏开发者快速构建复杂而有趣的关卡。"地牢生成器"这个标题可能指向一个软件项目或者开源代码库，专注于生成随机的地牢地图...
flx-dungeon-generator:Ha HaxeFlixel的随机地牢生成器
05-15
《HaxeFlixel随机地牢生成器：flx-dungeon-generator详解》 在游戏开发领域，随机地牢生成器是一种常见的元素，特别是在Roguelike类型游戏中，它为玩家提供每局游戏的新鲜感和无限探索的可能性。本文将深入探讨一款...
Unity-RandomDungeonGenerator:随机地牢生成器的 Unity 端口 (C#) by drow
06-23
unity-RandomDungeonGenerator drow 随机地牢生成器的 Unity 端口（C#）： : 工作正在进行中 学分 图块表： ://opengameart.org/content/instant-dungeon-v14-art-pack 去做 一旦修复了所有错误，让我们开始面向对象！ 单元测试
Unity 自动迷宫生成demo
09-22
Unity 迷宫插件，通过配置自动化生成迷宫地图，适合探险类游戏的开发
Unity版本的随机迷宫.rar
03-29
可以支持理论无限大的正方形随机迷宫生成,适用于UNITY的所有版本,使用方法超级简单.需要的朋友可以下载验证下,绝对不会后悔.
rooms-and-mazes:随机地牢生成器的动画演示代码
07-05
这是描述的随机地牢生成算法的动画演示的代码。 欢迎您使用此代码，但它实际上并不是地牢生成器的最佳参考。 将它切成动画形式会增加大量的复杂性，而且我几乎没有考虑到良好的软件工程。 如果你想要一个更简洁的实现，看看是在我的 roguelike 。 这是一个很好的，紧凑的 300 行干净代码。
Unity游戏随机地图生成系统
03-05
类似元气骑士的随机地牢生产,包含代码与场景!方便快速开发随机场景游戏,适合新手学习与参考,非常不错的,赶快来下载吧
随机迷宫地形脚本
07-16
Unity3D随机迷宫脚本（C#），场景中随机产生自然的迷宫地形。详情请看压缩包中的脚本说明。解压码：ChengHai37
c++游戏小技巧16：实例1（地牢生成算法）
最新发布
zzb的博客
05-03 1152
实例1之被代码薄纱
unity 使用 随机普里姆算法(Randomized Prim) 生成迷宫
weixin_30254435的博客
09-10 470
unity使用随机普里姆算法随机生成迷宫 下午闲着没事，继续上次的迷宫算法，鼓捣了一下Randomized Prim 效果图如下 参考如下文献： https://en.wikipedia.org/wiki/Maze_generation_algorithm 话不多说，直接贴代码。 1 using System.Collections; 2 using Syst...
随机迷宫
5431的专栏
07-30 1459
最近写unity的一个游戏，有一关要实现随机迷宫地图，就查了查随机迷宫实现的算法 随机迷宫设置一个地图，假设地图中都是墙，咱们要种墙中挖出一个通道，这样就可以实现一个随机迷宫。 在每个位置把空间用十字分成四个部分，若是不连通其他通道就接着挖。 #include #include #include #include #define MAZE_MAX 50 char map[MAZE_M
【用unity实现100个游戏之16】Unity程序化生成随机2D地牢游戏3（附项目源码）
向宇
11-21 443
前两期我们使用了随机游走算法已经实现了地牢的生成，本期再说另外一种生成地牢的方法，使用二叉空间分割算法，可以用来生成规则的房间或者不规则的地牢。
（原创 untiy） 随机地牢生成算法（二）
weixin_30642869的博客
03-06 438
分散的房间，以及实现三角剖分（Delaunay Triangulation）+图形 //TODO 转载于:https://www.cnblogs.com/m-f-s/p/6509173.html
python随机生成迷宫
03-03
Python可以使用随机算法来生成迷宫。下面是一个简单的示例代码，用于生成一个随机的迷宫： ```python import random def generate_maze(width, height): # 创建一个二维数组表示迷宫 maze = [['#'] * (2 * width...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值