devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

c语言：扫雷

作者：空白诗007 | 2024-08-03 03:31:24

赞

踩

c语言：扫雷

一、【扫雷】

二、【游戏逻辑】

1.游戏的初始化

2.雷区的翻转

3.误区

三、【代码实现】 

1.zcx.c 

1.1 面板显示

1.2 主函数 main()

1.3 实现扫雷游戏的各功能的引用

2.zdy.c

2.1 初始化棋盘函数 csh

2.2 打印棋盘函数 dyqb

2.3 布置雷函数 bzl

2.4 判断周围存在几个雷函数 zwjgl

2.5 排查雷函数 pcl

3.zdy.h

3.1 常量定义

3.2 函数声明

四、【完整代码】

1.zcx.c

2.zdy.h

3.zdy.c

一、【扫雷】

《扫雷》是一款经典的单人电脑游戏，旨在揭开一个方块网格，并避免触发隐藏的地雷。每个方块可能包含数字（表示周围地雷数量）或者地雷。玩家需要利用数字信息来推断哪些方块是安全的，并标记可能包含地雷的方块

二、【游戏逻辑】

1.游戏的初始化

      扫雷游戏的基础模式是 9×9 的雷区，为在c语言中方便实现，可以用 ' * ' 号表示未翻开的雷区，其中用字符 ' 1 ' 表示地雷，字符 ‘ 0 ’ 表示不存在地雷的区域，并用二维数组进行存储。

2.雷区的翻转

对于雷区的反转，可以通过两张二维表进行实现，分别将雷的信息，排查出雷的信息分别存储到不同二维表中。

排查表

     

雷表

在格子未被翻转前，用字符 ‘*’ 来对其进行遮盖，而格子翻转以后，该格子则显示周围的 8 个格子存在的地雷的个数。

3.误区

   扫雷游戏规则，规定了，若翻转的格子不是地雷，则显示该格子周围 8 个格子存在地雷的个数，但若选择的是边缘的格子，对雷区边界的格子执行这一操作可能会导致数组的越界访问

    为实现 9×9 的扫雷游戏，创建一个9×9的二维数组并不合适，既然对边界元素进行操作时，会导致数组越界访问，那直接将二维数组扩大一圈，使用时，我们继续使用原来的范围，对外圈不进行操作

三、【代码实现】 

为提高代码的可阅读性和让代码尽量简洁，便于维护，而分成三个文件。

1.zcx.c 

1.1 面板显示

  1. void mb()
  2. {
  3. 	printf("******************\n");
  4. 	printf("*****1.开始 1*****\n");
  5. 	printf("*****2.结束 0*****\n");
  6. 	printf("******************\n");
  7. }

这个函数用于打印游戏菜单，显示给玩家选择开始游戏或结束游戏

1.2 主函数 main()

  1. int main()
  2. {
  3.     int a = 0;
  4.     srand((unsigned int)time(NULL));
  5.     do {
  6.         mb();
  7.         printf("请选择:");
  8.         scanf("%d", &a);
  9.         switch (a)
  10.         {
  11.             case 1:
  12.                 printf("-----扫雷开始-----\n");
  13.                 dt(); // 调用 dt() 函数来执行扫雷游戏逻辑
  14.                 break;
  15.             case 0:
  16.                 printf("游戏结束\n");
  17.                 break;
  18.             default:
  19.                 printf("输入错误，请重新输入\n");
  20.                 break;
  21.         }
  22.     } while (a);
  23.     return 0;
  24. }

主函数首先初始化随机数种子，然后进入一个循环中。在每次循环中，程序会打印菜单（使用 mb() 函数），然后等待用户输入选择。根据用户选择不同，程序会执行相应的操作：如果选择开始游戏，则调用 dt() 函数；如果选择结束，则打印"游戏结束"；如果输入错误，则提示用户重新输入。

1.3 实现扫雷游戏的各功能的引用

  1. //打印扫雷的画面
  2. void dt()
  3. {
  4. 	char nqb[HANGS][LIES] = { 0 };//存放雷的信息
  5. 	char wqb[HANGS][LIES] = { 0 };//存放排查出雷的信息显示
  6. 	//初始化棋盘
  7. 	csh(nqb, HANGS, LIES, '0');//'0'
  8. 	csh(wqb, HANGS, LIES, '*');//'*'
  9.  
  10. 	//打印棋盘
  11. 	/*dyqb(wqb, HANG, LIE);*/
  12.  
  13. 	//布置雷
  14. 	bzl(nqb, HANG, LIE);
  15. 	dyqb(wqb, HANG, LIE);
  16.  
  17. 	//排查雷
  18. 	pcl(nqb, wqb, HANG, LIE);
  19.  
  20. }

 将初始化棋盘需要存储打印的字符，作为实参传递给函数，简化了存储字符的过程。

