C++ 迷宫游戏实现代码

2024-10-20 10:59:03

C++ 迷宫游戏实现代码

题目通过让游戏角色自动寻找迷宫出口，走出迷宫，来练习C++面向对象之封装的基础知识。迷宫图如下所示，其中X表示墙。

1、程序分析

走出去的原理：遵循右手规则或左手规则。右手扶墙走，就会走出迷宫，反之，亦然。

　　step1 创建迷宫类，打印出迷宫地图。

　step2 创建走迷宫的人的类。

2、程序实现

MazeMap.h

#ifndef MAZEMAP_H
#define MAZEMAP_H

#include <iostream>
#include <Windows.h>  //COORD

//在二维数组里，1代表墙，0代表路
#define WALL 1
#define ROAD 0

class MazeMap
{
public:
  MazeMap(char wall = 'X');
  ~MazeMap();
  /*设置迷宫地图*/
  void setMazeMap(int *mazemap, int row, int col);
  void pintMazeMap();
  int** getMap();             //返回地图二维数组指针
  const char m_cRoad;           //常数据成员：路
  void setExitPosition(int x,int y);   //设置迷宫出口
  COORD m_COORDExitPostion;  //迷宫的出口
private:
  const char m_cWall;     //常数据成员：墙
  int** m_pMap;        //指向迷宫地图二维数组的二级指针
  int m_iMapRow;       //二维数组的行数
  int m_iMapCol;       //二维数组的列数
};

#endif

MazeMap.cpp

#include "MazeMap.h"

/**************************
*函数名称：MazeMap()
*函数功能：构造函数，初始化参数
*函数参数：wall 墙的表示符号
*修改时间：2016.7.18
***************************/
MazeMap::MazeMap(char wall):m_cWall(wall),m_cRoad(' ')
{
  m_pMap = NULL;
}
/*************************
*函数名称：~MazeMap()
*函数功能：析构函数，释放动态申请的内存空间
*修改时间：2016.7.18
**************************/
MazeMap::~MazeMap()
{
  if(m_pMap)
  {
    for(int i = 0; i < m_iMapRow; i++)
    {
      delete m_pMap[i];
      m_pMap[i] = NULL;
    }
    delete m_pMap;
  }
}
/********************************
*函数名称：setMazeMap()
*函数功能：设置迷宫地图，传递参数
*函数参数：*mazemap 存储地图数据的二维数组的指针
*      row   二维数组的行数
*      col   二维数组的列数
*修改时间：2016.7.18
**********************************/
void MazeMap::setMazeMap(int *mazemap, int row, int col)
{
  m_iMapRow = row;
  m_iMapCol = col;
  //为存储迷宫地图的二维数组动态分配内存空间
  m_pMap = new int*[m_iMapRow];    //分配m_iMapRow个存储int类型指针的内存空间
  for(int i = 0; i < m_iMapRow; i++)
    m_pMap[i] = new int[m_iMapCol]; //分配m_iMapCol个存储int类型的内存空间

  //将二维数组迷宫地图的数据拷贝给二级指针
  for(int i = 0; i < m_iMapRow; i++)
  {
    for(int j = 0; j < m_iMapCol; j++)
    {
      m_pMap[i][j] = *mazemap;
      mazemap++;
    }
  }
}
/************************************************
*函数名称：pintMazeMap()
*函数功能：打印迷宫地图
*修改时间：2016.7.18
*************************************************/
void MazeMap::pintMazeMap()
{
  system("cls");
  for(int i = 0; i < m_iMapRow; i++)
  {
    for(int j = 0; j < m_iMapCol; j++)
    {
      if(m_pMap[i][j])      //数组元素为1，则打印代表墙的字符
        std::cout << m_cWall;
      else            //否则，打印代表路的字符
        std::cout << m_cRoad;
    }
    std::cout << std::endl;
  }
}

