C语言 扫雷（含递归展开）

已于 2023-03-11 18:51:16 修改
阅读量3.9k 收藏 86
点赞数 42
文章标签： c语言 小程序
于 2022-10-13 14:03:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73258319/article/details/127296295
版权

目录

前言

一.设计思路

基本的构思方向

准备基本框架

二.函数功能设置

菜单界面

主函数

初始化

显示棋盘

设置雷

计算周围雷数

排雷

 总体game函数

后续优化

1.标记雷

2.递归展开

3.防止第一次踩雷

4.惩罚功能

5.最终代码

总结

前言

想必大家在上学时代都或多或少玩过扫雷游戏，通过棋盘上已有的数据分析出雷所在的位置获取胜利，每一次游戏都带给我们强大的满足感与能力的提升。那么今天我就带领大家用C语言实现扫雷的编写。

let's go!

一.设计思路

基本的构思方向

首先，扫雷游戏结局包含两种情况

1.标记所有雷或掀开所有非雷地块

2.踩到雷，游戏结束

基本玩法：

掀开一个格子，如果是雷，游戏结束。

反之，显示周围有多少个雷。 

 

 如何达到上图的效果呢？

首先我们需要定义一个二维数组用于表示棋盘，我们在其上布置“地雷”。

假设我们用'0'表示安全，'1'表示雷的话，那么统计周围雷数就变得简单了：雷数(n)=周围八个格子的数值的和。

但这时候我们又会遇见一个问题：

如果一个地方被点开了，显示了其周围的总雷数（例如：4），在下次点开它周围格子时，就不免错误地将这个并不表示雷的'4'加上。就会造成bug

那么,设置表里两层棋盘或许是一个更好的选择：内层设置'雷',外层读取内层数据展示给用户显示周围雷数。

ps:下文中show/board2是外棋盘，mine/board1是雷棋盘。

之后，当用户选择外棋盘的坐标时，只需要统计内棋盘周围雷数就行了。

但这时候我们又会遇见另一个问题：在数组边界的格子并没有八个周围的格子

如何解决这个问题呢？我们可以把两个数组都开大一圈，这样访问时，排查边界的数据就不会越界了。eg:9*9的期望棋盘，我们开辟成11*11的棋盘，刚好大一圈。

准备基本框架

首先基于与用户的交互功能，需要以下功能

菜单界面：

用户在此选择开始游戏，结束游戏，输入非法提示重输。

显示棋盘：

未点开的地块统一用'?'表示，点开的地块用空格表示，如果周围有雷，显示'雷'数。

设置雷：

在游戏开始时用时间戳随机生成一定数目的雷。

排查雷

用户输入想排查的地块坐标，判定游戏状况：踩雷，安全

计数雷

 用户输入想排查的地块坐标，游戏状况安全，计算周围八个格子的数

胜利，失败判定：

当踩雷时结束游戏，并显示菜单界面

好，现在进入正文——函数功能设置！

二.函数功能设置

代码的功能会在代码段进行解释

菜单界面

达到提示输入的效果就行

eg:

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

主函数

因为我们玩游戏的时候希望的可能并非只是玩一局，这个时候就需要在游戏函数(game)上添加一个do while()循环！

void menu()
{
    printf("*******************************\n");
    printf("*****  1. play  0. exit   *****\n");
    printf("*******************************\n");
}
void text()
{
    int input = 0;
    do
    {
        menu();
        printf("请选择:>");
        scanf_s("%d", &input);
        system("cls");
        switch (input)
        {
        case 1:
            printf("游戏开始\n");
            game();
            Sleep(1000);
            system("cls");
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default :
            printf("输入非法，请重输！\n");
            break;
        }

    } while (input);
}

ps:在这里，我们选择使用switch case语句以达到多分枝的目的 

初始化

在这里我们设置棋盘的初始状态，使其元素统一地表现。

       initboard(board1, ROW, COL, '0');//mine
        initboard(board2, ROW, COL, '?');//show

由于棋盘初始化本质时将数组元素换成'0'或'?'，是一个重复单调的过程，索性就把它封装成一个函数。以char set来确定替换元素。

通过双层循环遍历替换数组元素（set）：

