devbox
爱喝兽奶帝天荒
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言实战项目】扫雷游戏_c语言项目实战案例

作者：爱喝兽奶帝天荒 | 2024-08-21 00:25:31

赞

踩

c语言项目实战案例

目录

一.了解扫雷游戏

二.分析游戏实现逻辑

三.逐步实现游戏及其逻辑详解

1.实现菜单功能：

2.实现游戏可循环玩：

3.初始化地图：

4.打印地图：

5.埋放地雷：

6.排查地雷：

四.整合代码测试及总结

game.c:

game.h:

test.c:

一.了解扫雷游戏

众所周知，扫雷是一项军事行动的代称，是指搜索和清除地雷、水雷及其他爆炸物的行动...哈哈，开玩笑的啦！扫雷使我们快乐：>！我们今天来学习如何使用C语言编写一个简易的扫雷游戏，如果还有不太了解扫雷游戏的同学推荐在https://minesweeper.online/cn扫雷游戏网站上了解扫雷的游戏规则，也可以在上面选择一个难度玩上几局体验一下。那我们废话不多说，下面开始我们扫雷之旅》》》

二.分析游戏实现逻辑

要编写一个游戏程序，首先要明确我们想要达到的效果是什么样，下面我将用vs2022编译器来为大家演示一下游戏运行时的样子：

首先，我们来到菜单界面，提醒用户选择玩游戏还是退出游戏：

 当玩家选择'0'时，退出游戏，结束程序：

当玩家选择'1'时，开始游戏，并打印地图，提醒玩家输入要排查的雷的坐标：

当玩家输入要排查的坐标时，如果该坐标下没有埋放雷，则该坐标被排查并显示周围8个格子中雷的数量，如下图被排查坐标显示‘0’的意思即附近8个格子中雷的数量为‘0’：

 当玩家输入要排查的坐标时，如果该坐标下埋放了雷，则玩家被炸死，游戏结束，并打印出该局游戏中所有雷的方位：

 

 当玩家成功排查出所有的雷时，游戏胜利，游戏结束：

 注意，当玩家输入排查过的坐标时，提醒玩家已排查过，重新输入：

 当玩家输入地图外坐标时，提醒玩家坐标非法，重新输入：

三.逐步实现游戏及其逻辑详解

      通过第二部分对流程的介绍，我们已经对游戏的流程有了大致的了解，虽然看似需要实现的功能很多，貌似一时间不知该如何下手，但我们可以分布分模块来分析这个游戏的流程，最后再将各各部分进行整合，所以大家不用担心，跟着我一步一步分析吧！

！！！注意，该部分的代码只是为了详细介绍某一部分的游戏实现逻辑，故可能会删减一些与该部分不相关的代码以便大家理解，需要查看完整详细代码可以移步本文第四部分。

1.实现菜单功能：

       菜单部分的逻辑比较简单，就是利用C语言printf函数打印出这个菜单界面即可。基础问题就不过多赘述了，代码如下：

  1. void menu() 
  2. {
  3. 	printf("********************************\n");
  4. 	printf("*********    1.play    *********\n");
  5. 	printf("*********    0.exit    *********\n");
  6. 	printf("********************************\n");
  7. }

2.实现游戏可循环玩：

      由于我们要实现玩不够可以继续玩的游戏逻辑，因此选择do...while的循环语句来实现这一部分的逻辑，每步的详细解释见代码注释：

  1. void menu()//菜单函数实现打印菜单
  2. {
  3. 	printf("*********************************************\n");
  4. 	printf("*********************************************\n");
  5. 	printf("*****************   1.play   ****************\n");
  6. 	printf("*****************   0.exit   ****************\n");
  7. 	printf("*********************************************\n");
  8. 	printf("*********************************************\n");
  9. }
  10.  
  11. void test()//测试游戏运行
  12. {
  13. 	//srand((unsigned int) time(NULL));
  14.     //利用时间戳生成随机数以达到电脑可以实现随机布雷
  15.  
  16. 	int input = 0;
  17.  
  18. 	do//使用do  while语句来实现游戏可以连续一直玩
  19. 	{
  20. 		menu();//菜单函数，打印菜单供玩家选择
  21.  
  22. 		printf("请选择：>\n");//提醒玩家选择
  23.  
  24. 		scanf("%d", &input);//用scanf接收玩家选择存入变量input中
  25.  
  26. 		switch (input)//利用分支语句实现玩家的选择
  27. 		{
  28. 		case 1://当玩家输入1，运行游戏
  29. 			game();
  30. 			break;
  31. 		case 0://当玩家输入0，提醒玩家游戏结束
  32. 			printf("游戏结束\n");
  33. 			break;
  34. 		default://当玩家输入了非选项数字时，提醒玩家重新输入
  35. 			printf("输入错误，请重新选择\n");
  36. 			break;
  37. 		}
  38.  
  39. 	} while (input);//用变量input的值作为while循环的判定执行条件
  40.                     //当input不为0时，该循环都可一直运行下去。
  41. }

