扫雷实现详解【递归展开+首次必展开+标记雷+取消标记雷】

扫雷

  • 一.扫雷设计思路
  • 二.扫雷代码逐步实现
    • 1.创建游戏菜单
    • 2.初始化棋盘
    • 3.打印棋盘
    • 4.随机布置雷
    • 5.统计周围雷的个数
    • 6.递归展开棋盘
    • 7.标记雷
    • 8.删除雷的标记
    • 9.保证第一次排雷的安全性+棋盘必定展开
    • 10.排查雷
    • 11.判断输赢
  • 三.扫雷总代码
  • 四.截图

一.扫雷设计思路

 1.创建游戏菜单。
 2.初始化棋盘。
 3.打印棋盘。
 4.随机布置雷。
 5.选择：排查雷，标记雷，或取消标记雷。
 7.循环，直到游戏结束。
 8.当然其中的细节处还有很多，带着你一步一步实现。

二.扫雷代码逐步实现

1.创建游戏菜单

void Menu()
{printf("-------------------------------------\n");printf("|              扫雷游戏！           |\n");printf("|        0.exit        1.play       |\n");printf("-------------------------------------\n");
}

当然可以美化一下，发挥你天马行空的想象力!

2.初始化棋盘

  • 扫雷的过程中，布置的雷的信息和排查出的周围雷的信息（周围雷的个数）都需要存储，所以我们需要⼀定的数据结构来存储这些信息。不妨用9 x 9的棋盘上布置的雷的信息和排查出的周围雷的信息（周围雷的个数），我们首先想到的就是创建⼀个9 x 9的数组来存放这些信息。1代表雷，0代表不是雷。

如图：
在这里插入图片描述
由于我们还要统计某个坐标周围雷的个数，所以要访问周围数组元素。

  • 假设我们排查(2,5)这个坐标时，我们访问周围的⼀圈8个黄色位置，统计周围雷的个数是1。
  • 假设我们排查(8,6)这个坐标时，我们访问周围的⼀圈8个黄色位置，统计周围雷的个数时，最下面的三个坐标就会越界。
  • 为了防止越界，我们在设计的时候，给数组扩大一圈，雷还是布置在中间的9 x 9的坐标上，周围一圈不去布置雷就⾏，这样就解决了越界的问题。所以我们将存放数据的数组创建成11 x 11是比较合适。

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

  • 再继续分析，我们在棋盘上布置了雷，棋盘上雷的信息（1）和非雷的信息（0），假设我们排查了某⼀个位置后，这个坐标处不是雷，这个坐标的周围有1个雷，那我们需要将排查出的雷的数量信息记录存储，并打印出来，作为排雷的重要参考信息。那这个雷的个数信息存放在哪里呢？如果存放在布置雷的数组中，这样雷的信息和雷的个数信息就可能或产生混淆和打印上的困难。

  • 我们肯定有办法解决，比如：雷和非雷的信息不要使用数字，使用某些字符就行，这样就避免冲突了，但是这样做棋盘上有雷和非雷的信息，还有排查出的雷的个数信息，就比较混杂，不够方便。

  • 我们采用另外⼀种方案，设置两个棋盘，我们专门给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。这样就互不干扰了，把雷布置到mine数组，在mine数组中排查雷，排查出的数据存放在show数组，并且打印show数组的信息给后期排查参考。

  • 为了保持神秘，show数组开始时初始化为字符 * ，为了保持两个数组的类型⼀致，可以使用同⼀套函数处理，mine数组最开始也初始化为字符’0’，布置雷改成’1’。

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

给出伪代码参考：

#define ROW 9//扫雷的行数
#define COL 9//扫雷的列数
#define ROWS ROW + 2//创建二维数组的行数
#define COLS COL + 2//创建二维数组的列数
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{int i = 0;for (i = 0;i < rows;i++){int j = 0;for (j = 0;j < cols;j++){board[i][j] = set;}}
}
//创建两个字符二维数组
char mine[ROWS][COLS];//存放该点是不是雷    （0代表不是雷，1代表是雷）
char show[ROWS][COLS];//存放该点周围有多少雷（数字代表周围有多少雷，*代表未知）

3.打印棋盘

代码1：

//定义打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col)
{int i = 0;//辅助观察棋盘for (i = 0;i <= row;i++){printf("%d ", i);}printf("\n");//打印棋盘for (i = 1;i <= row;i++){printf("%d ", i);//辅助观察棋盘int j = 0;for (j = 1;j <= col;j++){printf("\033[36m%c \033[0m", board[i][j]);//打印蓝色字符}printf("\n");}printf("--------扫雷--------\n");//辅助观察棋盘
}

为了使棋盘看起来更舒服，我们可以美化一下棋盘。
代码2：