/************************************************
*函数名称：getMap()
*函数功能：返回地图二维数组指针
*返 回 值：二级指针
*修改时间：2016.7.18
*************************************************/
int** MazeMap::getMap()
{
  return m_pMap;
}
/************************************************
*函数名称：setExitPosition()
*函数功能：设置迷宫的出口
*函数参数：x 迷宫出口位置所在行数
      y 迷宫出口位置所在列数
*修改时间：2016.7.18
*************************************************/
void MazeMap::setExitPosition(int x, int y)
{
  m_COORDExitPostion.X = x;
  m_COORDExitPostion.Y = y;
}

MazeMan.h

#ifndef MAZEMAN_H
#define MAZEMAN_H

#include <Windows.h>
#include "MazeMap.h"

enum direction{U,D,L,R};

class MazeMan
{
public:
  MazeMan(char man = 'T',char manface = R);
  void setPosition(int x, int y);   //设置游戏角色位置
  void setMap(MazeMap *map);     //设置地图对象
  bool walkUp();           //向上走
  bool walkDown();          //向下走
  bool walkLeft();          //向左走
  bool walkRight();          //向右走
  void moveForward(direction direct); //根据传入的方向让游戏角色前进一步
  void start();            //游戏开始函数
private:
  char m_cMan;            //代表游戏角色的字符
  char m_cManFace;          //游戏角色的朝向
  int m_iSteps;            //记录游戏角色已经走的步数
  COORD m_COORDManCurrentPosition;  //游戏角色的当前位置
  MazeMap *m_pMap;          //地图对象
};
#endif

MazeMan.cpp

#include "MazeMan.h"

/*************************
*函数名称：MazeMan()
*函数功能：构造函数，初始化数据成员
*函数参数：man 表示游戏角色的字符
      manface 游戏角色的朝向
*修改时间：2016.7.18
**************************/
MazeMan::MazeMan(char man,char manface)
{
  m_cMan = man;
  m_cManFace = manface;
  m_iSteps = 0;
}
/*******************************
*函数名称：setMap()
*函数功能：设置地图对象中的地图
*函数参数：*map 地图对象的指针
*修改时间：2016.7.18
********************************/
void MazeMan::setMap(MazeMap *map)
{
  m_pMap = map;
}

/******************************
*函数名称：setPosition()
*函数功能：设置游戏角色位置
*函数参数：x 角色所在位置的横坐标
      y 角色所在位置的纵坐标
*修改时间：2016.7.18
********************************/
void MazeMan::setPosition(int x, int y)
{
  unsigned long numWritten;
  //获得命令行窗口的窗口句柄
  HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  m_COORDManCurrentPosition.X = x;
  m_COORDManCurrentPosition.Y = y;
  //在指定坐标位置填充指定的字符,这里我们在游戏角色的当前位置填充代表游戏角色的字符，使游戏角色采出现
  FillConsoleOutputCharacter(handle,m_cMan,1,m_COORDManCurrentPosition,&numWritten);
  //参数说明：控制台屏幕缓冲区句柄，要向控制台缓冲区写入的字符；应写入的字符单元数；
  //一个COORD结构，它指定字符的字符是要写的第一个单元格的坐标；
  //指向接收的实际写入控制台屏幕缓冲区的字符数的变量的指针。
}
/************************************************
*函数名称：moveForward()
*函数功能：根据传入的方向让游戏角色前进一步
*函数参数：direct 移动的方向
*修改时间：2016.7.18
*************************************************/
void MazeMan::moveForward(direction direct)
{
  unsigned long numWritten;
  //获取命令行窗口的窗口句柄
  HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
  //在指定坐标位置填充指定的字符,这里我们在游戏角色的当前位置填充空格，使游戏角色消失
  FillConsoleOutputCharacter(handle,m_pMap->m_cRoad,1,m_COORDManCurrentPosition,&numWritten);
  switch(direct)
  {
  case U:
    m_COORDManCurrentPosition.Y -= 1;
    break;
  case D:
    m_COORDManCurrentPosition.Y += 1;
    break;
  case L:
    m_COORDManCurrentPosition.X -= 1;
    break;
  case R:
    m_COORDManCurrentPosition.X += 1;
    break;
  default:
    break;
  }
  //游戏角色坐标更新，在新的坐标
  FillConsoleOutputCharacter(handle,m_cMan,1,m_COORDManCurrentPosition,&numWritten);
  //移动完成后跟新游戏角色的朝向
  m_cManFace = direct;
}