3.初始化地图：

       实现了打印菜单供玩家选择和一直玩后，我们就要来到游戏的核心部分了，即第一步，由于我们是利用二维数组实现在“地图”上排雷的，因此当每局游戏开始时，我们应该先将地图全部初始化为‘0’（注意我们创建的是字符数组，因此0是字符0！），以便在后续埋雷时与雷做区分。

       如图，我们先来分析一下一个地图上的格子在一局游戏中会有几种状态：

      ①初始时代表未解密的"*"②埋雷时与‘1’(雷)区别的”0“③安放雷时代表雷的”1“④被排查之后代表周围雷数的数字”n“。

      即一个格子最多可能会有四种状态，而我们一个二维数组要写兼顾四种的状态的函数是非常复杂的，并且很容易出错，导致露馅，因此我们不妨创建两个二维数组来分别存放格子的四种状态：首先，第一个棋盘用来存放没埋雷的"0"和埋了雷的"1"。其次，第二个棋盘用来存放未解密的"*"和排查后的数字"n"。这样分别存放恰好可以让我们的后台埋放雷数组和玩家显示数组分开，因此我们先根据设想，将后台埋放雷数组全部初始化为”0“，其次再将玩家显示数组全部初始化为”*“。

       这里有一点需要注意：由于我们在排查棋盘最外围的那一圈格子时只能排查到六个，甚至四个角只能排查四个，因此我们不妨将原定的9*9数组上下左右各多加一行（或一列），但不在这一圈埋放雷或显示，仅用来防止我们后续排查雷时越界访问数组。

       如图，蓝线所画的格子即为我们加上防止越界的格子。

      初始化二维数组的函数很简单，上节三子棋中我们也有提到，但这次我们需要一次性初始化两个同样大小但不同内容的二位数组，可能有些同学会想：如果不好判断的话，要不写两个初始化函数分别初始化地图算了。但既然这两个数组一模一样大，我们不如在传参时多加一个参数来达到分别初始化的效果，该部分代码如下：

  1.    //调用函数时传参多传一个参数
  2.    //以下时函数调用示范
  3.     InitBoard(mine, ROWS, COLS,'0');
  4. 	InitBoard(show, ROWS, COLS,'*');
  5.  
  6.  
  7. //以下是函数体
  8. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
  9. {
  10. 	int i = 0;
  11. 	for (i = 0; i < rows; i++)
  12. 	{
  13. 		int j = 0;
  14. 		for (j = 0; j < cols; j++)
  15. 		{
  16. 			board[i][j] = set;
  17. 		}
  18. 	}
  19. }

4.打印地图：

      这里有三个点需要注意：

1.前面创建二维数组时我们为了不使数组出现越界访问因此使用的是11*11大小的数组，但是在向玩家打印时要注意只能打印中间的9*9的地图！。因此我们选择只打印每行每列下标为1-9下标的元素即可。并且只能打印show数组，不能将mine数组也打印出来，否则会露馅。

 2.如图，我们还需要在第一行和第一列前面加上序号来方便玩家选择，该部分实现逻辑较简单，就是在打印每一行前打印一个数字变量即可，详情见下方代码。

3.如图，为了使棋盘与棋盘间很好的分割辨识，我们会在每次打印棋盘前后打印“--------扫雷---------”的分割线来分割，该部分也较为简单，详见代码。

  1. //打印棋盘
  2. void DisplayBoard(char board[ROWS][COLS], int row, int col)
  3. {
  4. 	int i = 0;
  5. 	printf("--------扫雷--------\n");
  6. 	//控制列号
  7. 	for (i = 0;i <= row; i++)
  8. 	{
  9. 		printf("%d ", i);
  10. 	}
  11. 	printf("\n");
  12. 	for (i = 1; i <=row; i++)
  13. 	{
  14. 		int j = 0;
  15. 		printf("%d ", i);//控制行号
  16. 		for (j = 1; j <=col; j++)
  17. 		{
  18. 			printf("%c ", board[i][j]);
  19. 		}
  20. 		printf("\n");
  21. 	}
  22. 	printf("--------扫雷--------\n");
  23. }

5.埋放地雷：

       埋放地雷的实现也非常简单，即利用rand函数随机生成n（雷数）个坐标然后将初始化的字符0改为字符1即可。

如果还有对rand函数不了解的同学，请先移步：rand()函数详解。

  1. //布置雷
  2. void SetMine(char board[ROWS][COLS], int row, int col)
  3. {
  4. 	int count = EASY_COUNT;
  5. 	while (count)
  6. 	{
  7.         int x = rand() % row + 1;
  8. 	    int y = rand() % col + 1;
  9. 	    if (board[x][y] == '0')
  10. 	    {
  11. 	 	   board[x][y] = '1';
  12. 	 	   count--;
  13. 	    }
  14. 	}
  15. }

