C++游戏——迷宫

已于 2024-09-27 12:36:52 修改
阅读量295 收藏 2
点赞数 13
文章标签： c++ 游戏
于 2024-09-27 12:26:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SaltFishC/article/details/142590435
版权

大噶猴，我是鱼子酱(o)/~，作为一个爱好C++游戏的博主肯定发有关游戏的博客啦（也不一定）。
今天给大家带来C++迷宫！

迷宫！

作为一个好的游戏，一定要有一个难度选择啦。
咱们只需要写一个if语句再进行判断就好了，如下


	std::cout << "选择难度：1.和平 2.简单 3.中等 4.困难 5.噩梦 6.地狱" << std::endl;
	int ch;
	std::cin >> ch;

你们不会连这个都看不懂吧
我们再想个问题，说是迷宫，很多人就得创建很多关卡就可以了嘛。但是大家有没有想过，创建那么多关卡，倒不如进行随机迷宫呢，是吧。那么我们建一个create函数来随机一个迷宫，注意一定要保证有一条道走的出去。下面是代码：

void create(int x, int y) { //随机生成迷
	int c[4][2] = {0, 1, 1, 0, 0, -1, -1, 0}; //四个方向
	int i, j, t;
//将方向打乱
	for (i = 0; i < 4; i++) {
		j = rand() % 4;
		t = c[i][0];
		c[i][0] = c[j][0];
		c[j][0] = t;
		t = c[i][1];
		c[i][1] = c[j][1];
		c[j][1] = t;
	}
	map[x][y] = Road;
	for (i = 0; i < 4; i++)
		if (map[x + 2 * c[i][0]][y + 2 * c[i][1]] == Wall) {
			map[x + c[i][0]][y + c[i][1]] = Road;
			create(x + 2 * c[i][0], y + 2 * c[i][1]);
		}
}

在输出东西的时候，你会不会因为有个小光标而烦恼？只需要隐藏即可，如下：

void hidden() { //隐藏光标
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO cci;
	GetConsoleCursorInfo(hOut, &cci);
	cci.bVisible = 0; //赋1为显示，赋0为隐藏
	SetConsoleCursorInfo(hOut, &cci);
}

走迷宫嘛，不得移动（方向键）？用一个switch就可以了，由于这属于正在游戏的时候，所以咱们还要判断玩家是否到达终点，创造一个game函数即可：

void game() {
	int x = 2, y = 1; //玩家当前位置，刚开始在入口处
	int c; //用来接收按键
	while (1) {
		gotoxy(2 * y - 2, x - 1);
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
		printf("▇▇"); //画出玩家当前位置
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_GREEN);
		if (map[x][y] == End) { //判断是否到达出口
			gotoxy(30, 24);
			printf("到达终点，按任意键结束");
			getch();
			break;
		}
		c = get_key();
		if (c == Esc) {
			gotoxy(0, 24);
			break;
		}
		switch (c) {
			case Up: //向上走
				if (map[x - 1][y] != Wall) {
					paint(x, y);
					x--;
				}
				break;
			case Down: //向下走
				if (map[x + 1][y] != Wall) {
					paint(x, y);
					x++;
				}
				break;
			case Left: //向左走
				if (map[x][y - 1] != Wall) {
					paint(x, y);
					y--;
				}
				break;
			case Right: //向右走
				if (map[x][y + 1] != Wall) {
					paint(x, y);
					y++;
				}
				break;
		}
	}
}

最后就是我们亲爱的全代码啦：

#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <time.h>
#define Wall 1
#define Road 0
#define Start 2
#define End 3
#define Esc 5
#define Up 1
#define Down 2
#define Left 3
#define Right 4
int map[10101][10101];
void gotoxy(int x, int y) { //移动坐标
	COORD coord;
	coord.X = x;
	coord.Y = y;
	SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}
