C语言之扫雷

最新推荐文章于 2020-12-19 01:24:48 发布
最新推荐文章于 2020-12-19 01:24:48 发布
阅读量1.2w 收藏 1
点赞数
分类专栏： 练习 C/C++ 文章标签： 小玩意儿
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NeverWA/article/details/79629330
版权
C/C++ 同时被 2 个专栏收录
57 篇文章 2 订阅
订阅专栏
练习
17 篇文章 0 订阅
订阅专栏

前言

用C语言写出一个扫雷程序。像大家熟悉的电脑扫雷一样，如果选的位置有雷就结束游戏；如果没有雷，就标记出来周围格子雷的数量。这里写出来的扫雷不能用鼠标点击，也没有提供标记雷的功能，只在CMD黑框框里展示出来，所以看上去比较难看、用起来也没有windows系统自带的扫雷那样方便。

设计要求


  2. 首先需要写一个展示功能，否则玩家拿什么扫
  3. 其次，要对雷区进行随机布雷。这里布雷的要求是第一步永远不能被炸死。我想到了两种方法解决：第一种方法是先生成随机雷阵，待玩家走第一步后判断这一步的位置是否有雷，如果有雷就把雷随机放在一个没有雷的位置；第二种方法是让玩家先走第一步，然后在避开玩家走第一步的位置的前提下进行随机布雷。本人觉得第二种容易实现且代码简单，就选择了第二种。
  4. 然后，需要扫雷里最重要的东西–玩家扫雷。玩家通过输入坐标的方式选择要扫的位置，然后程序检查该位置是否有雷，有雷就失败，没有就标记出该位置或者该位置的扩展位置的周围8个位置的雷数。如果雷数为0则不显示。
  5. 最后就是对前面3步的调度，玩什么难度、失败后继续还是不玩了。。。 一切由玩家选择。

补充一点，我所使用的是VS2008， 采用TDD模式，扫雷程序分为3个源文件，分别是：game.h 、game.c 、index.c

正文

为了更好地解释代码和体现思维的连贯性，按照代码的顺序进行说明。文末附有扫雷的全部代码。

先来看 index.c 中的代码：

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"

int main(){
    char mine[MROW][MCOL];
    char show[MROW][MCOL];
    int row=0, col=0;
    int count=0;
    int dead[2]={0};
    char again[3]={'5'};
    int c=0;
    int Fx=-1, Fy=-1;
    int WinSign=0;
    srand((unsigned int) time(NULL));

AGAIN : Init_Board(mine,show, &row, &col);
    Show_Board(show, row, col);
    while(1)
    {
        printf("选择位置：>");
        scanf("%d%d", &Fx, &Fy);
        while((c = getchar()) != '\n' && c != EOF);     //清除键盘缓冲区的万能写法
        if ( Check_Legal(row, col, Fx, Fy) !=1)
        {
            printf("输入位置不合法，再次");
            continue;
        }
        break;
    }
    PutMine(mine, row, col, Fx, Fy, &count);
    while(Player_Do(mine, show, row, col, dead, &Fx, &Fy) ==0)
    {
        if(!Check_Win(show, row, col, count))
        {
            WinSign=0;
    //      Show_Board(mine, row, col);
            Show_Board(show, row, col);
            printf("*********************共有%d颗雷********************\n", count);
        }
        else
        {
            WinSign=1;
            break;
        }
    }
        if (WinSign==1)
        {
            Show_Board(show, row, col);
            printf("恭喜你，排完了所有雷!\n");
        }
        else
        {
            show[dead[0]][dead[1]] = '*'; 
            Show_Board(show, row, col);
        }
        printf("**********************************游戏结束****************************************\n");
        Sleep(2500);
        printf("你还想再玩一局吗？(Y/N)  >");
        scanf("%c", &again);
        while((c = getchar()) != '\n' && c != EOF);     //清除键盘缓冲区的万能写法
        if ( strcmp(again, "Y")==0 || strcmp(again, "y")==0 || strcmp(again, "YES")==0 || strcmp(again, "yes")==0 || strcmp(again, "Yes")==0 ) goto AGAIN ;

    return  0;
}