6.排查地雷：

    接下来来到最难的排查地雷，输入坐标，然后排查其周围八个坐标有几个“1”即可，代码实现只需将这8个区域的数值相加，然后减去8个字符“0”的大小再返回该数值即可。

八个坐标的代数表示如下：

        但有几点需要注意：

1.我们是利用排查次数来判断玩家是否排查完地雷取得胜利的，因此就需要保证排查过的坐标不能被二次排查，否则可能会导致程序误判玩家胜利。

2.其次，由于我们创建的是字符数组，因此放入数组的是字符的“0”和“1”，所以不能使用简单的整形加减法来返回数字，而应该使用周围八个字符“0”和“1”的总值来减去八个字符‘0’的值，最后返回的数字才是周围的含雷数。

3.因为是初级阶段的扫雷，因此暂不增加递归展开的功能，有兴趣的同学可以自己探索。

    代码如下：

  1. //排查1个坐标
  2. int get_mine_count(char mine[ROWS][COLS], int x, int y)
  3. {
  4.  
  5. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] + mine[x][y - 1]
  6. 		+ mine[x][y + 1] + mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] - 8 * '0');
  7. }
  8.  
  9. //排查雷
  10. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  11. {
  12. 	
  13. 	int x = 0;
  14. 	int y = 0;
  15. 	int win = 0;
  16. 	while (win<(row*col-EASY_COUNT))
  17. 	{
  18. 		printf("请输入要排查的坐标：>");
  19. 		scanf("%d %d", &x, &y);
  20.  
  21. 		if (x > 0 && x <=row && y>0 && y <=col)
  22. 		{
  23. 			if (show[x][y] != '*')
  24. 			{
  25. 				printf("该坐标已被排查过！\n");
  26. 				continue;
  27.  
  28. 			}
  29. 			if (mine[x][y] == '1')
  30. 			{
  31. 				printf("很遗憾，你被炸死了\n");
  32. 				DisplayBoard(mine, ROW, COL);
  33. 				break;
  34. 			}
  35. 			else
  36. 			{
  37. 				int n=get_mine_count(mine,x,y);
  38.  
  39. 				show[x][y] = n + '0';//数字2怎么变成字符2？
  40.  
  41. 				DisplayBoard(show, ROW, COL);
  42. 				win++;
  43. 			}
  44. 		}
  45. 		else
  46. 		{
  47. 			printf("输入坐标非法，请重新输入！");
  48. 		}
  49. 	}
  50. 	if (win == (row * col - EASY_COUNT))
  51. 		{
  52.             printf("恭喜你，扫雷成功！\n");
  53. 		}
  54. 	
  55. }

四.整合代码测试及总结

      我们同样将游戏运行的代码分为三个模块分开书写，完整代码如下：

game.c:

  1. #include"game.h"
  2.  
  3. //初始化棋盘
  4. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
  5. {
  6. 	int i = 0;
  7. 	for (i = 0; i < rows; i++)
  8. 	{
  9. 		int j = 0;
  10. 		for (j = 0; j < cols; j++)
  11. 		{
  12. 			board[i][j] = set;
  13. 		}
  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. 	for (i = 1; i <=row; i++)
  30. 	{
  31. 		int j = 0;
  32. 		printf("%d ", i);//控制行号
  33. 		for (j = 1; j <=col; j++)
  34. 		{
  35. 			printf("%c ", board[i][j]);
  36. 		}
  37. 		printf("\n");
  38. 	}
  39. 	printf("--------扫雷--------\n");
  40. }
  41.  
  42.  
  43. //布置雷
  44. void SetMine(char board[ROWS][COLS], int row, int col)
  45. {
  46. 	int count = EASY_COUNT;
  47. 	while (count)
  48. 	{
  49.         int x = rand() % row + 1;
  50. 	    int y = rand() % col + 1;
  51. 	    if (board[x][y] == '0')
  52. 	    {
  53. 	 	   board[x][y] = '1';
  54. 	 	   count--;
  55. 	    }
  56. 	}
  57. }
  58.  
  59. //排查1个坐标
  60. int get_mine_count(char mine[ROWS][COLS], int x, int y)
  61. {
  62.  
  63. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] + mine[x][y - 1]
  64. 		+ mine[x][y + 1] + mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] - 8 * '0');
  65. }
  66.  
  67. //排查雷
  68. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  69. {
  70. 	
  71. 	int x = 0;
  72. 	int y = 0;
  73. 	int win = 0;
  74. 	while (win<(row*col-EASY_COUNT))
  75. 	{
  76. 		printf("请输入要排查的坐标：>");
  77. 		scanf("%d %d", &x, &y);
  78.  
  79. 		if (x > 0 && x <=row && y>0 && y <=col)
  80. 		{
  81. 			if (show[x][y] != '*')
  82. 			{
  83. 				printf("该坐标已被排查过！\n");
  84. 				continue;
  85.  
  86. 			}
  87. 			if (mine[x][y] == '1')
  88. 			{
  89. 				printf("很遗憾，你被炸死了\n");
  90. 				DisplayBoard(mine, ROW, COL);
  91. 				break;
  92. 			}
  93. 			else
  94. 			{
  95. 				int n=get_mine_count(mine,x,y);
  96.  
  97. 				show[x][y] = n + '0';//数字2怎么变成字符2？
  98.  
  99. 				DisplayBoard(show, ROW, COL);
  100. 				win++;
  101. 			}
  102. 		}
  103. 		else
  104. 		{
  105. 			printf("输入坐标非法，请重新输入！");
  106. 		}
  107. 	}
  108. 	if (win == (row * col - EASY_COUNT))
  109. 		{
  110.             printf("恭喜你，扫雷成功！\n");
  111. 		}
  112. 	
  113. }
  114.  
  115.

