扫雷C语言（可展开一片空白）

已于 2024-02-14 19:59:52 修改
阅读量970 收藏 36
点赞数 19
分类专栏： 欢迎来到C语言世界 文章标签： c语言
于 2024-02-02 18:48:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79551553/article/details/135968312
版权

🪐🪐🪐欢迎来到程序员餐厅💫💫💫

         今日主菜：扫雷小游戏，

                 主厨：邪王真眼

            所属专栏： C语言知识点   

              主厨的主页：Chef‘s blog

引言：

                已经学会数组的朋友注意了，现在的你已经有能力写出两个小游戏了，一个是扫雷，一个是三子棋，上次咱们搞定了三子棋代码，今天这扫雷又送上了门。

         本章你可能会用到的知识：

1. 扫雷游戏要求

  1.  游戏可以通过菜单实现继续玩或者退出游戏
  2.  默认棋盘为9×9的格子，但可以修改
  3.  默认随机布置雷，默认雷的个数为9，但可以修改
  4. 关于排查雷

 （1） 如果位置不是雷，就显⽰周围有⼏个雷，并且循环展开。
 （2）如果位置是雷，就炸死游戏结束
 （3）把所有⾮雷都找出来，排雷成功，游戏结束

 （4）玩家可以对认为是雷的位置进行可能是雷或肯定是雷的标记。 

2 游戏的分析和设计

2.1 数据结构的分析
扫雷的过程中，布置的雷和排查出的雷的信息都需要存储，所以我们需要⼀定的数据结构来存储这些信息。 因为我们需要在9*9的棋盘上布置雷的信息和排查雷，我们⾸先想到的就是创建⼀个9*9的数组来存放信息。

那如果这个位置布置雷，我们就存放1，没有布置雷就存放0.

排查(8,6)这个坐标时，我们访问周围的⼀圈8个⻩⾊位置，最下⾯的三 个坐标就会越界，因此我们在设计的时候，给数组扩大⼀圈，雷还是布置在中间的9*9的坐标上，周围⼀圈不去布置雷就行，这样就解决了越界的问题。所以我们将存放数据的数组创建成11*11 是⽐较合适。
  1. 问题：假设我们排查了某 ⼀个位置后，这个坐标处不是雷，这个坐标的周围有1个雷，那我们需要将排查出的雷的数量信息记录下来，那这个雷的个数信息存放在哪⾥呢？如果存放在布 置雷的数组中，这样雷的信息和雷的个数信息就可能或产⽣混淆和打印上的困难。
  2. 解决：这⾥我们肯定有办法解决，⽐如：雷和⾮雷的信息不要使⽤数字，使⽤某些字符就行，但是这样做棋盘上有雷和非雷的信息，还有排查出的雷的个数信息，就⽐较混杂，不够⽅便。我们采⽤另外⼀种⽅案，我们专门给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再 给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。这样就互不⼲扰了，
  3. 补充：同时为了保持神秘，show开始时初始化为字符 '*'，mine数组最开始也初始化为字符'0'，布置雷改成'1'。如下如：

3.多文件操作


              为了方便代码的管理和保证游戏实现逻辑的清晰性，函数的声明与定义是分开写的，所以我们将采用多文件管理的模式。

        （1）创建头文件game.h，包含所有头文件(其他源文件只需引用它即可)，以及所有游戏功能的函数接口。

        （2）创建源文件game.c，负责所有游戏功能对应函数的具体代码实现。

        （3）创建源文件main.c，负责调用函数实现来游戏。

4.  简易菜单的实现

4.1功能介绍

 1.玩家可以通过选择1进入游戏，0退出游戏。

2.选错的话提醒玩家，重新选择。

3.告诉玩家游戏规则

4.2功能实现

void menu(void)
{
	printf("***************************\n");
	printf("***   1 开始游戏   ********\n");
	printf("***   0 结束游戏   ********\n");
	printf("***************************\n");
}
void rules()
{
	printf("游戏规则如下：\n");
	printf("1.你可以通过排雷和标记逐渐逼近胜利条件\n");
	printf("2.对同一坐标标记1次是!，标记2次是?，第3次恢复*\n");
	printf("3.标记!代表肯定是雷，标记?代表可能是雷\n");
	printf("4.标记!的次数最多为雷的个数\n");
	printf("5.如果选中雷，则游戏失败\n");
	printf("6.当成功标记所有雷，或者排查完所有格子，游戏胜利\n");
}