void hidden() { //隐藏光标
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO cci;
	GetConsoleCursorInfo(hOut, &cci);
	cci.bVisible = 0; //赋1为显示，赋0为隐藏
	SetConsoleCursorInfo(hOut, &cci);
}
void create(int x, int y) { //随机生成迷
	int c[4][2] = {0, 1, 1, 0, 0, -1, -1, 0}; //四个方向
	int i, j, t;
//将方向打乱
	for (i = 0; i < 4; i++) {
		j = rand() % 4;
		t = c[i][0];
		c[i][0] = c[j][0];
		c[j][0] = t;
		t = c[i][1];
		c[i][1] = c[j][1];
		c[j][1] = t;
	}
	map[x][y] = Road;
	for (i = 0; i < 4; i++)
		if (map[x + 2 * c[i][0]][y + 2 * c[i][1]] == Wall) {
			map[x + c[i][0]][y + c[i][1]] = Road;
			create(x + 2 * c[i][0], y + 2 * c[i][1]);
		}
}
int get_key() { //接收按键
	char c;
	while (c = getch()) {
		if (c == 27) return Esc; //Esc
		if (c != -32)continue;
		c = getch();
		if (c == 72) return Up; //上
		if (c == 80) return Down; //下
		if (c == 75) return Left; //左
		if (c == 77) return Right; //右
	}
	return 0;
}
void paint(int x, int y) { //画迷宫
	gotoxy(2 * y - 2, x - 1);
	switch (map[x][y]) {
		case Start:
			printf("入");
			break; //画入口
		case End:
			printf("出");
			break; //画出口
		case Wall:
			printf("▇");
			break; //画墙
		case Road:
			printf("  ");
			break; //画路
	}
}
void game() {
	int x = 2, y = 1; //玩家当前位置，刚开始在入口处
	int c; //用来接收按键
	while (1) {
		gotoxy(2 * y - 2, x - 1);
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
		printf("▇▇"); //画出玩家当前位置
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_GREEN);
		if (map[x][y] == End) { //判断是否到达出口
			gotoxy(30, 24);
			printf("到达终点，按任意键结束");
			getch();
			break;
		}
		c = get_key();
		if (c == Esc) {
			gotoxy(0, 24);
			break;
		}
		switch (c) {
			case Up: //向上走
				if (map[x - 1][y] != Wall) {
					paint(x, y);
					x--;
				}
				break;
			case Down: //向下走
				if (map[x + 1][y] != Wall) {
					paint(x, y);
					x++;
				}
				break;
			case Left: //向左走
				if (map[x][y - 1] != Wall) {
					paint(x, y);
					y--;
				}
				break;
			case Right: //向右走
				if (map[x][y + 1] != Wall) {
					paint(x, y);
					y++;
				}
				break;
		}
	}
}
int main() {
	int i, j;
	srand((unsigned)time(NULL)); //初始化随即种子
	hidden(); //隐藏光标
	system("cls");
	std::cout << "选择难度：1.和平 2.简单 3.中等 4.困难 5.噩梦 6.地狱" << std::endl;
	int ch;
	std::cin >> ch;
	system("cls");
	if (ch == 1) {
		const int Height = 11;
		const int Width = 11;
		for (i = 0; i <= Height + 1; i++)
			for (j = 0; j <= Width + 1; j++)
				if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) //初始化迷宫
					map[i][j] = Road;
				else map[i][j] = Wall;
		create(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); //从随机一个点开始生成迷宫，该点行列都为偶数
		for (i = 0; i <= Height + 1; i++) { //边界处理
			map[i][0] = Wall;
			map[i][Width + 1] = Wall;
		}
		for (j = 0; j <= Width + 1; j++) { //边界处理
			map[0][j] = Wall;
			map[Height + 1][j] = Wall;
		}
		map[2][1] = Start; //给定入口
		map[Height - 1][Width] = End; //给定出口
		for (i = 1; i <= Height; i++)
			for (j = 1; j <= Width; j++) //画出迷宫
				paint(i, j);
		game(); //开始游戏
		getch();
		printf("是否再来一局？(y/n)");
		char yn;
		std::cin >> yn;
		if (yn == 'y') main();
	} else if (ch == 2) {
		const int Height = 21;
		const int Width = 13;
		for (i = 0; i <= Height + 1; i++)
			for (j = 0; j <= Width + 1; j++)
				if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) //初始化迷宫
					map[i][j] = Road;
				else map[i][j] = Wall;
		create(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); //从随机一个点开始生成迷宫，该点行列都为偶数
		for (i = 0; i <= Height + 1; i++) { //边界处理
			map[i][0] = Wall;
			map[i][Width + 1] = Wall;
		}
		for (j = 0; j <= Width + 1; j++) { //边界处理
			map[0][j] = Wall;
			map[Height + 1][j] = Wall;
		}
		map[2][1] = Start; //给定入口
		map[Height - 1][Width] = End; //给定出口
		for (i = 1; i <= Height; i++)
			for (j = 1; j <= Width; j++) //画出迷宫
				paint(i, j);
		game(); //开始游戏
		getch();
		printf("是否再来一局？(y/n)");
		char yn;
		std::cin >> yn;
		if (yn == 'y') main();
	} else if (ch == 3) {
		const int Height = 31;
		const int Width = 21;
		for (i = 0; i <= Height + 1; i++)
			for (j = 0; j <= Width + 1; j++)
				if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) //初始化迷宫
					map[i][j] = Road;
				else map[i][j] = Wall;
		create(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); //从随机一个点开始生成迷宫，该点行列都为偶数
		for (i = 0; i <= Height + 1; i++) { //边界处理
			map[i][0] = Wall;
			map[i][Width + 1] = Wall;
		}
		for (j = 0; j <= Width + 1; j++) { //边界处理
			map[0][j] = Wall;
			map[Height + 1][j] = Wall;
		}
		map[2][1] = Start; //给定入口
		map[Height - 1][Width] = End; //给定出口
		for (i = 1; i <= Height; i++)
			for (j = 1; j <= Width; j++) //画出迷宫
				paint(i, j);
		game(); //开始游戏
		getch();
		printf("是否再来一局？(y/n)");
		char yn;
		std::cin >> yn;
		if (yn == 'y') main();
	} else if (ch == 4) {
		const int Height = 51;
		const int Width = 23;
		for (i = 0; i <= Height + 1; i++)
			for (j = 0; j <= Width + 1; j++)
				if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) //初始化迷宫
					map[i][j] = Road;
				else map[i][j] = Wall;
		create(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); //从随机一个点开始生成迷宫，该点行列都为偶数
		for (i = 0; i <= Height + 1; i++) { //边界处理
			map[i][0] = Wall;
			map[i][Width + 1] = Wall;
		}
		for (j = 0; j <= Width + 1; j++) { //边界处理
			map[0][j] = Wall;
			map[Height + 1][j] = Wall;
		}
		map[2][1] = Start; //给定入口
		map[Height - 1][Width] = End; //给定出口
		for (i = 1; i <= Height; i++)
			for (j = 1; j <= Width; j++) //画出迷宫
				paint(i, j);
		game(); //开始游戏
		getch();
		printf("是否再来一局？(y/n)");
		char yn;
		std::cin >> yn;
		if (yn == 'y') main();
	} else if (ch == 5) {
		const int Height = 81;
		const int Width = 31;
		for (i = 0; i <= Height + 1; i++)
			for (j = 0; j <= Width + 1; j++)
				if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) //初始化迷宫
					map[i][j] = Road;
				else map[i][j] = Wall;
		create(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); //从随机一个点开始生成迷宫，该点行列都为偶数
		for (i = 0; i <= Height + 1; i++) { //边界处理
			map[i][0] = Wall;
			map[i][Width + 1] = Wall;
		}
		for (j = 0; j <= Width + 1; j++) { //边界处理
			map[0][j] = Wall;
			map[Height + 1][j] = Wall;
		}
		map[2][1] = Start; //给定入口
		map[Height - 1][Width] = End; //给定出口
		for (i = 1; i <= Height; i++)
			for (j = 1; j <= Width; j++) //画出迷宫
				paint(i, j);
		game(); //开始游戏
		getch();
		printf("是否再来一局？(y/n)");
		char yn;
		std::cin >> yn;
		if (yn == 'y') main();
	} else if (ch == 6) {
		const int Height = 101;
		const int Width = 31;
		for (i = 0; i <= Height + 1; i++)
			for (j = 0; j <= Width + 1; j++)
				if (i == 0 || i == Height + 1 || j == 0 || j == Width + 1) //初始化迷宫
					map[i][j] = Road;
				else map[i][j] = Wall;
		create(2 * (rand() % (Height / 2) + 1), 2 * (rand() % (Width / 2) + 1)); //从随机一个点开始生成迷宫，该点行列都为偶数
		for (i = 0; i <= Height + 1; i++) { //边界处理
			map[i][0] = Wall;
			map[i][Width + 1] = Wall;
		}
		for (j = 0; j <= Width + 1; j++) { //边界处理
			map[0][j] = Wall;
			map[Height + 1][j] = Wall;
		}
		map[2][1] = Start; //给定入口
		map[Height - 1][Width] = End; //给定出口
		for (i = 1; i <= Height; i++)
			for (j = 1; j <= Width; j++) //画出迷宫
				paint(i, j);
		game(); //开始游戏
		getch();
		printf("是否再来一局？(y/n)");
		char yn;
		std::cin >> yn;
		if (yn == 'y') main();
	}
	return 0;
}