2.zdy.c

这段代码是扫雷游戏的一部分实现，包括了初始化棋盘、打印棋盘、布置雷、判断周围存在几个雷以及排查雷等功能。

2.1 初始化棋盘函数 csh

  1. void csh(char qqb[HANGS][LIES], int hangs, int lies, char cszf)
  2. {
  3.     for (int x = 0; x < HANGS; x++) 
  4.     {
  5.         for (int y = 0; y < LIES; y++) 
  6.         {
  7.             qqb[x][y] = cszf;
  8.         }
  9.     }
  10. }

这个函数用于初始化棋盘，将所有格子的状态设置为指定的字符。

2.2 打印棋盘函数 dyqb

  1. void dyqb(char wqb[HANGS][LIES], int hang, int lie)
  2. {
  3.     // 打印行号
  4.     for (int i = 0; i <= HANG; i++)
  5.     {
  6.         printf("%d", i);
  7.     }
  8.     printf("\n");
  9.  
  10.     // 打印每行的内容（包括列号和格子状态）
  11.     for (int x = 1; x <= HANG; x++)
  12.     {
  13.         printf("%d", x); // 打印列号
  14.         for (int y = 1; y <= LIE; y++)
  15.         {
  16.             printf("%c", wqb[x][y]); // 打印格子状态
  17.         }
  18.         printf("\n");
  19.     }
  20. }

这个函数用于打印棋盘，显示每个格子的位置，并打印首行首列所对应的数字，方便格子的翻转实现

2.3 布置雷函数 bzl

  1. void bzl(char nqb[HANGS][LIES], int hang, int lie) 
  2. {
  3.     // 随机布置地雷
  4.     int lei = LEI; // 设置地雷数量
  5.     srand((unsigned int)time(NULL)); // 使用当前时间作为随机种子
  6.  
  7.     while (lei) 
  8.    {
  9.         int x = rand() % hang + 1; // 随机生成行坐标
  10.         int y = rand() % lie + 1;  // 随机生成列坐标
  11.         
  12.         if (nqb[x][y] == '0') 
  13.         {                     // 如果该位置没有地雷，则放置地雷并减少剩余地雷数量
  14.             nqb[x][y] = '1';
  15.             lei--;
  16.         }
  17.     }
  18. }
  • 在循环开始之前，通过srand((unsigned int)time(NULL))设置了随机数种子。这样可以确保每次运行程序时都会得到不同的随机序列。
  • 在循环内部，使用 rand() 函数生成一个0到hang-1之间的随机整数，并加1得到x坐标；再生成一个0到lie-1之间的随机整数，并加1得到y坐标。
  • 然后检查所选位置是否已经有地雷（即nqb[x][y]是否等于'0'），如果是，则将该位置设为地雷（'1'），并将剩余地雷数量减一。

2.4 判断周围存在几个雷函数 zwjgl

  1. int zwjgl(char nqb[HANGS][LIES], int x, int y)
  2. {
  3. 	return nqb[x - 1][y - 1] + nqb[x - 1][y] + nqb[x - 1][y + 1] + nqb[x][y - 1]
  4. 	+ nqb[x][y + 1] + nqb[x + 1][y - 1] + nqb[x + 1][y] + nqb[x + 1][y + 1] - 8 * '0';
  5. }

  

  • 在这段代码中，通过将当前位置（x,y）及其周围八个格子的值相加，并减去8乘以字符'0'（即48），得到了周围地雷的数量。
  • 这是因为在ASCII码中，数字字符'0'到'9'依次对应的ASCII码值是48到57。因此减去8乘以字符'0'实际上就是将字符转换为对应的数字值。