这里引入头文件 game.c 是因为所有的函数实现是放在game.c文件中，函数和全局变量、对标准库的引用全是放在game.h文件中的。

mine 矩阵是雷矩阵，用于内部逻辑处理； show 矩阵是展示矩阵，用于和玩家交互。
MROW、MCOL 是在game.h中用define定义的两个宏常量。

row、col是玩家选择板子的行数和列数。

Init_Board 函数的作用是随机布雷并由玩家决定板子的行数row和列数col。

Show_Board 函数的作用是显示板子的内容。

Check_Legal 函数的作用是检测玩家选择的第一个位置是否合法，合法则返回1。

PutMine 函数的作用是利用玩家走完第一步、用Fx、Fy记录下该位置后在避开该位置的前提下布雷，同时将雷的总数放入 count 中。

Player_Do 函数的作用是玩家选择要排的位置，然后判断，该位置不是雷就扩展，是雷的话就在 dead[2] 数组中写入这个游戏结束位置。

Check_Win 函数的作用是通过检查剩余未判断区域的数量是否大于总雷数 count 来判断是否排完全部的雷，是则返回1。

接下来对各个函数进行说明

Init_Board

static void Create_Board(char mine[MROW][MCOL], char show[MROW][MCOL], const int level, int *row, int *col){
        int i=0, j=0;
        *row=level;
        *col=level;
        for(i=0; i<MROW; i++)
        {
            for(j=0; j<MCOL; j++)
            {
                mine[i][j]='0';
                show[i][j]='#';
            }
        }
}

void Init_Board(char mine[MROW][MCOL], char show[MROW][MCOL], int *row, int *col)
{
    int choose;
    int c=0;
    printf("请选择难度（  1：容易  2：一般  3：困难 ）>");
    scanf("%d", &choose);
    while((c = getchar()) != '\n' && c != EOF);
    while(choose!=1 && choose!=2 && choose!=3)
    {
        printf("输入有误，请重新选择难度（  1：容易  2：一般  3：困难 ）>");
        scanf("%d", &choose);
        while((c = getchar()) != '\n' && c != EOF);
    }
    switch (choose){
        case 1:Create_Board(mine,show, EAZY, row, col); break;
        case 2:Create_Board(mine, show,ORDINARY, row, col); break;
        case 3: Create_Board(mine,show, DIFFICUTE, row, col);break;
        default: printf("输入错误\n");
    }
}

这里使用开关语句比较 choose 的值，根据 choose 值的不同，调用静态函数 Create_Board 创建用不同枚举常量的 mine 、 show 矩阵且将玩家选择的板子的行数和列数用 rwo、col 记录。注意这里的初始化并内有布雷，只是无差别地让 mine 的每个单元为字符O、让 show 的每个单元为字符#。布雷函数单独存在。

PutMine

void PutMine(char mine[MROW][MCOL], const int row, const int col, int Fx, int Fy, int *count)
{
    int i=0, j=0;
    int x=0, y=0;
    int ss=0;

    *count = row + (int)pow(2,(col/4))-3;           //雷数   一级： 14颗      二级：32颗    三级：88颗

    for (i=0; i<*count; i++)
    {
        x=rand()%row + 1;
        y=rand()%col + 1;
        if(mine[x][y]=='1' || ((x==Fx) && (y==Fy)) )
        {
            i--;
            continue;
        }
        mine[x][y]='1';
        ss++;
        //          printf("第%d颗雷的位置是 (%d, %d)\n", ss, x ,y);
    }
}

这里根据初始化板子时确定的 row、col 来指定雷数 count，采用随机函数布雷, 有雷的位置在 mine 矩阵里用字符1代表。

Show_Board

