扫雷

编写扫雷游戏，要求:

1>第一次下子，不炸死。
2>坐标周围没雷，可以实现展开。

分析1：首先要弹出菜单，使玩家选择是玩还是不玩；

          玩家选择玩，则进入游戏，若不玩，则退出游戏；

          玩家玩完一次后，或退出游戏后，可能再想玩，此时就需要使玩家在进行选择，所以此处应该进行循环。

代码1：此处是主函数入口：

int main()
{
 test();
}

代码2：void menu()//菜单
{
 printf("***********************************\n");
 printf("*******1.开始游戏 0.退出游戏*******\n");
 printf("***********************************\n");
}

代码3：在test()函数中进入菜单进行选择：

void test()
{
 int input = 0;
 do
 {
  menu();
  printf("请选择;");
  scanf("%d", &input);
  switch (input)
  {
  case 1:
   printf("开始游戏！\n");
   game();
   printf("\n");
   break;
  case 0:
   printf("退出游戏！\n");
   break;
  default:
   printf("选择错误,请重新输入!\n");
   printf("\n");
   break;
  }
 } while (input);

}

分析2：玩家进入游戏：

             1）首先要打印出扫雷的矩阵供玩家点击，这个是玩家看到的矩阵arr1，该矩阵用于显示玩家点击后是炸死还是计数还是展开

             2）当玩家点击时，要计算该点周围一圈8个点处的雷数，所以可以把雷赋为一个字符，无雷的的赋为另一种字符，

                  该矩阵若用arr1表示，则就会将雷的位置显示出来， 所以再创建一个矩阵arr2用于计算用户点击后的相关操作

            3）假设玩家看到的雷阵是10*10的，当点击最外圈周围的雷数时，不便计算，所以将两个矩阵周围在加一圈，均表示为12*12的，

                 只要雷的排放不放在12*12矩阵的最外圈即可，但在打印时依然打印10*10矩阵，即打印12*12矩阵的除去最外圈部分

            4）接下来就是玩家点击后的相关操作

代码4：进入游戏后的相关操作

void game()
{
 srand((unsigned int)time(NULL));
 int i = 0;
 int m = 0;
 int n = 0;
 int p = 0;
 int q = 0;
 int count = 0;
 int sum = 0;
 //创建两个数组一个用于计算雷的个数，一个用于输出
 char arr1[ROWS][COLS] = { 0 };//输出数组
 char arr2[ROWS][COLS] = { 0 };//计算雷的个数数组
 Init(arr1, ROWS, COLS, '*');//初始化arr1数组
 Init(arr2, ROWS, COLS, '0');//初始化arr2数组
 Print(arr1, ROW, COL);//打印arr1数组
 //printf("\n");
 //Print(arr2, ROW, COL);//打印arr2数组
 set(arr2, ROW, COL);//设置雷函数

 //Print(arr1, ROW, COL);
 printf("\n");
// Print(arr2, ROW, COL);
 Findmine(arr2, arr1, ROW, COL);//该函数为玩家点击后的相关操作
}

代码5：初始化矩阵函数

//数组初始化函数
void Init(char arr[ROWS][COLS], int x, int y, char ch)
{
 int i = 0;
 int j = 0;
 for (i = 0; i < x; i++)
 {
  for (j = 0; j < y; j++)
  {
   arr[i][j] = ch;//将数值arr的每个元素都初始化为ch代表的字符
  }
 }
}

代码6：打印10*10矩阵函数

//打印函数
//x,y为ROS-2，COL-2
void Print(char arr[ROWS][COLS], int x, int y)
{
 int i = 0;
 int j = 0;
 for (i = 1; i <= x; i++)//输出矩阵的第二行到倒数第二行
 {
  for (j = 1; j <= y; j++)
  {
   printf("%c ", arr[i][j]);
  }
  printf("\n");
 }
}

代码7：随机将雷设置在12*12矩阵出去最外一圈的部分

//设置雷函数
void set(char arr2[ROWS][COLS], int x, int y)
{
 int i = 0;
 int m = 0;
 int n = 0;
 for (i = 0; i < NUM; i++)//NUM为雷的个数
 {
  m = rand() % x + 1;//设置雷只能在arr2数组的第2列（行）和倒数第2列（行)之间
  n = rand() % y + 1;
  while (arr2[m][n] != '0')
  {
   m = rand() % x + 1;//设置雷只能在arr2数组的第2列（行）和倒数第2列（行)之间
   n = rand() % y + 1;
  }
  arr2[m][n] = '+';//将雷用"+"代表
 }
}

分析3：玩家不断的点击，判断点击处是否为雷

             1）如果是第一次点击时，该处为雷，所以要使该处的雷放入其他没有雷的地方，使玩家点击不被炸死

             2）若不是第一次点击，但该处为雷，则炸死，本轮游戏结束

             3）若该处不为雷，则要计算周围一圈8个点处的雷数，计算完后判断在该处是展开，还是计数

             4）当点击了除去雷数的其余点数时，则排雷成功

代码8：玩家点击后