void initboard(char board[ROWS][COLS], int row, int col,char set)//初始化show棋盘和mine棋盘，set，传什么打印什么
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row+2; i++)
    {
        for (j = 0; j < col+2; j++)
        {
            board[i][j] = set;
        }
    }
}

 函数调用过程：

    char board1[ROWS][COLS] = { 0 };
    char board2[ROWS][COLS] = { 0 };

显示棋盘

我们玩游戏显然不可能只是我们凭意识玩，所以就需要对每一步进行及时反馈（显示外棋盘到电脑）——对棋盘（不论内外棋盘）进行遍历打印。  display(board2, ROW, COL); 


void display(char board[ROWS][COLS], int row, int col)//打印棋盘，传什么打印什么
{
    int i = 0;
    int j = 0;
    for (j = 0; j < col + 1; j++)//打印数轴，便于用户输入坐标
    {
        printf("   %d", j);
    }
    printf("\n");
    printf("\n");
    for (i = 1; i < row + 1; i++)
    {
        printf("   %d", i);//美观
        for (j = 1; j < col + 1; j++)//遍历每一行内的元素，遍历列次
        {
            printf("   %c", board[i][j]);
        }
        printf("\n");
        printf("\n\n");//留出空格
    }
}

 ps:11 20行主要是为了保持排版美观，打印效果如下     相当美观

设置雷

我们需要在mine数组里布置雷。 setmine(board1, ROW, COL);
利用一个循环，每次随机生成一个坐标，如果这个位置不是雷，就在这个位置放雷，直到把所有的雷放完为止。

这一步就比较简单了，但随机数涉及到一个时间戳的概念，我在此不再赘述。

 主函数部分要设置一个随机数种子（不需要理解）

​
​
void setmine(char board[ROWS][COLS], int row, int col)//埋雷
{
    int count = easy_mine;
    while(count>0)
    {
/*rand()函数的意思是生成任意大小的一个数，
我们使用%row对row取余后，就限制到了0到row-1之间了，
为了用户方便输入又进行了+1*/
        int i = rand() % row + 1;//雷的横坐标在[0,row]之间
        int j = rand() % col + 1;//同理
        if (board[i][j] == '0')//只有未被埋雷的地方才能埋雷；
        {
            count--;
            board[i][j] = '1';
        }
    }
}

​

​
​#include <time.h>//部分编译器需要加
int main()
{
    srand((unsigned int)time(NULL));//设置由时间设置的随机数种子
    text();
}

​

计算周围雷数

调用count_mine函数计算周围雷数（可以包涵自己格子）设当前格子坐标[i,j]

只需要双层循环遍历行数在[i-1,i+1]，列数在[j-1,j+1]的数，计算就行

int count_mine(char mine[ROWS][COLS], int i, int j)//数包括自己在内的九个格子的雷数
{
    int a = 0;
    int b = 0;
    int count = 0;
    for (a = i  - 1; a <= i  + 1; a++)
    {
        for (b = j - 1; b <= j  + 1; b++)
        {
            if(a> 0 && b > 0 && a < ROW + 1 && b < COL + 1)
            count =mine[a][b] - '0'+count;//'1'-'0'=1;
        }
    }
    return count;
}

我看很多博主选择用字符1减去字符0来统计，不经循环直接遍历上八个格子，我只能说：

确实可以，但没必要！

 直接++也未免不可！

int count_mine(char mine[ROWS][COLS], int i, int j)//数包括自己在内的九个格子的雷数
{
    int a = 0;
    int b = 0;
    int count = 0;
    for (a = i  - 1; a <= i  + 1; a++)
    {
        for (b = j - 1; b <= j  + 1; b++)
        {
            if(mine[a][b]='1')
            count ++;
        }
    }
    return count;
}

排雷

ok!今天的重头戏来了，

布置好雷后，就开始排雷。排查雷需要同时操作两个数组。

int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)//排雷

用户输入坐标，同时操作两个数组的判断条件


if (i > 0 && i < row + 1 && j>0 && j < col + 1 && show[i][j] == '?')//检验坐标合法性
//排查过的都不能排查

​

只有满足条件才进入排雷的环境中

