AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【用C语言轻松实现】- 扫雷【超详细教程】

2024-05-21 37
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【用C语言轻松实现】- 扫雷【超详细教程】

一、游戏规则

扫雷就是要将所有非地雷的格子揭开即胜利，踩到地雷格子就算失败。游戏是由很多个方格组成，用鼠标随机点击一个方格，若格子被打开后没有地雷，即方格会被打开并显示出其周围 8 个方格隐藏地雷的个数。所以若想顺利过关就需要利用好这些显示出来的数字提示。

二、文件的创建

  1. test.c（实现游戏的整体思路，用于测试扫雷游戏的逻辑）
  2. game.c（游戏的实现）
  3. game.h（声明 .c 文件的函数，包含所有需要用到的头文件以及 define 定义的常量）

三、初始页面的实现

1、实现主菜单页面

// test.c

（1）menu()
void menu()
{
  printf("***********************************\n");
  printf("**********    1.paly     **********\n");
  printf("**********    0.exit     **********\n");
  printf("***********************************\n");
}

效果图如下：

（2）test()： 
void test()
{
  int input = 0;
  srand((unsigned int)time(NULL));
  do
  {
    menu();// 主菜单
    printf("请选择：>");
    scanf("%d", &input);// 玩家选择
    switch (input)// 判断玩家是否进行游戏以及是否输入合法选项
    {
    case 1:
      game();// 游戏
      break;
    case 0:
      printf("退出游戏\n");
      break;
    default:
      printf("选择错误，请重新选择!\n");
      break;
    }
  } while (input);
}

注：这里使用 do while() 循环可以保证至少会进行一次选择。如果选择 0，会被判定为假，则跳出循环，退出游戏；如果输入选择则不会退出游戏，可以1保证游戏能够重复游玩。

srand((unsigned int)time(NULL))  利用时间戳，形成随机数，主要目的是实现游戏中地雷的随机埋放。

（3）main()： 
int main()
{
  test();
  return 0;
}

2、在 game.h 中引用所需要的文件和必要的定义

// game.h

#pragma once
 
// 9*9
#define ROW 9// 行
#define COL 9// 列
 
// 11*11
#define ROWS ROW+2
#define COLS COL+2
 
#define EASY_COUNT 10// 地雷的数量
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

四、棋盘函数的声明、创建和实现（打印棋盘函数同理）

1、声明棋盘的函数（附加打印棋盘函数）

// game.h

//初始化排雷界面
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
 
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);

2、棋盘函数的创建 （附加打印功能）

// test.c

void game()
{
    // 扫雷游戏的实现
  char mine[ROWS][COLS] = { 0 };// 布置地雷的信息 // '0'
  char show[ROWS][COLS] = { 0 };// 排查地雷的信息 // '*'
 
    // 初始化棋盘
  InitBoard(mine, ROWS, COLS, '0');
  InitBoard(show, ROWS, COLS, '*');
 
    // 打印棋盘
  DisplayBoard(mine, ROW, COL);
  DisplayBoard(show, ROW, COL);
}

char mine[ROWS][COLS]        '1' -- 雷        '0' -- 非雷

char show[ROWS][COLS]        '*‘ -- 未排查        数组字符 -- 已排查

注：初始化两个棋盘，一个为 mine，一个为 show，其中在 mine 数组中我们定义有雷为 '1'，没有雷为 '0'。由扫雷规则可知：当我们输入一个坐标时，会在该坐标上出现一个数字，表示在该坐标周围 8 个格子有多少个地雷，但是当四周只有一个雷的时候所出现的 ‘1’ 不是会与有雷的 '1' 混淆吗？所以我们创建了另外一个数组 show，show 数组中不表示雷，只打印数值，这样就解决了 '1' 的混淆问题。为什么要用 '1' 来代替地雷呢？后面会有介绍到。

首先对埋雷的数组进行初始化为字符 '0'（非雷用字符 '0' 表示，地雷用字符 '1' 表示），对显示棋盘的数组全部用 '*'，将埋雷的数组覆盖起来，因此在 game() 函数里对 InitBorad() 函数调用两次。

1、为什么要创建两个相同的数组呢？

答：因为我们在玩游戏时首先在屏幕上看到的是一个初始化的棋盘，并不清楚哪里埋放着地雷。如果我们触碰到地雷结束游戏，需要给玩家呈现这局游戏所有地雷位置的情况，这样以便于玩家清楚所有雷都在哪个位置，因此我们在屏幕上显示的是 9*9 的数组，但是创建的时候是 11*11 的数组，所以需要两个棋盘才能完成这项任务。其中一个隐藏在暗处用来存放这些地雷、数字的信息，玩家是看不见的；另一个则是专门向玩家展示的棋盘。