void Show_Board( const char board[MROW][MCOL], const int row, const int col){
    int i = 0, j = 0;
    for(i=0; i<row+1; i++)
    {
        if (i==0)
        {
            for (j=0; j<row+1; j++)     (j<10) ? printf("  %d ", j) : printf(" %d ", j);

            printf("\n");
        }
        else
        {
            for(j=0; j<col+1; j++)      (j==0) ? printf("   ") : printf(" ---");

            printf("\n");
            for (j=0; j<col+1; j++)
            {
                if (j==0)   (i<10) ? printf("  %d", i) : printf(" %d", i); 

                else printf("| %c ",board[i][j]);
            }

            printf("|\n");
            if(i==row)
                for(j=0; j<col+1; j++)      (j==0) ? printf("   ") : printf(" ---");

        }

    }
    printf("\n\n");
}

这里没什么可说。

Check_Legal

int Check_Legal(const int row, const int col, const int x, const int y)
{
    return ( x<row+1  && x>0 && y<col+1 && y>0 ); 
}

当玩家选择的第一步的位置不在板子的范围类判定为非法，返回0。

Check_Win

int Check_Win(static char show[MROW][MCOL], static int row, static int col, int count)
{
    int i=0, j=0;
    for (i=1; i<=row; i++)
    {
        for(j=1; j<=col; j++)
        {
            if (show[i][j]=='#')
            {
//              printf("show[%d][%d]=%c  ", i, j, show[i][j]);
                count--;
            }
//          else printf("show[%d][%d]=  ", i, j);
        }
//      printf("\n");
    }
//  printf("\n");
    if (count<0)
    {
        return 0;
    }
    return 1;
}

遍历 row*col show矩阵， 若 count 小于0，说明剩余 ‘#’个数大于雷的总数，没有排完雷，返回0。否则，返回1。

Player_Do

该函数最为复杂，也是扫雷的核心程序，故而放在最后。先放出 Player_Do 函数的实现，接下来分别对 Player_Do 函数内部的一些调用做出解释。

int  Player_Do(char mine[MROW][MCOL], char show[MROW][MCOL], const int row, const int col, int dead[2], int *Fx, int *Fy)
{
    int x=0, y=0;
    int c=0;
    x=*Fx; y=*Fy;
Reput:  
    if (*Fx ==-1 && *Fy ==-1)
    {
        printf("选择位置：>");
        scanf("%d%d", &x, &y);
        while((c = getchar()) != '\n' && c != EOF);
    }

    *Fx=-1;  *Fy=-1;
    if(Check_Legal(row, col, x, y)==1)
    {
        if(mine[x][y]=='1')
        {
            dead[0] = x; 
            dead[1] = y;
            return 1;
        }
        else if (mine[x][y] == '-')
        {
            printf("此位置无效， 再次");
            goto Reput;
        }
        else
        {
            expand(mine, show, row, col, x, y);
        }
    }

    else
    {
        printf("输入位置不合法，再次");
        goto Reput;
    }
    return 0;
}

该函数对玩家第一次选择以后的位置做出合法性、该位置是否已排过检查，若通过检查，则调用 expand 函数进行判断扩展，达到类似爆炸一样的效果。

Player_Do 调用的 expand
int expand(const char mine[MROW][MCOL], char show[MROW][MCOL], const int row, const int col, const int x, const int y)
{

    if (  Check_Legal(row, col, x, y) !=1 )
    {
        return -1;
    }
    else if (mine[x][y] == '1' || mine[x][y] == '-')
    {
        return -2;
    }

    else
    {
        Mark_MineCount(mine, show, row, col, x, y);
        if(show[x][y] == ' ')
        {
            expand(mine, show, row, col, x-1, y-1);
            expand(mine, show, row, col, x-1, y);
            expand(mine, show, row, col, x-1, y+1);
            expand(mine, show, row, col, x, y-1);
            expand(mine, show, row, col, x, y+1);
            expand(mine, show, row, col, x+1, y-1);
            expand(mine, show, row, col, x+1, y);
            expand(mine, show, row, col, x+1, y+1);
        }
    }
    return 0;
}