1.无雷，调用count函数计算周围八个格子雷数

2.有雷，提示炸死，结束game返回主菜单

​
  if (show[i][j] == '?' && mine[i][j] == '0')
                {
                    show[i][j]=count_mine(mine,i,j);
                    system("cls");//清除上一步
                    display(show, ROW, COL);
                    break;
                }
                else if (show[i][j] == '?' && mine[i][j] == '1')
                {
                    step++;
                    system("cls");
                    printf("很遗憾，你被炸死了\n");
                    printf("雷阵如下\n");
                    display(mine, ROW, COL);
                    break;
                }
                else if (show[i][j] != '?')
                    printf("坐标非法，请重输\n");

​

 在这里，我们还可以添加一个获胜的判断条件

设置一个win=行和列的乘积,每排一个地块，win--，

当win=row*col-easy_mine，即等于所有空地块时，获胜

即，代码如下 


int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    int win = row*col;
    while (win> row * col - easy_mine)
    {
        again:
        printf("请输入坐标:>");
        scanf_s("%d %d", &i, &j);
        if (i > 0 && i < row + 1 && j>0 && j < col + 1 && show[i][j] == '?')
        {//坐标合法
            if (mine[i][j] == '1')
            {//排雷失败
                printf("很遗憾，你被炸死了！\n");
                display(mine, ROW, COL);
                break;
            }
            else
            {//排雷成功
                
                int count = count_mine(mine, i, j);
                    show[i][j] = count + '0';
                    display(show, ROW, COL);
              for (int m = 1; m < row+1 ; m++)//放在“扫雷”工作之后
                {
                    for (int n = 1; n < col+1; n++)//从一开始
                    {
                        if (show[m][n] == '?')
                            win--;
                    }
                }
        }
        else if (show[i][j] != '?')
        {
            printf("输入非法，请重输\n");
            goto again;
        }
    }
    if (win == row * col - easy_mine)//
    {
        printf("你赢了！\n");
        return 1;
    }
}


​

 为了是屏幕干净引入了清屏函数 system("cls");注意头文件。

  system("cls");//其头文件是#include<windows.h>，用于清空屏幕，简化画面

排雷是一个很多步骤的一个操作 ，为search_mine函数加上死循环保证其可以一直进行排雷操作，并且以p接受该函数的返回值：

一旦返回值为1（排雷失败），跳出循环，game函数结束，显示主界面。

 总体game函数

​
void game()
{
        char board1[ROWS][COLS] = { 0 };
        char board2[ROWS][COLS] = { 0 };
        initboard(board1, ROW, COL, '0');//mine
        initboard(board2, ROW, COL, '?');//show
        display(board2, ROW, COL);   
        setmine(board1, ROW, COL);
        //display(board1, ROW, COL);//用于debug
        while (1)
        {           
            int p = search_mine(board1, board2, ROW, COL);
            if (p == 1)
                break;
        }
    
}

​

综上，最终代码如下

