【c语言】扫雷游戏(包含递归展开+标记功能) 源码可运行

已于 2023-07-28 20:58:53 修改
阅读量771 收藏 3
点赞数 3
分类专栏： C语言 实践项目 文章标签： c语言 游戏 开发语言
于 2023-07-28 20:45:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Colorful___/article/details/131975717
版权

目录

前言:

扫雷是一款经典而富有挑战性的电脑游戏，它不仅考验玩家的智力和策略，还能够提升观察力和反应能力。本文将介绍如何使用C语言来编写一个简单的扫雷游戏，让我们一起来开发这个有趣的项目吧！

效果展示

🔗：https://live.csdn.net/v/315352

【c语言】扫雷游戏(包含递归展开+标记功能) 源码可运行

1.游戏规则

扫雷游戏的基本规则很简单：在一个由方格组成的棋盘上，随机分布着一些地雷。玩家需要揭开方格，如果方格下面没有地雷，则显示该方格周围的地雷数目；如果周围的地雷数为零则展开棋盘周围的位置；如果方格下面有地雷，则游戏结束。玩家可以标记怀疑有地雷的方格，以帮助自己记忆。

2.开始编写

搭建起这个扫雷游戏的框架，我们首先创建一个 game() 函数，用于存放游戏的主要逻辑。在函数中，我们使用一个二维字符数组来表示棋盘，其中每个方格的状态都会被保存。另外，我们还需要一个字符数组来记录已经被翻开的方格。

//test.c
void game()
{
    char board[SIZE][SIZE] = { 0 };     // 棋盘数组，用于保存格子的状态
    char revealed[SIZE][SIZE] = { 0 };  // 标记已翻开的格子
    srand(time(NULL));                  // 初始化随机种子
    InitBord(board, revealed);          // 初始化棋盘和已翻开格子的状态
    system("cls");                      // 清屏
    printf("**************** 游戏难度 ****************\n");
    printf("***（1）5个雷  （2）10个雷  （3）15个雷 ***\n");
    printf("***（4）20个雷 （5）25个雷  （6）30个雷 ***\n");
    printf("***（7）35个雷 （8）40个雷  （9）45个雷 ...\n");
AGAIN:
    printf("---请选择游戏难度：>");
    int Level = 0;
    scanf("%d", &Level);
    MineNum = Level * 5;                 // 设置地雷数量
    if (MineNum > SIZE * SIZE)
    {
        printf("你的所选的难度太大，不适合该棋盘大小，请重新输入!\n");
        goto AGAIN;                      // 如果地雷数量超过棋盘格子总数，则要求重新选择难度
    }
    placeMine(board);                    // 在棋盘上布置地雷

    while (1)
    {
        system("cls");                   // 清屏
        printf("---------扫雷游戏----------\n");
        printf("*** 雷数:%2d   标记数:%2d ***\n", MineNum, MarkNum);
        printf("---------------------------\n");

        if (WinNum == MineNum && MarkNum == MineNum)
        {
            printf("!!!!!!!!!恭喜你赢啦!!!!!!!!!!\n");
            printMine(board);            // 打印所有地雷的位置
            MarkNum = 0;
			WinNum = 0;
            break;                       // 游戏胜利，退出循环
        }
        if (printBoard(board, revealed)) // 打印棋盘和已翻开的格子
        {
            printf("你踩雷了！\n");       // 打印棋盘和已翻开的格子
            printMine(board);
            MarkNum = 0;
			WinNum = 0;
            break;
        }
        printf("\n请输入要揭示的格子坐标（x ,y）;\n");
        printf("如果怀疑哪里是雷输入请在做标前加上负号（-x,-y）\n");
        printf("重复标记可以取消标记怀疑的雷！(雷被全部标记正确为胜)\n");
        printf("请输入：");
        int x, y;
        scanf("%d %d", &y, &x);
        if (x > 0 && y > 0 && x <= SIZE && y <= SIZE)   // 揭示格子
        {
            reveal(revealed, board, x - 1, y - 1);
        }
        else if (x < 0 && y < 0 && x >= -SIZE && y >= -SIZE)
        {
            MarkMine(board, revealed, -x - 1, -y - 1); // 标记雷
        }
        else
        {
            printf("输入有误请重新输入！\n");  // 输入不合法，要求重新输入
        }
    }
}