2、显示 9*9 大小的棋盘，为什么要创建 11*11 大小的棋盘？

答：这是因为在排雷的过程中，会显示其周围 8 个格子地雷的个数。如果创建一个 9*9 的棋盘，那当我们选择边角方格的时候，我们周围的格子不足 8 个，但是我们还要访问周围 8 个格子，这时候必然会造成数组越界的问题。如果创建 11*11 的棋盘，对 11*11 的棋盘都初始化为字符 '0'， 我们只显示内部的 9*9 的格子，这样就解决了数组越界的问题，游戏正常运行。

3、棋盘函数的实现（附加打印棋盘函数的实现）

// game.c

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
  int i = 0;
  int j = 0;
  for (i = 0; i < rows; i++)
  {
    for (j = 0; j < cols; j++)
    {
      board[i][j] = set;
    }
  }
}
 
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
  int i = 0;
  int j = 0;
  for (i = 0; i <= col; i++)
  {
    printf("%d ", i);
  }
  printf("\n");
  for (i = 1; i <= row; i++)
  {
    printf("%d ", i);
    for (j = 1; j <= col; j++)
    {
      printf("%c ", board[i][j]);// 要用%c打印 否则打印结果会出现问题
    }
    printf("\n");
  }
}

注：因为游戏要重复进行，所以每次都要先对数组进行初始化，防止因上次游戏的干扰。

我们对第一块 mine 棋盘全部初始化为字符 '0' ，对第二块 show 棋盘全部初始化为字符 '*' ，最终玩家会先看到一个全是字符 '*' 的棋盘，这样也符合游戏规则。

打印效果如下：（只需要将show棋盘展示给游戏用户）

（1）布置棋盘（mine）：

（2）展示棋盘（show）：

五、布置地雷

// game.h

// 布置地雷
void SetMine(char board[ROWS][COLS], int row, int col);

// game.c

void SetMine(char board[ROWS][COLS], int row, int col)
{
  int count = EASY_COUNT;// 在 9*9 棋盘里随机布置10个雷
  while (count)
  {
    int x = rand() % row + 1;// 1~9
    int y = rand() % col + 1;// 1~9
    if (board[x][y] == '0')// 如果没有雷就布置雷
    {
      board[x][y] = '1';
      count--;// 布置完一个雷，雷数-1
    }
  }
}
如何实现随机布雷？

答：创建 rand 函数，利用时间戳生成随机数。因为我们创建的棋盘大小是 9*9 大小的，所以只需要给生成的随机数模上 row/col ，即可得到 0~row-1，因此我们再 +1，即可得到一个在 0~row(col) 的随机数，从而实现随机布雷的效果。一共设定 count 个雷，如果我们埋下一颗雷，就 count -1，同时将初始化的字符 '0' 变成字符 '1'，只有我们识别到目标方格是字符 '0' 时才会埋雷，这也解决了在同一位置重复埋雷的问题。在使用 while() 循环，直到减到 count 为 0 时，while 不再循环，count 颗雷正好布置完成。

六、排查地雷

// game.h

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

注：为什么 FindMine 传的参数是 ROW COL 而不是 ROWS COLS ？原因：首先要明白，要打印 9*9 的棋盘，如果定义棋盘大小只有 9*9，那么当我们检查边界坐标的周围时就会出现越界访问的问题。所以排雷时就只需要将 ROW COL 传过去就好了。

//game.c

int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
  return
    mine[x - 1][y] +
    mine[x - 1][y - 1] +
    mine[x][y - 1] +
    mine[x + 1][y - 1] +
    mine[x + 1][y] +
    mine[x + 1][y + 1] +
    mine[x][y + 1] +
    mine[x - 1][y + 1] - 8 * '0';
}
 
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
  int x = 0;
  int y = 0;
  int win = 0; //9*9-10=71 //判断雷是否都被排查干净
  while (win < row * col - EASY_COUNT)
  {
    printf("请输入排查雷的坐标：>");
    scanf("%d%d", &x, &y);
    if (x >= 1 && x <= row && y >= 1 && y <= col)
    {
      //坐标合法
      if (mine[x][y] == '1')
      {
        printf("很遗憾，你被炸死了\n");//踩雷
        DisplayBoard(mine, row, col);
        break;
      }
      else//不是雷
      {
        //计算x，y坐标周围有几个雷
        int count = get_mine_count(mine, x, y);
        show[x][y] = count + '0';
                //必须加上'0'（实际上是 count 返回的整型值加上0的ASCII值后，再转化为字符）
        DisplayBoard(show, row, col);
        win++;
      }
    }
    else
    {
      printf("输入坐标非法，请重新输入！\n");
    }
  }
  if (win == row * col - EASY_COUNT)
  {
    printf("恭喜你，排雷成功\n");
    DisplayBoard(mine, row, col);
  }
}

