[C++知识库]C语言实现扫雷游戏

一、扫雷规则

扫雷游戏基本规则，在棋盘上有几个指定位置是雷，踩雷则失败，游戏结束。在没有雷的格子上显示周围8格的雷的总数。

二、菜单打印

在实现游戏前，先打印菜单，为玩家提供选项，玩，或者退出。因为菜单至少打印一次，使用了do…while…循环。主要代码如下

void menu()
{
	printf("********************************\n");
	printf("*********   1. play     ********\n");
	printf("*********   0. exit     ********\n");
	printf("********************************\n");
}
int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择！\n");
			break;
		}
	} while (input);
	return 0;
}

三、游戏实现

打印棋盘

第一步要做的是打印棋盘，而在打印棋盘前要提前为雷和要存储的数目预留位置。将几种信息置入二维数组，假定字符1代表雷，字符0-8代表雷的数目。如果将雷，周围雷的数目（下文中简称数目）全部放在一个数组里，那数目计算时要判断周围存放的是数目信息还是雷，判断完毕计数，即使雷和数目中的字符1不会产生冲突，处理起来也十分麻烦。因此我们将雷和数目各自单独放在一个数组里。扫雷时，对应着雷数组，将计算结果放入数目数组。
计算数目时，最边缘的一圈在计算数目时会出现越界问题，为解决越界问题，我们将数组额外增加两行两列。以9×9棋盘为例，我们将其数组扩大为11×11的二维数组。打印时，只打印数目数组中间的9×9信息。

棋盘初始化与雷的布置

在打印棋盘之前还要预先进行两个数组的初始化。首先声明，放雷的数组中，雷是‘1’，非雷是’0’。初始化时，将数组全部置入’0’，为雷的布置做铺垫。放数目的数组，是直接显现的棋盘，全部置入 ’ * ’ ,在玩家扫到非雷的格子时，将对应的数字置入格子对应的数组位，随下一次棋盘打印出来。
初始化完成后，使用随机数生成和时间戳在棋盘9×9范围内随机生成一定数量的雷。
主要代码如下

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)     //哪个字符传给set，数组就初始化为对应的字符
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;          //count为雷的总数

	while (count)
	{
		//1. 生成随机下标
		int x = rand() % row + 1;    //取余之后数值范围为0-8，+1之后正好满足1-9，范围刚好是中间的9*9数组
		int y = rand() % col + 1;
		if (board[x][y] != '1')      //将'1'认为是雷，随机在9*9范围内找到未放雷的位置，并置入雷——'1'
		{
			board[x][y] = '1';
			count--;                 //布置一次雷，数量-1，直到雷布置完成，循环终止。
		}
	}
}

扫雷与数目的计算

扫雷开始，玩家需要指定9×9范围的坐标进行扫描，一次扫描一格。扫雷后，需将已扫到的无雷位周围8格的雷的数目计算出来，随后打印。
计算数目，则根据玩家指定坐标，来将周围数组元素的下标找出。并计数，雷是‘1’，非雷是’0’。前者的ASCII码值减后者的就是1，将8格的ASCII码求和，再减去8×’0’的ASCII码值，得到的就是雷的数量。最后展示时，该数值加’0’的ASCII码值，就是该数字的ASCII码值，就能打印出该数字。
主要代码如下

int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
	return (mine[x - 1][y] +                     //将非雷位置周围雷的数量置入数组对应位置
		mine[x - 1][y - 1] +                     //将mine[x][y]周围八格的内容都放入算式
		mine[x][y - 1] +                         //'1'代表着雷，'0'代表着非雷，8格内容-8*'0'，得到的整数刚好就是非雷位置周围雷的数量
		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');
}

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0;
	while (win < row * col - EASY_COUNT)    //一共10个雷，71个空格子，排出即获胜
	{
		printf("请输入要排查的坐标:>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)     //保证坐标在9*9范围内
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");           //踩雷
				DisplayBoard(mine, ROW, COL);
				break;
			}
			else
			{
				int count = GetMineCount(mine, x, y);    //若未被炸死，就将周围8格雷的数量置入show数组的对应位置
				show[x][y] = count + '0';                //由ASCAII码表的规律知，数量加0的ASCALL码值，就是数量对应数字的ASCAII码值，如3+'0'='3'
				DisplayBoard(show, ROW, COL);
				win++;
			}
		}
		else
		{
			printf("坐标非法，重新输入\n");
		}
	}

	if (win == row * col - EASY_COUNT)                //排出71个安全的格子才算成功
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, ROW, COL);
	}
}