game.h:

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #pragma once
  4. #include<stdio.h>
  5.  
  6. #define ROW 9
  7. #define COL 9
  8.  
  9.  
  10. #define ROWS ROW+2
  11. #define COLS COL+2
  12.  
  13.  
  14. #define EASY_COUNT 10
  15.  
  16.  
  17. #include<stdlib.h>
  18. #include<time.h>
  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 row,int col);
  25. //你传了一个11*11的数组，就要拿一个11*11的数组接收！
  26.  
  27.  
  28. //布置雷
  29. void SetMine(char board[ROWS][COLS], int row, int col);
  30.  
  31. //排查雷
  32. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row,int col);

test.c:

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include"game.h"
  4.  
  5. void menu() 
  6. {
  7. 	printf("********************************\n");
  8. 	printf("*********    1.play    *********\n");
  9. 	printf("*********    0.exit    *********\n");
  10. 	printf("********************************\n");
  11.  }
  12.  
  13. void game()
  14. {
  15.     //需要俩个二维数组，一个存放布置好的雷的信息，一个存放排查出的雷的信息
  16. 	//排查坐标时，为了防止坐标越界，我们给数组的行增加两行，列增加两列
  17. 	char mine[ROWS][COLS] = { 0 };//存放布置的雷
  18. 	char show[ROWS][COLS] = { 0 };//存放排查雷的信息
  19.  
  20. 	//初始化棋盘
  21. 	InitBoard(mine, ROWS, COLS,'0');
  22. 	InitBoard(show, ROWS, COLS,'*');
  23.  
  24. 	//打印棋盘
  25. 	//DisplayBoard(mine, ROW, COL);
  26. 	DisplayBoard(show, ROW, COL);
  27.  
  28. 	//布置雷
  29. 	SetMine(mine,ROW,COL);
  30.     
  31. 	//排查雷
  32. 	//DisplayBoard(mine, ROW, COL);
  33. 	FindMine(mine,show,ROW,COL);
  34.  
  35. }
  36.  
  37.  
  38.  
  39. void test()
  40. {
  41. 	srand((unsigned int)time(NULL));
  42. 	int input = 0;
  43. 	do
  44. 	{
  45.         menu();
  46. 	    printf("请选择：>\n");
  47. 		scanf("%d", &input);
  48. 		switch (input)
  49. 		{
  50.           case 1:
  51. 			  game();
  52.             break;
  53. 				
  54. 		  case 0:
  55. 			  printf("退出游戏\n");
  56. 			  break;
  57.  
  58. 		  default:
  59. 			  printf("输入错误，请重新输入：");
  60. 			  break;
  61. 		}
  62. 	} while (input);
  63.  
  64. }
  65.  
  66.  
  67. int main()
  68. {
  69. 	test();
  70.  
  71. 	return 0;
  72. }
  73.  
  74.

     结语： 

       扫雷与三子棋游戏都是比较经典的电脑游戏，通过这些游戏的设计，我感受到了程序设计的巧思之处，或许我们不会设计好看的界面，或许我们也不会非常厉害的编程技术，但就即使利用最基础的字符打印，随机数生成，顺序，分支，循环，就可以设计组合出这样有模有样的游戏了，编程当真是奇妙。

       当然在这次尝试中我也发现了很多自己的不足，以及因为能力而做的妥协与阉割，但这我还愿意将这次探索认为是一个好的开始，希望以后的自己能就这样变得越来越厉害！

       最后的最后：Hello,world!

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

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

  

闽ICP备14008679号