首先进行的仍是对传入的位置进行检查，若排查位置超出板子范围Check_Legal(row, col, x, y) !=1、排查位置有雷mine[x][y] == ‘1’、排查位置已排查过（mine[x][y] == ‘-‘），则函数返回以作为递归结束条件。 这里分别返回 -1和-2 是为了在编写代码的过程中思路更清晰，其实该函数的返回值并没有在后续的过程中用到，只是起到结束递归的作用。
写成这样也可以：

if(Check_Legal(row, col, x, y) !=1 || mine[x][y] == '1' || mine[x][y] == '-') 
    return 0;

甚至还可以将 expand 函数的返回类型设为 viod ，返回时写

if(Check_Legal(row, col, x, y) !=1 || mine[x][y] == '1' || mine[x][y] == '-') 
    return;

如果通过检查，就调用 Mark_MineCount 函数标记该位置周围8个位置雷的数量，然后在该位置周围雷数为0的情况下再递归地调用 expand 函数对传入位置的周围8个位置进行扩展。为什么是 “在该位置周围雷数为0的情况下” 呢？ 因为在扫雷的过程中，如果一个位置本身没有雷但它周围8个位置有雷，那么这个位置应该显示出一个数字，并且停止扩展。

expand 调用的 Mark_MineCount
static void Mark_MineCount(char mine[MROW][MCOL], char show[MROW][MCOL], const int  row, const int col, const int x, const int y)
{
    char c = '0';

    if (  Check_Legal(row, col, x, y) !=1 )
    {
        return;
    }
    else if (mine[x][y] == '1' || mine[x][y] == '-' || show[x][y]!='#')
    {
        return;
    }
    else
    {
        if(mine[x-1][y-1] !='-')  (c = c + mine[x-1][y-1] - '0');
        if(mine[x-1][y] !='-')   (c = c + mine[x-1][y] - '0');
        if(mine[x-1][y+1] !='-')  (c = c + mine[x-1][y+1] - '0');

        if(mine[x][y-1] !='-')  (c = c + mine[x][y-1] - '0');
        if(mine[x][y+1] !='-')  (c = c + mine[x][y+1] - '0');

        if(mine[x+1][y-1] !='-')  (c = c + mine[x+1][y-1] - '0');
        if(mine[x+1][y] !='-')  (c = c + mine[x+1][y] - '0');
        if(mine[x+1][y+1] !='-')  (c = c + mine[x+1][y+1] - '0');

        if(c == '0') show[x][y] = ' ';
        else show[x][y] = c;
        mine[x][y] = '-';
    }
}

这个函数的参数太多，足足有6个，这样做没有错，但是非常不提倡。因为函数的参数一旦多了之后，就会使别人容易看不懂你的代码。我这里的 Mark_MineCount 是静态函数，仅供 game.c 内部使用，6个参数勉强能说的过去。。。 但身为开发人员，应尽量避免这种问题。
这里对参数做出解释：

char mine[MROW][MCOL] ： mine板子的最大范围

char show[MROW][MCOL] ： show板子的最大范围

const int row ： 实际使用的板子的行数

const int col ： 实际使用的板子的列数

const int x ： 想要进行周围雷数标记的位置的所在行

const int y ： 想要进行周围雷数标记的位置的所在列

函数一开始进行的仍是检查： 检查位置的合法性、检查该位置是否有雷、是否已经排过，如果没有通过检查，那么说明这个位置上不能用数字标示出它周围8个位置的雷数； 若通过检查，就以变量 C 来记录周围的雷数。并且如果雷数为0，说明这个位置周围没有雷，可以进行扩展。 最后的C
mine[x][y] = '-'; 将 mine 矩阵的[x][y]位置标记为’-‘用来告诉 expand 函数这个位置不是雷并且已经排查过了。

源代码

扫雷程序的完成代码放在了 GitHub 上，点击这里获取完整代码