//定义打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col)
{printf("\033[34m-----------------扫雷-----------------\033[0m\n");//辅助观察棋盘int i = 0;//辅助观察棋盘printf("0 |");for (i = 1;i <= row;i++){printf(" %-2d", i);if (i < row){printf("|");}}printf("\n");printf("--|");for (i = 1; i <= col; i++){printf("---");if (i < row){printf("|");}}printf("\n");//打印棋盘for (i = 1;i <= row;i++){printf("%-2d|", i);//辅助观察棋盘int j = 0;for (j = 1;j <= col;j++){if (board[i][j] == '1' || board[i][j] == '5'){printf("\033[36m %c \033[0m", board[i][j]);//打印蓝色}else if (board[i][j] == '2' || board[i][j] == '6'){printf("\033[32m %c \033[0m", board[i][j]);//打印绿色}else if (board[i][j] == '3' || board[i][j] == '7'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else if (board[i][j] == '4' || board[i][j] == '8'){printf("\033[35m %c \033[0m", board[i][j]);//打印紫色}else if (board[i][j] == '!'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else{printf(" %c ", board[i][j]);//打印白色}if (j < col){printf("|");}}//辅助观察棋盘printf("\n");if (i < row){printf("--|");}for (j = 1; j <= col; j++){if (i < row){printf("---");if (j < col){printf("|");}}}printf("\n");}
}

效果如下：
在这里插入图片描述

4.随机布置雷

  • 这里用到了随机数，不知道的小伙伴，可以去我写的猜字小游戏看看
  • 点击即可前往猜字小游戏
//定义布置雷的函数
void SetMine(char mine[ROWS][COLS], int row, int col)
{int count = MINE_NUMBER;//雷的个数while (count){int x = rand() % row + 1;int y = rand() % col + 1;if (mine[x][y] != '1'){mine[x][y] = '1';//如果该坐标不是雷，则布置雷count--;}}
}

5.统计周围雷的个数

代码1：暴力取遍

//统计周围雷的个数的函数1.0
int AroundMineCount(char mine[ROWS][COLS], int x, int y)
{return mine[x - 1][y] + mine[x - 1][y - 1] +mine[x][y - 1] + mine[x + 1][y - 1] +mine[x + 1][y] + mine[x + 1][y + 1] +mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0';
}

代码2：循环取遍

//统计周围雷的个数的函数
int AroundMineCount(char mine[ROWS][COLS], int x, int y)
{int i = 0;int count = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){count += mine[i][j] - '0';}}return count;
}

6.递归展开棋盘

  • 已知该坐标不是雷，若周围没有雷，该坐标赋为空，再向外扩展（达到展开一片的效果），否则只显示该坐标周围雷的个数。
//已知该坐标不是雷，若周围没有雷,该坐标赋为空，再向外扩展（达到展开一片的效果），否则只显示该坐标周围雷的个数
void ExpandAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//限制在棋盘内展开，防止下标越界{int count = AroundMineCount(mine, x, y);//获取雷数if (count == 0)//周围没雷，递归展开{show[x][y] = ' ';//周围没雷，赋值为空格int i = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){if (show[i][j] == '*')//只对位排查的坐标进行展开，防止死循环{ExpandAround(mine, show, i, j);}}}}else{show[x][y] = count + '0';//周围有雷，显示雷数}}
}

7.标记雷