/************************************************
*函数名称：walkUp()
*函数功能：向上走一步，若成功，则返回ture；若失败，则返回false
*修改时间：2016.7.18
*************************************************/
bool MazeMan::walkUp()
{
  if(m_pMap->getMap()[m_COORDManCurrentPosition.Y - 1][m_COORDManCurrentPosition.X])
    return false;
  else
    moveForward(U);
    return true;
}
/************************************************
*函数名称：walkDown()
*函数功能：向下走一步，若成功，则返回ture；若失败，则返回false
*修改时间：2016.7.18
*************************************************/
bool MazeMan::walkDown()
{
  if(m_pMap->getMap()[m_COORDManCurrentPosition.Y + 1][m_COORDManCurrentPosition.X])
    return false;
  else
    moveForward(D);
    return true;
}
/************************************************
*函数名称：walkLeft()
*函数功能：向左走一步，若成功，则返回ture；若失败，则返回false
*修改时间：2016.7.18
*************************************************/
bool MazeMan::walkLeft()
{
  if(m_pMap->getMap()[m_COORDManCurrentPosition.Y][m_COORDManCurrentPosition.X - 1])
    return false;
  else
    moveForward(L);
    return true;
}
/************************************************
*函数名称：walkRight()
*函数功能：向右走一步，若成功，则返回ture；若失败，则返回false
*修改时间：2016.7.18
*************************************************/
bool MazeMan::walkRight()
{
  if(m_pMap->getMap()[m_COORDManCurrentPosition.Y][m_COORDManCurrentPosition.X + 1])
    return false;
  else
    moveForward(R);
    return true;
}
/************************************************
*函数名称：start()
*函数功能：游戏开始函数
*修改时间：2016.7.18
*************************************************/
void MazeMan::start()
{
  while(true)
  {
    m_pMap->pintMazeMap();
    switch(m_cManFace)
    {
    case U:
      //游戏角色朝上时，先向右，再向上，再向左，最后向下（右手原则）
      walkRight() || walkUp() || walkLeft() || walkDown();
      break;
    case D:
      walkLeft() || walkDown() || walkRight() || walkUp();
      break;
    case L:
      walkUp() || walkLeft() || walkDown() || walkRight();
      break;
    case R:
      walkDown() || walkRight() || walkUp() || walkLeft();
      break;
    default:
      break;
    }
    m_iSteps++;
    if(m_COORDManCurrentPosition.X == m_pMap->m_COORDExitPostion.X && m_COORDManCurrentPosition.Y == m_pMap->m_COORDExitPostion.Y)
      break;
    std::cout << "已经走了" << m_iSteps - 1 << "步";
    Sleep(500);
  }
}

Main.cpp

#include "MazeMap.h"
#include "MazeMan.h"

#define MapRow 11    //迷宫地图的行数
#define MapCol 11    //迷宫地图的列数

