• c语言小项目（排雷游戏实现）

    文章目录

    逻辑思路才是写好代码的关键，加油，望大佬们支持！

    1.了解项目搭建

    项目用多文件来搭建，便于分工和包装，这里我们用三个文件来完成这个项目，分别是game.c、mian.c、game.h,game.c文件中写的是实现函数，main.c文件中写的是主要的mian函数的总体思路，game.h文件中写的是头文件以及函数声明。

    2.了解扫雷游戏

    首先提示有几个雷，然后点击一下会出现一大片，有的格子上会显示数字，这个数字就表示这个空格周围一圈有几个雷，没有数字的空格表示周围一圈没有雷。如果点击空格是雷，那么游戏结束，如果排完雷，那么游戏取得成功并结束。

    3.游戏主逻辑

    思路：
    首先我们要知道这游戏不是玩一把，而是玩多把并且至少玩一次，所以这里用到do_while循环，然后打印一个菜单给用户进行选择，1表示玩游戏，0表示退出游戏。这里用到switch语句来进行分支实现，输入1进入游戏，输入0直接退出，输入其他则显示重新输入。

    4.玩游戏实现逻辑

    4.1 前提

    4.1.1 棋盘越界问题的解决

    我实现一个9*9的棋盘，这里有个问题就是在边界的话我们还要考虑越界问题，并且对其周围进行扫描是否有雷，这样就很麻烦。什么意思呢？看图：

    解决方案：就是让其扩充一圈的范围，这样就不用考虑到越界问题，这里有9 * 9的棋盘，我们就需要11 * 11的棋盘。实际上在展示和使用的时候都是用的9 * 9的棋盘
    如图：

    4.1.2 置雷棋盘和排雷棋盘的设置

    为什么要设置为两个棋盘呢？
    原因是置雷棋盘当我们置雷的时候是用1代表雷，0代表非雷，在我们每次选择哪个方块时，会对周围进行扫描然后在此方块上打印一个数子（代表这个方块的一圈中有多少个雷），在用户每玩一次，都必须把整个棋盘打印出来让用户知道这个方块周围有几个雷，但是我们一但打印出来我们的雷就全部暴露出来了，用户可以直接看到1（雷）在哪里，所以我们需要再创建一个数组，这个数组用来观察，那么这个棋盘是用来观察的说明已经全部覆盖，这里用*覆盖所有方块，对设置的这个棋盘进行扫描，然后数出的数字在这个排雷棋盘中展示，其他的全部覆盖掉。

    看效果：

    4.2 玩游戏主逻辑

    思路：

    1. 创建并初始化一个置雷棋盘和一个排雷棋盘（注意细节：置雷棋盘中用1表示雷，0表示非雷。排雷棋盘中用*覆盖所有信息）
    2. 设置雷
    3. 打印排雷棋盘
    4. 排查地雷

    4.3 游戏细节问题

    4.3.1 创建置雷棋盘和排雷棋盘

    这里创建我们要创建一个11*11的棋盘，这样就不用考虑越界问题。

    C语言编写的扫雷（exe文件，附排行榜）
    rar 5星 超过95%的资源 11KB
    下载

    4.3.2 初始化置雷棋盘和排雷棋盘

    置雷棋盘全部初始化为0，排雷中全部初始化为*（这里再11 * 11棋盘中）。

    void init_board(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
//置雷棋盘初始化
init_board(mine, ROWS, COLS, '0');
//排雷棋盘初始化
init_board(show, ROWS, COLS, '*');

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    注意：这里为了方便，直接传’0’和’*'，函数用char类型接收，这样就可以很好公用一个函数初始化两个数组。

    4.3.3 布置雷

    注意：布置雷是在被11 * 11的棋盘中包裹着的9 * 9的棋盘

    思路：
    这里我们随机布置10个雷，用到rand()函数和srand()随机数生成器，这里设置雷用到while循环，布置一个就循环减少一次，布置一个就减少一次循环，那么就能布置完成10个雷，这里我们要考虑到是否被占用的问题，不被占用就给其方块赋值为1，就相当于这个埋了一个地雷，被占用了就重新找个随机方块。

    代码展示：

    void set_mine(char mine[ROWS][COLS], int row, int col)//row=9,col=9
{
	//布置10个雷
	int count = EASY_COUNT;
	while (count)
	{
		//在11*11的棋盘中给9*9棋盘布置雷，所以坐标都要+1
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		//判断该方块是否被占用，不被占用就赋值1表示有雷
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    4.3.4 打印排雷棋盘

    这里我们打印出行号和列号以及排雷棋盘内容：

    void display_board(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	//列号
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		//行号
		printf("%d ", i);
		//排雷棋盘内容
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    java小项目-扫雷简易版源码
    zip 5星 超过95%的资源 1.53MB
    下载

    4.3.5 找雷实现

    思路：
    首先是要知道这个找雷的这个过程是循环进行的所以用到while循环结构。其次我们在9 * 9这个棋盘中要进行寻找，这里寻找的方式是通过下标来寻找，首先考虑的问题就是输入的下标是否在9 * 9这个棋盘范围中，如果不在则是非法越界，重现输入坐标，。然后再考虑这个坐标是否被排查过了，如果没有被排查过则重新输入。最后才是判断输入的该坐标是否是雷，如果是则被炸死，并输出置雷棋盘让用户知道错哪了，如果不是则判断周围一圈共有多少个雷，并展示出排雷棋盘。最后当排完71个方块后则游戏结束跳出循环，游戏结束。

    代码展示：

    void find_mine(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)
	{
		printf("请输入要排查雷的坐标:>");
		scanf("%d %d", &x, &y);
		//考虑是否越界（在9*9的棋盘中）
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//坐标被排查过
			if (show[x][y] == '*')
			{
				if (mine[x][y] == '1')
				{
					printf("很遗憾，你被炸死了\n");
					//打印置雷棋盘
					display_board(mine, ROW, COL);
					break;
				}
				else
				{
					//对其周围一圈进行判断有几个雷
					int count = get_mine_count(mine, x, y);
					show[x][y] = count + '0';
					//打印排雷棋盘
					display_board(show, ROW, COL);
					win++;
				}
			}
			else
			{
				printf("该坐标已经被排查过了\n");
			}
		}
		else
		{
			printf("坐标非法，请重新输入\n");
		}
	}//while循环结束

	//当排完后则游戏结束
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		display_board(mine, ROW, COL);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    5. 整个项目代码

    5.1 main.c文件代码

    #define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

//菜单，提供用户选择界面
void menu()
{
	printf("**********  1. play  ********\n");
	printf("**********  0. exit  ********\n");
}

void game()
{
	//设计2个数组存放信息
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
	//mine初始化为全‘0’
	//show初始化为全‘*’
	//这里为了方便，直接传'0'和'*'，函数用char类型接收，这样就可以很好公用一个函数初始化两个数组
	init_board(mine, ROWS, COLS, '0');
	init_board(show, ROWS, COLS, '*');

	//布置雷
	set_mine(mine, ROW, COL);
	//排雷
	display_board(show, ROW, COL);
	//找雷
	find_mine(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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    5.2 game.c文件代码

    #define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

//初始化棋盘
void init_board(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}

//打印棋盘
void display_board(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	//列号
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		//行号
		printf("%d ", i);
		//排雷棋盘内容
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

//随机设置地雷
void set_mine(char mine[ROWS][COLS], int row, int col)//row=9,col=9
{
	//布置10个雷
	int count = EASY_COUNT;
	while (count)
	{
		//在11*11的棋盘中给9*9棋盘布置雷，所以坐标都要+1
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		//判断该方块是否被占用，不被占用就赋值1表示有雷
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

//判断该方块周围一圈有几个雷
int get_mine_count(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');
}

//找雷
void find_mine(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)
	{
		printf("请输入要排查雷的坐标:>");
		scanf("%d %d", &x, &y);
		//考虑是否越界（在9*9的棋盘中）
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			//坐标被排查过
			if (show[x][y] == '*')
			{
				if (mine[x][y] == '1')
				{
					printf("很遗憾，你被炸死了\n");
					//打印置雷棋盘
					display_board(mine, ROW, COL);
					break;
				}
				else
				{
					//对其周围一圈进行判断有几个雷
					int count = get_mine_count(mine, x, y);
					show[x][y] = count + '0';
					//打印排雷棋盘
					display_board(show, ROW, COL);
					win++;
				}
			}
			else
			{
				printf("该坐标已经被排查过了\n");
			}
		}
		else
		{
			printf("坐标非法，请重新输入\n");
		}
	}//while循环结束

	//当排完后则游戏结束
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		display_board(mine, ROW, COL);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125

    5.3 game.h文件代码

    #pragma once

#include 
#include 
#include 

//9*9棋盘
#define ROW 9
#define COL 9

//11*11棋盘
#define ROWS ROW+2
#define COLS COL+2

//设置的雷的个数
#define EASY_COUNT 10

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

//打印棋盘
void display_board(char board[ROWS][COLS], int row, int col);

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

//排查雷
void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    排雷游戏到此结束，望大家多多关注和支持！

  • 相关阅读:
    volatile的用途和说明
    ★「C++游戏」BattleOfPhantom：大乱斗游戏升级版
    PHP 基础/练习
    iTOP-RK3568开发板Linux 修改kernel logo
    【一起来学C++】————（7）多态
    Mysql索引Hash和BTree的区别
    Spring-依赖注入DI
    Nagios自定义插件的编写规范
    js获取Element元素的常用方法
    使用mybatis或mybatisplus存储数据库加密，解密
  • 原文地址：https://blog.csdn.net/m0_46343224/article/details/126169400