#include <iostream>
#define ROWS 11
#define COLS 11
#define ROW 9
#define COL 9
#define easy_mine 10
#define mid_mine 30
#define dif_mine 50
#define debug_mine 80
#define debug+_mine 0
void display(char board[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    for (j = 0; j < col + 1; j++)
    {
        printf("   %d", j);
    }
    printf("\n");
    printf("\n");
    for (i = 1; i < row + 1; i++)
    {
        printf("   %d", i);
        for (j = 1; j < col + 1; j++)
        {
            printf("  %c", board[i][j]);
        }
        printf("\n");
        printf("\n\n");
    }
}
int count_mine(char mine[ROWS][COLS], int i, int j)
{
    int a = 0;
    int b = 0;
    int count = 0;
    for (a = i  - 1; a <= i  + 1; a++)
    {
        for (b = j - 1; b <= j  + 1; b++)
        {
           if(mine[i][j]=='1')
count++;
        }
    }
    return count;
}
int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    int win = row*col;
    while (win> row * col - easy_mine)
    {
        again:
        printf("请输入坐标:>");
        scanf_s("%d %d", &i, &j);
        if (i > 0 && i < row + 1 && j>0 && j < col + 1 && show[i][j] == '?')
        {//坐标合法
            if (mine[i][j] == '1')
            {//排雷失败
                printf("很遗憾，你被炸死了！\n");
                display(mine, ROW, COL);
                break;
            }
            else
            {//排雷成功
                
                int count = count_mine(mine, i, j);
                    show[i][j] = count + '0';
                    display(show, ROW, COL);
              for (int m = 1; m < row+1 ; m++)//放在“扫雷”工作之后
                {
                    for (int n = 1; n < col+1; n++)//从一开始
                    {
                        if (show[m][n] == '?')
                            win--;
                    }
                }
        }
        else if (show[i][j] != '?')
        {
            printf("输入非法，请重输\n");
            goto again;
        }
    }
    if (win == row * col - easy_mine)//
    {
        printf("你赢了！\n");
        return 1;
    }
}
void setmine(char board[ROWS][COLS], int row, int col)
{
    int count = easy_mine;
    while(count>0)
    {
        again:
        int i = rand() % 9 + 1;
        int j = rand() % 9 + 1;
        if (board[i][j] == '0')
        {
            board[i][j] = '1';
        }
        else//如果没有else；if条件不满足；也会count--;
            goto again;
        count--;
    }
}

void inboard(char board[ROWS][COLS], int row, int col,char set)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row+2; i++)
    {
        for (j = 0; j < col+2; j++)
        {
            board[i][j] = set;
        }
    }
}
void game()
{char board1[ROWS][COLS] = { 0 };
        char board2[ROWS][COLS] = { 0 };
        inboard(board1, ROW, COL, '0');
        inboard(board2, ROW, COL, '?');
        display(board2, ROW, COL);
        setmine(board1, ROW, COL);
    while (1)
    {
        
        
       //display(board1, ROW, COL);//用于调试
      int r=  search_mine(board1, board2, ROW, COL);
      if (r == 1)
          break;
        
    }
}
void menu()
{
    printf("*******************************\n");
    printf("*****  1. play  0. exit   *****\n");
    printf("*******************************\n");
}
void text()
{
    int input = 0;
    do
    {
        menu();
        printf("请选择:>");
        scanf_s("%d", &input);
        system("cls");
        printf("扫雷\n");      
        switch (input)
        {
        case 1:
            printf("游戏开始\n");
            game();
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default :
            printf("输入非法，请重输！\n");
            break;
        }

    } while (input);
}
int main()
{
    srand((unsigned int)time(NULL));
    text();
}

后续优化

 一个完整的扫雷当然不止于此，还应当有以下功能：（还有一些小优化也加在里面了）

1.标记雷

比较简单的代码，在终极代码中加入了。

2.递归展开

即，一点棋盘开一大片的功能。

ps:利用递归，这里不再赘述。

void expendboard(char mine[ROWS][COLS], char show[ROWS][COLS], int i, int j)//进行空白展开
{
    int a = 0;
    int b = 0;
    int count = count_mine(mine, i, j);//计算周围雷数
    if (count == 0)//如果没雷，进去
    {
        show[i][j] = ' ';       
        for (a = i - 1; a <= i + 1; a++)
        {
            for (b = j - 1; b <= j + 1; b++)
            {
                if (show[a][b]=='?'&&(mine[a][b]!='1'||show[a][b]=='*'))
//并且展开到出现数字为止，而非展到雷为止
                    expendboard(mine, show, a, b);//递归：连续展开
            }
        }
    }
    else
    {
        show[i][j] = count + '0';   //显示雷数
       
    }
}

3.防止第一次踩雷

如果是上面的伪完整代码的话，如果运气不好，第一次就能被炸死。

所以我们对其也要做相应优化

基本原理就是，设置雷以后，不管你第一次有没有踩到雷都是没有雷：

当你踩雷以后，不提示你被炸死，而是把这颗雷换走，再随机找一个地方埋下

​
 if (step == 1 && show[i][j] == '?' && mine[i][j] == '1')
                {
                    mine[i][j] = '0';
                    while (1)
                    {
                        int a = rand() % 9 + 1;
                        int b = rand() % 9 + 1;
                        if ((a != i || b != j) && mine[a][b] == '0')
                        {
                            mine[a][b] = '1';
                            break;
                        }
                    }
                }