函数文件解析

（1）初始化函数（InitBoard）

代码如下：

//初始化棋盘
void InitBord(char board[SIZE][SIZE] ,char revealed[SIZE][SIZE])
{
	int i, j;
	for ( i = 0; i < SIZE; i++)
	{
		for ( j = 0; j < SIZE; j++)
		{
			board[i][j] = EMPTY;
			revealed[i][j] = EMPTY;
		}
	}
}

（2）在棋盘上布雷（placeMine）

代码如下：

//在棋盘上布置雷
void placeMine(char board[SIZE][SIZE])
{
    int count = 0;
    while (count < MineNum)
    {
        int x = rand() % SIZE; //在棋盘上随机布雷
        int y = rand() % SIZE;
        if (board[x][y] == EMPTY)
        {
            board[x][y] = MINE;
            count++;
        }
    }
}

（3）统计周围八个格子的地雷数（countMines）

这段代码通过遍历当前坐标 (x, y) 周围八个方向上的格子，使用偏移量计算出每个方向上的新坐标 (nx, ny)。然后通过检查新坐标的合法性和对应格子是否为地雷，来统计周围的地雷数量。最后将统计到的地雷数量返回。

int countMines(char board[SIZE][SIZE], int x, int y)
{
    int count = 0;
    int round[8][2] = { { 1, -1}, { 1, 0}, { 1, 1}
                       ,{ 0, -1},          { 0, 1} 
                       ,{-1, -1}, {-1, 0}, {-1, 1} };
    // 定义一个二维数组 round 来表示相对于当前坐标 (x, y) 周围八个格子的偏移量

     // 遍历每个方向上的格子
    for (int i = 0; i < 8; i++)
    {
        int dx = round[i][0]; // 根据 round 数组获取当前方向的 x 偏移量
        int dy = round[i][1]; // 根据 round 数组获取当前方向的 y 偏移量
        int nx = x + dx;  // 计算当前方向的 x 坐标
        int ny = y + dy;  // 计算当前方向的 y 坐标

        // 检查当前方向的坐标是否在合法范围内，并且当前方向的格子是否为地雷
        if (nx >= 0 && ny >= 0 && nx < SIZE && ny < SIZE && board[nx][ny] == MINE)
        {
            count++;// 如果是地雷，则地雷数量加一
        }
    }
    return count; // 返回统计到的地雷数量
}

（4）揭示格子（reveal）

这段代码首先检查当前待揭示的格子是否已经被揭示过或者标记过，如果是，则直接返回。否则，将当前格子标记为已揭示状态。然后判断当前格子周围是否有地雷，如果没有地雷，则递归地揭示周围八个方向上的格子。递归过程中，会不断检查并揭示每个格子周围的相邻格子，直到不能再继续揭示为止。这段代码实现了扫雷游戏中的连锁揭露效果。
在这里插入图片描述

//揭示格子
void reveal(char revealed[SIZE][SIZE], char board[SIZE][SIZE], int x, int y)
{
    //如果格子已经揭示过,或者标记过,直接返回
    if (revealed[x][y] == REVEAL || revealed[x][y] == MARK)
    {
        return;
    }
    //标记格子为以揭示
    revealed[x][y] = REVEAL;
    //如果格子周围没有地雷，则递归揭示周围的格子
    if (countMines(board, x, y) == 0)
    {
        int round[8][2] = { { 1, -1}, { 1, 0}, { 1, 1}
                           ,{ 0, -1},          { 0, 1}
                           ,{-1, -1}, {-1, 0}, {-1, 1} };
        // 定义一个二维数组 round 来表示相对于当前坐标 (x, y) 周围八个格子的偏移量

        // 遍历每个方向上的格子
        for (int i = 0; i < 8; i++)
        {
            int dx = round[i][0]; // 根据 round 数组获取当前方向的 x 偏移量
            int dy = round[i][1]; // 根据 round 数组获取当前方向的 y 偏移量
            int nx = x + dx; // 计算当前方向的 x 坐标
            int ny = y + dy; // 计算当前方向的 y 坐标
            // 检查当前方向的坐标是否在合法范围内
            if (nx >= 0 && ny >= 0 && nx < SIZE && ny < SIZE)
            {
                reveal(revealed, board, nx, ny);// 递归揭示当前方向上的格子
            }
        }
    }
}