此处的功能还不够完整，笔者能力有限，还未能实现。就是在无雷格子周围8格都无雷时，应当自动排除周围8格，以节省人力。
最后进行效果演示与完整代码展示。

效果演示

此处为方便演示，将雷数组也打印出来

完整代码展示

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

game.h
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <time.h>


#define ROW 9             //因为制作9*9的扫雷游戏，故定义两个标识符常量
#define COL 9

#define ROWS ROW+2        //若是未多预留两行两列，检查9*9最边缘的格子时，将会出现越界问题，更改算法解决过于复杂
#define COLS COL+2        //所以数组定为11*11，方便检查某一格周围有几个雷，在9*9的范围内检查，11*11比9*9多一圈，使得检查算法具有普遍性

#define EASY_COUNT 10

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);

//显示棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);

//布置雷
void SetMine(char board[ROWS][COLS], int row, int col);

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
test.c
#include "game.h"

void menu()
{
	printf("********************************\n");
	printf("*********   1. play     ********\n");
	printf("*********   0. exit     ********\n");
	printf("********************************\n");
}

void game()
{
	char mine[ROWS][COLS] = { 0 };//存放雷的信息
	char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息
	//初始化一下棋盘
	InitBoard(mine, ROWS, COLS, '0');//'0'，使用最后一个参数来初始化数组内容
	InitBoard(show, ROWS, COLS, '*');//'*'
	 
	//布置雷
	SetMine(mine, ROW, COL);       //随机在9*9范围内生成10个雷
	DisplayBoard(show, ROW, COL);  //将扫雷的图打印出来
	//DisplayBoard(mine, ROW, COL);//此处将雷数组打印出来，方便演示，可根据需要选择是否调用
	//排查雷
	FindMine(mine, show, ROW, COL);//开始扫雷
}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择！\n");
			break;
		}
	} while (input);

	return 0;
}
game.c
#include "game.h"

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)     //哪个字符传给set，数组就初始化为对应的字符
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	printf(" ");
	for (i = 0; i < row + 1; i++)
	{
		printf("%d ", i);              //打印列的参照坐标，方便观察
	}
	printf("\n");

	printf("  -------------------   \n");//分隔线

	for (i = 1; i <= row; i++)
	{
		int j = 0;
		printf("%d| ", i);             //打印行的参照坐标
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]); //打印棋盘
		}
		printf("|\n");
	}
	printf("  -------------------   \n");
}
void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;          //count为雷的总数

	while (count)
	{
		//1. 生成随机下标
		int x = rand() % row + 1;    //取余之后数值范围为0-8，+1之后正好满足1-9，范围刚好是中间的9*9数组
		int y = rand() % col + 1;
		if (board[x][y] != '1')      //将'1'认为是雷，随机在9*9范围内找到未放雷的位置，并置入雷——'1'
		{
			board[x][y] = '1';
			count--;                 //布置一次雷，数量-1，直到雷布置完成，循环终止。
		}
	}
}

int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
	return (mine[x - 1][y] +                     //将非雷位置周围雷的数量置入数组对应位置
		mine[x - 1][y - 1] +                     //将mine[x][y]周围八格的内容都放入算式
		mine[x][y - 1] +                         //'1'代表着雷，'0'代表着非雷，8格内容-8*'0'，得到的整数刚好就是非雷位置周围雷的数量
		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');
}

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0;
	while (win < row * col - EASY_COUNT)    //一共10个雷，71个空格子，排出即获胜
	{
		printf("请输入要排查的坐标:>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)     //保证坐标在9*9范围内
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");           //踩雷
				DisplayBoard(mine, ROW, COL);
				break;
			}
			else
			{
				int count = GetMineCount(mine, x, y);    //若未被炸死，就将周围8格雷的数量置入show数组的对应位置
				show[x][y] = count + '0';                //由ASCAII码表的规律知，数量加0的ASCALL码值，就是数量对应数字的ASCAII码值，如3+'0'='3'
				DisplayBoard(show, ROW, COL);
				win++;
			}
		}
		else
		{
			printf("坐标非法，重新输入\n");
		}
	}

	if (win == row * col - EASY_COUNT)                //排出71个安全的格子才算成功
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, ROW, COL);
	}
}

笔者能力有限，如有问题还请指出。