注：将周围 8 个格子的字符全部加起来，如果是字符 '0' 和字符 '1' 所对应的 ASCII 码值相差1，我们可以通过 ASCII 码值来进行判断。将周围 8 个字符相加，然后再减去8个字符 '0' 的和，就可以得到周围 8 个格子中有多少个字符 '1' 的格子，也就是雷的个数。

当我们输入正确的坐标时，我们需要对这个坐标下所对应的字符进行判断，如果是字符 '1' ，说明踩中地雷，游戏结束，这时再将完整的棋盘打印出来，玩家也可以了解本局游戏的情况。如果是字符 '0'，说明玩家没有踩中地雷，根据游戏规则，我们需要显示这个格子周围 8个格子中存在地雷的个数，所以调用了get_mine_count函数。

七、代码整合

1、// test.c

#include "game.h"
 
void menu()
{
  printf("***********************************\n");
  printf("**********    1.paly     **********\n");
  printf("**********    0.exit     **********\n");
  printf("***********************************\n");
}
 
void game()
{
  //布置雷的信息
  char mine[ROWS][COLS] = { 0 };// '0'
  //排查出雷的信息
  char show[ROWS][COLS] = { 0 };// '*'
 
  //两个棋盘的初始化
  InitBoard(mine, ROWS, COLS, '0');
  InitBoard(show, ROWS, COLS, '*');
 
  //棋盘的打印
  //DisplayBoard(mine, ROW, COL);
  DisplayBoard(show, ROW, COL);
 
  //布置雷
  SetMine(mine, ROW, COL);
 
  //排查地雷
  FindMine(mine, show, ROW, COL);
}
 
void test()
{
  int input = 0;
  srand((unsigned int)time(NULL));
  do
  {
    menu();// 主菜单
    printf("请选择：> ");
    scanf("%d", &input);// 玩家选择
    switch (input)// 判断玩家是否进行游戏以及是否输入合法选项
    {
    case 1:
      game();// 游戏
      break;
    case 0:
      printf("退出游戏\n");
      break;
    default:
      printf("选择错误，请重新选择!\n");
      break;
    }
  } while (input);
}
 
int main()
{
  test();
  return 0;
}

2、// game.c

#include "game.h"
 
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
  int i = 0;
  int j = 0;
  for (i = 0; i < rows; i++)
  {
    for (j = 0; j < cols; j++)
    {
      board[i][j] = set;
    }
  }
}
 
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
  int i = 0;
  int j = 0;
  printf("--------扫雷--------\n");
  for (i = 0; i <= col; i++)
  {
    printf("%d ", i);
  }
  printf("\n");
  for (i = 1; i <= row; i++)
  {
    printf("%d ", i);
    for (j = 1; j <= col; j++)
    {
      printf("%c ", board[i][j]);// 要用%c打印 否则打印结果会出现问题
    }
    printf("\n");
  }
  printf("--------扫雷--------\n");
}
 
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
  printf("   ");// 考虑到y轴占3格
  for (int j = 1; j <= col; j++)// 打印x轴坐标
  {
    printf(" %d  ", j);
  }
  printf("\n");
  printf("  |");
  for (int j = 0; j < col; j++)// 打印棋盘封顶
  {
    printf("---|");
  }
  printf("\n");
  for (int i = 1; i <= row; i++)
  {
    for (int j = 0; j <= col; j++)
    {
      if (j == 0)
      {
        printf("%2d|", i);// 顺带打印y轴坐标
      }
      else
        printf(" %c |", board[i][j]);// 打印数据
    }
    printf("\n");
    for (int j = 1; j <= col+1; j++)// 注意这里col应该+1
    {
      if (j == 1)
        printf("  |");
      else
        printf("---|");
    }
    printf("\n");
  }
}
 
void SetMine(char board[ROWS][COLS], int row, int col)
{
  int count = EASY_COUNT;// 在 9*9 棋盘里随机布置10个雷
  while (count)
  {
    int x = rand() % row + 1;// 1~9
    int y = rand() % col + 1;// 1~9
    if (board[x][y] == '0')// 如果没有雷就布置雷
    {
      board[x][y] = '1';
      count--;// 布置完一个雷，雷数-1
    }
  }
}
 