NeverWA
关注
专栏目录
C语言实现扫雷游戏及其优化
08-25
C语言实现扫雷游戏及其优化 本文将详细介绍C语言实现扫雷游戏及其优化，具体包括游戏的设计思想、实现代码和优化方法。 游戏设计思想 扫雷游戏的设计思想是使用两个二维数组，一个用于显示，一个用于后台雷的布置...
C语言：9*9>简易扫雷
TwinkleCapricorns的博客
10-14 1977
简易扫雷主要实现的功能具有： 1、输出9*9雷阵； 2、通过输入坐标开始扫雷； 3、可以判断坐标处四周有多少个雷。 #include #include #include #include #include"game.h" void start_game() { char mine[ROWS][COLS] = { 0 }; char show[ROWS][COLS] = { 0 };
C语言——扫雷游戏
FTALYB的博客
05-29 861
C语言——扫雷游戏 利用C语言学习到的知识，就可以写一些简单的小游戏，比如：扫雷游戏。 在开始敲代码之前，需要做如下准备： 一、 回顾一下怎么玩扫雷： 点击格子中的任意一个位置，如果点到雷，那么就炸死，游戏结束，如果这个位置没有雷，就会显示周围8个位置的雷的总数，同时会展开该位置周围没雷的地方，就这样直到游戏结束； 二、思考用C语言实现游戏： 要求如下： - 扫雷中第一步不能被炸死...
扫雷（C语言）
matilda_art的博客
03-28 189
为了用C语言实现扫雷。 首先我们创建三个文件，如下图：（代码执行环境为VS2013） 我们在头文件game.h中声明各种函数： #define ROW 9 #define COL 9 #define ROWS ROW+2 #define COLS COL+2 #define EASY_COUNT 10 #include <stdio.h> #include <stdlib...
C++ 简单的扫雷实现
丨奇古丨的博客
07-13 2780
C++ 简单的扫雷实现 这里是一个刚接触编程一年的新手！ 所以程序有一些地方我做不到还原原版扫雷（比如……可能会格子上会出现数字0，周围的格子需要一个一个手动扫过去……） ps：地雷密度可能稍微有点大？不管了你们加油（手动滑稽） #include "stdafx.h" #include <stdlib.h> #include <time.h> #include <io...
用c++实现扫雷
只是个菜鸡
12-05 5068
扫雷是一个经典的电脑小游戏，用C++来编一下，效果自己试一下，有错请评论 #include #include #define YELLOW FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY #define CYAN FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSIT
C语言简易扫雷游戏
08-25
主要为大家详细介绍了C语言简易扫雷游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现扫雷程序
08-25
本文将深入讲解如何使用C语言实现扫雷程序。 首先，我们创建两个二维数组：`mine` 用于存储雷的位置，`show` 用于显示给玩家的棋盘。`mine` 数组的大小为 ROWxCOL，`show` 数组的大小为 ROWSxCOLS。ROW 和 COL 分别...
C语言实现扫雷小游戏（适合初学者）
08-19
C语言实现扫雷小游戏（适合初学者） 本文将详细介绍C语言实现扫雷小游戏的知识点，适合初学者练习，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 函数定义和声明 在game.h...
C/C++语言扫雷小游戏（eaxyX图形库的应用）
addy_li的博客
12-19 6067
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、扫雷的玩法，以及实现功能介绍二、代码实现1.引入库2.宏定义部分3.初始化游戏界面4.加载图片5.绘制图片到窗口6.操作控制（鼠标控制）及功能实现7.main函数总结 前言 提示：这里给大家介绍的是easyX图形库的应用，来制作扫雷小游戏 解释：EasyX 是针对 C++ 的图形库，可以帮助 C/C++ 初学者快速上手图形和游戏编程。 过多的在这我不多说自己去了解 提示：以下是本篇文章正文内容，下面案例可供参考 一、扫雷
C语言实现扫雷
dxtianlei的博客
08-19 597
要用C语言实现一个扫雷小游戏，扫雷中有一个棋盘和若干个地雷。而棋盘上要有初始状态，要是还要在棋盘上设置地雷的话就要求棋盘上一个位置能同时存在两种状态或信息。这是很难做到的，所以我们要有一个棋盘，一个雷区。这样的话我们就定义两个数组，一个数组就是棋盘数组，一个数组就是雷区数组。 扫雷游戏中有些情况下需要统计雷数，所以我们就将地雷在雷区上的表示设置为1，没有地雷的地方则设置为0。这样雷区数组就可以确...
扫雷（通俗易懂简易版）
haishark的博客
04-11 2623
我们绝大部分人都玩过扫雷，玩起来真的很简单，只需要1用鼠标点一点就可以了（要赢还是需要费脑经的） 但是现在自己来编写一个简易版的扫雷，发现不是那么简单的，经过了几天的编写，终于实现了属于我的简易版的扫雷，过程简单，对于我这菜鸟来说，难的部分就是怎么去实现点一次一大片就空了（这里用了递归）。接下来就是我的扫雷程序和截图 先看看电脑的扫雷界面，和我的扫雷界面（发现自己的好丑） 玩过扫
gcc 链接文件
热门推荐
NeverWA的博客
04-15 1万+
gcc 链接文件 生成静态库 gcc -c add.c minus.c ar rcv libtest1.a add.o minus.o 链接静态库 方法一： gcc -o test test.c libtest1.a 方法二： gcc -o test test.c -L. -ltest1 生成动态库 gcc -c add.c minus.c gcc -shared...
C语言写日历
NeverWA的博客
03-22 1万+
用C语言写一个日历 #include&lt;stdio.h&gt; /*1970-1-1 星期四*/ // 以1970-1-1作为基准 int start_year = 1970; int start_month = 1; int start_day = 1; //将以char输进来的字符串转换成int型，并完成错误检查和信息筛选 int char_to_int(char *s, ...
C语言几种特殊的自定义类型
NeverWA的博客
03-29 1万+
C语言几种特殊的自定义类型 结构体 结构体的创建 可以在创建结构体的时候添加结构体的标签tag，用来为该结构体取唯一的名字，以便于和其它结构体区分开。 struct tag{ member_list; } variable_list; 也可以在创建结构体的时候不加标签，声明为一个匿名结构体。如： struct { char name[20];//名字 int a...
Core Dump
NeverWA的博客
06-13 1万+
Core Dump 事后调试 当一个进程要异常终止时，可以选择把进程的用户空间内存数据全部保存到磁盘上，文件名通常叫core，这叫做Core Dump。进程异常终止通常是因为有Bug，比如非法访问内存导致段错误，事后可以用gdb调试器检查core文件以查清错误原因，这叫做事后调试。一个进程允许产生多大的core文件取决于进程的Resource Limit。 系统默认不允许产生core文件的，是...
C语言动态分配内存
NeverWA的博客
06-18 1万+
C语言动态分配内存 malloc 动态开辟内存的函数： void* malloc (size_t size); 这个函数向内存申请⼀块连续可⽤的空间，并返回指向这块空间的指针 如果开辟成功，则返回⼀个指向开辟好空间的指针 如果开辟失败，则返回⼀个NULL指针，因此malloc的返回值⼀定要做检查 返回值的类型是 void* ，所以malloc函数并不知道开辟空间的类型，具体在...
素数筛
NeverWA的博客
03-18 1万+
素数筛#include<stdio.h> #include<math.h> #define num 200 int a[num+1]; int main(){ int i, j; for(i=0;i<=num;i++) a[i]=1; a[0]=a[1]=0; for(i=2;i<=num;i++){ if(a[i]==1){
C语言实现扫雷游戏代码解析
"C语言实现扫雷游戏代码" 扫雷是一款广为人知的益智游戏，其核心在于逻辑推理和概率分析。在这个项目中，我们看到一个完全使用C语言编写的扫雷游戏代码实现。C语言是一种强大的、低级别的编程语言，适合于创建这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值