int main()
{
	srand((unsigned int)time(NULL));
	rules();
	do
	{
		menu();
	again:
		printf("请选择->");
		int input;
		scanf("%d", &input);
		gets(brr);
		switch (input)
		{
		case 1:
			printf("----------------扫雷游戏----------------\n");
			game();
			break;
		case 0:
			printf("结束游戏\n");
			return 0;
		default:
			printf(" 选择错误，重新选择\n");
			goto again;
		}
	} while (1);
	return 0;
}

4.3功能展示

5. 游戏功能实现

  5.1 预定义信息

（1）要求

  • 1.包含需要的头文件
  • 2.包含需要的宏定义
  • 3.包含需要的函数接口

（2）代码实现

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define L 9
#define W 9
#define LS L+2
#define WS L+2
#define NUM 9
void intiboard(char arr[LS][WS], int ls, int ws, char a);
void printboard(char arr[LS][WS], int l, int w);
void setmine(char arr[LS][WS], int l, int w,int a,int b);
void mark(char arr[LS][WS], int l, int w);
int conuts(char arr1[LS][WS], int x, int y);
void judge(char arr1[LS][WS], char arr2[LS][WS], int l, int w, int num,int x,int y);
int iswin(char arr1[LS][WS], char arr2[LS][WS], int l, int w);

 5.2 初始化棋盘

   （1）要求

1. mine棋盘初始化为全‘0’。

2. show棋盘初始化为全‘*’。

（2）实现
  1. void intiboard(char arr[LS][WS], int ls, int ws, char a)
{
	for (int i = 0; i < ls; i++)
	{
		for (int j = 0; j < ws; j++)
		{
			arr[i][j] = a;
		}
	}
}

    5.3 打印棋盘

        （1）要求

    1. 打印出棋盘中的元素。

    2. 利用---,|模拟出棋盘框。

    3. 显示出每行，每列的序号。

        （2）实现 
    void printboard(char arr[LS][WS], int l, int w)
{
	printf("----------------扫雷ing----------------\n");
	for (int i = 0; i <= l; i++)
		printf(" %d  ", i);
	printf("\n");
	printf("   |---|---|---|---|---|---|---|---|---|");
	
	printf("\n");
	for (int i = 1; i <= l; i++)
	{
		printf(" %d |", i);
		for (int j = 1; j <= w; j++)
		{
			printf(" %c |", arr[j][i]);
		}printf("\n");
		printf("   |---|---|---|---|---|---|---|---|---|");
		printf("\n");
		
	}
}
    （3）效果展示

 5.4 埋雷 
    （1）要求

1.在mine棋盘中随机布置9个雷，雷为‘0’。

2.重复位置不能布置。

3.在第一次输入坐标后在埋雷，防止第一次直接炸死（这个实现不在这个函数里）

    （2）实现 
void setmine(char arr[LS][WS], int l, int w)
{
	int num = NUM;
	while (num)
	{
		int x, y;
	a:    x = rand() % l + 1;
		y = rand() % l + 1;
		if (arr[x][y] == '0')
		{
			arr[x][y] = '1';
			num--;
		}
		else
			goto a;
	}
}

