C++ 迷宫游戏

已于 2023-08-28 17:03:59 修改
阅读量1.8w 收藏 208
点赞数 30
分类专栏： C++ 文章标签： 游戏
于 2018-12-26 15:00:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43675051/article/details/85262289
版权
介绍

本程序是根据广度优先遍历算法的思想设计的一款迷宫游戏，游戏设计了两种模式一种自动游戏模式，一种手动模式。因为项目在 Linux 开发，需要在 Windows 开发的，请查看源代码中需要修改地方的备注。

截图

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码
#include <iostream>
#include <cstdlib>			//标准库
#include <unistd.h>			//延时函数
#include <stdio.h>			//getchar	
#include <ctime>			
#include <termios.h>		//终端设置

#define MAX_X 20
#define MAX_Y 30
bool flag = false;
bool slow = false;
bool autogame = true;

using namespace std;

int maze[MAX_X][MAX_Y];		//迷宫

//路线栈
class stack_of_maze{
private:
	//记录迷宫坐标
	struct node
	{
		int x;
		int y;
		char direction;  	//上一步路径（如何来的）
		node* next;
	};
	node* head;
public:
	stack_of_maze(){
		head = NULL;
	}

	~stack_of_maze(){
		node* p = head;
		while(head!=NULL){
			head = head->next;
			delete p;
			p = head;
		}
	}

	//压栈
	void push(int xx,int yy,char ddirection){
		node* new_node = new node;
		if(new_node!=NULL){
			new_node->x = xx;
			new_node->y = yy;
			new_node->direction = ddirection;
			new_node->next = NULL;

			if(head==NULL)
				head = new_node;
			else{
				new_node->next = head;
				head = new_node;
			}
		}
		else
			cout<<"内存分配失败"<<endl;

	}

	//出栈
	node* pop(int& xx,int& yy){
		if(head!=NULL){
			node* p = head;
			head = head->next;
			xx = p->x;
			yy = p->y;
			delete p;
		}
		return head;
	}

	void print(){
		if(head!=NULL){
			node* p = head;
			while(p!=NULL){
				cout<<" "<<p->x<<" "<<p->y<<" "<<p->direction<<endl;
				p = p->next;
			}
		}
		else
			cout<<"栈为空，打印失败"<<endl;
	}
};

//创建迷宫
void createMaze(){
	int maxway = MAX_X * MAX_Y;		//最大通路
	int x,y;

	for(x=0;x<MAX_X;x++)
		for(y=0;y<MAX_Y;y++)
			maze[x][y] = 1;			//先填充迷宫

	srand((unsigned)time(NULL));	//随机函数种子，以时间为参数
	for(int i=0;i<maxway;i++)		//随机构建迷宫通路
	{
		x = rand() % (MAX_X-2) + 1;
		y = rand() % (MAX_Y-2) + 1;
		maze[x][y] = 0;
	}	

	maze[1][1] = 0; 				//入口
	maze[MAX_X-2][MAX_Y-2] = 0;		//出口

	maze[0][1] = 3;
 	maze[MAX_X-1][MAX_Y-2] = 0;
}

//输出迷宫
void printMaze(){
	int x,y;
	system("clear");				//windows下使用system("cls")
	//cout<<endl;
	for(x=0;x<MAX_X;x++)
	{
		for(y=0;y<MAX_Y;y++)
		{
			if(maze[x][y]==0){cout<<"  ";continue;}		//通路
			if(maze[x][y]==1){cout<<"■";continue;}		//墙
			if(maze[x][y]==2){cout<<"×";continue;}		//死胡同
			if(maze[x][y]==3){cout<<"↓";continue;}		//向下走
			if(maze[x][y]==4){cout<<"→";continue;}
			if(maze[x][y]==5){cout<<"←";continue;}
			if(maze[x][y]==6){cout<<"↑";continue;}
			if(maze[x][y]==7){cout<<"※";continue;}		//当前站立位置
		}
		cout<<endl;
	}
	if(slow){
		sleep(1);											//延时函数
	}
}