int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
  return
    mine[x - 1][y] +
    mine[x - 1][y - 1] +
    mine[x][y - 1] +
    mine[x + 1][y - 1] +
    mine[x + 1][y] +
    mine[x + 1][y + 1] +
    mine[x][y + 1] +
    mine[x - 1][y + 1] - 8 * '0';
}
 
炸金花式展开函数
//void explode_spread(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
//{
//  // 限制非法坐标的展开
//  if (x >= 1 && x <= row && y >= 1 && y <= col)
//  {
//    // 计算该位置附近四周地雷的个数
//    int count = get_mine_count(mine, x, y);
//    // 若四周没有一个地雷，则需要向该位置的四周展开，直到展开到某个位置附近存在地雷为止
//    if (count == 0)
//    {
//      // 把附近没有地雷的位置变成字符' '
//      show[x][y] = '0';
//      int i = 0;
//      // 向四周共8个位置递归调用
//      for (i = x - 1; i <= x + 1; i++)
//      {
//        int j = 0;
//        for (j = y - 1; j <= y + 1; j++)
//        {
//          // 限制对点位置的重复展开调用，使得每一个位置只能向四周展开一次
//          if (show[i][j] == '*')
//          {
//            explode_spread(mine, show, row, col, i, j);
//          }
//        }
//      }
//    }
//    // 若四周存在地雷则应该在这个位置上标注上地雷的个数
//    else
//    {
//      show[x][y] = count + '0';
//    }
//  }
//}
 
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
  int x = 0;
  int y = 0;
  int win = 0; //9*9-10=71 //判断雷是否都被排查干净
  while (win < row * col - EASY_COUNT)
  {
    printf("请输入排查雷的坐标：>");
    scanf("%d%d", &x, &y);
    if (x >= 1 && x <= row && y >= 1 && y <= col)
    {
      //坐标合法
      if (mine[x][y] == '1')
      {
        printf("很遗憾，你被炸死了\n");//踩雷
        DisplayBoard(mine, row, col);
        break;
      }
      else//不是雷
      {
        //explode_spread(mine, show, row, col, x, y);
        //计算x，y坐标周围有几个雷
        int count = get_mine_count(mine, x, y);
        show[x][y] = count + '0';
        //必须加上'0'（实际上是 count 返回的整型值加上0的ASCII值后，再转化为字符）
        DisplayBoard(show, row, col);
        win++;
      }
    }
    else
    {
      printf("输入坐标非法，请重新输入！\n");
    }
  }
  if (win == row * col - EASY_COUNT)
  {
    printf("恭喜你，排雷成功\n");
    DisplayBoard(mine, row, col);
  }
}

3、//game.h

#pragma once
 
// 9*9
#define ROW 9// 行
#define COL 9// 列
 
// 11*11
#define ROWS ROW+2
#define COLS COL+2
 
#define EASY_COUNT 10// 地雷的数量
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
// 初始化排雷界面
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
 
// 打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);
 
// 布置地雷
void SetMine(char board[ROWS][COLS], int row, int col);
 
// 排查地雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

八、程序展示

运行效果图：

九、改进建议

1、棋盘优化

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
  printf("   ");// 考虑到y轴占3格
  for (int j = 1; j <= col; j++)// 打印x轴坐标
  {
    printf(" %d  ", j);
  }
  printf("\n");
  printf("  |");
  for (int j = 0; j < col; j++)// 打印棋盘封顶
  {
    printf("---|");
  }
  printf("\n");
  for (int i = 1; i <= row; i++)
  {
    for (int j = 0; j <= col; j++)
    {
      if (j == 0)
      {
        printf("%2d|", i);// 顺带打印y轴坐标
      }
      else
        printf(" %c |", board[i][j]);// 打印数据
    }
    printf("\n");
    for (int j = 1; j <= col+1; j++)// 注意这里col应该+1
    {
      if (j == 1)
        printf("  |");
      else
        printf("---|");
    }
    printf("\n");
  }
}

运行效果图如下：（增加了棋盘边界线）

2、炸金花式展开函数

这是一个递归函数，该函数实现的功能为：如果排查的位置周围没有雷，则向四周爆炸式展开，直至遇到周围有地雷的坐标时才停下来。那该怎么实现该递归函数呢？当排查的位置没有雷且该位置周围没有雷时，就展开其周围一圈的 8 个坐标，然后看这 8 个坐标是否可以再逐个向其自身周围接着展开，这样一次就递归调用函数自身 8 次的展开速度就像爆炸了一样，所以称其为：炸金花式展开（深度优先遍历）。