//定义标记雷的函数（用！标记）
void MarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要标记雷的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){if (show[x][y] == '*'){show[x][y] = '!';system("cls");PrintBoard(show, ROW, COL);break;}else{printf("该坐标已经被排查过，无法标记，请重新输入\n");}}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){printf("该坐标已经被标记过了，无法二次标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}

8.删除雷的标记

//定义删除雷的标记的函数
void DelectMarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要删除雷的标记的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){show[x][y] = '*';system("cls");PrintBoard(show, ROW, COL);break;}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){printf("该坐标未被标记过，无法删除标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}

9.保证第一次排雷的安全性+棋盘必定展开

//定义第一次排雷是安全的，不是雷并且可以达到展开一片的效果，增加了可玩性
void FirstIsSafe(char mine[ROWS][COLS], char show[ROWS][COLS],int x, int y)
{//若该点不是雷且周围无雷，直接展开if (mine[x][y] != '1' && AroundMineCount(mine, x, y) == 0){ExpandAround(mine, show, x, y);}//否则分情况else{//先判断该点是不是雷if (mine[x][y] == '1')//该点为雷，将其移走{mine[x][y] = '0';while (1){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if (mine[x1][y1] != '1' && x1 != x && y1 != y){mine[x1][y1] = '1';break;}}}//以及将雷移走了，在判断周围是否有雷if (AroundMineCount(mine, x, y) != 0)//该点周围有雷，将它们移走{int count = AroundMineCount(mine, x, y);//计算周围雷的数量int i = 0;for (i = x - 1;i <= x + 1; i++){int j = 0;for (j = y - 1; j <= y + 1; j++){mine[i][j] = '0';//将周围的雷变为无雷的状态}}while (count){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if ((x1 != x - 1 && y1 != y - 1)&&(x1 != x - 1 && y1 != y)&&(x1 != x - 1 && y1 != y + 1)&&(x1 != x && y1 != y - 1)&&(x1 != x && y1 != y)&&(x1 != x && y1 != y + 1)&&(x1 != x + 1 && y1 != y - 1)&&(x1 != x + 1 && y1 != y)&&(x1 != x + 1 && y1 != y + 1))//不能将雷移回来{if (mine[x1][y1] != '1'){mine[x1][y1] = '1';//如果该坐标不是雷，则布置雷count--;}}}}ExpandAround(mine, show, x, y);}
}

10.排查雷

  • 代码1：不能实现展开一片的效果
//定义排查雷的函数1.0：不能实现展开一片的效果
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '*')//判断输入的坐标是否合法且未被排查过{if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{system("cls");//清空屏幕——头文件windows.hint count = AroundMineCount(mine, x, y);show[x][y] = count + '0';//该坐标要存放雷的个数int ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '*')//该坐标已经被排查过{printf("该坐标已经被排查过，请重新输入坐标\n");}else//越界{printf("输入的坐标错误，请重新输入\n");}}return ret1;
}
  • 代码2：可以实现展开一片的效果
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过{if (show[x][y] == '*' || show[x][y] == '!'){if (show[x][y] == '*'){again:if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{ExpandAround(mine, show, x, y);//直接展开system("cls");//清空屏幕——头文件windows.hint ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else{int select = 0;printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");while (1){printf("请输入（0/1）:>");scanf("%d", &select);if (select == 0){return 0;}else if (select == 1){goto again;}else{printf("输入错误，请重新输入\n");}}}}else{printf("该坐标已经被排查过，请重新输入\n");}}else//越界{printf("该坐标越界，请重新输入\n");}}return ret1;
}
  • 代码3：结合FirstIsSafe函数，第一次排查确保该点不是雷以及周围没有雷，达到网页版扫雷的效果，由于是随机排雷，不能保证该点以及周围有无雷，可以将雷，神不知鬼不觉地换掉。
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{//第一次排查确保该点不是雷以及周围没有雷，达到网页版扫雷的效果//由于是随机排雷，不能保证该点以及周围有无雷，可以将雷，神不知鬼不觉地换掉static int FindMineCount = 1;if (FindMineCount == 1){int x = 0;int y = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col){FirstIsSafe(mine, show, x, y);FindMineCount++;system("cls");//PrintBoard(mine, ROW, COL);PrintBoard(show, ROW, COL);return 0;}else{printf("输入的坐标越界，请重新输入\n");}}}//以后雷的位置就固定下来了else{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过{if (show[x][y] == '*' || show[x][y] == '!'){if (show[x][y] == '*'){again:if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{ExpandAround(mine, show, x, y);//直接展开system("cls");//清空屏幕——头文件windows.hint ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else{int select = 0;printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");while (1){printf("请输入（0/1）:>");scanf("%d", &select);if (select == 0){return 0;}else if (select == 1){goto again;}else{printf("输入错误，请重新输入\n");}}}}else{printf("该坐标已经被排查过，请重新输入\n");}}else//越界{printf("该坐标越界，请重新输入\n");}}FindMineCount++;return ret1;}
}

11.判断输赢

  • 利用剩余的*数目等于雷的数目，返回1，代表游戏胜利，否则返回0，代表游戏继续。
//定义游戏胜利的函数
int IsWin(char show[ROWS][COLS], int row, int col)
{int count = 0;int i = 0;for (i = 1; i <= row; i++){int j = 0;for (j = 1; j <= col; j++){if (show[i][j] == '*')//统计show中*的个数{count++;}}}if (count == MINE_NUMBER)//若剩余的*数目等于雷的数目，返回1，代表游戏胜利{return 1;}return 0;//否则返回0，代表游戏继续
}

三.扫雷总代码

  • game.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<windows.h>#define ROW 9//扫雷的行数
#define COL 9//扫雷的列数#define ROWS ROW + 2//创建二维数组的行数
#define COLS COL + 2//创建二维数组的列数#define MINE_NUMBER 10//设置雷的个数//声明初始化棋盘的函数
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);//声明打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col);//声明布置雷的函数
void SetMine(char mine[ROWS][COLS], int row, int col);//声明标记雷的函数
void MarkMine(char show[ROWS][COLS], int row, int col);//声明删除雷的标记的函数
void DelectMarkMine(char show[ROWS][COLS], int row, int col);//声明第一次排雷是安全的，不是雷并且可以达到展开一片的效果，增加了可玩性
void FirstIsSafe(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);//声明排查雷的函数
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//声明游戏胜利的函数
int IsWin(char show[ROWS][COLS], int row, int col);

game.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"//printf("\033[36m%c \033[0m", board[i][j]);//打印蓝色
//printf("\033[31m%c \033[0m", board[i][j]);//打印红色//定义初始化棋盘的函数
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{int i = 0;for (i = 0;i < rows;i++){int j = 0;for (j = 0;j < cols;j++){board[i][j] = set;}}
}//定义打印棋盘的函数
//void PrintBoard(char board[ROWS][COLS], int row, int col)
//{
//	int i = 0;
//	//辅助观察棋盘
//	for (i = 0;i <= row;i++)
//	{
//		printf("%d ", i);
//	}
//	printf("\n");
//	//打印棋盘
//	for (i = 1;i <= row;i++)
//	{
//		printf("%d ", i);//辅助观察棋盘
//		int j = 0;
//		for (j = 1;j <= col;j++)
//		{
//			printf("\033[36m%c \033[0m", board[i][j]);//打印蓝色
//		}
//		printf("\n");
//	}
//	printf("--------扫雷--------\n");//辅助观察棋盘
//}//定义打印棋盘的函数
void PrintBoard(char board[ROWS][COLS], int row, int col)
{printf("\033[34m-----------------扫雷-----------------\033[0m\n");//辅助观察棋盘int i = 0;//辅助观察棋盘printf("0 |");for (i = 1;i <= row;i++){printf(" %-2d", i);if (i < row){printf("|");}}printf("\n");printf("--|");for (i = 1; i <= col; i++){printf("---");if (i < row){printf("|");}}printf("\n");//打印棋盘for (i = 1;i <= row;i++){printf("%-2d|", i);//辅助观察棋盘int j = 0;for (j = 1;j <= col;j++){if (board[i][j] == '1' || board[i][j] == '5'){printf("\033[36m %c \033[0m", board[i][j]);//打印蓝色}else if (board[i][j] == '2' || board[i][j] == '6'){printf("\033[32m %c \033[0m", board[i][j]);//打印绿色}else if (board[i][j] == '3' || board[i][j] == '7'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else if (board[i][j] == '4' || board[i][j] == '8'){printf("\033[35m %c \033[0m", board[i][j]);//打印紫色}else if (board[i][j] == '!'){printf("\033[31m %c \033[0m", board[i][j]);//打印红色}else{printf(" %c ", board[i][j]);//打印白色}if (j < col){printf("|");}}//辅助观察棋盘printf("\n");if (i < row){printf("--|");}for (j = 1; j <= col; j++){if (i < row){printf("---");if (j < col){printf("|");}}}printf("\n");}
}//定义布置雷的函数
void SetMine(char mine[ROWS][COLS], int row, int col)
{int count = MINE_NUMBER;//雷的个数while (count){int x = rand() % row + 1;int y = rand() % col + 1;if (mine[x][y] != '1'){mine[x][y] = '1';//如果该坐标不是雷，则布置雷count--;}}
}//统计周围雷的个数的函数1.0
//int AroundMineCount(char mine[ROWS][COLS], int x, int y)
//{
//	return mine[x - 1][y] + mine[x - 1][y - 1] +
//		mine[x][y - 1] + mine[x + 1][y - 1] +
//		mine[x + 1][y] + mine[x + 1][y + 1] +
//		mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0';
//}//统计周围雷的个数的函数2.0
int AroundMineCount(char mine[ROWS][COLS], int x, int y)
{int i = 0;int count = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){count += mine[i][j] - '0';}}return count;
}//已知该坐标不是雷，若周围没有雷,该坐标赋为空，再向外扩展（达到展开一片的效果），否则只显示该坐标周围雷的个数
void ExpandAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//限制在棋盘内展开，防止下标越界{int count = AroundMineCount(mine, x, y);//获取雷数if (count == 0)//周围没雷，递归展开{show[x][y] = ' ';//周围没雷，赋值为空格int i = 0;for (i = x - 1;i <= x + 1;i++){int j = 0;for (j = y - 1;j <= y + 1;j++){if (show[i][j] == '*')//只对位排查的坐标进行展开，防止死循环{ExpandAround(mine, show, i, j);}}}}else{show[x][y] = count + '0';//周围有雷，显示雷数}}
}//定义标记雷的函数
void MarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要标记雷的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){if (show[x][y] == '*'){show[x][y] = '!';system("cls");PrintBoard(show, ROW, COL);break;}else{printf("该坐标已经被排查过，无法标记，请重新输入\n");}}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){printf("该坐标已经被标记过了，无法二次标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}//定义删除雷的标记的函数
void DelectMarkMine(char show[ROWS][COLS], int row, int col)
{int x = 0;int y = 0;while (1){printf("请输入你要删除雷的标记的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '!'){show[x][y] = '*';system("cls");PrintBoard(show, ROW, COL);break;}else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '!'){printf("该坐标未被标记过，无法删除标记，请重新输入\n");}else{printf("该坐标越界，请重新输入\n");}}
}//定义游戏胜利的函数
int IsWin(char show[ROWS][COLS], int row, int col)
{int count = 0;int i = 0;for (i = 1; i <= row; i++){int j = 0;for (j = 1; j <= col; j++){if (show[i][j] == '*')//统计show中*的个数{count++;}}}if (count == MINE_NUMBER)//若剩余的*数目等于雷的数目，返回1，代表游戏胜利{return 1;}return 0;//否则返回0，代表游戏继续
}//定义排查雷的函数1.0：不能实现展开一片的效果
//int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
//{
//	int x = 0;
//	int y = 0;
//	int ret1 = 0;
//	while (1)
//	{
//		printf("请输入你要排查的坐标:>");
//		scanf("%d %d", &x, &y);
//		if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] == '*')//判断输入的坐标是否合法且未被排查过
//		{
//			if (mine[x][y] == '1')//该坐标是雷
//			{
//				system("cls");//清空屏幕——头文件windows.h
//				printf("很遗憾，你被雷炸死了，游戏失败！\n");
//				printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//				PrintBoard(mine, ROW, COL);
//				ret1 = 1;
//				break;
//			}
//			else//该坐标不是雷
//			{
//				system("cls");//清空屏幕——头文件windows.h
//				int count = AroundMineCount(mine, x, y);
//				show[x][y] = count + '0';//该坐标要存放雷的个数
//				int ret2 = IsWin(show, row, col);
//				if (ret2 == 1)
//				{
//					printf("恭喜你！找到了所有的雷，游戏胜利！\n");
//					printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//					PrintBoard(mine, row, col);
//				}
//				else
//				{
//					PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷
//				}
//				break;
//			}
//		}
//		else if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y] != '*')//该坐标已经被排查过
//		{
//			printf("该坐标已经被排查过，请重新输入坐标\n");
//		}
//		else//越界
//		{
//			printf("输入的坐标错误，请重新输入\n");
//		}
//	}
//	return ret1;
//}//定义排查雷的函数2.0：可以实现展开一片的效果
//int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
//{
//	int x = 0;
//	int y = 0;
//	int ret1 = 0;
//	while (1)
//	{
//		printf("请输入你要排查的坐标:>");
//		scanf("%d %d", &x, &y);
//		if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过
//		{
//			if (show[x][y] == '*' || show[x][y] == '!')
//			{
//				if (show[x][y] == '*')
//				{
//				again:
//					if (mine[x][y] == '1')//该坐标是雷
//					{
//						system("cls");//清空屏幕——头文件windows.h
//						printf("很遗憾，你被雷炸死了，游戏失败！\n");
//						printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//						PrintBoard(mine, ROW, COL);
//						ret1 = 1;
//						break;
//					}
//					else//该坐标不是雷
//					{
//						ExpandAround(mine, show, x, y);//直接展开
//						system("cls");//清空屏幕——头文件windows.h
//						int ret2 = IsWin(show, row, col);
//						if (ret2 == 1)
//						{
//							printf("恭喜你！找到了所有的雷，游戏胜利！\n");
//							printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");
//							PrintBoard(mine, row, col);
//						}
//						else
//						{
//							PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷
//						}
//						break;
//					}
//				}
//				else
//				{
//					int select = 0;
//					printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");
//					while (1)
//					{
//						printf("请输入（0/1）:>");
//						scanf("%d", &select);
//						if (select == 0)
//						{
//							return 0;
//						}
//						else if (select == 1)
//						{
//							goto again;
//						}
//						else
//						{
//							printf("输入错误，请重新输入\n");
//						}
//					}
//				}
//			}
//			else
//			{
//				printf("该坐标已经被排查过，请重新输入\n");
//			}
//		}
//		else//越界
//		{
//			printf("该坐标越界，请重新输入\n");
//		}
//	}
//	return ret1;
//}//定义排查雷的函数3.0：可以实现展开一片的效果
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{//第一次排查确保该点不是雷以及周围没有雷，达到网页版扫雷的效果//由于是随机排雷，不能保证该点以及周围有无雷，可以将雷，神不知鬼不觉地换掉static int FindMineCount = 1;if (FindMineCount == 1){int x = 0;int y = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col){FirstIsSafe(mine, show, x, y);FindMineCount++;system("cls");//PrintBoard(mine, ROW, COL);PrintBoard(show, ROW, COL);return 0;}else{printf("输入的坐标越界，请重新输入\n");}}}//以后雷的位置就固定下来了else{int x = 0;int y = 0;int ret1 = 0;while (1){printf("请输入你要排查的坐标:>");scanf("%d %d", &x, &y);if (x >= 1 && x <= row && y >= 1 && y <= col)//判断输入的坐标是否合法且未被排查过{if (show[x][y] == '*' || show[x][y] == '!'){if (show[x][y] == '*'){again:if (mine[x][y] == '1')//该坐标是雷{system("cls");//清空屏幕——头文件windows.hprintf("很遗憾，你被雷炸死了，游戏失败！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, ROW, COL);ret1 = 1;break;}else//该坐标不是雷{ExpandAround(mine, show, x, y);//直接展开system("cls");//清空屏幕——头文件windows.hint ret2 = IsWin(show, row, col);if (ret2 == 1){printf("恭喜你！找到了所有的雷，游戏胜利！\n");printf("雷的布局如下图所示（0代表不是雷，1代表是雷）\n");PrintBoard(mine, row, col);}else{PrintBoard(show, ROW, COL);//打印存放展示雷的信息，以便于下一次排雷}break;}}else{int select = 0;printf("确定要排查标记过的坐标吗？ 0.取消排查 1.坚持排查\n");while (1){printf("请输入（0/1）:>");scanf("%d", &select);if (select == 0){return 0;}else if (select == 1){goto again;}else{printf("输入错误，请重新输入\n");}}}}else{printf("该坐标已经被排查过，请重新输入\n");}}else//越界{printf("该坐标越界，请重新输入\n");}}FindMineCount++;return ret1;}
}//定义第一次排雷是安全的，不是雷并且可以达到展开一片的效果，增加了可玩性
void FirstIsSafe(char mine[ROWS][COLS], char show[ROWS][COLS],int x, int y)
{//若该点不是雷且周围无雷，直接展开if (mine[x][y] != '1' && AroundMineCount(mine, x, y) == 0){ExpandAround(mine, show, x, y);}//否则分情况else{//先判断该点是不是雷if (mine[x][y] == '1')//该点为雷，将其移走{mine[x][y] = '0';while (1){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if (mine[x1][y1] != '1' && x1 != x && y1 != y){mine[x1][y1] = '1';break;}}}//以及将雷移走了，在判断周围是否有雷if (AroundMineCount(mine, x, y) != 0)//该点周围有雷，将它们移走{int count = AroundMineCount(mine, x, y);//计算周围雷的数量int i = 0;for (i = x - 1;i <= x + 1; i++){int j = 0;for (j = y - 1; j <= y + 1; j++){mine[i][j] = '0';//将周围的雷变为无雷的状态}}while (count){int x1 = rand() % ROW + 1;int y1 = rand() % COL + 1;if ((x1 != x - 1 && y1 != y - 1)&&(x1 != x - 1 && y1 != y)&&(x1 != x - 1 && y1 != y + 1)&&(x1 != x && y1 != y - 1)&&(x1 != x && y1 != y)&&(x1 != x && y1 != y + 1)&&(x1 != x + 1 && y1 != y - 1)&&(x1 != x + 1 && y1 != y)&&(x1 != x + 1 && y1 != y + 1))//不能将雷移回来{if (mine[x1][y1] != '1'){mine[x1][y1] = '1';//如果该坐标不是雷，则布置雷count--;}}}}ExpandAround(mine, show, x, y);}
}
  • test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"//菜单
void Menu()
{printf("-------------------------------------\n");printf("|              扫雷游戏！           |\n");printf("|        0.exit        1.play       |\n");printf("-------------------------------------\n");
}
void Game()
{//创建两个二维数组char mine[ROWS][COLS];//存放该点是不是雷    （0代表不是雷，1代表是雷）char show[ROWS][COLS];//存放该点周围有多少雷（数字代表周围有多少雷，*代表未知）//初始化棋盘InitBoard(mine, ROWS, COLS, '0');InitBoard(show, ROWS, COLS, '*');//打印棋盘//PrintBoard(mine, ROW, COL);//PrintBoard(show, ROW, COL);//布置雷SetMine(mine, ROW, COL);//PrintBoard(mine, ROW, COL);PrintBoard(show, ROW, COL);int select = 0;int ret1 = 0;int ret2 = 0;while (ret1 != 1 && ret2 != 1){printf("1.排查雷  2.标记雷  3.删除雷的标记\n");printf("请选择:>");scanf("%d", &select);switch (select){case 1:ret1 = FindMine(mine, show, ROW, COL);ret2 = IsWin(show, ROW, COL);break;case 2:MarkMine(show, ROW, COL);break;case 3:DelectMarkMine(show, ROW, COL);break;default:printf("输入的值错误，请重新输入\n");break;}}
}
int main()
{int input = 0;srand((unsigned int)time(NULL));//设置随机种子do{Menu();printf("请输入(0/1):>");scanf("%d", &input);switch (input){case 1:Game();break;case 0:printf("退出游戏\n");break;default:printf("输入错误，请重新输入\n");break;}} while (input);return 0;
}

四.截图

  • 最后附上其中一张截图。

请添加图片描述

  • 感兴趣的可以去玩一下哈，最后到这文章也就结束了，日后还会更新更多的小游戏，例如贪吃蛇等等，喜欢的话可以三连下下哦，以防找不到了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/831801.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Leetcode—1056. 易混淆数【简单】Plus

Leetcode—1056. 易混淆数【简单】Plus

2024每日刷题&#xff08;126&#xff09; Leetcode—1056. 易混淆数 &#x1f4a9;山实现代码 class Solution { public:bool confusingNumber(int n) {int arr[10] {0};int notNum 0;int arr2[12] {0};int size 0;while(n) {int x n % 10;arr[x] 1;arr2[size] x;if(…
阅读更多...
OneFlow深度学习框原理、用法、案例和注意事项

OneFlow深度学习框原理、用法、案例和注意事项

本文将基于OneFlow深度学习框架&#xff0c;详细介绍其原理、用法、案例和注意事项。OneFlow是由中科院计算所自动化研究所推出的深度学习框架&#xff0c;专注于高效、易用和扩展性强。它提供了一种类似于深度学习库的接口&#xff0c;可以用于构建神经网络模型&#xff0c;并…
阅读更多...
【Java基础】Maven的生命周期（clean+site+default）

【Java基础】Maven的生命周期（clean+site+default）

1. 前言 在 Maven 出现之前&#xff0c;项目构建的生命周期就已经存在&#xff0c;开发人员每天都在对项目进行清理&#xff0c;编译&#xff0c;测试及部署&#xff0c;但由于没有统一的规范&#xff0c;不同公司甚至不同项目之间的构建的方式都不尽相同。 Maven 从大量项目…
阅读更多...
Java Web网页设计（7）-网页查看

Java Web网页设计（7）-网页查看

7.面我们讲最后一个操作 修改的操作 在讲修改之前 我们先讲一个知识点 表单调用的通常是doPost方法 超链接通常调用的是doGet方法 操作如何在同一个方法 (doGet中) 进行区分 type OrderDao orderDaonew OrderDao(); String typereq.getParameter("type"); …
阅读更多...
nn.GRU层输出:state与output的关系

nn.GRU层输出:state与output的关系

在 GRU&#xff08;Gated Recurrent Unit&#xff09;中&#xff0c;output 和 state 都是由 GRU 层的循环计算产生的&#xff0c;它们之间有直接的关系。state 实际上是 output 中最后一个时间步的隐藏状态。 GRU 的基本公式 GRU 的核心计算包括更新门&#xff08;update gat…
阅读更多...
ZooKeeper以及DolphinScheduler的用法

ZooKeeper以及DolphinScheduler的用法

目录 一、ZooKeeper的介绍 数据模型 ​编辑 操作使用 ①登录客户端 ​编辑 ②可以查看下面节点有哪些 ③创建新的节点&#xff0c;并指定数据 ④查看节点内的数据 ⑤、删除节点及数据 特殊点&#xff1a; 运行机制&#xff1a; 二、DolphinScheduler的介绍 架构&#…
阅读更多...
将java项目上传到GitHub步骤

将java项目上传到GitHub步骤

文章目录 GitHub 作用github如何修改默认分支为master手把手教你把项目上传github上github怎么删除仓库或项目执行到push时报错的解决办法github怎么修改仓库语言 GitHub 作用 GitHub 是一个存放软件代码的网站&#xff0c;主要用于软件开发者存储和管理其项目源代码&#xff…
阅读更多...
HTB Intuition

HTB Intuition

Intuition User nmap ┌──(kali㉿kali)-[~/…/machine/SeasonV/linux/iClean] └─$ nmap -A 10.129.22.134 Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-04-30 05:29 EDT Nmap scan report for 10.129.22.134 Host is up (0.49s latency). Not shown: 998 …
阅读更多...
连接HiveMQ代理器实现MQTT协议传输

连接HiveMQ代理器实现MQTT协议传输

先下载MQTTX: MQTTX: Your All-in-one MQTT Client Toolbox 使用线上免费的MQTTX BROKER:The Free Global Public MQTT Broker | Try Now | EMQ 打开MQTTX&#xff0c;创建连接&#xff0c;点击NEW SUBSCRIPTION,创建一个主题&#xff0c;这里使用test/topic,在下面Json中填写…
阅读更多...
日本2024年铃木亮平主演的电影《城市猎人》

日本2024年铃木亮平主演的电影《城市猎人》

《城市猎人》是由佐藤祐市执导、三岛龙朗担任编剧、铃木亮平主演的动作片&#xff0c;于2024年4月25日上线Netflix。 该片改编自北条司的同名漫画&#xff0c;讲述了负责处理黑社会纠纷的清道夫在寻找失踪的Cosplayer时被卷入巨大阴谋的故事 [2]。 相关星图 查看更多 佐藤佑…
阅读更多...
中间件之搜索和数据分析组件Elasticsearch

中间件之搜索和数据分析组件Elasticsearch

一、概述 1.1介绍 The Elastic Stack, 包括 Elasticsearch、Kibana、Beats 和 Logstash&#xff08;也称为 ELK Stack&#xff09;。 能够安全可靠地获取任何来源、任何格式的数据&#xff0c;然后实时地对数据进行搜索、分析和可视 化。Elaticsearch&#xff0c;简称为 ES&a…
阅读更多...
【Android学习】自定义文本框和输入监听

【Android学习】自定义文本框和输入监听

实现功能 以上代码可实现功能&#xff1a; 1 自定义文本框样式 2. 文本框触发形式转变 3. 文本框输入长度监听&#xff0c;达到最大长度关闭软键盘 4. password框触发检测phone框内容 1. drawable自定义形状 我创建了editor_focus.xml 和 editor_unfocus.xml&#xff0c;两者仅…
阅读更多...
Codeforces Round 943 (Div. 3 ABCDEFG1G2题) 视频讲解

Codeforces Round 943 (Div. 3 ABCDEFG1G2题) 视频讲解

A. Maximize? Problem Statement You are given an integer x x x. Your task is to find any integer y y y ( 1 ≤ y < x ) (1\le y<x) (1≤y<x) such that gcd ⁡ ( x , y ) y \gcd(x,y)y gcd(x,y)y is maximum possible. Note that if there is more tha…
阅读更多...
计算机毕业设计Python+Spark考研预测系统 考研推荐系统 考研数据分析 考研大数据 大数据毕业设计 大数据毕设

计算机毕业设计Python+Spark考研预测系统 考研推荐系统 考研数据分析 考研大数据 大数据毕业设计 大数据毕设

安顺学院本科毕业论文(设计)题目申请表 院别&#xff1a;数学与计算机科学 专业&#xff1a;数据科学与大数据 时间&#xff1a;2022年 5月26日 题 目 情 况 题目名称 基于hive数据仓库的考研信息离线分析系统的设计与实现 学生姓名 杨娣荧 学号 201903144042 …
阅读更多...
华为鸿蒙系统（Huawei HarmonyOS）

华为鸿蒙系统（Huawei HarmonyOS）

华为鸿蒙系统&#xff08;华为技术有限公司开发的分布式操作系统&#xff09; 华为鸿蒙系统&#xff08;HUAWEI HarmonyOS&#xff09;&#xff0c;是华为公司在2019年8月9日于东莞举行的华为开发者大会&#xff08;HDC.2019&#xff09;上正式发布的分布式操作系统。 华为鸿蒙…
阅读更多...
使用DependencyCheck工具检测JAR依赖包的安全漏洞

使用DependencyCheck工具检测JAR依赖包的安全漏洞

引言 Dependency-Check 是一个开源工具，用于检测软件项目中使用的第三方库和组件是否存在已知的安全漏洞。它可以帮助开发团队及时发现和解决项目中的潜在安全风险，从而提高软件的安全性。 该工具通过分析项目的依赖关系，识别其中使用的第三方库和组件，并与已知的漏洞数据…
阅读更多...
IOS 开发 - block 使用详解

IOS 开发 - block 使用详解

1.Blobk的定义 block的写法相对难记,不必司机应被,只需要在xcode里打出"inlineBlock"--回车, 系统会自动帮你把基础版写法给你匹配出来 //Block的基础声明//等号""之前是blobk的声明,等号“”后面是block的实现/*returnType:返回类型(void、int、String *…
阅读更多...
zabbix监控Tongweb7企业版（by lqw+sy）

zabbix监控Tongweb7企业版（by lqw+sy）

此贴参考zabbix通过jmx监控Tongweb7企业版&#xff08;by lqw&#xff09;&#xff0c;是在此帖子的基础和同事整理的文档基础上重新部署验证的优化版&#xff0c;使用的是centos7。 优点&#xff1a; 1.不需要通过jmx配置进行监控。&#xff08;jmx配置需要修改tongweb的配置…
阅读更多...
IO复用技术（1）——select/poll/epoll原理介绍及使用案例

IO复用技术（1）——select/poll/epoll原理介绍及使用案例

文章目录 1.Select1.1 工作流程1.2 fd_set函数1.3 select函数1.4 例程 2.poll2.1 poll函数2.2 例程 3.epoll3.1 工作流程3.2 相关函数3.3 epoll的两种工作模式3.4 示例代码 4.总结 原理&#xff1a;使用一个线程来检查多个文件描述符&#xff0c;委托内核进行检查&#xff0c;如…
阅读更多...
Mac OS系统如何更新

Mac OS系统如何更新

用了好几年的Mac Book安装软件经常提示需要更高的系统版本&#xff0c;因此要升级系统版本&#xff0c;但是开始在系统设置里面找了一下没有找到升级的按钮&#xff0c;找了资料后才知道如何升级。有以下两种入口 一、App Store搜索MacOs&#xff0c;在出现的搜索结果中选择下载…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站