void check(stack_of_maze &s){
	int temp[MAX_X][MAX_Y];

	for(int x=0;x<MAX_X;x++)
		for(int y=0;y<MAX_Y;y++)
			temp[x][y] = maze[x][y];

	int x=1,y=1;					//出发点	
	while(1){
		temp[x][y] = 2;

		//向下
		if(temp[x+1][y]==0){
			s.push(x,y,'D');
			temp[x][y] = 3;			//在当前位置做一个向下的标志
			x = x + 1;
			temp[x][y] = 7;			//当前位置
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				flag = true;
				return;
			}
			else
				continue;
		}

		//向右
		if(temp[x][y+1]==0){
			s.push(x,y,'R');
			temp[x][y] = 4;			//在当前位置做一个向右的标志
			y = y + 1;
			temp[x][y] = 7;
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				flag = true;
				return;
			}
			else
				continue;
		}

		//向上
		if(temp[x-1][y]==0){
			s.push(x,y,'U');
			temp[x][y] = 6;			//在当前位置做一个向上的标志
			x = x - 1;
			temp[x][y] = 7;
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				flag = true;
				return;
			}
			else
				continue;
		}

		//向左
		if(temp[x][y-1]==0){
			s.push(x,y,'L');
			temp[x][y] = 5;			//在当前位置做一个向右的标志
			y = y - 1;
			temp[x][y] = 7;
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				flag = true;
				return;
			}
			else
				continue;
		}

		//上下左右不通，则回退
		if(s.pop(x,y)==NULL && temp[x-1][y]!=0 && temp[x][y-1]!=0 && temp[x][y+1]!=0 && temp[x+1][y]!=0){
			temp[0][1] = 7;
			if(temp[1][1]!=1)
				temp[1][1] = 2;
			return;
		}
	}
}

//输入,windows下可以使用#incldue<conio.h>替代此函数
char getch(){
	char ch;   
    static struct termios oldt, newt;				//保存原有终端属性和新设置的终端属性
    tcgetattr( STDIN_FILENO, &oldt);				//获得终端原有属性并保存在结构体oldflag

    //设置新的终端属性
    newt = oldt;
    newt.c_lflag &= ~(ICANON);          
    tcsetattr( STDIN_FILENO, TCSANOW, &newt);

    //取消回显
    system("stty -echo");
    ch = getchar();
    system("stty echo");    

    tcsetattr( STDIN_FILENO, TCSANOW, &oldt);		//让终端恢复为原有的属性
	return ch;
}

void move(){
	int x=1,y=1;					//出发点	
	while(1){
		switch(getch()){
			case 's':
				if(maze[x+1][y]==0){
					maze[x][y] = 0;
					x = x + 1;
					maze[x][y] = 7;			//当前位置
					printMaze();
					if((x==MAX_X-1)&&(y==MAX_Y-2)){
						cout<<"\n\n              成功走出"<<endl;
						return;
					}
				}				
				break;
			case 'd':
				if(maze[x][y+1]==0){
					if(maze[x][y+1]==0){
						maze[x][y] = 0;
						y = y + 1;
						maze[x][y] = 7;
						printMaze();
						if((x==MAX_X-1)&&(y==MAX_Y-2)){
							cout<<"\n\n              成功走出"<<endl;
							return;
						}
					}		
				}
				
				break;
			case 'w':
				if(maze[x-1][y]==0){
					maze[x][y] = 0;
					x = x - 1;
					maze[x][y] = 7;
					printMaze();
					if((x==MAX_X-1)&&(y==MAX_Y-2)){
						cout<<"\n\n              成功走出"<<endl;
						return;
					}
				}	
				break;
			case 'a':
				if(maze[x][y-1]==0){
					maze[x][y] = 0;
					y = y - 1;
					maze[x][y] = 7;
					printMaze();
					if((x==MAX_X-1)&&(y==MAX_Y-2)){
						cout<<"\n\n              成功走出"<<endl;
						return;
					}
				}		
				break;
		}
	}
}

void autoMove(stack_of_maze &s){
	int x=1,y=1;					//出发点	
	while(1){
		maze[x][y] = 2;

		//向下
		if(maze[x+1][y]==0){
			s.push(x,y,'D');
			maze[x][y] = 3;			//在当前位置做一个向下的标志
			x = x + 1;
			maze[x][y] = 7;			//当前位置
			if(slow)
				printMaze();
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				s.push(x,y,'*');
				cout<<"\n\n              成功走出"<<endl;
				return;
			}
			else
				continue;
		}

		//向右
		if(maze[x][y+1]==0){
			s.push(x,y,'R');
			maze[x][y] = 4;			//在当前位置做一个向右的标志
			y = y + 1;
			maze[x][y] = 7;
			if(slow)
				printMaze();
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				s.push(x,y,'*');
				cout<<"\n\n              成功走出"<<endl;
				return;
			}
			else
				continue;
		}

		//向上
		if(maze[x-1][y]==0){
			s.push(x,y,'U');
			maze[x][y] = 6;			//在当前位置做一个向上的标志
			x = x - 1;
			maze[x][y] = 7;
			if(slow)
				printMaze();
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				s.push(x,y,'*');
				cout<<"\n\n              成功走出"<<endl;
				return;
			}
			else
				continue;
		}

		//向左
		if(maze[x][y-1]==0){
			s.push(x,y,'L');
			maze[x][y] = 5;			//在当前位置做一个向右的标志
			y = y - 1;
			maze[x][y] = 7;
			if(slow)
				printMaze();
			if((x==MAX_X-1)&&(y==MAX_Y-2)){
				s.push(x,y,'*');
				cout<<"\n\n              成功走出"<<endl;
				return;
			}
			else
				continue;
		}

		//上下左右不通，则回退
		if(s.pop(x,y)==NULL && maze[x-1][y]!=0 && maze[x][y-1]!=0 && maze[x][y+1]!=0 && maze[x+1][y]!=0){
			cout<<"\n\n              没有找到合适的路径"<<endl;
			maze[0][1] = 7;
			if(maze[1][1]!=1)
				maze[1][1] = 2;
			return;
		}
	}
}