//玩游戏时的流程
void Findmine(char arr2[ROWS][COLS], char arr1[ROWS][COLS], int row, int col)
{
 int flag = 0;
 int*p = &flag;//因为每点击一次，排除一个雷，所以需要不断的在原有基础上递增，所以用指针
 int x = 0;
 int y = 0;
 int count = 0;
 while (1)
 {
  printf("请输入坐标：");
  scanf("%d%d", &x, &y);
  count++;
  if (count == 1 && arr2[x][y] == '+')  //保证它不被第一步炸死
  {
   Player_first(arr2, arr1, x, y);
  }
  else if (arr2[x][y] == '+')  //踩到雷了，炸死
  {
   printf("炸死了！！！\n");
   Print(arr2, row, col);//输出数组2
   break;//结束
  }
  else if (arr2[x][y] == '0')  //不是雷  可能展开或计数
  {
   digui(arr2, arr1, x, y, p);//调用递归函数
  }
  Print(arr1, row, col);
  if (flag == row*col - NUM)
  {
   printf("恭喜你排雷成功\n");
   Print(arr2, row, col);
   break;
  }
 }
}

代码9：保证第一次点击不被炸死

//保证第一次不会踩雷炸死
void Player_first(char arr2[ROWS][COLS], char arr1[ROWS][COLS], int x, int y)
{
 int flag = 1;//因为第一次已经点击了，所以初值赋为1
 int *p = &flag;//因为每点击一次，排除一个雷，所以需要不断的在原有基础上递增，所以用指针
 int m = 0;
 int n = 0;
 arr2[x][y] = '0';
 m = rand() % ROW + 1;//设置雷只能在arr2数组的第2列（行）和倒数第2列（行)之间
 n = rand() % COL + 1;//将第一次踩到的雷随机放到其他没有雷的地方
 if ((arr2[m][n] == '0') && (m != x) && (n != y))
 {
  arr2[m][n] = '+';
 }
 digui(arr2, arr1, x, y, p);//再调用递归函数，判断在该点处是要展开，还是计数
}

分析4：玩家点击处无雷时，计算周围一圈雷的个数

             1）若雷的个数不为0，则不展开，将周围一圈的雷数显示在该点处

             2）若雷的个数为0，则展开，分别以周围一圈8个点为中心，进行1）--2）的判断，运用递归实现

代码10：计算周围一圈雷的个数

//计算(p,q)附近的雷数
int jisuan(char arr2[ROWS][COLS], int p, int q)
{
 int count = 0;
  if (arr2[p - 1][q - 1] == '+')
  {
   count++;
  }
  if (arr2[p - 1][q] == '+')
  {
   count++;
  }
  if (arr2[p - 1][q + 1] == '+')
  {
   count++;
  }
  if (arr2[p + 1][q - 1] == '+')
  {
   count++;
  }
  if (arr2[p + 1][q] == '+')
  {
   count++;
  }
  if (arr2[p + 1][q + 1] == '+')
  {
   count++;
  }
  if (arr2[p][q - 1] == '+')
  {
   count++;
  }
  if (arr2[p][q + 1] == '+')
  {
   count++;
  }
 return count;
}

代码11：判断点击处无雷时，是展开还是计数

void digui(char arr2[ROWS][COLS], char arr1[ROWS][COLS], int x, int y, int*flag)
{
 int i = 0;
 int j = 0;
 int count = 0;
 if ((x >= 1) && (x <= 10) && (y >= 1) && (y <= 10))  //防止越界
 {
  count = jisuan(arr2, x, y);  //统计周围雷的个数
  if (count == 0)  //周围没有雷  需要展开
  {
   arr1[x][y] = ' ';//将该处的值赋为空，再向外扩展
   (*flag) += 1;  //位置个数加1，
   for (i = x - 1; i <= x + 1; i++)  //周围一圈进行递归
   {
    for (j = y - 1; j <= y + 1; j++)
    {
     if (arr1[i][j] == '*')
     {
      digui(arr2, arr1, i, j,&(*flag));
     }
    }
   }
  }
  
  else  //周围有雷  只需要统计个数
  {
    arr1[x][y] = count + '0';
    (*flag) += 1;
  }
 }
}

代码12：头文件声明

#ifndef __GAME_H__
#define __GAME_H__

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<time.h>

#define COL 10
#define ROW 10
#define COLS COL+2
#define ROWS ROW+2
#define NUM 95

void menu();
//菜单函数
void Init(char arr[ROWS][COLS], int x, int y, char ch);
//x为数组行数，y为数组列数，ch为给数组初始化的字符串
void set(char arr[ROWS][COLS], int x, int y);
//m，n为雷的横纵坐标
void Print(char arr[ROWS][COLS], int x, int y);
//打印函数，x为数组行数，y为数组列数
int jisuan(char arr2[ROWS][COLS], int p, int q);
//计算雷函数，p，q为玩家点击的坐标，返回(p,q)周围一圈雷的个数
void Findmine(char arr2[ROWS][COLS], char arr1[ROWS][COLS], int row, int col);
//该函数是玩家玩游戏的流程，row,col分别是输出数组的行数，列数
void digui(char arr2[ROWS][COLS], char arr1[ROWS][COLS], int x, int y, int*flag);
//该函数是递归打开一片函数，x,y是玩家点击的坐标
void Player_first(char arr2[ROWS][COLS], char arr1[ROWS][COLS], int x, int y);
//该函数是防止玩家第一次点击踩雷，x,y是玩家点击的坐标

#endif