（5）标记出你怀疑的雷（MarkMine）

}
这段代码首先检查当前待标记的格子的状态，如果格子已经被揭示过，则直接返回。如果格子已经被标记过，则取消标记，更新计数和状态。取消标记时，会减少标记计数 MarkNum，并且如果取消标记的格子是地雷，则减少胜利计数 WinNum，并将格子状态恢复为未揭示状态。如果格子既没有被揭示过也没有被标记过，则进行标记操作，并更新计数和状态。标记操作时，如果标记的格子是地雷，则增加胜利计数 WinNum，并增加标记计数 MarkNum，并将格子状态设置为标记状态。这段代码实现了扫雷游戏中对怀疑为地雷的格子进行标记和相应计数的功能。

// 标记出你怀疑的雷

```c
void MarkMine(char board[SIZE][SIZE], char revealed[SIZE][SIZE], int x, int y)
{
    // 如果格子已经揭示过，则直接返回
    if (revealed[x][y] == REVEAL)
    {
        return;
    }
    // 如果格子已经被标记过，则取消标记，更新计数和状态
    else if(revealed[x][y] == MARK)
    {
        MarkNum--; // 减少标记计数
        if (board[x][y] == MINE)
        {
            WinNum--;// 如果取消标记的格子是地雷，则减少胜利计数
        }
        revealed[x][y] = UNREVEAL; // 将格子状态恢复为未揭示
        return;
    }
    else
    {
        // 如果格子没有被揭示过且没有被标记过，则进行标记，并更新计数和状态
        if (board[x][y] == MINE)
        {
            WinNum++; // 如果标记的格子是地雷，则增加胜利计数
        }
        MarkNum++; // 增加标记计数
        revealed[x][y] = MARK;  // 增加标记计数
    }
}

（6）打印扫雷棋盘，并返回游戏是否结束的标志（printBoard）

这段代码使用嵌套循环遍历二维数组，打印出扫雷游戏棋盘的状态。首先打印列号，然后打印分隔线。接下来，通过循环遍历行和列，判断每个格子的状态并进行相应打印。如果格子已经被揭示过，根据其内容打印地雷符号或周围地雷数量。如果格子被标记过，则打印标记符号。如果格子既没有被揭示过也没有被标记过，则打印未揭示的格子符号。在打印过程中，如果发现地雷，则设置游戏结束标志为已结束。最后返回游戏是否结束的标志。这段代码实现了打印扫雷游戏棋盘的功能，并可以判断游戏是否结束。

int printBoard(char board[SIZE][SIZE], char revealed[SIZE][SIZE])
{
    int over = 0;// 游戏结束标志，默认为未结束
    printf("    ");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("%-2d", i); // 打印列号
    }
    printf("\n");
    printf("  +");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("--"); // 打印分隔线
    }
    printf("\n");
    for (int i = 0; i < SIZE; i++) 
    {
        printf("%2d", i + 1); // 打印行号
        printf("|");
        for (int j = 0; j < SIZE; j++) 
        {
            if (revealed[i][j] == REVEAL) // 如果格子已经揭示过
            {
                if (board[i][j] == MINE) 
                {
                    printf(" %c", MINE);  // 打印地雷符号
                    over = 1; // 设置游戏结束标志为已结束
                }
                else {
                    int count = countMines(board, i, j); // 计算周围地雷数量
                    printf("%2d", count);  // 打印周围地雷数量
                }
            }
            else if (revealed[i][j] == MARK) // 如果格子被标记过
            {
                printf(" %c", MARK); // 打印标记符号
            }
            else 
            {
                printf(" %c", UNREVEAL); // 打印未揭示的格子符号
            }
        }
        printf("\n");
    }
    return over; // 返回游戏是否结束的标志
}

（7） 打印所有格子的状态，包括地雷和周围地雷数量（ printMine）

这段代码与前面的打印棋盘函数类似，但不同之处在于它会打印出所有格子的状态，包括地雷和周围地雷数量。代码首先打印列号，然后打印分隔线。接下来，通过循环遍历行和列，判断每个格子的状态并进行相应打印。如果格子是地雷，则打印地雷符号。如果格子不是地雷，则计算其周围地雷数量，并打印该数字。最后输出整个棋盘的状态。
在这里插入图片描述

// 打印所有格子的状态，包括地雷和周围地雷数量
void printMine(char board[SIZE][SIZE])
{
    printf("    ");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("%-2d", i); // 打印列号
    }
    printf("\n");
    printf("  +");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("--"); // 打印分隔线
    }
    printf("\n");
    for (int i = 0; i < SIZE; i++)
    {
        printf("%2d", i + 1); // 打印行号
        printf("|");
        for (int j = 0; j < SIZE; j++)
        {
            if (board[i][j] == MINE) // 如果格子是地雷
            {
                printf(" %c", MINE); // 打印地雷符号
            }
            else {
                int count = countMines(board, i, j); // 计算周围地雷数量
                printf("%2d", count); // 打印周围地雷数量
            }
        }
        printf("\n");
    }
}

完整代码+详细注释

（1）头文件 game.h

//game.h
#pragma once

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

#define SIZE 9//棋盘的大小(可更改)

#define EMPTY '-'
#define MINE '*'
#define REVEAL '.'
#define UNREVEAL '+'
#define MARK '?'

//初始化棋盘
void InitBord(char board[SIZE][SIZE], char revealed[SIZE][SIZE]);
//在棋盘上布置雷
void placeMine(char board[SIZE][SIZE]);
//统计周围八个格子的地雷数
int countMines(char board[SIZE][SIZE], int x, int y);
//揭示格子
void reveal(char revealed[SIZE][SIZE], char board[SIZE][SIZE], int x, int y);
// 标记出你怀疑的雷
void MarkMine(char board[SIZE][SIZE], char revealed[SIZE][SIZE], int x, int y);
// 打印扫雷棋盘，并返回游戏是否结束的标志
int printBoard(char board[SIZE][SIZE], char revealed[SIZE][SIZE]);
//  打印所有格子的状态，包括地雷和周围地雷数量
void printMine(char board[SIZE][SIZE]);

(2) 源文件 game.c

// game.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

extern int MineNum;
extern int MarkNum;
extern int WinNum;


//初始化棋盘
void InitBord(char board[SIZE][SIZE] ,char revealed[SIZE][SIZE])
{
	int i, j;
	for ( i = 0; i < SIZE; i++)
	{
		for ( j = 0; j < SIZE; j++)
		{
			board[i][j] = EMPTY;
			revealed[i][j] = EMPTY;
		}
	}
}

//在棋盘上布置雷
void placeMine(char board[SIZE][SIZE])
{
    int count = 0;
    while (count < MineNum)
    {
        int x = rand() % SIZE; //在棋盘上随机布雷
        int y = rand() % SIZE;
        if (board[x][y] == EMPTY)
        {
            board[x][y] = MINE;
            count++;
        }
    }
}

//统计周围八个格子的地雷数
int countMines(char board[SIZE][SIZE], int x, int y)
{
    int count = 0;
    int round[8][2] = { { 1, -1}, { 1, 0}, { 1, 1}
                       ,{ 0, -1},          { 0, 1} 
                       ,{-1, -1}, {-1, 0}, {-1, 1} };
    // 定义一个二维数组 round 来表示相对于当前坐标 (x, y) 周围八个格子的偏移量

     // 遍历每个方向上的格子
    for (int i = 0; i < 8; i++)
    {
        int dx = round[i][0]; // 根据 round 数组获取当前方向的 x 偏移量
        int dy = round[i][1]; // 根据 round 数组获取当前方向的 y 偏移量
        int nx = x + dx;  // 计算当前方向的 x 坐标
        int ny = y + dy;  // 计算当前方向的 y 坐标

        // 检查当前方向的坐标是否在合法范围内，并且当前方向的格子是否为地雷
        if (nx >= 0 && ny >= 0 && nx < SIZE && ny < SIZE && board[nx][ny] == MINE)
        {
            count++;// 如果是地雷，则地雷数量加一
        }
    }
    return count; // 返回统计到的地雷数量
}

//揭示格子
void reveal(char revealed[SIZE][SIZE], char board[SIZE][SIZE], int x, int y)
{
    //如果格子已经揭示过,或者标记过,直接返回
    if (revealed[x][y] == REVEAL || revealed[x][y] == MARK)
    {
        return;
    }
    //标记格子为以揭示
    revealed[x][y] = REVEAL;
    //如果格子周围没有地雷，则递归揭示周围的格子
    if (countMines(board, x, y) == 0)
    {
        int round[8][2] = { { 1, -1}, { 1, 0}, { 1, 1}
                           ,{ 0, -1},          { 0, 1}
                           ,{-1, -1}, {-1, 0}, {-1, 1} };
        // 定义一个二维数组 round 来表示相对于当前坐标 (x, y) 周围八个格子的偏移量

        // 遍历每个方向上的格子
        for (int i = 0; i < 8; i++)
        {
            int dx = round[i][0]; // 根据 round 数组获取当前方向的 x 偏移量
            int dy = round[i][1]; // 根据 round 数组获取当前方向的 y 偏移量
            int nx = x + dx; // 计算当前方向的 x 坐标
            int ny = y + dy; // 计算当前方向的 y 坐标
            // 检查当前方向的坐标是否在合法范围内
            if (nx >= 0 && ny >= 0 && nx < SIZE && ny < SIZE)
            {
                reveal(revealed, board, nx, ny);// 递归揭示当前方向上的格子
            }
        }
    }
}

// 标记出你怀疑的雷
void MarkMine(char board[SIZE][SIZE], char revealed[SIZE][SIZE], int x, int y)
{
    // 如果格子已经揭示过，则直接返回
    if (revealed[x][y] == REVEAL)
    {
        return;
    }
    // 如果格子已经被标记过，则取消标记，更新计数和状态
    else if(revealed[x][y] == MARK)
    {
        MarkNum--; // 减少标记计数
        if (board[x][y] == MINE)
        {
            WinNum--;// 如果取消标记的格子是地雷，则减少胜利计数
        }
        revealed[x][y] = UNREVEAL; // 将格子状态恢复为未揭示
        return;
    }
    else
    {
        // 如果格子没有被揭示过且没有被标记过，则进行标记，并更新计数和状态
        if (board[x][y] == MINE)
        {
            WinNum++; // 如果标记的格子是地雷，则增加胜利计数
        }
        MarkNum++; // 增加标记计数
        revealed[x][y] = MARK;  // 增加标记计数
    }
}

// 打印扫雷棋盘，并返回游戏是否结束的标志
int printBoard(char board[SIZE][SIZE], char revealed[SIZE][SIZE])
{
    int over = 0;// 游戏结束标志，默认为未结束
    printf("    ");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("%-2d", i); // 打印列号
    }
    printf("\n");
    printf("  +");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("--"); // 打印分隔线
    }
    printf("\n");
    for (int i = 0; i < SIZE; i++) 
    {
        printf("%2d", i + 1); // 打印行号
        printf("|");
        for (int j = 0; j < SIZE; j++) 
        {
            if (revealed[i][j] == REVEAL) // 如果格子已经揭示过
            {
                if (board[i][j] == MINE) 
                {
                    printf(" %c", MINE);  // 打印地雷符号
                    over = 1; // 设置游戏结束标志为已结束
                }
                else {
                    int count = countMines(board, i, j); // 计算周围地雷数量
                    printf("%2d", count);  // 打印周围地雷数量
                }
            }
            else if (revealed[i][j] == MARK) // 如果格子被标记过
            {
                printf(" %c", MARK); // 打印标记符号
            }
            else 
            {
                printf(" %c", UNREVEAL); // 打印未揭示的格子符号
            }
        }
        printf("\n");
    }
    return over; // 返回游戏是否结束的标志
}

// 打印所有格子的状态，包括地雷和周围地雷数量
void printMine(char board[SIZE][SIZE])
{
    printf("    ");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("%-2d", i); // 打印列号
    }
    printf("\n");
    printf("  +");
    for (int i = 1; i <= SIZE; i++)
    {
        printf("--"); // 打印分隔线
    }
    printf("\n");
    for (int i = 0; i < SIZE; i++)
    {
        printf("%2d", i + 1); // 打印行号
        printf("|");
        for (int j = 0; j < SIZE; j++)
        {
            if (board[i][j] == MINE) // 如果格子是地雷
            {
                printf(" %c", MINE); // 打印地雷符号
            }
            else {
                int count = countMines(board, i, j); // 计算周围地雷数量
                printf("%2d", count); // 打印周围地雷数量
            }
        }
        printf("\n");
    }
}

(3)源文件 test.c

//test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

int MineNum = 0;
int MarkNum = 0;
int WinNum = 0;

void menu()
{
    printf("\n---------扫雷游戏----------\n");
    printf("********* 1.play *********\n");
    printf("********* 0.play *********\n");
    printf("---------------------------\n");

}

void game()
{
    char board[SIZE][SIZE] = { 0 };     // 棋盘数组，用于保存格子的状态
    char revealed[SIZE][SIZE] = { 0 };  // 标记已翻开的格子
    srand(time(NULL));                  // 初始化随机种子
    InitBord(board, revealed);          // 初始化棋盘和已翻开格子的状态
    system("cls");                      // 清屏
    printf("**************** 游戏难度 ****************\n");
    printf("***（1）5个雷  （2）10个雷  （3）15个雷 ***\n");
    printf("***（4）20个雷 （5）25个雷  （6）30个雷 ***\n");
    printf("***（7）35个雷 （8）40个雷  （9）45个雷 ...\n");
AGAIN:
    printf("---请选择游戏难度：>");
    int Level = 0;
    scanf("%d", &Level);
    MineNum = Level * 5;                 // 设置地雷数量
    if (MineNum > SIZE * SIZE)
    {
        printf("你的所选的难度太大，不适合该棋盘大小，请重新输入!\n");
        goto AGAIN;                      // 如果地雷数量超过棋盘格子总数，则要求重新选择难度
    }
    placeMine(board);                    // 在棋盘上布置地雷

    while (1)
    {
        system("cls");                   // 清屏
        printf("---------扫雷游戏----------\n");
        printf("*** 雷数:%2d   标记数:%2d ***\n", MineNum, MarkNum);
        printf("---------------------------\n");

        if (WinNum == MineNum && MarkNum == MineNum)
        {
            printf("!!!!!!!!!恭喜你赢啦!!!!!!!!!!\n");
            printMine(board);            // 打印所有地雷的位置
            MarkNum = 0;
            WinNum = 0;
            break;                       // 游戏胜利，退出循环
        }
        if (printBoard(board, revealed)) // 打印棋盘和已翻开的格子
        {
            printf("你踩雷了！\n");       // 打印棋盘和已翻开的格子
            printMine(board);
            MarkNum = 0;
            WinNum = 0;
            break;
        }
        printf("\n请输入要揭示的格子坐标（x ,y）;\n");
        printf("如果怀疑哪里是雷输入请在做标前加上负号（-x,-y）\n");
        printf("重复标记可以取消标记怀疑的雷！(雷被全部标记正确为胜)\n");
        printf("请输入：");
        int x, y;
        scanf("%d %d", &y, &x);
        if (x > 0 && y > 0 && x <= SIZE && y <= SIZE)   // 揭示格子
        {
            reveal(revealed, board, x - 1, y - 1);
        }
        else if (x < 0 && y < 0 && x >= -SIZE && y >= -SIZE)
        {
            MarkMine(board, revealed, -x - 1, -y - 1); // 标记雷
        }
        else
        {
            printf("输入有误请重新输入！\n");  // 输入不合法，要求重新输入
        }
    }
}

int main()
{
    while (1)
    {
        menu();
        printf("请输入：");
        int input;
        scanf("%d", &input);
        if (input)
        {
            game();
        }
        else
        {
            printf("游戏结束！\n");
            break;
        }
    }
	return 0;
}
Q_hd
关注
专栏目录
【C语言】扫雷(递归展开 + 标记功能)
StackFrame
07-29 2465
扫雷图文讲解实现 + 递归展开一篇 + 标记功能
【C语言基础学习---扫雷游戏】（包含普通版+递归炼狱版）
大家好我叫张同学
05-05 7306
游戏背景介绍 扫雷游戏是一款大众类的益智小游戏，于1992年发行。游戏目标是在最短的时间内根据点击格子出现的数字找出所有非雷格子，同时避免踩雷，踩到一个雷即全盘皆输。 扫雷在科技历史上也扮演了相似的角色。这个基于数字的逻辑谜题最早来自20世纪六七十年代，当时Jerimac Ratliff推出的名为“Cube”的游戏已经非常受人欢迎。几十年后的1992年，扫雷游戏被加入了Windows3.1，这并不是为了展示Windows是游戏操作系统专家，而是为了训练用户的鼠标左右键操作能力，让这些动作变得非常自然，并培养
【C语言游戏】扫雷游戏（含递归展开，难度选择，雷位标记等功能）
52Herzt的博客
09-08 3298
游戏功能： 1. 难度选择 2. 为棋盘动态分配内存 3. 自动调整窗口大小 4. 标记雷位 5. 递归展开 6. 优化游戏界面，提高游戏体验
C语言实现扫雷（含展开，附源码）
热门推荐
m0_62171658的博客
11-13 1万+
我相信在做的各位都是玩过扫雷的，游戏玩法就不赘述了。 直接进入主题:先思考后敲代码！！ 首先，我将扫雷分为两个棋盘，一个放雷，另一个为玩家猜测盘。 这就有同学问了，设置一个棋盘不就完了，这样不就搞复杂了吗？ 先简短的回答这位同学的问题: 因为我的考虑是这样的，我用‘1’代表有雷，‘0’代表没有雷，如果放在一个盘中，出现多个1的时候，无法确定这是雷还是代表周围8个格子中有一个雷。 进一步解释 图片参考： 当雷是1，还有记录数字也为1时，以下黄色标记位置为例： ...
C语言实现扫雷（含标记、展开）（含源码）
flashier的博客
10-03 300
用C语言实现扫雷，包括标记和展开的功能。
C语言--扫雷游戏（第一个不会炸+展开+标记+完整源码）
qq_51504544的博客
12-08 895
这是一个用C语言写出来的扫雷小游戏，重难点在于递归与数组的运用。提示：以下是本篇文章正文内容，下面案例可供参考这个游戏不难，此外还有很大的改进空间，此外，要是想屏幕干净些，也可以在适当位置加上system(“cls”)语句，用来清空屏幕。
【C语言】手把手带你实现控制台小游戏扫雷(附源码)
hdxbufcbjuhg的博客
08-26 1443
如果存放在布置雷的数组中，这样雷的信息和雷的个数信息就可能或产⽣混淆和打印上的困难，比如周围有1个雷，就要显示1，但是1原本是表示雷的，就导致了混淆。排查雷的重点就是，我们要看玩家输入的坐标位置是不是雷，也就是是不是字符1，如果是字符1，说明踩到雷了，游戏失败，如果是字符0，也就是不是雷，那么该处就显示为周围8个坐标的雷的个数，所以它既要涉及到show数组，又要涉及到hide数组，hide数组用来查看玩家输入的坐标是否是雷，show数组用于该坐标不是雷的时候，在该坐标处显示周围有几个雷。
扫雷C语言（可展开一片空白）
2301_79551553的博客
02-02 1007
1.玩家可以通过选择1进入游戏，0退出游戏。2.选错的话提醒玩家，重新选择。3.告诉玩家游戏规则1.包含需要的头文件2.包含需要的宏定义3.包含需要的函数接口恭喜你，看完了这~么长的文章，熟能生巧，看完记得练习哦，ps：本章部分图片来源《比特就业课课件》。
C语言实现扫雷游戏（含展开、含标记）---完整源码与分析！！！
m0_56399733的博客
09-15 236
本次我们利用C语言实现了扫雷游戏，包含标记功能，0位展开功能，对于各个模块进行了细致的分析与分模块代码的讲解，最后再文章附有完整的源码，欢迎大家学习。
c语言扫雷游戏(包含递归展开+标记功能) 源码可运行
07-28
扫雷是一款经典而富有挑战性的电脑游戏，它不仅考验玩家的智力和策略，还能够提升观察力和反应能力。本文将介绍如何使用**C语言**来编写一个简单的**扫雷游戏**，让我们一起来开发这个有趣的项目吧！
c语言小游戏源码
09-08
本文将深入探讨基于C语言实现的小游戏源码，包括贪吃蛇、五子棋、扫雷和推箱子等经典游戏的开发知识。 首先，我们来看“贪吃蛇”游戏。贪吃蛇是一款简单但极具挑战性的游戏，玩家需要控制一条不断增长的蛇来吃食物...
C语言实现【扫雷游戏】完整版（实现源码）
m0_57018588的博客
06-17 1007
C语言实现扫雷游戏（完整版）实现源码，具体步骤分析
理解C语言之深入理解指针
do_yo的博客
11-11 1014
⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。
Unity3D 帧同步定点数物理引擎解决方案详解
最新发布
Thomas_YXQ的博客
11-11 558
在Unity3D开发中，帧同步技术对于实现多人在线游戏至关重要，它能确保所有玩家在同一时间看到相同的游戏状态。帧同步定点数物理引擎解决方案是这一技术的重要组成部分，它通过结合定点数和物理引擎计算，来确保不同客户端之间游戏状态的精确同步。对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！
Unity Windows 2023 Release-Notes
qq_26318597的博客
11-07 865
Unity Windows 2023 Release-Notes
Unity常见问题合集（一）
我与岁月的森林的博客
11-10 161
Unity常见问题合集（一）
游戏之地图找怪进行PK升级。C++
laocooon的博客
11-09 232
游戏之地图找怪进行PK升级。
Mesh网格
2301_76618920的博客
11-10 305
定义：Mesh 是一个包含等数据的对象。它定义了3D模型的几何形状。功能：顶点（Vertices）：构成3D模型的点。三角形（Triangles）：由三个顶点组成的面，定义了模型的表面。法线（Normals）：定义了表面的朝向，对于光照计算非常重要。UV坐标（UV Coordinates）：用于将纹理映射到3D模型上。颜色（Colors）：可以为每个顶点或每个子网格指定颜色。骨骼权重（Bone Weights）：用于骨骼动画，定义了顶点如何受到骨骼的影响。
运用Agent搭建“狼人杀”游戏服务器端！
python12345_的博客
11-08 846
总的来说，Agent是当下比较火热的技术。在本文中，我们主要聚焦于如何使用大模型来驱动游戏Agent，并结合提示词工程的一些技巧以及游戏的特性进行架构设计。可以看到，LLM的能力不断增长，超长上下文、响应速度、拒答率等因素不再成为约束，其在”游戏智能 NPC”的探索和应用会越来越多。借助其优秀的推理能力，游戏的玩法和设计也会变得更加丰富多彩。然而，目前我们还看到一些其他的限制：角色的表现力、游戏的沉浸感这块目前属于大模型能力的短板。
C语言实战：贪吃蛇与扫雷游戏源码学习指南
- 用户将学习如何在C语言中实现复杂的逻辑和算法，如二维数组的使用、递归算法等，这些都是扫雷游戏所必需的。 - 项目还将涉及到如何在MFC环境下与用户界面交互，实现游戏状态的更新，以及响应用户的操作。 4. VC...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Q_hd

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值