void menu();

void gamestart(){
	flag = false;
	while(!flag){
		stack_of_maze stack;			//定义一个栈的对象，用来记录行走路线	
		createMaze();
		check(stack);
		system("clear");
		cout<<"\t*                loading.              *"<<endl;
		system("clear");
		cout<<"\t*                loading..             *"<<endl;
		system("clear");
		cout<<"\t*                loading...            *"<<endl;
	}
	printMaze();						//输出当前迷宫的初始状态
	cout<<"\n\n              输入enter键继续"<<endl;
	getchar();
	if(!autogame){
		move();
		cout<<"\n\n              输入enter键继续"<<endl;
		getchar();
		menu();
	}
	else{
		stack_of_maze stack1;				
		autoMove(stack1);					//行走中……
	}	
	printMaze();							//输出迷宫的最终状态
	cout<<"\n\n              输入enter键继续"<<endl;
	getchar();
	menu();
}

void menu(){
	system("clear");
	int num;
	cout<<"\t****************************************"<<endl;
	cout<<"\t*                                      *"<<endl;
	cout<<"\t*               1.查看路径             *"<<endl;
	cout<<"\t*                                      *"<<endl;
	cout<<"\t*               2.自动进行             *"<<endl;
	cout<<"\t*                                      *"<<endl;
	cout<<"\t*               3.自行游戏             *"<<endl;
	cout<<"\t*                                      *"<<endl;
	cout<<"\t*               4.退出游戏             *"<<endl;
	cout<<"\t*                                      *"<<endl;
	cout<<"\t****************************************"<<endl;
	slow = false;
	switch(getch()){
		case '1':
			autogame = true;
			gamestart();break;
		case '2':
			autogame = true;
			slow = true;
			gamestart();
			break;
		case '3':
			autogame = false;
			gamestart();
			break;
		case '4':
			exit(1);break;
		default:
			cout<<"\n\n              错误操作，输入enter返回！"<<endl;
			getchar();
			menu();
	}
	getchar();
}