关注我看更多c++游戏，我们下期再见！

キャビアC++
关注
C语言C++编写——迷宫游戏
12-25 3747
最初用C语言写的，写了一天多写好。后来又改用C++，由于对C++不是很熟悉，改成C++用了三四天才改好。 程序是在VC++6.0中写的，新建一个Win32 Application即可。  最初觉得程序的关键应该是求解迷宫，后来发现求解迷宫很简单，难点是如何生成迷宫。 这里采用接合图的深度优先遍历，生成迷宫的算法，定义了搜索步长以便控制迷宫分支多少和分支深度。 由于程序中多处用到链表，所以对于迷...
用C++/C设计简易小游戏——走迷宫
iiicesea的博客
10-16 1421
走迷宫 1.定义一个二维数组作为迷宫 2.进入循环 1.检查迷宫 2.检查是否走出迷宫 获取游戏结束时的时间：计算出共花费多少时间 是：结束程序 3.移动角色一次 4.获取方向键并处理 判断接下来要走的位置是否有路 1.把新位置赋值为老鼠@ 2.把旧位置赋值为路 3.把记录老鼠的坐标更新 注意： 获取方向键使用get.h头文件中的函数 把get.h头文件复制到共享文件夹，然后通过获取超级管理员权限来移动到/usr/include/ sudo cp getch.h /u
c++小游戏——迷宫
HAFT41016的博客
10-31 1715
#include<bits/stdc++.h> #include<windows.h> #include<conio.h> using namespace std; int main() { int i123,ab; for(i123=500;i123<=1000;i123+=100){ Beep(i123,1000); } char a,b,c,d,aa,bb,cc,dd; cout<<"输入四位字母ID"; cin>&.
C++小游戏——走迷宫
热门推荐
hh_cnyali的博客
07-15 3万+
大家想不想成名，那就一步步来吧，先写一些小游戏热热身。 下载地址 主程序代码：#include<conio.h> #include<stdlib.h> #include<time.h> #include<string.h> #include<windows.h> #include<iostream> using namespace std; char pr[10]={1,' ','E','O'}
C++ 自制迷宫游戏
oscar1224的博客
08-17 260
对于一个迷宫游戏，最重要的功能就是要让角色实时移动。在这里，我们可以利用getch()函数。但是这里我们用另外一个函数——GetAsyncKeyState。这个函数更加方便，不懂的可以自行再去搜索。至于里面的check函数就根据自己的设定编写即可。这里的KD其实就是前面的GetAsyncKeyState函数（使用了define缩短代码长度）。KD中的值为键值，详细可自行搜索。除此之外，我们在让角色坐标移动的同时要让地图实时更新。打印函数如下。
小白程序员的第一个C++项目——迷宫A*算法(上)
weixin_44991673的博客
12-11 933
C++迷宫实验迷宫生成迷宫解决A*算法 C++项目：玩转迷宫游戏 迷宫生成 迷宫搜索路径算法 Maze generation A* with motions limited to 1 cell A* with motions using straight lines A* with motions using corridors 迷宫生成 迷宫生成的代码在维基百科上面。下面我们...
C++数据结构——迷宫问题之最短时间
weixin_44546342的博客
04-28 3092
迷宫问题之最短时间 小明某天不小心进入了一个迷宫（如上图所示），请帮他计算走出迷宫的最少的时间。规定每走一格需要1个单位时间。如果不能走到出口，则输出impossible。每次能走的仅有上、下、左、右4个方向。 输入格式: 测试数据有多组，处理到文件尾。每组测试数据首先输入2个整数n，m(0<n，m≤100)，代表迷宫的高和宽，然后n行，每行m个字符，其中各字符的含义如下： 'S’代表小明现在所在的位置；‘T’代表迷宫的出口；’#‘代表墙，不能走；’.'代表路，可以走； 'd’代表该位置有怪物
游戏——Qt迷宫
Joey博客
06-26 2170
小游戏——Qt迷宫 源码 源码中有详细的注释，有空再把迷宫游戏的思路补充到博客中。 效果图
c++ 迷宫思路_迷宫问题求解——C++
weixin_42517137的博客
01-17 1523
迷宫问题思路根据昨天的博客，有如下几种解决方案克鲁斯卡尔 ，为避免死循环，需要设定优化路径的次数。Prim，为避免死循环，需要设定优化路径的次数，暂定200次。BFS ， 实现简单，无死循环。DFS , 实现简单，无死循环，复杂度较低。动态规划，实时根据权重调整方向，目前看来最合适的解决方案。需要以数据证明。综上，本次优先选择BFS，首先不存在死循环的风险，其次算法复杂度较低，容易理解且实现。...
c++游戏——吃豆人（普通版）
06-24
吃豆人游戏是一款极具代表性的2D迷宫游戏，玩家控制的角色需要在迷宫中吃掉所有的豆子，同时避开鬼魂。下面，我们将讨论实现这个游戏所需的关键技术和步骤。 1. **基础结构**： - 游戏主循环：所有游戏的核心都是...
C++写的小游戏——迷宫
08-14
迷宫自动生成 上、下、左、右键移动 到达标有“出”的出口即为胜利
【C/C++、easyX】一款迷宫类记忆力游戏——《暗夜迷踪》-附件资源
03-02
【C/C++、easyX】一款迷宫类记忆力游戏——《暗夜迷踪》-附件资源
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 961
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 849
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
最新发布
scy2429828663的博客
09-26 232
【代码】求n的阶乘的相反数（c语言）
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 650
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 657
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
C#测试调用Ghostscript.NET浏览PDF文件
gc_2299的博客
09-23 425
学习并测试调用Ghostscript.NET模块打开及浏览PDF文件的基本用法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值