注：会发现不管先展开哪一个位置都将陷入死递归当中。当要展开 (x,y) 坐标周围的一圈坐标时，假如其首先会从 (x-1,y+1) 位置开始，然后又由该坐标向其自身周围的一圈展开时，你会发现坐标 (x,y) 也在需要展开的范围内。这样不就会重复要求再次展开坐标(x,y)，然后再由 (x,y) 要求展开(x-1,y+1)，两个坐标相互疯狂调用。若每次判断一个坐标上没有雷且该坐标周围一圈同样没有雷时，则将向我们展示的棋盘上表示未知的字符 '*' 改成 ' '。然后在之后每次递归调用前给一个判断：如果这个将要被递归调用的坐标在展示的棋盘上存放的是字符 '*' 时才能进行下一步，否则将直接跳过此次递归。

如若发生向外扩张的递归，那拓展出来最外围的一圈坐标完全无法起到限制的作用，无法阻止炸金花式的向外展开。因此只能在每次进入递归函数后加一条限制。

//炸金花式展开函数
void explode_spread(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
{
  // 限制非法坐标的展开
  if (x >= 1 && x <= row && y >= 1 && y <= col)
  {
    // 计算该位置附近四周地雷的个数
    int count = get_mine_count(mine, x, y);
    // 若四周没有一个地雷，则需要向该位置的四周展开，直到展开到某个位置附近存在地雷为止
    if (count == 0)
    {
      // 把附近没有地雷的位置变成字符' '
      show[x][y] = ' ';
      int i = 0;
      // 向四周共8个位置递归调用
      for (i = x - 1; i <= x + 1; i++)
      {
        int j = 0;
        for (j = y - 1; j <= y + 1; j++)
        {
          // 限制对点位置的重复展开调用，使得每一个位置只能向四周展开一次
          if (show[i][j] == '*')
          {
            explode_spread(mine, show, row, col, i, j);
          }
        }
      }
    }
    // 若四周存在地雷则应该在这个位置上标注上地雷的个数
    else
    {
      show[x][y] = count + '0';
    }
  }
}


文章标签：
C语言
关键词：
C语言扫雷
C语言教程
C语言扫雷教程
炫酷的伊莉娜
目录
相关文章
星霜旅人
|
1月前
|
C语言
扫雷游戏（用C语言实现）
扫雷游戏（用C语言实现）
星霜旅人
79 0
温轻舟
|
3月前
|
机器学习/深度学习 C语言
九/十：《初学C语言》— 扫雷游戏实现和函数递归基础
【8月更文挑战第5天】本篇文章用C语言采用多文件编写实现了一个基础的扫雷游戏（附源码），并讲解了关于函数递归的基础概念及其相对应的习题练习（附源码）
温轻舟
41 1
九/十：《初学C语言》— 扫雷游戏实现和函数递归基础
2的n次方_
|
2月前
|
存储 安全 算法
C 语言——实现扫雷小游戏
本文介绍了使用二维数组创建棋盘并实现扫雷游戏的方法。首先，通过初始化数组创建一个9x9的棋盘，并添加行列标识以便操作。接着，利用随机数在棋盘上布置雷。最后，通过判断玩家输入的坐标来实现扫雷功能，包括显示雷的数量和处理游戏胜利或失败的情况。文中提供了完整的代码实现。
2的n次方_
43 1
C 语言——实现扫雷小游戏
平凡程序猿~
|
1月前
|
C语言 开发者
C语言实现猜数字小游戏（详细教程）
C语言实现猜数字小游戏（详细教程）
平凡程序猿~
114 3
平凡程序猿~
|
1月前
|
编译器 C语言 C++
VSCode安装配置C语言（保姆级教程）
VSCode安装配置C语言（保姆级教程）
平凡程序猿~
138 3
平凡程序猿~
|
1月前
|
存储 算法 安全
C语言实现扫雷游戏
C语言实现扫雷游戏
平凡程序猿~
36 1
白子寰
|
1月前
|
C语言
初学者指南：使用C语言实现简易版扫雷游戏
初学者指南：使用C语言实现简易版扫雷游戏
白子寰
34 0
小强在此
|
1月前
|
C语言
C语言扫雷游戏（详解）
C语言扫雷游戏（详解）
小强在此
37 0
Hoshiᅟᅠ
|
1月前
|
存储 编译器 C语言
【C语言篇】数组和函数的实践：扫雷游戏（附源码）
【C语言篇】数组和函数的实践：扫雷游戏（附源码）
Hoshiᅟᅠ
35 0
chian-ocean
|
3月前
|
C语言
扫雷（C语言）
扫雷（C语言）
chian-ocean
43 4