​

4.惩罚功能

 游戏输了，怎么能没有惩罚呢？

送你一个关机小代码，回来可以加载到完整函数上

void shut()
{
	char getput[20] = {0};
	system("shutdown -s -t 60");
	while (1)
	{
	again:
		system("cls");
		printf("\n\t\t\t再一再而不再三！！！\n");
		printf("请注意，你的电脑将在60秒内关机，输入“哥，我再也不敢了”取消关机:>\n");
		scanf_s("%s", getput, (unsigned int)sizeof(getput));
		if (strcmp(getput, "哥，我再也不敢了") == 0)
		{
			system("shutdown -a");
			system("cls");
			break;
		}
		else
		{
			goto again;
		}
	}

}

5.最终代码

#include <iostream>
#include<windows.h>
#include <synchapi.h>
#define ROWS 11
#define COLS 11
#define ROW 9
#define COL 9
#define easy_mine 10
int record = 0;
void display(char board[ROWS][COLS], int row, int col)//打印棋盘，传什么打印什么
{
    int i = 0;
    int j = 0;
    for (j = 0; j < col + 1; j++)
    {
        printf("   %d", j);
    }
    printf("\n");
    printf("\n");
    for (i = 1; i < row + 1; i++)
    {
        printf("   %d", i);
        for (j = 1; j < col + 1; j++)
        {
            printf("   %c", board[i][j]);
        }
        printf("\n");
        printf("\n\n");
    }
}
int count_mine(char mine[ROWS][COLS], int i, int j)//数包括自己在内的九个格子的雷数
{
    int a = 0;
    int b = 0;
    int count = 0;
    for (a = i  - 1; a <= i  + 1; a++)
    {
        for (b = j - 1; b <= j  + 1; b++)
        {
           // if(a> 0 && b > 0 && a < ROW + 1 && b < COL + 1)
            count =mine[a][b] - '0'+count;//'1'-'0'=1;
        }
    }
    return count;
}
void expendboard(char mine[ROWS][COLS], char show[ROWS][COLS], int i, int j)//进行空白展开
{
    int a = 0;
    int b = 0;
    int count = count_mine(mine, i, j);
    if (count == 0)
    {
        show[i][j] = ' ';       
        for (a = i - 1; a <= i + 1; a++)
        {
            for (b = j - 1; b <= j + 1; b++)
            {
                if (a >0 && b>0&&a<ROW+1&&b<COL+1 &&show[a][b]=='?'&&(mine[a][b]!='1'||show[a][b]=='*'))
                    expendboard(mine, show, a, b);//递归：连续展开
            }
        }
    }
    else
    {
        show[i][j] = count + '0';   //显示雷数
      
    }
}
int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)//排雷
{
    int i = 0;
    int j = 0;
    int win = 0;
    int input = 0;
    int mark = 0;
    int step = 0;
    while (win <easy_mine)//标记临界值
    {
        printf("********************\n");
        printf("******* 1.标记 *****\n");
        printf("******* 2.查看 *****\n");
        printf("********************\n"); 
        printf("\n\t\t\t\t\t已标记:%d\n", win);//显示标记个数
        printf("\n\t\t\t\t\t排雷步数:%d\n", step);//步数
        printf("请选择:>");
        scanf_s("%d", &input);        
        switch (input)
        {
          
        case 1:
            printf("选择要标记的地块坐标（再次标记后取消）:>");
            scanf_s("%d %d", &i, &j);
            if (show[i][j] == '?' && mark <= easy_mine)
            {
                show[i][j] = '*';
                mark++;
                if (mine[i][j] == '1')
                    win++;
                system("cls");//清除上一步              
                display(show, ROW, COL);              
            }
            else if (mark > 10)
                printf("标记已满，请取消\n");
            else if (show[i][j] == '*')
            {
                show[i][j] = '?';
                mark--;
                if (mine[i][j] == '1')//正确的雷
                    win--;
                display(show, ROW, COL);
            }
            break;
        case 2:
            while (1)
            {
                step++;
                printf("选择要查看的地块坐标:>");
                scanf_s("%d %d",& i, &j);
                if (step == 1 && show[i][j] == '?' && mine[i][j] == '1')
                {
                    mine[i][j] = '0';
                    while (1)
                    {
                        int a = rand() % 9 + 1;
                        int b = rand() % 9 + 1;
                        if ((a != i || b != j) && mine[a][b] == '0')
                        {
                            mine[a][b] = '1';
                            break;
                        }
                    }
                }
                if (show[i][j] == '?' && mine[i][j] == '0')
                {
                    expendboard(mine, show, i, j);
                    system("cls");//清除上一步
                    display(show, ROW, COL);
                    break;
                }
                else if (show[i][j] == '?' && mine[i][j] == '1')
                {
                    step++;
                    system("cls");
                    printf("很遗憾，你被炸死了\n");
                    printf("雷阵如下\n");
                    display(mine, ROW, COL);
                    printf("\n\t\t\t排雷步数:%d\n", step);//步数
                    break;
                }
                else if (show[i][j] != '?')
                    printf("坐标非法，请重输\n");
            }
            break;
        default:
            system("cls");
            display(show, ROW, COL);
            printf("输入非法，请重输\n");
            break;
        }
        if(mine[i][j]=='1'&&input==2)
        break;
        if (win == easy_mine||step==col*row-easy_mine)
        {
            system("cls");
            display(show, ROW, COL);//展示成果
            printf("排雷成功\n");
            printf("\n\t\t\t排雷步数:%d\n", step);//步数
            if ((record != 0 && record > step) || record == 0)
                record = step;
            system("pause");
            break;
        }
    }
    return 1;
}
void setmine(char board[ROWS][COLS], int row, int col)//埋雷
{
    int count = easy_mine;
    while(count>0)
    {
        int i = rand() % 9 + 1;
        int j = rand() % 9 + 1;
        if (board[i][j] == '0')
        {
            count--;
            board[i][j] = '1';
        }
            
      
    }
}
void initboard(char board[ROWS][COLS], int row, int col,char set)//初始化show棋盘和mine棋盘，set，传什么打印什么
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row+2; i++)
    {
        for (j = 0; j < col+2; j++)
        {
            board[i][j] = set;
        }
    }
}
void game()
{
        char board1[ROWS][COLS] = { 0 };
        char board2[ROWS][COLS] = { 0 };
        initboard(board1, ROW, COL, '0');//mine
        initboard(board2, ROW, COL, '?');//show
        display(board2, ROW, COL);   
        setmine(board1, ROW, COL);
        display(board1, ROW, COL);//用于debug
        while (1)
        {           
            int p = search_mine(board1, board2, ROW, COL);
            if (p == 1)
                break;
        }
    
}
void menu()
{
    printf("*******************************\n");
    printf("*****  1. play  0. exit   *****\n");
    printf("*******************************\n");
}
void text()
{
    int input = 0;
    do
    {
        printf("\n\t\t\t扫雷\n");    
        printf("\t\t\t\t\t最好记录:%d\n",record);
        menu();
        printf("请选择:>");
        scanf_s("%d", &input);
        system("cls");
        switch (input)
        {
        case 1:
            printf("游戏开始\n");
            game();
            Sleep(1000);
            system("cls");
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default :
            printf("输入非法，请重输！\n");
            break;
        }

    } while (input);
}
int main()
{
    srand((unsigned int)time(NULL));//设置由时间设置的随机数种子
    text();
}