int main()
{
  //定义并初始化存储地图数据的二维数组
  int map[MapRow][MapCol] = {
    {WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL},
    {WALL, ROAD, ROAD, ROAD, WALL, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD},
    {WALL, ROAD, WALL, WALL, WALL, ROAD, WALL, WALL, WALL, ROAD, WALL},
    {WALL, ROAD, ROAD, ROAD, WALL, ROAD, ROAD, ROAD, WALL, ROAD, WALL},
    {WALL, ROAD, WALL, ROAD, WALL, ROAD, WALL, ROAD, WALL, WALL, WALL},
    {WALL, ROAD, WALL, ROAD, ROAD, ROAD, WALL, ROAD, WALL, ROAD, WALL},
    {WALL, ROAD, WALL, WALL, WALL, ROAD, WALL, WALL, WALL, ROAD, WALL},
    {WALL, ROAD, WALL, ROAD, WALL, ROAD, ROAD, ROAD, WALL, ROAD, WALL},
    {WALL, WALL, WALL, ROAD, WALL, WALL, WALL, ROAD, WALL, ROAD, WALL},
    {ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, WALL},
    {WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL}
  };
  //从堆中实例化地图对象
  MazeMap *mm = new MazeMap();
  mm->setMazeMap(&map[0][0],MapRow,MapCol);
  mm->setExitPosition(10,1);
  mm->pintMazeMap();
  //从堆中实例化游戏角色对象
  MazeMan *man = new MazeMan();
  //设置角色起始位置
  man->setPosition(0,9);
  //设置游戏要走的地图
  man->setMap(mm);
  //用new的方式从堆中实例化的对象，使用完毕之后需要手动释放内存
  man->start();
  delete mm;
  mm = NULL;
  delete man;
  man = NULL;
  std::cout << "闯关成功！" << std::endl;
  system("pause");
}

3、运行结果

T代表人

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

C语言使用广度优先搜索算法解决迷宫问题（队列）

本文实例讲述了C语言使用广度优先搜索算法解决迷宫问题.分享给大家供大家参考,具体如下: 变量 head 和 tail 是队头和队尾指针, head 总是指向队头, tail 总是指向队尾的下一个元素.每个点的 predecessor 成员也是一个指针,指向它的前趋在 queue 数组中的位置.如下图所示: 广度优先是一种步步为营的策略,每次都从各个方向探索一步,将前线推进一步,图中的虚线就表示这个前线,队列中的元素总是由前线的点组成的,可见正是队列先进先出的性质使这个算法具有了广度优先的特点.广
C语言单链队列的表示与实现实例详解