2.5 排查雷函数 pcl

  1. void pcl(char nqb[HANGS][LIES], char wqb[HANGS][LIES], int hang, int lie)
  2. {
  3.     int x = 0;
  4.     int y = 0;
  5.     int w = 0;
  6.  
  7.     while (w < HANG * LIE - LEI) // 当未排查的格子数量小于总格子数减去地雷数量时执行循环
  8.     {
  9.         printf("请输入排查的坐标：");
  10.         scanf("%d %d", &x, &y); // 获取用户输入的坐标
  11.  
  12.         if (x >= 1 && x <= hang && y >= 1 && y <= lie) // 检查输入坐标是否合法
  13.         {
  14.             if (nqb[x][y] == '1') // 如果踩到地雷，则游戏失败并结束
  15.             {
  16.                 printf("很遗憾，你被炸死了\n");
  17.                 dyqb(nqb, HANG, LIE); // 展示所有地雷位置
  18.                 break; // 结束游戏循环
  19.             }
  20.             else
  21.             {
  22.                 if (wqb[x][y] != '*') // 如果该位置已经排查过，则提示无需再次排查
  23.                 {
  24.                     printf("该位置已经排查，无需再次排查\n");
  25.                 }
  26.                 else // 否则进行排雷操作，并更新展示给玩家看的数组，并检查是否游戏胜利。
  27.                 {
  28.                     int a = zwjgl(nqb, x, y); // 获取周围地雷数量
  29.                     wqb[x][y] = a + '0'; // 更新展示给玩家看的数组
  30.                     dyqb(wqb, HANG, LIE); // 打印更新后的棋盘状态（展示给玩家看）
  31.                     w++; // 增加已排查格子数量计数器
  32.                 }
  33.             }
  34.         }
  35.         else 
  36.         {
  37.             printf("坐标非法，请重新输入\n"); // 提示用户重新输入合法坐标
  38.         }
  39.     }
  40.  
  41.     if (w == HANG * LIE - LEI) 
  42.     {
  43.         printf("恭喜你排雷成功\n"); 
  44.         // 如果已经成功排除所有非地雷格子，则输出恭喜信息并展示整个地雷分布情况。
  45.         dyqb(nqb, HANG, LIE); 
  46.     }
  47. }
  48.

  1. 初始化变量：

    • 初始化变量 x 和 y 为0，用于接收玩家输入的坐标。
    • 初始化变量 w 为0，用于计算已经排查过的格子数量。

  2. 循环排查：

    • 使用 while 循环，条件是当未排查的格子数量小于总格子数减去地雷数量时执行循环。
    • 在循环内部，首先提示用户输入要排查的坐标，并使用 scanf 获取用户输入。

  3. 检查合法性：

    • 检查用户输入坐标是否在合法范围内（即大于等于1且小于等于行数或列数）。

  4. 处理用户输入：

    • 如果用户踩到地雷，则输出失败信息并展示所有地雷位置，并结束游戏循环。
    • 如果该位置已经排查过，则提示无需再次排查；否则进行排雷操作，并更新展示给玩家看的数组，并检查是否游戏胜利。

  5. 判断游戏结果：

    • 如果已经成功排除所有非地雷格子，则输出恭喜信息并展示整个地雷分布情况。

3.zdy.h

这段代码是一个头文件，其中包含了一些函数的声明和预处理指令。

3.1 常量定义

  1. //方便动态管理行列数
  2. #define HANG 9
  3. #define LIE  9
  4.  
  5. #define HANGS HANG+2
  6. #define LIES  LIE+2
  7.  
  8. #define LEI 10

这里定义了一些常量，包括棋盘的行数和列数，以及雷的数量，方便动态设置。

3.2 函数声明

  1. //初始化棋盘
  2. void csh(char qqb[HANGS][LIES], int hangs, int lies,char cszf);
  3. //打印棋盘
  4. void dyqb(char wqb[HANGS][LIES], int hang, int lie);
  5. //布置雷
  6. void bzl(char nqb[HANGS][LIES], int hang, int lie);
  7. //排查雷
  8. void pcl(char nqb[HANGS][LIES], char wqb[HANGS][LIES], int hang, int lie);
  9. //判断周围存在几个雷
  10. int zwjgl(char nqb[HANGS][LIES], int x, int y);

这些是函数声明，用于告诉编译器这些函数的存在及其参数类型。在实际的源文件中需要实现这些函数，并且可以使用这个头文件来引入这些函数声明。

四、【完整代码】

1.zcx.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. //扫雷游戏
  3.  
  4. #include "zdy.h"
  5. //面板
  6. void mb()
  7. {
  8. 	printf("******************\n");
  9. 	printf("*****1.开始 1*****\n");
  10. 	printf("*****2.结束 0*****\n");
  11. 	printf("******************\n");
  12. }
  13. //打印扫雷的画面
  14. void dt()
  15. {
  16. 	char nqb[HANGS][LIES] = { 0 };//存放雷的信息
  17. 	char wqb[HANGS][LIES] = { 0 };//存放排查出雷的信息显示
  18. 	//初始化棋盘
  19. 	csh(nqb, HANGS, LIES, '0');//'0'
  20. 	csh(wqb, HANGS, LIES, '*');//'*'
  21.  
  22. 	//打印棋盘
  23. 	/*dyqb(wqb, HANG, LIE);*/
  24.  
  25. 	//布置雷
  26. 	bzl(nqb, HANG, LIE);
  27. 	dyqb(wqb, HANG, LIE);
  28.  
  29. 	//排查雷
  30. 	pcl(nqb, wqb, HANG, LIE);
  31.  
  32. }
  33. int main()
  34. {
  35. 	int a = 0;
  36. 	srand((unsigned int)time(NULL));
  37. 	do {
  38. 		mb();
  39. 		printf("请选择:");
  40. 		scanf("%d", &a);
  41. 		switch (a)
  42. 		{
  43. 		case 1:
  44. 			printf("-----扫雷开始-----\n");
  45. 			dt();
  46. 			break;
  47. 		case 0:
  48. 			printf("游戏结束\n");
  49. 			break;
  50. 		default:
  51. 			printf("输入错误，请重新输入\n");
  52. 			break;
  53. 		}
  54. 	} while (a);
  55. 	return 0;
  56. }