总结

一万两千多字，码了四个多小时，求三连！

琦悠
关注
【C语言】扫雷(递归展开 + 标记功能)
StackFrame
07-29 2463
扫雷图文讲解实现 + 递归展开一篇 + 标记功能
室友说你怎么才学到数组，然后我用C语言做了个扫雷(递归展开+难度选择+优化打印)
AAxiao_bei的博客
11-21 8018
该文章优化了扫雷的递归展开、难度选择、棋盘打印，希望能够帮助到你
扫雷-c语言
04-04
一个用c语言图形库写的扫雷小游戏，当时做的课程设计，供学习交流使用
C语言扫雷
weixin_47103535的博客
05-10 785
文章目录一.扫雷规则二.设计思路三.代码详解四.完整代码 一.扫雷规则 扫雷的详细规则是随便点开一个方格，根据展开方格的数字去推断其相邻九宫格内未展开方格下面是否是地雷，最终任务就是点开所有没有地雷的方格，以找出所有的地雷。 二.设计思路 1.创建二维数组来表示地图 （1）第一个二维数组（showMap）表示未翻开状态（草地）和已翻开状态（数字） 用表示未翻开，字符0-8表示已经翻开的数字 （2）第二个二维数组(mineMap)表示每个格子是否是地雷 1 表示是地雷 0表示不是地雷 2.初始化地图 （1）将
c语言必做——扫雷游戏（含展开一片雷区）
最新发布
2301_80151382的博客
08-14 1210
在完成代码之前，我们要先了解一下我们想实现功能1.使用控制台来实现简单扫雷游戏2.游戏通过菜单实现游戏的开始与结束3.扫雷棋盘为9*94.默认随机步至10个雷（当然我们的代码也可以根据要求更改雷的个数5.排查雷如果是雷，提醒玩家被炸死，并提供雷的分布如果不是雷，计算周围一圈雷的数量，并告知玩家，直到所有雷都被排查出来，排雷成功。6.拓展：当不是雷时，能够展开一片提示：以下是本篇文章正文内容，下面案例可供参考。
c语言：扫雷
weixin_74150890的博客
01-30 2232
/方便动态管理行列数这里定义了一些常量，包括棋盘的行数和列数，以及雷的数量，方便动态设置。
C语言版扫雷
02-02
扫雷完整代码，玩家第一下不会被炸死，可以选择难度。
C语言扫雷（递归展开）（详细注释）（完整代码）
AAAAA_9的博客
08-02 8458
c语言扫雷游戏
c语言扫雷游戏(包含递归展开+标记功能) 源码可运行
07-28
扫雷是一款经典而富有挑战性的电脑游戏，它不仅考验玩家的智力和策略，还能够提升观察力和反应能力。本文将介绍如何使用**C语言**来编写一个简单的**扫雷游戏**，让我们一起来开发这个有趣的项目吧！
【C语言实现游戏】（二）扫雷（递归实现排雷）
wqnhbskl的博客
11-11 5129
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 扫雷，相信各位都不陌生，以前每台电脑上面都会自带这个小游戏。因此，它可以说是我们的童年回忆了，今天来用C语言实现简单的扫雷小游戏。 一、游戏思路 1、程序开始时出现菜单，让玩家选择开始游戏或者退出游戏。 2、玩家选择开始游戏后，出现雷盘，并且随机布置雷。 3、玩家进行排雷 二、游戏框架 1.
扫雷(C语言)
03-22
用C加上windows的easyx的图形库编写的一个扫雷游戏。
c语言 扫雷
07-12
C语言 扫雷 主要特色： 1.彩色界面 2.方向键控制方向，Enter键确认 3.支持多用户登录，存储每个用户的游戏记录，支持用户注册 4.可标记雷区
扫雷游戏(c语言)
一氧化二氢的执着
04-07 1305
扫雷游戏(c语言) #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <time.h> #define ROW 9 #define COL 9 #define MAX_MINE 10 void Init(char show_map[ROW][COL], char mine_map[ROW][COL]) ...
C语言——扫雷
Stewie Lee的博客
12-30 6668
扫雷是一款经典的小游戏，那如何使用C语言实现一个扫雷游戏呢？
[C语言] [游戏] 扫雷
热门推荐
博主学浅才疏，权当信笔涂鸦。嘿嘿，就算是记录我的学习历程吧，不过有时我会写得很细，但解题思路常常只有一种，别介意哈 ^ ^ （也许能学到一点点）。希望大家多来踩踩，顺便可以关注我，一起交流学习。
03-28 1万+
使用C语言写一个扫雷游戏 ！（练习二维数组）！(超详细的游戏设置思路和书写细节）！（看看7318字就很......）
扫雷递归展开的代码C语言
06-01
下面是一个简单的扫雷游戏递归展开的代码实现，使用C语言编写，希望能对您有帮助。 ```c void expand(char board[][COL], int row, int col) { if (board[row][col] == 'M') { board[row][col] = 'X'; } else { ...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值