int main(int argc,char** argv){
	menu();
	return 0;
}
麦迪尔
关注
  • 30
    点赞
  • 踩
  • 208
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
c++课程设计之迷宫游戏
xdl229的博客
02-21 7508
第一章 任务概述 1.1背景 1.2总体任务要求 第二章 需求分析 2.1总体需求概述 2.2功能需求 2.3非功能需求 第三章 概要设计 3.1总体架构设计 3.2关键流程设计 第四章 详细设计 4.1界面详细设计 4.2数据结构详细设计 一、任务概述 1.1背景 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，...
C++实现迷宫游戏
01-20
本文实例为大家分享了C++实现迷宫游戏的具体代码，供大家参考，具体内容如下 #include using namespace std; //点为2表示迷宫图为█，点为0表示迷宫图为 int migo[9][9]= { {2, 2, 2, 2, 2, 2, 2, 2, 2}, {2, 0,...
C++迷宫游戏
03-15
内容索引:VC/C++源码,游戏编程,迷宫　　一款C++迷宫游戏源代码，早两年时候写的，仅供学习。
【C++】迷宫
None
05-16 3660
C++实现迷宫
迷宫游戏(c++)
最新发布
yymer214的博客
05-15 781
2.否则我们就需要从该格子出发，可以分别枚举向左、向下、向右、向上四个方向，依次去判断它旁边的四个点是否可以作为下一步合法的目标点，如果可以，那么我们就进行这一步，走到目标点，然后继续进行操作。很明显，当我们从任意格子出发，都有可能往四个方向走：上，下，左，右。而初始的时候，我们是在起点S处，之后开始进行我们的搜索过程，也就是我们要讲的 DFS 算法。3.当然有可能左、下、右、上四个点都无法再成为合法的目标点了，那么我们就回退一步，然后从上一步所在的那个格子向其他 未尝试的方向 继续枚举。
c语言课程设计走迷宫游戏,C语言课程设计-迷宫游戏.doc
weixin_30302513的博客
05-20 620
计算机技术基础课程设计C语言设计报告题目：完整的二维迷宫游戏学院：工商管理学院专业：信息系统与信息管理班级：050507姓名：孙月指导教师：张首伟设计日期：2004年12月10日题目：完整的二维迷宫游戏一、选题背景：问题的提出:我们在玩迷宫游戏的时候,常常在过了一关之后就结束了，这里设计的迷宫游戏足够多，难以程度也不尽相同，可以过瘾的玩。模仿的有那么一点意思，还请多多指教！二、设计思想：(1).问...
纯c++简易的迷宫小游戏
X_StarX的博客
01-15 3354
一个用c++写的黑框框迷宫适合新手入门学习也适合大学生小作业下面附上代码。
c++深搜1-迷宫类问题
Mark1277的博客
06-11 3718
深搜-迷宫类问题
C++迷宫问题完全详解
weixin_42163707的博客
12-20 2174
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
C++ 实现迷宫问题
ztt_1105的博客
07-21 2536
通过C++设计了一个迷宫游戏，涉及到链表，C++基本操作，终端字符处理，深度优先遍历算法。下面开始吧！ 在全局变量中定义地图，包括地图的长和高（30*20），同时还需定义一些标记。 flag 用于创建地图，true代表地图传创建成功。 slow用于更换游戏速度，true代表游戏慢速。 autogame用于更换游戏模式，true代表自动游戏。 #define MAX_X 20 #define...
用C++制作一个走迷宫的游戏
m0_70506179的博客
04-07 462
给迷宫游戏加上步数限制 n，当不超过 n 步到达出口时，显示游戏成功；1.自己设计一张至少 9*9 的迷宫地图，并按照课上介绍，完成迷宫游戏的开发。能否去掉按键控制，让小人 1 秒走一步，自己慢慢走到出迷宫。小人事先不知道出去的路径（不能人为帮它预设）达，显示游戏失败并结束游戏。它需要自己摸索怎么走出去。
C++迷宫实验设计程序
07-10
迷宫程序设计，使用C++编写，简单明了，可随机生成迷宫地图，也可自己定义障碍位置，程序逐步演示算法探寻路径的过程，具有动态显示效果。
c++迷宫小游戏
11-16
无聊的小游戏
迷宫游戏C++代码
08-06
华南理工大学计算机专业，C++作业，大一写的，共享一下，慎下。
迷宫源代码（C++版）
11-27
数据结构中用堆栈实现的走迷宫问题，含所有源代码
3D迷宫（演示程序）
12-22
此资源是演示程序，无需积分即可下载。 ------------------------------------------------ 前面几日我重新实现了迷宫的自动生成方法，并且添加了迷宫自动寻路方法。有了一个独立于GUI的迷宫库，我开始迫不及待地实现三维迷宫了！ 研制三维迷宫，需要攻破几个难点： 1、迷宫的生成。如果你是将迷宫数据硬编码或者从文件中读取，那么此步掠过，否则可以看看我写的文章：这里 2、纹理贴图知识。我使用的是游戏开发领域比较常用的tga文件格式。为此我写了一个读写tga文件的类，自己设定纹理贴图的方式。 3、摄像机系统。摄像机系统是第一人称游戏必须具备的功能。我自己也制作了一个基于OpenGL的摄像机系统的实现。 除此之外，在研究的过程中，还有一些需要突破的知识难关： 1、怎样将迷宫类的行和列映射到真实的三维坐标中？迷宫应该用哪个参考系来描述？ 2、迷宫的“上、下、左、右”在三维中应该叫做什么？ 3、三维点绘制顺序以及OpenGL裁剪模式造成的一些面不可见问题。 4、怎样设置阻挡？ 5、绘制二维视图的问题。 在下一篇博客，我会简单地介绍我是怎么解决上面五个问题的。
C++ 迷宫游戏实现代码
01-01
C++ 迷宫游戏实现代码 题目 通过让游戏角色自动寻找迷宫出口，走出迷宫，来练习C++面向对象之封装的基础知识。迷宫图如下所示，其中X表示墙。   1、程序分析 走出去的原理：遵循右手规则或左手规则。右手扶墙走...
用C++完成走迷宫游戏的编写
m0_70506179的博客
04-10 532
作者只是对原始的游戏进行了简单包装，读者根据自己的设想进行编写。游戏中或者显示游戏说明时，按下 q 键，回到上级菜单。读取存档：读取存档，继续游戏。游戏中按下 m 键，自动存档。主界面菜单包括四个选项。游戏说明：显示游戏说明。开始游戏：开始新游戏。
C/C++ 迷宫游戏
Stephen_Curry___的博客
02-29 781
这个迷宫探险游戏有以下功能： 1. 探险：选择该选项后，玩家会进入地下迷宫进行探险。在随机事件中，可能会遇到陷阱、发现金币或者什么都没有发生。陷阱会使玩家失去一定的生命值，金币可以增加玩家的金币数量。 2. 休息：选择该选项后，玩家可以休息一会儿。在休息过程中，有50%的概率会丢失随机数量的金币。而体力值将会回复15点，但不超过上限100。 3. 查看背包：选择该选项后，玩家可以查看背包中的道具。当前游戏中有三种道具：能量药水、地图和食物。能量药水可以增加20点体力值，地图可以指示方向，而食物则可以增
dfs生成迷宫c语言
09-10
深度优先搜索(Depth First Search, DFS)是一种用于图和树的遍历算法。它可以用来生成迷宫。下面是一个用C语言实现DFS迷宫生成的简单示例程序： ```c #include <stdio.h> #include <stdlib.h> #include <time.h> // 定义迷宫的行数和列数 #define ROW 10 #define COL 10 // 定义迷宫的墙壁和路径符号 #define WALL '#' #define PATH ' ' // 定义四个方向的移动向量：上、右、下、左 int dx[4] = {-1, 0, 1, 0}; int dy[4] = {0, 1, 0, -1}; char maze[ROW][COL]; // 迷宫地图 // 初始化迷宫地图，所有位置都设置为墙壁 void initMaze() { for (int i = 0; i < ROW; i++) { for (int j = 0; j < COL; j++) { maze[i][j] = WALL; } } } // 检查位置(x, y)是否在迷宫范围内 int isValid(int x, int y) { return (x >= 0 && x < ROW && y >= 0 && y < COL); } // 以点(x, y)为起点，进行DFS遍历生成迷宫 void DFS(int x, int y) { maze[x][y] = PATH; // 将当前位置标记为路径 // 随机打乱四个方向的顺序 int dirs[4] = {0, 1, 2, 3}; for (int i = 0; i < 4; i++) { int j = rand() % 4; int temp = dirs[i]; dirs[i] = dirs[j]; dirs[j] = temp; } // 在四个方向上进行探索 for (int i = 0; i < 4; i++) { int nx = x + dx[dirs[i]]; int ny = y + dy[dirs[i]]; // 判断新位置(nx, ny)是否有效及是否是墙壁 if (isValid(nx, ny) && maze[nx][ny] == WALL) { int wallCount = 0; // 统计周围的墙壁数量 for (int j = 0; j < 4; j++) { int adjX = nx + dx[j]; int adjY = ny + dy[j]; if (isValid(adjX, adjY) && maze[adjX][adjY] == WALL) { wallCount++; } } // 如果周围有多于1个的墙壁，则打通新位置(nx, ny) if (wallCount >= 2) { maze[nx][ny] = PATH; DFS(nx, ny); // 递归探索新位置 } } } } // 打印迷宫地图 void printMaze() { for (int i = 0; i < ROW; i++) { for (int j = 0; j < COL; j++) { printf("%c ", maze[i][j]); } printf("\n"); } } int main() { srand(time(0)); // 设置随机数种子，以保证每次生成的迷宫都不一样 initMaze(); // 初始化迷宫地图 DFS(0, 0); // 以起点(0, 0)开始进行DFS生成迷宫 printMaze(); // 打印迷宫地图 return 0; } ``` 这是一个简单的使用DFS算法生成迷宫的示例程序。该程序使用一个二维字符数组`maze`来表示迷宫地图，`'#'`表示墙壁，`' '`表示路径。通过递归调用`DFS`函数，从起点开始生成迷宫。在`DFS`函数中，首先将当前位置标记为路径，然后随机打乱四个方向的顺序，从每个方向上递归探索新的位置，直到所有位置都被访问完毕。最后，调用`printMaze`函数打印生成的迷宫地图。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

麦迪尔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值