2.zdy.h

  1. #pragma once
  2.  
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<time.h>
  6. //方便动态管理行列数
  7. #define HANG 9
  8. #define LIE  9
  9.  
  10. #define HANGS HANG+2
  11. #define LIES  LIE+2
  12.  
  13. #define LEI 10
  14. //初始化棋盘
  15. void csh(char qqb[HANGS][LIES], int hangs, int lies,char cszf);
  16. //打印棋盘
  17. void dyqb(char wqb[HANGS][LIES], int hang, int lie);
  18. //布置雷
  19. void bzl(char nqb[HANGS][LIES], int hang, int lie);
  20. //排查雷
  21. void pcl(char nqb[HANGS][LIES], char wqb[HANGS][LIES], int hang, int lie);
  22. //判断周围存在几个雷
  23. int zwjgl(char nqb[HANGS][LIES], int x, int y);

3.zdy.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include "zdy.h"
  4. //初始化棋盘函数
  5. void csh(char qqb[HANGS][LIES], int hangs, int lies, char cszf)
  6. {
  7. 	for (int x = 0; x < HANGS; x++) 
  8. 	{
  9. 		for (int y = 0; y < LIES; y++) 
  10. 		{
  11. 			qqb[x][y] = cszf;
  12. 		}
  13. 	}
  14. }
  15. //打印棋盘函数
  16. void dyqb(char wqb[HANGS][LIES], int hang, int lie)
  17. {
  18. 	for (int i = 0; i <= HANG; i++)
  19. 	{
  20. 		printf("%d", i);
  21. 	}
  22. 	printf("\n");
  23.  
  24. 	for (int x = 1; x <= HANG; x++)
  25. 	{
  26. 		printf("%d", x);
  27. 		for (int y = 1; y <= LIE; y++)
  28. 		{
  29. 			printf("%c", wqb[x][y]);
  30. 		}
  31. 		printf("\n");
  32. 	}
  33. }
  34. //布置雷函数
  35. void bzl(char nqb[HANGS][LIES], int hang, int lie) 
  36. {
  37. 	int lei = LEI;
  38. 	srand((unsigned int)time(NULL));
  39.  
  40. 	while (lei) {
  41. 		int x = rand() % hang + 1;
  42. 		int y = rand() % lie + 1;
  43. 		if (nqb[x][y] == '0') 
  44. 		{
  45. 			nqb[x][y] = '1';
  46. 			lei--;
  47. 		}
  48. 	}
  49. }
  50.  
  51. //判断周围存在几个雷
  52. int zwjgl(char nqb[HANGS][LIES], int x, int y)
  53. {
  54. 	return nqb[x - 1][y - 1] + nqb[x - 1][y] + nqb[x - 1][y + 1] + nqb[x][y - 1]
  55. 		+ nqb[x][y + 1] + nqb[x + 1][y - 1] + nqb[x + 1][y] + nqb[x + 1][y + 1] - 8 * '0';
  56. }
  57. //排查雷函数
  58. void pcl(char nqb[HANGS][LIES], char wqb[HANGS][LIES], int hang, int lie)
  59. {
  60. 	int x = 0;
  61. 	int y = 0;
  62. 	int w = 0;
  63. 	while (w<HANG*LIE-LEI)
  64. 	{
  65. 		printf("请输入排查的坐标：");
  66. 		scanf("%d %d", &x, &y);
  67. 		if (x >= 1 && x <= hang && y >= 1 && y <= lie)
  68. 		{
  69. 			if (nqb[x][y] == '1')
  70. 			{
  71. 				printf("很遗憾，你被炸死了\n");
  72. 				dyqb(nqb, HANG, LIE);
  73. 				break;
  74. 			}
  75. 			else
  76. 			{
  77. 				if (wqb[x][y] != '*')
  78. 				{
  79. 					printf("该位置已经排查，无需再次排查\n");
  80. 				}
  81. 				else
  82. 				{
  83. 					int a = zwjgl(nqb, x, y);
  84. 					wqb[x][y] = a + '0';
  85. 					dyqb(wqb, HANG, LIE);
  86. 					w++;
  87. 				}
  88. 			}
  89. 		}
  90. 		else
  91. 		{
  92. 			printf("坐标非法，请重新输入\n");
  93. 		}
  94. 	}
  95. 	if (w == HANG * LIE - LEI) 
  96. 	{
  97. 		printf("恭喜你排雷成功\n");
  98. 		dyqb(nqb, HANG, LIE);
  99. 	}
  100.  
  101.  
  102. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/921217
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号