• C语言-扫雷游戏的实现

    🌈write in front🌈
    🧸大家好，我是Aileen🧸.希望你看完之后，能对你有所帮助，不足请指正！共同学习交流.
    🆔本文由Aileen_0v0🧸 原创 CSDN首发🐒 如需转载还请通知⚠️
    📝个人主页：Aileen_0v0🧸—CSDN博客
    🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝​
    📣系列专栏：Aileen_0v0🧸的C语言学习系列专栏——CSDN博客
    🗼我的格言:"没有罗马,那就自己创造罗马~"

    目录

    1.扫雷游戏的分析和设计👻

    1.1扫雷游戏的功能说明💭

    1.2游戏的界面▶️​编辑

    2.扫雷游戏的代码实现🔆

    2.1数据结构的分析🙉

    ​编辑

    2.2文件结构设计💫

    2.3游戏的过程实现,代码块💦

    主函数,用户菜单页面代码⏸️:

    棋盘打印*️⃣:

    给棋盘加坐标:🔢

    布置雷💣:

    排雷💥:

    3.扫雷游戏的完整代码✨

    1.扫雷游戏的分析和设计👻

    1.1扫雷游戏的功能说明💭

    • 使用控制台实现经典的扫雷游戏

    • 游戏可以通过菜单实现继续玩或退出游戏
    • 扫雷的棋盘是9*9的格子
    • 默认随机布置10个雷
    •  可以排查雷
            

    1.2游戏的界面▶️

    初始界面

    排雷界面

    排雷失败界面

    2.扫雷游戏的代码实现🔆

    2.1数据结构的分析🙉

    但是如果我们判断边缘的格子位置是否含雷时,

    由于周围边界没有东西,导致我们需要判断这个格子是否位于边缘位置,这就会让代码变的复杂~

    于是,我们可以通过 在原来9 * 9 的方格的 上下 , 左右位置 放没有雷的空格子(如上面左右两个数组的橙色边界)

    根据刚刚的分析,

    我们在左边创建一个mine数组 布置好雷的信息,全部初始化成 字符"0" ~

    雷 - "1"

    非雷 - "0"

    在右边创建一个show数组放置 排查处的雷的信息, 最初未排查时,都放 *

    没有排查 - "*"

    排查 - 数字字符

    小细节:之所以都用 字符数组 是因为 只需要定义字符函数, 方便操作~

    如果 左边是整形数组,右边是字符数组 就 需要调用两个不同的函数~

    在game.c中打印棋盘的时候,我们只打印9*9的~

    因为外边的绿色空格只是为了编写变得容易一点,不会越界~~

    但是,按照这种方式打印,我们很难知道是第几行第几列,因为没有标识

    于是我们,再利用 for 循环打印出 行和列的序号 

    利用库函数rand 来随机布置雷

    要从1到n中随机取一个数的公式是:


    rand()%n+1.


    解释一下:
    1、库函数rand()会返回一个大于0的随机整数;
    2、rand()%n，对这个返回的随机整数除以n取余，结果是一个0到n-1的随机整数

    3、rand()%n+1，将rand()%n的结果加上1，就可得到一个1到n的随机整数;

    更通用一点的公式，产生m到n中(n>m)的一个随机数的公式是:
    rand()%(n-m+1)+m。

    2.2文件结构设计💫

    首先,先创建这三个文件.

    2.3游戏的过程实现,代码块💦

    主函数,用户菜单页面代码⏸️:
    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3.  
    4. //扫雷页面都实现
    5. void menu()
    6. {
    7. 	printf("*********************************\n");
    8. 	printf("******		1. play	    *****\n");
    9. 	printf("******		0. exit	    *****\n");
    10. 	printf("*********************************\n");
    11. }
    12.  
    13.  
    14. int main()
    15. {
    16. 	int input = 0;
    17. 	do
    18. 	{
    19. 		menu();
    20. 		printf("请选择:<");
    21. 		scanf("%d", &input);
    22. 		switch (input)
    23. 		{
    24. 		case 1:
    25. 			printf("扫雷\n");
    26. 			break;
    27. 		case 0:
    28. 			printf("退出游戏\n");
    29. 			break;
    30. 		default:
    31. 			printf("选择错误,请重新选择\n");
    32. 			break;
    33.  
    34. 		}
    35. 	//case 1 和 default 都是非零
    36. 	//里层switch语句走完 就会走while语句
    37. 	} while (input);
    38. 	return 0;
    39. 	//如果while 后面为0,程序就会自动退出游戏
    40. 	//非0   1就打印扫雷    其他值则重新打印菜单让用户选择
    41.  
    42. }

    运行效果:

    棋盘打印*️⃣:

    头文件game.h 的代码:

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3. #pragma once
    4.  
    5. #define ROW 9
    6. #define COL 9
    7.  
    8. #define ROWS ROW + 2
    9. #define COLS COL + 2
    10.  
    11. // 函数的声明
    12.  
    13. //初始化棋盘
    14. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);
    15.  
    16. //打印棋盘的
    17. void DisplayBoard(char board[ROWS][COLS],int rows, int cols);

    源文件game.c 的代码:

    1. #define _CRT_SECURE_NO_WARNINGS
    2.  
    3. #include "game.h"
    4.  
    5. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
    6. {
    7. 	int i = 0;
    8. 	for (i = 0; i < rows; i++)
    9. 	{
    10. 		int j = 0;
    11. 		for (j = 0; j < cols; j++)
    12. 		{
    13. 			board[i][j] = set;
    14. 		}
    15. 	}
    16. }
    17.  
    18. //打印棋盘,就是打印数组
    19. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    20. {
    21. 	int i = 0;
    22. 	for (i = 1; i <= row; i++)
    23. 	{
    24. 		int j = 0;
    25. 		for (j = 1; j <= col; j++)
    26. 		{
    27. 			printf("%c ", board[i][j]);
    28. 		}
    29. 		printf("\n");
    30. 	}
    31. }

    源文件 test.c 的代码:

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3. #include "game.h"
    4.  
    5. //扫雷页面都实现
    6. void menu()
    7. {
    8. 	printf("*********************************\n");
    9. 	printf("******		1. play	    *****\n");
    10. 	printf("******		0. exit	    *****\n");
    11. 	printf("*********************************\n");
    12. }
    13.  
    14. void game()
    15. {
    16. 	//数组
    17. 	char mine[ROWS][COLS];//"0"
    18. 	char show[ROWS][COLS];//"*"
    19. 	InitBoard(mine, ROWS, COLS,'0');
    20. 	InitBoard(show, ROWS, COLS,'*');
    21. 	//棋盘打印
    22. 	DisplayBoard(mine, ROW, COL);
    23. 	DisplayBoard(show, ROW, COL);
    24. 	//布置雷
    25. 	//排查雷
    26.  
    27. }
    28.  
    29.  
    30. int main()
    31. {
    32. 	int input = 0;
    33. 	do
    34. 	{
    35. 		menu();
    36. 		printf("请选择:<");
    37. 		scanf_s("%d", &input);
    38. 		switch (input)
    39. 		{
    40. 		case 1:
    41. 			printf("扫雷\n");
    42. 			game();//游戏代码模块化
    43. 			break;
    44. 		case 0:
    45. 			printf("退出游戏\n");
    46. 			break;
    47. 		default:
    48. 			printf("选择错误,请重新选择\n");
    49. 			break;
    50.  
    51. 		}
    52. 	//case 1 和 default 都是非零
    53. 	//里层switch语句走完 就会走while语句
    54. 	} while (input);
    55. 	return 0;
    56. 	//如果while 后面为0,程序就会自动退出游戏
    57. 	//非0   1就打印扫雷    其他值则重新打印菜单让用户选择
    58.  
    59. }

     打印结果:

    给棋盘加坐标:🔢

    在原来打印棋盘上加上坐标,进行定位,只需修改game.c部分的代码:

    1. #define _CRT_SECURE_NO_WARNINGS
    2.  
    3. #include "game.h"
    4.  
    5. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
    6. {
    7. 	int i = 0;
    8. 	for (i = 0; i < rows; i++)
    9. 	{
    10. 		int j = 0;
    11. 		for (j = 0; j < cols; j++)
    12. 		{
    13. 			board[i][j] = set;
    14. 		}
    15. 	}
    16. }
    17.  
    18. //打印棋盘,就是打印数组
    19. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    20. {
    21. 	int i = 0;
    22. 	printf("-----------扫雷游戏-----------\n");
    23. 	//打印棋盘序号
    24. 	for (i = 0; i <= row; i++)
    25. 	{
    26. 		printf("%d ", i);
    27. 	}
    28. 	printf("\n");
    29. 	//打印9*9的棋盘
    30. 	for (i = 1; i <= row; i++)
    31. 	{
    32. 		printf("%d ", i);
    33. 		int j = 0;
    34. 		for (j = 1; j <= col; j++)
    35. 		{
    36. 			printf("%c ", board[i][j]);
    37. 		}
    38. 		printf("\n");
    39. 	}
    40. 	printf("-----------扫雷游戏-----------\n");
    41. }

    打印结果:

    布置雷💣:

    game.h:

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3. #include //标准库头文件
    4. #include
    5.  
    6. //布置雷
    7. void SetMine(char mine[ROWS][COLS],int row , int col);
    8. //虽然布置雷是在9*9的格子里面布置--->row 和 col
    9. //但是,数组传参还是11*11的格子,即ROWS和COLS

    game.c: 

    1.  
    2. //布置雷
    3. void SetMine(char mine[ROWS][COLS], int row, int col)
    4. {
    5. 	int count = EASY_COUNT;
    6.  
    7. 	while (count)
    8. 	{
    9. 		int x = rand() % row + 1;
    10. 		int y = rand() % col + 1;
    11. 		if (mine[x][y] == '0')//如果该位置无雷才在这个位置放雷
    12. 		{
    13. 			mine[x][y] = '1';
    14. 			count--;
    15. 		}
    16. 	}
    17.  
    18.  
    19. }

    test.c文件: 

    1. 	//布置雷
    2. 	SetMine(mine, ROW, COL);
    3. 	DisplayBoard(mine, ROW, COL);

     打印结果:

    排雷💥:

    通过观察,ASCII表可知:

    字符'0'-->ASCII值:48

    字符'1'-->ASCII值:49

    字符'2'-->ASCII值:50

    字符'3'-->ASCII值:51

    依此类推

    得出规律:'1' - '0' = 49-48 = 1

                    '3' - '0' = 51-48 = 3

    字符-字符=数字   ----------> 反推: 数字+字符=字符

    统计 x y 周围有几个雷 --->

    把其周围的字符值'0'和'1'加起来即可

    然后减去8个字符'0' 得到数字,去代替  x y 处的 '*'.

    game.h:

    1. //排查雷
    2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

    game.c:

    1.  
    2. //实现GetMineCount数组
    3. static int GetMineCount(char mine[ROWS][COLS], int x, int y)
    4. {
    5. 	return(mine[x - 1][y] +
    6. 		mine[x - 1][y - 1] +
    7. 		mine[x][y - 1] +
    8. 		mine[x + 1][y - 1] +
    9. 		mine[x + 1][y] +
    10. 		mine[x + 1][y + 1] +
    11. 		mine[x][y + 1] +
    12. 		mine[x - 1][y + 1] - 8 * '0');
    13. }
    14. //排查雷
    15. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    16. {
    17. 	int x = 0;
    18. 	int y = 0;
    19. 	while (1)//死循环排雷
    20. 	{
    21. 		printf("请输入要排查的坐标:>");
    22. 		scanf("%d %d", &x, &y);
    23. 		//注意:x y 要在有效的排查范围(9*9)之内
    24. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    25. 		{
    26. 			//开始排查是否是雷
    27. 			if (mine[x][y] == '1')
    28. 			{
    29. 				printf("很遗憾,你被炸死了\n");
    30. 				DisplayBoard(mine, ROW, COL);
    31. 				break;
    32. 			}
    33. 			else
    34. 			{
    35. 				int count = GetMineCount(mine, x, y);
    36. 				show[x][y] = count + '0';
    37. 				DisplayBoard(show, ROW, COL);
    38. 				//count + 字符'0;变成对应的数字字符放到show数组里
    39. 			}
    40.  
    41. 		}
    42. 		else
    43. 		{
    44. 			printf("坐标非法,重新输入\n");
    45. 		}
    46. 	}
    47.  
    48. }

    test.c:

    1. 	//排查雷
    2. 	FindMine(mine, show, ROW, COL);

    注意:GetMineCount 没有在其它文件中声明是因为,我们只希望它在game.c处悄悄使用它,所以前加static

    运行结果:

    上面的排雷,未限制排雷次数,即可无限循环下去,这样子的游戏设计显然不合理~

    于是,我们可以根据,雷和非雷的数量关系进行排雷循环次数的限制.

    game.h:

    1. //布置80个雷
    2. #define EASY_COUNT 80

    game.c: 

    1. //排查雷
    2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    3. {
    4. 	int x = 0;
    5. 	int y = 0;
    6. 	int win = 0;
    7. 	while (win//根据雷和非雷的数量关系限制循环次数
    8. 	{
    9. 		printf("请输入要排查的坐标:>");
    10. 		scanf("%d %d", &x, &y);
    11. 		//注意:x y 要在有效的排查范围(9*9)之内
    12. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    13. 		{
    14. 			//开始排查是否是雷
    15. 			if (mine[x][y] == '1')
    16. 			{
    17. 				printf("很遗憾,你被炸死了\n");
    18. 				DisplayBoard(mine, ROW, COL);
    19. 				break;
    20. 			}
    21. 			else
    22. 			{
    23. 				int count = GetMineCount(mine, x, y);
    24. 				show[x][y] = count + '0';
    25. 				DisplayBoard(show, ROW, COL);
    26. 				//count + 字符'0;变成对应的数字字符放到show数组里
    27. 				win++;
    28. 			}
    29.  
    30. 		}
    31. 		else
    32. 		{
    33. 			printf("坐标非法,重新输入\n");
    34. 		}
    35. 	}
    36. 	if (win == row * col - EASY_COUNT)
    37. 	{
    38. 		printf("恭喜你,扫雷成功\n");
    39. 		DisplayBoard(mine, ROW, COL);
    40. 	}
    41.  
    42. }

    我们可以通过改变雷的个数,然后根据mine的数组打印的结果对照着进行排雷成功的结果输出,检查是否有误. 

    运行结果:

    3.扫雷游戏的完整代码✨

    game.h:

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3. #include //标准库头文件
    4. #include
    5. #pragma once
    6.  
    7. #define ROW 9
    8. #define COL 9
    9.  
    10. #define ROWS ROW + 2
    11. #define COLS COL + 2
    12.  
    13. //布置10个雷
    14. #define EASY_COUNT 10
    15.  
    16.  
    17.  
    18. // 函数的声明
    19.  
    20. //初始化棋盘
    21. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);
    22.  
    23. //打印棋盘的
    24. void DisplayBoard(char board[ROWS][COLS],int rows, int cols);

    game.c:

    1. #define _CRT_SECURE_NO_WARNINGS
    2.  
    3. #include "game.h"
    4. #include 
    5.  
    6. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
    7. {
    8. 	int i = 0;
    9. 	for (i = 0; i < rows; i++)
    10. 	{
    11. 		int j = 0;
    12. 		for (j = 0; j < cols; j++)
    13. 		{
    14. 			board[i][j] = set;
    15. 		}
    16. 	}
    17. }
    18.  
    19. //打印棋盘,就是打印数组
    20. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    21. {
    22. 	int i = 0;
    23. 	printf("-----------扫雷游戏-----------\n");
    24. 	//打印棋盘序号
    25. 	for (i = 0; i <= row; i++)
    26. 	{
    27. 		printf("%d ", i);
    28. 	}
    29. 	printf("\n");
    30. 	//打印9*9的棋盘
    31. 	for (i = 1; i <= row; i++)
    32. 	{
    33. 		printf("%d ", i);
    34. 		int j = 0;
    35. 		for (j = 1; j <= col; j++)
    36. 		{
    37. 			printf("%c ", board[i][j]);
    38. 		}
    39. 		printf("\n");
    40. 	}
    41. 	printf("-----------扫雷游戏-----------\n");
    42. }
    43.  
    44. //布置雷
    45. void SetMine(char mine[ROWS][COLS], int row, int col)
    46. {
    47. 	int count = EASY_COUNT;
    48.  
    49. 	while (count)
    50. 	{
    51. 		int x = rand() % row + 1;
    52. 		int y = rand() % col + 1;
    53. 		if (mine[x][y] == '0')//如果该位置无雷才在这个位置放雷
    54. 		{
    55. 			mine[x][y] = '1';
    56. 			count--;
    57. 		}
    58. 	}
    59.  
    60.  
    61. }
    62.  
    63. //实现GetMineCount数组
    64. static int GetMineCount(char mine[ROWS][COLS], int x, int y)
    65. {
    66. 	return(mine[x - 1][y] +
    67. 		mine[x - 1][y - 1] +
    68. 		mine[x][y - 1] +
    69. 		mine[x + 1][y - 1] +
    70. 		mine[x + 1][y] +
    71. 		mine[x + 1][y + 1] +
    72. 		mine[x][y + 1] +
    73. 		mine[x - 1][y + 1] - 8 * '0');
    74. }
    75. //排查雷
    76. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    77. {
    78. 	int x = 0;
    79. 	int y = 0;
    80. 	int win = 0;
    81. 	while (win//根据雷和非雷的数量关系限制循环次数
    82. 	{
    83. 		printf("请输入要排查的坐标:>");
    84. 		scanf("%d %d", &x, &y);
    85. 		//注意:x y 要在有效的排查范围(9*9)之内
    86. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    87. 		{
    88. 			//开始排查是否是雷
    89. 			if (mine[x][y] == '1')
    90. 			{
    91. 				printf("很遗憾,你被炸死了\n");
    92. 				DisplayBoard(mine, ROW, COL);
    93. 				break;
    94. 			}
    95. 			else
    96. 			{
    97. 				int count = GetMineCount(mine, x, y);
    98. 				show[x][y] = count + '0';
    99. 				DisplayBoard(show, ROW, COL);
    100. 				//count + 字符'0;变成对应的数字字符放到show数组里
    101. 				win++;
    102. 			}
    103.  
    104. 		}
    105. 		else
    106. 		{
    107. 			printf("坐标非法,重新输入\n");
    108. 		}
    109. 	}
    110. 	if (win == row * col - EASY_COUNT)
    111. 	{
    112. 		printf("恭喜你,扫雷成功\n");
    113. 		DisplayBoard(mine, ROW, COL);
    114. 	}
    115.  
    116. }

    test.c:

    1. #define _CRT_SECURE_NO_WARNINGS
    2. #include 
    3. #include "game.h"
    4.  
    5. //扫雷页面都实现
    6. void menu()
    7. {
    8. 	printf("*********************************\n");
    9. 	printf("******		1. play	    *****\n");
    10. 	printf("******		0. exit	    *****\n");
    11. 	printf("*********************************\n");
    12. }
    13.  
    14. void game()
    15. {
    16. 	//数组
    17. 	char mine[ROWS][COLS];//"0"
    18. 	char show[ROWS][COLS];//"*"
    19. 	InitBoard(mine, ROWS, COLS,'0');
    20. 	InitBoard(show, ROWS, COLS,'*');
    21. 	//棋盘打印
    22. 	//DisplayBoard(mine, ROW, COL);  雷的位置注释掉不打印出来,保持神秘感
    23. 	DisplayBoard(show, ROW, COL);
    24. 	//布置雷
    25. 	SetMine(mine, ROW, COL);
    26. 	//DisplayBoard(mine, ROW, COL);
    27. 	//排查雷
    28. 	FindMine(mine, show, ROW, COL);
    29.  
    30. }
    31.  
    32.  
    33. int main()
    34. {
    35. 	int input = 0;
    36. 	srand((unsigned int)time(NULL));//强制转换成无符号整型
    37. 	do
    38. 	{
    39. 		menu();
    40. 		printf("请选择:<");
    41. 		scanf_s("%d", &input);
    42. 		switch (input)
    43. 		{
    44. 		case 1:
    45. 			printf("扫雷\n");
    46. 			game();//游戏代码模块化
    47. 			break;
    48. 		case 0:
    49. 			printf("退出游戏\n");
    50. 			break;
    51. 		default:
    52. 			printf("选择错误,请重新选择\n");
    53. 			break;
    54.  
    55. 		}
    56. 	//case 1 和 default 都是非零
    57. 	//里层switch语句走完 就会走while语句
    58. 	} while (input);
    59. 	return 0;
    60. 	//如果while 后面为0,程序就会自动退出游戏
    61. 	//非0   1就打印扫雷    其他值则重新打印菜单让用户选择
    62.  
    63. }

     

    🌻今天的扫雷游戏就分享到这里啦~🌻

    🌻喜欢就一键三连支持一下吧♥~🌻

    🌻附上今天的日落图☺️🌻

    🌻谢谢家人们!🌻

  • 相关阅读:
    SpringBoot 整合 Minio 实现 文件上传
    【PTA-训练day8】L2-020 功夫传人 + L1-032 Left-pad
    最新 IntelliJ IDEA 旗舰版和社区版下载安装教程（图解）
    Nginx网络服务三-----(三方模块和内置变量)
    JDBC封装查询单个和查询多个
    深入理解Java IO流（第二篇）
    【医学】基于Matlab实现 3-D 内表面轴细化算法构建骨架模型
    Spring高手之路16——解析XML配置映射为BeanDefinition的源码
    jmeter性能测试常见的一些问题
    docker jenkins 安装配置
  • 原文地址：https://blog.csdn.net/Aileenvov/article/details/133109952