1.概述: C语言的队列(queue),是指先进先出(FIFO, First-In-First-Out)的线性表.在具体应用中通常用链表或者数组来实现.队列只允许在后端(称为rear)进行插入操作,在前端(称为front)进行删除操作. 而单链队列使用链表作为基本数据结果,因此不存在伪溢出的问题,队列长度也没有限制.但插入和读取的时间代价会比较高 2.实例代码: /* 单链队列--队列的链式存储结构 */ typedef struct QNode { QElemType data; struct
深入浅析C语言中堆栈和队列

1.堆和栈 (1)数据结构的堆和栈堆栈是两种数据结构. 栈(栈像装数据的桶或箱子):是一种具有后进先出性质的数据结构,也就是说后存放的先取,先存放的后取.这就如同要取出放在箱子里面底下的东西(放入的比较早的物体),首先要移开压在它上面的物体(放入的比较晚的物体). 堆(堆像一棵倒过来的树):是一种经过排序的树形数据结构,每个结点都有一个值.通常所说的堆的数据结构,是指二叉堆.堆的特点是根结点的值最小(或最大),且根结点的两个子树也是一个堆.由于堆的这个特性,常用来实现优先队列,堆的存取是随意,
C语言循环队列的表示与实现实例详解

1.概述: C语言的队列(queue),是先进先出(FIFO, First-In-First-Out)的线性表数据结构.在具体应用中通常用链表或者数组来实现.队列只允许在后端(称为rear)进行插入操作,在前端(称为front)进行删除操作. 循环队列可以更简单的防止伪溢出的发生,但是队列大小是固定的. 2.实例代码: /* 队列的顺序存储结构(循环队列) */ #define MAX_QSIZE 5 /* 最大队列长度+1 */ typedef struct { QElemType *base
使用C语言来解决循环队列问题的方法

题目描述: 大家都知道数据结构里面有一个结构叫做循环队列.顾名思义,这是一个队列,并且是循环的.但是现在,淘气的囧哥给这个循环队列加上了一些规矩,其中有5条指令: (1) Push K, 让元素K进队列. (2) Pop,对头元素出队列. (3) Query K,查找队列中第K个元素,注意K的合法性. (4) Isempty,判断队列是否为空. (5) Isfull,判断队列是否已满. 现在有N行指令,并且告诉你队列大小是M. 输入: 第一行包含两个整数N和M.1<=N,M<=100000.
使用C/C++语言生成一个随机迷宫游戏

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

本文以实例形式描述了C++实现迷宫算法.本例中的迷宫是一个矩形区域,它有一个入口和一个出口.在迷宫的内部包含不能穿越的墙或障碍.障碍物沿着行和列放置,它们与迷宫的矩形边界平行.迷宫的入口在左上角,出口在右下角本实例迷宫算法的功能主要有: 1.自动生成10*10迷宫图 2.判断是否有迷宫出口,并且画出路线图具体实现代码如下: # include <iostream> # include <list> # include <sys/timeb.h> # include
详解数据结构C语言实现之循环队列

本文讲的是循环队列,首先我们必须明白下面几个问题循环队列的基础知识 1.循环队列需要几个参数来确定循环队列需要2个参数,front和rear 2.循环队列各个参数的含义 (1)队列初始化时,front和rear值都为零: (2)当队列不为空时,front指向队列的第一个元素,rear指向队列最后一个元素的下一个位置: (3)当队列为空时,front与rear的值相等,但不一定为零: 3.循环队列入队的伪算法 (1)把值存在rear所在的位置: (2)rear=(rear+1)%maxsize
优先队列(priority_queue)的C语言实现代码

优先队列(priority_queue)和一般队列(queue)的函数接口一致,不同的是,优先队列每次出列的是整个队列中最小(或者最大)的元素. 本文简要介绍一种基于数组二叉堆实现的优先队列,定义的数据结构和实现的函数接口说明如下: 一.键值对结构体:KeyValue 复制代码代码如下: // =============KeyValue Struct==================================typedef struct key_value_struct KeyValu
C++实现随机生成迷宫地牢

可以用这个地图核心做成一个无限迷宫类的游戏 main.cpp // Author: FreeKnight 2014-09-02 #include "stdafx.h" #include <iostream> #include <string> #include <random> #include <cassert> /* 简单逻辑流程描述: 将整个地图填满土在地图中间挖一个房间出来选中某一房间(如果有多个的话)的墙壁确定要修建某种新
C++ 自定义栈实现迷宫求解

C++ 自定义栈实现迷宫求解一:迷宫求解是一个锻炼我们的算法求解能力的问题,它的实现方法有很多:今天我们就介绍其中的用栈求解的方法. 二:什么是栈: 大家应该都有往袋子里装东西的经历,在往袋子里装满东西之后,当我们去取的时候,总是先从最后放进去的东西的地方去取.也就是后进先出(FILO).虽然栈的单向性用起来会没有链表那样可以在任意位置对数据进行操作,但是正因为如此栈也带来了很大的方便. 三:迷宫求解现在我们要在下面的迷宫寻找一条可行的路径 1 1 1 1 1 1 1 1 1 1 1 0
C语言数据结构中求解迷宫问题实现方法

C语言数据结构中求解迷宫问题实现方法在学习数据结构栈的这一节遇到了求迷宫这个问题,拿来分享一下~ 首先求迷宫问题通常用的是"穷举求解" 即从入口出发,顺某一方向试探,若能走通,则继续往前走,否则原路返回,换另一个方向继续试探,直至走出去. 我们可以先建立一个8*8的迷宫其中最外侧为1的是墙 int mg[M+2][N+2]={ {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,

C++ 迷宫游戏实现代码

相关推荐

随机推荐