（3）效果展示

 5.5 排雷和标记


  （1）要求·：

  1.  每次玩家都可以先进行排雷和标记。
  2.  玩家输入的值不合法时提醒玩家重新输入
  3.  对于同一个坐标，第一次标记为！代表肯定是雷；第二次标记为？代表可能是雷；第三次   标记恢复‘*’。
  4.  排雷时，玩家输入要排除的坐标，如果是雷，则游戏结束；如果不是雷，则统计周围雷的个数。
  5.  如果周围没有雷，则向周围展开至有雷为止。

 （2）递归排雷的实现 

}
int conuts(char arr1[LS][WS], int x, int y)
{
	int count = 0;
	for (int i = x - 1; i <= x + 1; i++)
	{
		for (int j = y - 1; j <= y + 1; j++)
		{
			if (arr1[i][j] == '1')
				count++;
		}
	}
	return count;
}
void judge(char arr1[LS][WS], char arr2[LS][WS], int l, int w, int num, int x, int y)
{
	if (x > L || y > L || x < 1 || y < 1)
	{
		return;
	}
	if (arr1[x][y] == '1')
		return;
	int count = 0;//这个格子一圈的雷，你找到的非雷
	if (flag == 0)
	{
		arr2[x][y] = ' ';
		flag++;
		setmine(arr1, L, W, x, y);
		count = conuts(arr1, x, y);
		if (!count)
		{
			arr2[x][y] = ' ';
			if (arr2[x - 1][y] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y);
			if (arr2[x - 1][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y - 1);
			if (arr2[x - 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y + 1);
			if (arr2[x][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y - 1);
			if (arr2[x][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y + 1);
			if (arr2[x + 1][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y - 1);
			if (arr2[x + 1][y] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y);
			if (arr2[x + 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y + 1);
		}
		else
			arr2[x][y] = count + '0';
		z++;
	}
	else
	{
		count = conuts(arr1, x, y);
		if (!count)
		{
			arr2[x][y] = ' ';
			if (arr2[x - 1][y] != ' ' &&(arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y);
			if (arr2[x - 1][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y - 1);
			if (arr2[x - 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y + 1);
			if (arr2[x][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y - 1);
			if (arr2[x][y + 1] != ' ' &&( arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y + 1);
			if (arr2[x + 1][y - 1] != ' ' &&( arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y - 1);
			if (arr2[x + 1][y] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y);
			if (arr2[x + 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y + 1);
		}
		else
			arr2[x][y] = count + '0';
		z++;
	}
}

效果展示

（3）标记的实现 

void mark(char arr[LS][WS], int l, int w)
{
	printf("标记雷输入1，不标记输入0\n");
	int a = 0;
	scanf("%d", &a);
	gets(brr);
	if (a)
	{
		printf("请输入你要标记的坐标->\n");
		int x, y;
	again:	scanf("%d %d", &x, &y);
		gets(brr);
		if (x > l || y > l || x < 1 || y < 1)
		{
			printf("输入错误，请重新输入\n");
			goto again;
		}
		else if (arr[x][y] == '*')
			arr[x][y] = '!';
		else if (arr[x][y] == '!')
			arr[x][y] = '?';
		else if (arr[x][y] == '?')
			arr[x][y] = '*';
	}
}

5.6 胜利条件

（1）要求

成功排查完除雷外所有格子，游戏胜利。

（2）实现

int iswin(char arr1[LS][WS], char arr2[LS][WS], int l, int w)
{
	int num = 0;
	for(int i=1;i<=l;i++)
		for (int j = 1; j <= w; j++)
		{
			if (arr2[i][j] == ' ' && arr1[i][j] == '1')
				return -1;
			if (arr2[i][j]-'0'<=9&&arr2[i][j]-'0'>=0||arr2[i][j]==' ')
				num++;
		}
	return num;
}

6. 游戏实现 

  6.1函数调用分析顺序

1. 初始化棋盘。

2. 先让玩家输入一个排雷坐标再埋雷，防止第一次就被炸死。

3. 玩家选择标记还是埋雷。

4. 判断玩家是否被炸死，判断玩家是否胜利。

5.如果步骤4未成功执行，就重复执行步骤3,4。

 6.2 实现

void game()
{
	char arr1[LS][WS] = { 0 };
	char arr2[LS][WS] = { 0 };
	intiboard(arr2, LS, WS, '*');
	intiboard(arr1, LS, WS, '0');
	printboard(arr2, L, W);
	int flag0 = 1;
	do
	{
		int x, y;
		printf("请输入坐标->");
	again:	scanf("%d %d", &x, &y);
		gets(brr);
		if (x > L || y > L || x < 1 || y < 1)
		{
			printf("输入坐标不再棋盘内，请重新输入\n");
			goto again;
		}
		else 	if (arr2[x][y] == ' ' || arr2[x][y] - '0' <= 9 && arr2[x][y] - '0' >= 1)
		{
			printf("此位置已被排雷，请重新输入\n");
			goto again;
		}
		judge(arr1, arr2, L, W, NUM, x, y);
		int flag0=iswin( arr1, arr2, L,  W);
		if (flag0 == -1)
		{
			printf("你被炸死了，游戏结束");
			break;
		}
		if (L * L - flag0 == NUM)
		{
			printf("恭喜你，顺利通关\n");
			break;
		}
		mark( arr2, L, W);
		printboard(arr2, L, W);
	} while (1);
}

7. 源码 

  （1）game.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"源.h"
char brr[100];
void menu(void)
{
	printf("***************************\n");
	printf("***   1 开始游戏   ********\n");
	printf("***   0 结束游戏   ********\n");
	printf("***************************\n");
}
void rules()
{
	printf("游戏规则如下：\n");
	printf("1.你可以通过排雷和标记逐渐逼近胜利条件\n");
	printf("2.对同一坐标标记1次是!，标记2次是?，第3次恢复*\n");
	printf("3.标记!代表肯定是雷，标记?代表可能是雷\n");
	printf("4.标记!的次数最多为雷的个数\n");
	printf("5.如果选中雷，则游戏失败\n");
	printf("6.当成功标记所有雷，或者排查完所有格子，游戏胜利\n");
}

void game()
{
	char arr1[LS][WS] = { 0 };
	char arr2[LS][WS] = { 0 };
	intiboard(arr2, LS, WS, '*');
	intiboard(arr1, LS, WS, '0');
	printboard(arr2, L, W);
	int flag0 = 1;
	do
	{
		int x, y;
		printf("请输入坐标->");
	again:	scanf("%d %d", &x, &y);
		gets(brr);
		if (x > L || y > L || x < 1 || y < 1)
		{
			printf("输入坐标不再棋盘内，请重新输入\n");
			goto again;
		}
		else 	if (arr2[x][y] == ' ' || arr2[x][y] - '0' <= 9 && arr2[x][y] - '0' >= 1)
		{
			printf("此位置已被排雷，请重新输入\n");
			goto again;
		}
		judge(arr1, arr2, L, W, NUM, x, y);
		int flag0=iswin( arr1, arr2, L,  W);
		if (flag0 == -1)
		{
			printf("你被炸死了，游戏结束");
			break;
		}
		if (L * L - flag0 == NUM)
		{
			printf("恭喜你，顺利通关\n");
			break;
		}
		mark( arr2, L, W);
		printboard(arr2, L, W);
	} while (1);
}
int main()
{
	srand((unsigned int)time(NULL));
	rules();
	do
	{
		menu();
	again:
		printf("请选择->");
		int input;
		scanf("%d", &input);
		gets(brr);
		switch (input)
		{
		case 1:
			printf("----------------扫雷游戏----------------\n");
			game();
			break;
		case 0:
			printf("结束游戏\n");
			return 0;
		default:
			printf(" 选择错误，重新选择\n");
			goto again;
		}
	} while (1);
	return 0;
}

（2）源.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"源.h"
int flag = 0, z = 0;
char brr[100];
void intiboard(char arr[LS][WS], int ls, int ws, char a)
{
	for (int i = 0; i < ls; i++)
	{
		for (int j = 0; j < ws; j++)
		{
			arr[i][j] = a;
		}
	}
}
void printboard(char arr[LS][WS], int l, int w)
{
	printf("----------------扫雷ing----------------\n");
	for (int i = 0; i <= l; i++)
		printf(" %d  ", i);
	printf("\n");
	printf("   |---|---|---|---|---|---|---|---|---|");
	
	printf("\n");
	for (int i = 1; i <= l; i++)
	{
		printf(" %d |", i);
		for (int j = 1; j <= w; j++)
		{
			printf(" %c |", arr[j][i]);
		}printf("\n");
		printf("   |---|---|---|---|---|---|---|---|---|");
		printf("\n");
		
	}
}
void setmine(char arr[LS][WS], int l, int w,int a,int b)
{
	int num = NUM;
	while (num)
	{
		int x, y;
	a:    x = rand() % l + 1;
		y = rand() % l + 1;
		if (arr[x][y] == '0'&&(a!=x||b!=y))
		{
			arr[x][y] = '1';
			num--;
		}
		else
			goto a;
	}
}
int conuts(char arr1[LS][WS], int x, int y)
{
	int count = 0;
	for (int i = x - 1; i <= x + 1; i++)
	{
		for (int j = y - 1; j <= y + 1; j++)
		{
			if (arr1[i][j] == '1')
				count++;
		}
	}
	return count;
}
void judge(char arr1[LS][WS], char arr2[LS][WS], int l, int w, int num, int x, int y)
{
	if (x > L || y > L || x < 1 || y < 1)
	{
		return;
	}
	if (arr1[x][y] == '1')
		return;
	int count = 0;//这个格子一圈的雷，你找到的非雷
	if (flag == 0)
	{
		arr2[x][y] = ' ';
		flag++;
		setmine(arr1, L, W, x, y);
		//printboard(arr1, 9, 9);
		count = conuts(arr1, x, y);
		if (!count)
		{
			arr2[x][y] = ' ';
			if (arr2[x - 1][y] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y);
			if (arr2[x - 1][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y - 1);
			if (arr2[x - 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y + 1);
			if (arr2[x][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y - 1);
			if (arr2[x][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y + 1);
			if (arr2[x + 1][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y - 1);
			if (arr2[x + 1][y] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y);
			if (arr2[x + 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y + 1);
		}
		else
			arr2[x][y] = count + '0';
		z++;
	}
	else
	{
		count = conuts(arr1, x, y);
		if (!count)
		{
			arr2[x][y] = ' ';
			if (arr2[x - 1][y] != ' ' &&(arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y);
			if (arr2[x - 1][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y - 1);
			if (arr2[x - 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x - 1, y + 1);
			if (arr2[x][y - 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y - 1);
			if (arr2[x][y + 1] != ' ' &&( arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x, y + 1);
			if (arr2[x + 1][y - 1] != ' ' &&( arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y - 1);
			if (arr2[x + 1][y] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y);
			if (arr2[x + 1][y + 1] != ' ' && (arr2[x][y] - '0' > 9 || arr2[x][y] - '0' < 1))
				judge(arr1, arr2, l, w, num, x + 1, y + 1);
		}
		else
			arr2[x][y] = count + '0';
		z++;
	}
}
void mark(char arr[LS][WS], int l, int w)
{
	printf("标记雷输入1，不标记输入0\n");
	int a = 0;
	scanf("%d", &a);
	gets(brr);
	if (a)
	{
		printf("请输入你要标记的坐标->\n");
		int x, y;
	again:	scanf("%d %d", &x, &y);
		gets(brr);
		if (x > l || y > l || x < 1 || y < 1)
		{
			printf("输入错误，请重新输入\n");
			goto again;
		}
		else if (arr[x][y] == '*')
			arr[x][y] = '!';
		else if (arr[x][y] == '!')
			arr[x][y] = '?';
		else if (arr[x][y] == '?')
			arr[x][y] = '*';
	}
}
int iswin(char arr1[LS][WS], char arr2[LS][WS], int l, int w)
{
	int num = 0;
	for(int i=1;i<=l;i++)
		for (int j = 1; j <= w; j++)
		{
			if (arr2[i][j] == ' ' && arr1[i][j] == '1')
				return -1;
			if (arr2[i][j]-'0'<=9&&arr2[i][j]-'0'>=0||arr2[i][j]==' ')
				num++;
		}
	return num;
}

（3）源.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#define L 9
#define W 9
#define LS L+2
#define WS L+2
#define NUM 9
void intiboard(char arr[LS][WS], int ls, int ws, char a);
void printboard(char arr[LS][WS], int l, int w);
void setmine(char arr[LS][WS], int l, int w,int a,int b);
void mark(char arr[LS][WS], int l, int w);
int conuts(char arr1[LS][WS], int x, int y);
void judge(char arr1[LS][WS], char arr2[LS][WS], int l, int w, int num,int x,int y);
int iswin(char arr1[LS][WS], char arr2[LS][WS], int l, int w);

结语：

恭喜你，看完了这~么长的文章，熟能生巧，看完记得练习哦，

ps：本章部分图片来源《比特就业课课件》。

一颗青果
关注
专栏目录
【C语言】扫雷详解（可展开一片）
cc`.的博客
05-03 968
c语言扫雷
C语言扫雷（递归展开）（详细注释）（完整代码）
AAAAA_9的博客
08-02 8348
c语言扫雷游戏
C语言扫雷代码（可以展开一片）
s13057696399的博客
12-10 868
展开函数需要用到两个数组，因为在计算雷个数的函数中需要用到mine数组，在展开时候需要在show数组中展示出来。
【C语言】扫雷（可展开空白版与鼠标操作版）
Kevin ’ s blog
01-20 1606
扫雷游戏是一款经典的单人电脑游戏，最初由微软公司开发。玩家需要根据数字提示，在不触雷的情况下揭开所有格子。这是一款考验逻辑思维和运气的游戏，而我们将用C语言来实现它。该程序有一个头文件和两个源文件构成。在头文件game.h中进行函数的声明，在源文件game.c中进行函数的实现，在test.c中进行程序测试，实现主函数。接下来我将从主函数开始进行代码的逐一讲解，需要源代码可以在中的bite_begin路径下进行查找或者在文章结尾会有全部源代码。
扫雷展开空白的实现
weidaimafendou的博客
01-26 327
关于扫雷空白展开的实现
C语言扫雷游戏实现(增加展开一片与标记)
anjibgdexuexi的博客
01-19 828
C语言学习: 坚持每日C语言练习 (gitee.com)
扫雷大战（命令行版，可以连续扫除一片空白区域）
越努力越幸运
11-13 1621
命令行版扫雷
扫雷自定义最难C语言,C语言实现扫雷游戏（可标记雷）有三种难度等级！选中空白可开辟一片空间，高仿扫雷...
weixin_39632291的博客
05-17 596
源文件#define _CRT_SECURE_NO_WARNINGS 1#include "game.h"void menu(){printf("***************************\n");printf("******** 1.play *********\n");printf("******** 0.exit *********\n");printf("*******...
C语言扫雷（递归实现清消一片）
m0_67038767的博客
05-09 466
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决.
c语言实现扫雷+排雷时展开一片的效果
11-03
扫雷
扫雷C语言代码，可自己调节难度
05-10
扫雷C语言代码，可自己调节难度
扫雷 C语言源代码
03-11
C语言源程序，带注释
【C语言】数据在内存中的存储
2401_86272648的博客
09-11 886
内存中以一个字节为单元，超过一个字节的数据（short、int、long）在内存中存储，必然就有存储顺序的问题。另外，对于大于8位的处理器，例如16位、32位处理器，由于寄存器宽度大于一个字节，也会存在多个字节的存储顺序的问题。在内存中数据是以二进制存储的，这里为了方便书写和观察，用十六进制表示。
C/C++内存管理
黎相思的博客
09-14 876
int main()//new/delete 和 malloc/free最大区别是 new/deeletc对于//自定义类型除了开空间还会调用构造函数和析构函数。//没有默认构造就会报错,当然也可以自己传参//这里有点像匿名对象,但不是匿名对象//这是在堆上new一个对象,然后构造。然后把对象的地址返回给p3free(p1);//释放空间delete p2;
基于C语言--解读main(int agrc,char* argv[ ])（命令行参数+环境变量）
binhyun的博客
09-15 633
0.背景 1.主函数的参数的几种类型 2.只有两个参数的主函数 3.使用命令行参数实现一个任务 3.1任务的说明 3.2任务的实现 4.拥有三个参数的主函数 4.1环境变量的解释 4.2参数说明
5110-微信小程序健身房私教预约微信小程序+ssm（源码+数据库+lun文）.zip
09-15
本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。本系统主要针对计算机相关专业的正在做毕业设计的学生和需要项目实战练习的学习者，可作为毕业设计、课程设计、期末大作业。
Fast_integration_dependencies_in_spring_boot.是一个快速_fastdep.zip
最新发布
09-15
Fast_integration_dependencies_in_spring_boot.是一个快速_fastdep
05-Python数据类型-列表的相关运算
09-15
05_Python数据类型_列表的相关运算 文章对应的 jupyter notebook 源文件，可以用来做练习。欢迎下载使用。 目录如下： Python的基础数据类型 列表运算符 赋值和深浅拷贝 赋值 浅拷贝 深拷贝 附件
扫雷c语言
05-26
扫雷是一种经典的游戏，可以使用C语言来实现。以下是一个简单的扫雷程序的实现示例： ```c #include #include #include #define ROWS 10 // 行数 #define COLS 10 // 列数 #define MINES 10 // 雷的数量 void ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值