C++实现随机生成迷宫地牢_C 语言

可以用这个地图核心做成一个无限迷宫类的游戏

main.cpp

// 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;
}

演示图：

以上所述就是本文的全部内容了，希望大家能够喜欢。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索c++
， 随机
迷宫地牢
c语言随机生成迷宫、随机迷宫生成算法、随机生成迷宫、c随机迷宫生成算法、随机地牢生成规则，以便于您获取更多的相关知识。

时间： 2024-09-12 16:30:12

C++实现随机生成迷宫地牢_C 语言的相关文章

基于C语言实现简单的走迷宫游戏_C 语言

本文实例讲述了C语言实现简单的走迷宫游戏的方法,代码完整,便于读者理解. 学数据结构时用"栈"写的一个走迷宫程序,实际上用到双向队列,方便在运行完毕后输出经过的点. #include <cstdio> #include <deque> #include <windows.h> using namespace std; class node { public: int x,y; int lastOpt; }; deque<node> sta

C/C++语言实现随机生成迷宫游戏的实例代码

迷宫相信大家都走过,毕竟书本啊啥啥啥的上面都会有迷宫,主要就是考验你的逻辑思维.那么我们学习C/C++也是需要学习到逻辑思维方式的,那今天我就来分享一下,如何用C/C++打造一个简单的随机迷宫游戏.(代码的话我只截取了如何创建迷宫的代码,如果想要全套代码的话可以加群:558502932,群内有很多C/C++学习资料提供学习,大家一起交流进步) 完整版的迷宫游戏效果如下: 代码如下: //创建迷宫 voidCreateMaze(intx,inty) { //定义4个方向 intdir[4][2]

解析四则表达式的编译过程及生成汇编代码_C 语言

1.前序这是编译原理的实验,自认为是上大学以来做过的最难的一个实验.实验用到的基础知识:C语言.数据结构.汇编(只需简单的了解).开发工具:VC 2.问题描述编译整数四则运算表达式,将整数四则运算表达式翻译为汇编语言代码.消除左递归后的文法:E→TE'E'→+TE' |εT→FT'T'→*FT' |εF→(E) | i消除左递归后的翻译模式:E ::=     T    {E'.i:=T.nptr}E'    {E.nptr:=E'.s}E'::=      + T  {E'1.i:=mknod

c语言生成随机uuid编码示例_C 语言

c语言生成随机uuid编码 复制代码 代码如下: #include <stdio.h>#include <stdlib.h> /** * Create random UUID * * @param buf - buffer to be filled with the uuid string */char *random_uuid( char buf[37] ){    const char *c = "89ab";    char *p = buf;    in

C++实现正态随机分布的方法_C 语言

高斯分布也称为正态分布(normal distribution) 常用的成熟的生成高斯分布随机数序列的方法由Marsaglia和Bray在1964年提出,C++版本如下: 复制代码 代码如下: #include <stdlib.h>#include <math.h> double gaussrand(){    static double V1, V2, S;    static int phase = 0;    double X;     if ( phase == 0 ) {

怎么通过C语言自动生成MAC地址_C 语言

最近在做虚拟机项目时,需要给创建的每一个虚拟机自动生成一个MAC地址,由于MAC地址为48位,而且格式是以:隔开的,所以下面我写了一个c程序,来自动生成MAC地址. 复制代码 代码如下: //   MAC.c#include<stdio.h>#include<stdlib.h>#include<time.h>#include<unistd.h> #define RANDOM(x) (rand()%x)#define MAC_ADDR_LENGTH 12#de

C/C++实现的游戏角色名称名字随机生成代码_C 语言

#ifndef __NAME_H__ #define __NAME_H__ class CName { public: CName(); virtual ~CName(); const char* GetName(); protected: void InitSurname(); void InitName(); char* m_pSurname_OneDimensional; char** m_ppSurname; // 姓 char* m_pName_OneDimensional; char

基于C语言实现的迷宫游戏代码_C 语言

本文实例讲述了基于C语言实现迷宫游戏的方法,代码备有较为详尽的注释,便于读者理解.通过该游戏代码可以很好的复习C语言的递归算法与流程控制等知识,相信对于学习游戏开发的朋友有一定的借鉴价值. 完整的实例代码如下: #include <graphics.h> #include <stdlib.h> #include <stdio.h> #include <conio.h> #include <dos.h> #define N 20/*迷宫的大小,可改

C语言/C++如何生成随机数_C 语言

本文分享了C语言/C++如何生成随机数的具体实现方法,供大家参考,具体内容如下 C语言/C++怎样产生随机数:这里要用到的是rand()函数, srand()函数,C语言/C++里没有自带的random(int number)函数. (1) 如果你只要产生随机数而不需要设定范围的话,你只要用rand()就可以了:rand()会返回一随机数值, 范围在0至RAND_MAX 间.RAND_MAX定义在stdlib.h, 其值为2147483647. 例如: #include<stdio.h> #i