• 扫雷游戏(C语言）

    扫雷：

    游戏简述：

    1、在一个棋盘中的任意位置，随机埋上一个雷，这个雷的数量是固定的，

    2、然后让用户去选择位置排雷，

            若选择的该位置没有雷，则在该位置显示周边一圈位置中雷的个数，
            若选择的位置有雷，则就被炸死了，游戏结束

            若选择的位置没有雷，并且将所有没有雷的位置都找出来，则玩家排雷成功，游戏结束

    逐步实现：

    1、打印菜单

    我们首先要有一个菜单供用户选择，是否开始游戏 

    选择 1 开始游戏，选择 0 结束游戏

    实现：我们首先创建一个整型变量，让用户给变量输入值，

               若 输入1 则游戏开始，

               若  输入0  则退出游戏，

               若 输入其它数字 则提醒用户 并让用户重新输入

    为了实现功能在这里我们采用 do  while();  循环，让用户至少进行一次选择

    再用 switch case 语句 判断所输入的数字是否合法

    若合法则进入游戏，若不合法则重新让用户输入(选择)

    代码如下：

    1. #include 
    2. void Mune(void)
    3. {
    4. 	printf("*****************************\n");
    5. 	printf("*********  1、play  *********\n");
    6. 	printf("*********  0、exit  *********\n");
    7. 	printf("*****************************\n");
    8. }
    9.  
    10. void Text(void)
    11. {
    12. 	int input = 0;//封装用户的输入
    13. 	//运用do while 至少执行一次
    14. 	do {
    15.         //游戏菜单
    16. 	    Mune();
    17. 		printf("请选择->:");
    18. 		scanf("%d", &input);
    19. 		//用switch语句判断
    20. 		switch (input)
    21. 		{
    22. 		case 1:
    23. 			//进入游戏
    24. 			Games();
    25. 			break;
    26. 		case 0:
    27. 			printf("退出成功\n");
    28. 			break;
    29. 		default:
    30. 			printf("输入无效，请重新选择\n");
    31. 			break;
    32. 		}
    33. 	} while (input);//当变量的值为0时结束循环
    34. }
    35.  
    36. int main()
    37. {
    38. 	//扫雷游戏
    39. 	//游戏测试
    40. 	Text();
    41. 	return 0;
    42. }

    2、创建棋盘

    1、创建棋盘1

    假设我们创建一个 9 行 9 列 的棋盘 ，

    因为后期在玩家排雷的过程中，要在玩家选择的位置显示周边雷的个数，为了更方便的显示该位置周边一圈雷的个数  所以我们在创建棋盘的时候在本来用到的棋盘上的行和列分别加上2进行创建棋盘

    也就是创建一个 11 行 11 列的棋盘

    2、创建棋盘2

    为了给原来的棋盘加密，我们再创建一个跟原来棋盘一样大的新棋盘，供用户扫雷

    代码如下：

    1. #define ROW 9
    2. #define COL 9
    3. #define ROWS ROW+2
    4. #define COLS COL+2
    5. //进入游戏
    6. void Games(void)
    7. {
    8. 	//创建棋盘1
    9. 	char encychessboard[ROWS][COLS] = { 0 };
    10. 	//创建棋盘2
    11. 	char chessboard[ROWS][COLS] = { 0 };
    12. }

    3、初始化棋盘

    我们自行规定：’0‘ 表示没有雷 ’1‘ 表示雷 

    将 encychessboard(棋盘1)全部初始化为 ’0‘

    我们让用户看到的是棋盘2

    要将棋盘2 进行加密所以将棋盘2全部初始化为 ’*‘

    代码如下：

    1. //初始化棋盘
    2. //传行、传列、传要初始化成啥字符
    3. void intit_board(char board[ROWS][COLS], int rows, int cols, char c)
    4. {
    5. 	int i = 0;
    6. 	for (i = 0; i < rows; i++)
    7. 	{
    8. 		int j = 0;
    9. 		for (j = 0; j < cols; j++)
    10. 		{
    11. 			board[i][j] = c;
    12. 		}
    13. 	}
    14. }
    15.  
    16. //进入游戏
    17. void Games(void)
    18. {
    19. 	//创建棋盘1
    20. 	char encychessboard[ROWS][COLS] = { 0 };
    21. 	//创建棋盘2
    22. 	char chessboard[ROWS][COLS] = { 0 };
    23.  
    24. 	//初始化棋盘1
    25. 	init_board(encychessboard, ROWS, COLS, '0');
    26. 	//初始化棋盘2
    27. 	init_board(chessboard, ROWS, COLS, '*');
    28. }

    4、打印棋盘

    我们在打印棋盘的时候只打印我们所用到的棋盘大小，也就是原先的假设的 9 行 9 列

    只让用户在原先的行和列中操作，打印的时候我们只让用户看到棋盘2，因为棋盘2全是’*‘

    让用户按照棋盘2 进行操作！

    在打印的同时将棋盘的行和列的序号也打印出来 以供用户按坐标选择

    代码入下：

    1. //打印棋盘
    2. //我们只打印最初设置的棋盘大小
    3. void print_board(char board[ROWS][COLS], int row, int col)
    4. {
    5. 	printf("-------------棋盘------------\n");
    6. 	int i = 0;
    7. 	int j = 0;
    8. 	//打印列号
    9. 	printf(" ");
    10. 	for (j = 1; j <= col; j++)
    11. 	{
    12. 		printf("  %d", j);
    13. 	}
    14. 	printf("\n");
    15. 	for (i = 1; i <= row; i++)
    16. 	{
    17. 		//打印行号
    18. 		printf("%d ", i);
    19. 		for (j = 1; j <= col; j++)
    20. 		{
    21. 			printf(" %c ", board[i][j]);
    22. 		}
    23. 		printf("\n");
    24. 	}
    25. 	printf("-------------棋盘------------\n");
    26. }
    27. //进入游戏
    28. void Games(void)
    29. {
    30. 	//创建棋盘1
    31. 	char encychessboard[ROWS][COLS] = { 0 };
    32. 	//创建棋盘2
    33. 	char chessboard[ROWS][COLS] = { 0 };
    34.  
    35. 	//初始化棋盘1
    36. 	init_board(encychessboard, ROWS, COLS, '0');
    37. 	//初始化棋盘2
    38. 	init_board(chessboard, ROWS, COLS, '*');
    39.  
    40. 	//打印棋盘2
    41. 	print_board(chessboard, ROW, COL);
    42. }

    5、进行埋雷

    我们规定 ‘0’ 不是雷，‘1’是雷

    首先给定一个固定的雷数，让系统随机埋雷

    埋雷是埋在棋盘1中的，也就是将一个随机位置中的内容 ’0‘ 改成 ’1‘

    让系统产生两个随机数，两个不超出棋盘的随机坐标并对其进行判断

    判断该坐标里面是否有雷，若是有则重新随机生成坐标

    只有在没有雷的情况下进行埋雷

    也就是判断该位置是否为‘0’ 若是则将其改为‘1’，若该位置是‘1’ 则重新生成坐标继续判断

    显然在这里我们一直在做重复操作，所以用while循环来解决该问题

    代码如下：

    1. #define NUMBER 20//埋雷的个数
    2.  
    3. void mine_laying(char board[ROWS][COLS],int row,int col)
    4. {
    5. 	int cun = NUMBER;
    6. 	while (cun)
    7. 	{
    8. 		//生成两个随机坐标
    9. 		int x = rand() % row + 1;
    10. 		int y = rand() % col + 1;
    11. 		//判断该位置是否有雷
    12. 		//没有雷则放置雷
    13. 		if (board[x][y] == '0')
    14. 		{
    15. 			board[x][y] = '1';
    16. 			cun--;
    17. 		}
    18. 	}
    19. }
    20.  
    21. //进入游戏
    22. void Games(void)
    23. {
    24. 	//创建棋盘1
    25. 	char encychessboard[ROWS][COLS] = { 0 };
    26. 	//创建棋盘2
    27. 	char chessboard[ROWS][COLS] = { 0 };
    28.  
    29. 	//初始化棋盘1
    30. 	init_board(encychessboard, ROWS, COLS, '0');
    31. 	//初始化棋盘2
    32. 	init_board(chessboard, ROWS, COLS, '*');
    33.  
    34. 	//打印棋盘
    35. 	print_board(chessboard, ROW, COL);
    36.  
    37. 	//埋雷
    38. 	mine_laying(encychessboard, ROW, COL);
    39. 	//print_board(encychessboard, ROW, COL);//测试是否埋雷成功
    40. }

    6、进行排雷

    玩家开始输入坐标，进行排雷，

    若该位置有雷，则提示玩家被炸死，并结束游戏

    若该位置无雷，则在该位置显示周边一圈雷的个数，且让玩家继续排雷，直到将所有无雷的位置都找出来，则提示玩家胜利，结束游戏

    以上操作都是重复的所以我们运用循环

    在排雷的时候是在棋盘1中进行判断该位置是否等于‘1’，若是’1‘则是有雷，

    若是’0‘则没有雷，没有雷的时候，我们计算出棋盘1中该位置周边的雷的数量，因为我们让玩家看到的是棋盘2 所以将雷的数量存放在棋盘2的该坐标位置

    代码如下：

    1. //统计周边雷的个数
    2. int Statistics(char board[ROWS][COLS], int x, int y)
    3. {
    4. 	//让周边的字符减去'0' 得到与该字符相同的整型值
    5. 	//因为没有雷的时候是‘0’ 有雷是‘1’
    6. 	//所以将他们转化成与其相同的整型数再求和就是周边雷的总数
    7. 	return board[x - 1][y] - '0' + board[x - 1][y - 1] - '0' + board[x][y - 1] - '0' +
    8. 		board[x + 1][y - 1] - '0' + board[x + 1][y] - '0' + board[x + 1][y + 1] - '0' +
    9. 		board[x][y + 1] - '0' + board[x - 1][y + 1] - '0';
    10. }
    11.  
    12. //排雷
    13. mine_clearance(char encychessboard[ROWS][COLS],char chessboard[ROWS][COLS],int row,int col)
    14. {
    15. 	int cun = row * col - NUMBER;//没有雷的位置的数量
    16. 	int a = 0;
    17. 	int x = 0;//封装横坐标
    18. 	int y = 0;//封装竖坐标
    19. 	while (1)
    20. 	{
    21. 		printf("请输入要排除的坐标->");
    22. 		scanf("%d %d", &x, &y);
    23. 		//判断输入的坐标是否合法
    24. 		if ((x >= 1 && x <= row) && (y >= 1 && y <= col))
    25. 		{
    26.  
    27. 			if (encychessboard[x][y] == '1')
    28. 			{
    29. 				printf("\n");
    30. 				printf("该位置有雷，你被炸死了！\n");
    31. 				break;
    32. 			}
    33. 			if (encychessboard[x][y] == '0')
    34. 			{
    35. 				//若是没有雷 将该坐标周边雷的个数保存在棋盘2上的该位置
    36. 				chessboard[x][y] = Statistics(encychessboard, x, y) + '0';
    37. 				//再打印一下棋盘2
    38. 				print_board(chessboard, ROW, COL);
    39. 				a++;
    40. 				if (a == cun)
    41. 				{
    42. 					printf("恭喜你排雷成功取得胜利\n");
    43. 					break;
    44. 				}
    45. 			}
    46. 		}
    47. 		else
    48. 		{
    49. 			printf("\n");
    50. 			printf("该坐标不合法 请重新选择：\n");
    51. 			printf("\n");
    52. 		}
    53. 	}
    54. }
    55.  
    56. //进入游戏
    57. void Games(void)
    58. {
    59. 	//创建棋盘1
    60. 	char encychessboard[ROWS][COLS] = { 0 };
    61. 	//创建棋盘2
    62. 	char chessboard[ROWS][COLS] = { 0 };
    63.  
    64. 	//初始化棋盘1
    65. 	init_board(encychessboard, ROWS, COLS, '0');
    66. 	//初始化棋盘2
    67. 	init_board(chessboard, ROWS, COLS, '*');
    68.  
    69. 	//打印棋盘
    70. 	print_board(chessboard, ROW, COL);
    71.  
    72. 	//埋雷
    73. 	mine_laying(encychessboard, ROW, COL);
    74. 	//print_board(encychessboard, ROW, COL);//测试是否埋雷成功
    75.  
    76. 	//排雷
    77. 	mine_clearance(encychessboard, chessboard, ROW, COL);
    78. 	//排雷结束之后打印棋盘1让玩家看到雷的位置
    79. 	print_board(encychessboard, ROW, COL);
    80. }

    总代码：

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define ROW 9
    6. #define COL 9
    7. #define ROWS ROW+2
    8. #define COLS COL+2
    9. #define NUMBER 20//埋雷的个数
    10.  
    11. //打印棋盘
    12. //我们只打印最初设置的棋盘大小
    13. void print_board(char board[ROWS][COLS], int row, int col)
    14. {
    15. 	printf("\n-------------棋盘------------\n");
    16. 	int i = 0;
    17. 	int j = 0;
    18. 	//打印列号
    19. 	printf(" ");
    20. 	for (j = 1; j <= col; j++)
    21. 	{
    22. 		printf("  %d", j);
    23. 	}
    24. 	printf("\n");
    25. 	for (i = 1; i <= row; i++)
    26. 	{
    27. 		//打印行号
    28. 		printf("%d ", i);
    29. 		for (j = 1; j <= col; j++)
    30. 		{
    31. 			printf(" %c ", board[i][j]);
    32. 		}
    33. 		printf("\n");
    34. 	}
    35. 	printf("-------------棋盘------------\n\n");
    36. }
    37.  
    38. //统计周边雷的个数
    39. int Statistics(char board[ROWS][COLS], int x, int y)
    40. {
    41. 	//让周边的字符减去'0' 得到与该字符相同的整型值
    42. 	//因为没有雷的时候是‘0’ 有雷是‘1’
    43. 	//所以将他们转化成与其相同的整型数再求和就是周边雷的总数
    44. 	return board[x - 1][y] - '0' + board[x - 1][y - 1] - '0' + board[x][y - 1] - '0' +
    45. 		board[x + 1][y - 1] - '0' + board[x + 1][y] - '0' + board[x + 1][y + 1] - '0' +
    46. 		board[x][y + 1] - '0' + board[x - 1][y + 1] - '0';
    47. }
    48.  
    49. //排雷
    50. mine_clearance(char encychessboard[ROWS][COLS],char chessboard[ROWS][COLS],int row,int col)
    51. {
    52. 	int cun = row * col - NUMBER;//没有雷的位置的数量
    53. 	int a = 0;
    54. 	int x = 0;//封装横坐标
    55. 	int y = 0;//封装竖坐标
    56. 	while (1)
    57. 	{
    58. 		printf("请输入要排除的坐标->");
    59. 		scanf("%d %d", &x, &y);
    60. 		//判断输入的坐标是否合法
    61. 		if ((x >= 1 && x <= row) && (y >= 1 && y <= col))
    62. 		{
    63.  
    64. 			if (encychessboard[x][y] == '1')
    65. 			{
    66. 				printf("\n");
    67. 				printf("该位置有雷，你被炸死了！\n");
    68. 				break;
    69. 			}
    70. 			if (encychessboard[x][y] == '0')
    71. 			{
    72. 				//若是没有雷 将该坐标周边雷的个数保存在棋盘2上的该位置
    73. 				chessboard[x][y] = Statistics(encychessboard, x, y) + '0';
    74. 				//再打印一下棋盘2
    75. 				print_board(chessboard, ROW, COL);
    76. 				a++;
    77. 				if (a == cun)
    78. 				{
    79. 					printf("恭喜你排雷成功取得胜利\n");
    80. 					break;
    81. 				}
    82. 			}
    83. 		}
    84. 		else
    85. 		{
    86. 			printf("\n");
    87. 			printf("该坐标不合法 请重新选择：\n");
    88. 			printf("\n");
    89. 		}
    90. 	}
    91. }
    92.  
    93. void mine_laying(char board[ROWS][COLS],int row,int col)
    94. {
    95. 	int cun = NUMBER;
    96. 	while (cun)
    97. 	{
    98. 		//生成两个随机坐标
    99. 		int x = rand() % row + 1;
    100. 		int y = rand() % col + 1;
    101. 		//判断该位置是否有雷
    102. 		//没有雷则放置雷
    103. 		if (board[x][y] == '0')
    104. 		{
    105. 			board[x][y] = '1';
    106. 			cun--;
    107. 		}
    108. 	}
    109. }
    110.  
    111. //初始化棋盘
    112. //传行、传列、传要初始化成啥字符
    113. void init_board(char board[ROWS][COLS], int rows, int cols, char c)
    114. {
    115. 	int i = 0;
    116. 	int j = 0;
    117. 	for (i = 0; i < rows; i++)
    118. 	{
    119. 		for (j = 0; j < cols; j++)
    120. 		{
    121. 			board[i][j] = c;
    122. 		}
    123. 	}
    124. }
    125.  
    126. //进入游戏
    127. void Games(void)
    128. {
    129. 	//创建棋盘1
    130. 	char encychessboard[ROWS][COLS] = { 0 };
    131. 	//创建棋盘2
    132. 	char chessboard[ROWS][COLS] = { 0 };
    133.  
    134. 	//初始化棋盘1
    135. 	init_board(encychessboard, ROWS, COLS, '0');
    136. 	//初始化棋盘2
    137. 	init_board(chessboard, ROWS, COLS, '*');
    138.  
    139. 	//打印棋盘
    140. 	print_board(chessboard, ROW, COL);
    141.  
    142. 	//埋雷
    143. 	mine_laying(encychessboard, ROW, COL);
    144. 	//print_board(encychessboard, ROW, COL);//测试是否埋雷成功
    145.  
    146. 	//排雷
    147. 	mine_clearance(encychessboard, chessboard, ROW, COL);
    148. 	//排雷结束之后打印棋盘1让玩家看到雷的位置
    149. 	print_board(encychessboard, ROW, COL);
    150. }
    151.  
    152. void Mune(void)
    153. {
    154. 	printf("*****************************\n");
    155. 	printf("*********  1、play  *********\n");
    156. 	printf("*********  0、exit  *********\n");
    157. 	printf("*****************************\n");
    158. }
    159.  
    160. void Text(void)
    161. {
    162. 	//用时间戳创建随机数，用后面布置雷做准备
    163. 	srand((unsigned int)time(NULL));
    164. 	//srand的参数是unsigned int  
    165. 	// time函数的参数是一个指针在这里我们不知道该传什么所以给其传空指针
    166. 	//time 函数的返回值是 time_t(time_t实则是一个与时间有关的长整型）
    167. 	//所以将其强制转换
    168. 	
    169. 	int input = 0;//封装用户的输入
    170. 	//运用do while 至少执行一次
    171. 	do {
    172. 		//游戏菜单
    173. 		Mune();
    174. 		printf("请选择->:");
    175. 		scanf("%d", &input);
    176. 		//用switch语句判断
    177. 		switch (input)
    178. 		{
    179. 		case 1:
    180. 			//进入游戏
    181. 			Games();
    182. 			break;
    183. 		case 0:
    184. 			printf("退出成功\n");
    185. 			break;
    186. 		default:
    187. 			printf("输入无效，请重新选择\n");
    188. 			break;
    189. 		}
    190. 	} while (input);//当变量的值为0时结束循环
    191. }
    192.  
    193. int main()
    194. {
    195. 	//扫雷游戏
    196. 	//游戏测试
    197. 	Text();
    198. 	return 0;
    199. }

  • 相关阅读:
    vscode 设置左边文件栏缩进
    [机缘参悟-53]：《素书》-3-修身养志[求人之志章第三]
    物理机、虚拟机、容器（docker）
    总结：K8S指标与Prometheus实现
    AYIT嵌入式实验室2023级C语言训练1-4章训练题
    【设计模式】聊聊职责链模式
    Scala的高级用法
    unicodedata.normalize ——Unicode字符串标准化
    Flutter高仿微信-第22篇-支付-二维码收款(二维码)
    C++数据结构之链表栈
  • 原文地址：https://blog.csdn.net/dd811923461/article/details/127788395