扫 雷 小 游 戏

最新推荐文章于 2017-03-11 10:16:04 发布
最新推荐文章于 2017-03-11 10:16:04 发布
阅读量355 收藏 2
点赞数
分类专栏： C语言 文章标签： 函数 二维数组 游戏 扫雷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skyroben/article/details/53326218
版权 
  扫雷游戏的实现的关键是要创建好两个同样大小二维数组，一个用来随机生成雷，一个用来更新游戏界面.在创建游戏过程中应注意输入坐标和数组下标之间的关系。为了增加游戏的乐趣，本游戏将使玩家第一步不会踩到雷，并且可以显示周围坐标雷的个数，还可以让玩家是否标记出雷的位置，降低了游戏的难度.

将扫雷的代码分为三部分：头文件存放game.h （主要用来声明各种函数，以便调用） ；源文件分别存放game.c（主要用来存放各种函数实现的代码）以及test.c（主要用来实现整个游戏代码框架）。

game.h代码：

#ifndef __GAME_H__
#define __GAME_H__
#define ROWS 14    //宏定义行
#define COLS 14    //列
#define sweep 20
void Init_Interface(int board1[ROWS][COLS], int board2[ROWS][COLS], int rows, int cols);  //初始化扫雷棋盘
void  display_board(int board2[ROWS][COLS], int rows, int cols); //打印扫雷棋盘
int   play_move(int board1[ROWS][COLS], int board2[ROWS][COLS], int rows, int cols); //玩家输入坐标并判断是否是雷
void  pai_lei(int board1[ROWS][COLS], int  board2[ROWS][COLS], int rows, int cols);  //玩家是否排雷
int   win(int board2[ROWS][COLS], int rows, int cols);    //判断玩家输赢
int  error_sweep(int board2[ROWS][COLS], int rows, int cols);    //判断玩家扫雷错误数
int  check_sweep(int board2[ROWS][COLS], int rows, int cols);   //判断雷阵是否填满
void  sweep_board(int board1[ROWS][COLS], int rows, int cols); //打印布雷棋盘
#endif //__GAME_H__

game.c代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "game.h"
#include <string.h>
#include <stdlib.h>
#include <time.h>

void Init_Interface(int board1[ROWS][COLS], int board2[ROWS][COLS], int rows, int cols)  //初始化扫雷棋盘,以及布雷其中0代表无雷,1代表有雷
{
    int i = 0;
    int j = 0;
    int x = 0;
    int y = 0;
    int count = 0;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board1[i][j] = 0;
        }
    }
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < cols; j++)
        {
            board2[i][j] = '*';
        }
    }
    srand((unsigned int)time(NULL));
    while (count != sweep)   //产生20个雷
    {
        int x = rand() % 10 + 2;
        int y = rand() % 10 + 2;
        if (board1[x][y] == 0)
        {
            count++;
            board1[x][y] = 1;
        }
    }
    //初始化雷盘
    printf("     1   2   3   4   5   6   7   8   9  10  \n");
    printf("   _________________________________________\n");
    for (i = 2; i < rows - 2; i++)
    {
        if (i > 10)
        {
            printf("%d |   |", i - 1);
        }
        else if (i <= 10)
        {
            printf("%d  |   |", i - 1);
        }
        for (j = 3; j < cols - 2; j++)
        {
            printf("   |");
        }
        printf("\n");
        printf("   | %c |", board2[i][2]);
        for (j = 3; j < cols - 2; j++)
        {
            printf(" %c |", board2[i][j]);
        }
        printf("\n");
        printf("   |___|");
        for (j = 3; j < cols - 2; j++)
        {
            printf("___|");
        }
        printf("\n");
    }


}

void  display_board(int board2[ROWS][COLS], int rows, int cols) //打印扫雷棋盘
{
    int i = 0;
    int j = 0;
    printf("     1   2   3   4   5   6   7   8   9  10  \n");
    printf("   _________________________________________\n");
    for (i = 2; i < rows - 2; i++)
    {
        if (i > 10)
        {
            printf("%d |   |", i - 1);
        }
        else if (i <= 10)
        {
            printf("%d  |   |", i - 1);
        }
        for (j = 3; j < cols - 2; j++)
        {
            printf("   |");
        }
        printf("\n");
        if ((board2[i][2] == '*') || (board2[i][2] == 'Y') || (board2[i][2] == 'N'))
        {
            printf("   | %c |", board2[i][2]);
        }
        if ((board2[i][2] != '*') && (board2[i][2] != 'Y') && (board2[i][2] != 'N'))
        {
            printf("   | %d |", board2[i][2]);
        }
        for (j = 3; j < cols - 2; j++)
        {
            if ((board2[i][j] == '*') || (board2[i][j] == 'Y') || (board2[i][j] == 'N'))
                printf(" %c |", board2[i][j]);
            if (((board2[i][j] != '*') && (board2[i][j] != 'Y')) && (board2[i][j] != 'N'))
                printf(" %d |", board2[i][j]);
        }
        printf("\n");
        printf("   |___|");
        for (j = 3; j < cols - 2; j++)
        {
            printf("___|");
        }
        printf("\n");
    }
}




int   play_move(int board1[ROWS][COLS], int board2[ROWS][COLS], int rows, int cols)    //玩家输入坐标
{
    int x = 0;
    int y = 0;
    int i = 0;
    int j = 0;
    int static  first_move = 0;    //定义一个静态变量,判断first_move是不是第一步棋子
    int count = 0;
    printf("请输入坐标：");
    while (1)
    {
        scanf("%d%d", &x, &y);
        x++;
        y++;
        if ((x >= 2) && (x <= rows - 3) && (y >= 2) && (y <= cols - 3))
        {
            first_move++;
            if (1 == first_move)
            {
                if (board1[x][y] == 1)   //第一步是雷,并转移
                {
                    for (i = 2; i < rows - 2; i++)
                    {
                        for (j = 2; j < cols - 2; j++)
                        {
                            if (board1[i][j] == 0)
                            {
                                board1[i][j] = 1;
                                board1[x][y] = 0;
                                break;
                            }
                        }
                        break;
                    }
                }
                //统计第一步周围雷的情况
                count = board1[x - 1][y] + board1[x - 1][y + 1] + board1[x - 1][y - 1]
                    + board1[x + 1][y] + board1[x + 1][y + 1] + board1[x + 1][y - 1]
                    + board1[x][y + 1] + board1[x][y - 1];
                board2[x][y] = count;
                if (board1[x][y - 1] != 1)
                {
                    count = 0;
                    count = board1[x - 1][y - 1] + board1[x - 1][y] + board1[x - 1][y - 2]
                        + board1[x + 1][y - 1] + board1[x + 1][y] + board1[x + 1][y - 2]
                        + board1[x][y] + board1[x][y - 2];
                    board2[x][y - 1] = count;
                }
                if (board1[x][y + 1] != 1)
                {
                    count = 0;
                    count = board1[x - 1][y + 1] + board1[x - 1][y + 2] + board1[x - 1][y]
                        + board1[x + 1][y + 1] + board1[x + 1][y + 2] + board1[x + 1][y]
                        + board1[x][y + 2] + board1[x][y];
                    board2[x][y + 1] = count;
                }
                if (board1[x + 1][y] != 1)
                {
                    count = 0;
                    count = board1[x][y] + board1[x][y + 1] + board1[x][y - 1]
                        + board1[x + 2][y] + board1[x + 2][y + 1] + board1[x + 2][y - 1]
                        + board1[x + 1][y + 1] + board1[x + 1][y - 1];
                    board2[x + 1][y] = count;
                }
                if (board1[x - 1][y] != 1)
                {
                    count = 0;
                    count = board1[x - 2][y] + board1[x - 2][y + 1] + board1[x - 2][y - 1]
                        + board1[x][y] + board1[x][y + 1] + board1[x][y - 1]
                        + board1[x - 1][y + 1] + board1[x - 1][y - 1];
                    board2[x - 1][y] = count;
                }
                if (board1[x + 1][y - 1] != 1)
                {
                    count = 0;
                    count = board1[x][y - 1] + board1[x][y] + board1[x][y - 2]
                        + board1[x + 2][y - 1] + board1[x + 2][y] + board1[x + 2][y - 2]
                        + board1[x + 1][y] + board1[x + 1][y - 2];
                    board2[x + 1][y - 1] = count;
                }
                if (board1[x - 1][y - 1] != 1)
                {
                    count = 0;
                    count = board1[x - 2][y - 1] + board1[x - 2][y] + board1[x - 2][y - 2]
                        + board1[x][y - 1] + board1[x][y] + board1[x][y - 2]
                        + board1[x - 1][y] + board1[x - 1][y - 2];
                    board2[x - 1][y - 1] = count;
                }
                if (board1[x - 1][y + 1] != 1)
                {
                    count = 0;
                    count = board1[x - 2][y + 1] + board1[x - 2][y + 2] + board1[x - 2][y]
                        + board1[x][y + 1] + board1[x][y + 2] + board1[x - 2][y]
                        + board1[x - 1][y + 2] + board1[x - 1][y];
                    board2[x - 1][y + 1] = count;
                }
                if (board1[x + 1][y + 1] != 1)
                {
                    count = 0;
                    count = board1[x][y + 1] + board1[x][y + 2] + board1[x][y]
                        + board1[x + 2][y + 1] + board1[x + 2][y + 2] + board1[x + 2][y]
                        + board1[x + 1][y + 2] + board1[x + 1][y];
                    board2[x + 1][y + 1] = count;
                }
                return -2;
            }
            if (board2[x][y] == '*')
            {
                board2[x][y] = 1;
                if (board1[x][y] == board2[x][y])
                {
                    return -1;     //证明踩到雷了
                }
                else
                {
                    int count = 0;
                    count = board1[x - 1][y] + board1[x - 1][y + 1] + board1[x - 1][y - 1]
                        + board1[x + 1][y] + board1[x + 1][y + 1] + board1[x + 1][y - 1]
                        + board1[x][y + 1] + board1[x][y - 1];
                    board2[x][y] = count;
                    return count;
                }
            }
        }
        printf("\n输入错误,请重新输入坐标：");
    }
}

void  sweep_board(int board1[ROWS][COLS], int rows, int cols)   //打印布好雷的图
{
    int i = 0;
    int j = 0;
    printf("     1   2   3   4   5   6   7   8   9  10  \n");
    printf("   _________________________________________\n");
    for (i = 2; i < rows - 2; i++)
    {
        if (i > 10)
        {
            printf("%d |   |", i - 1);
        }
        else if (i <= 10)
        {
            printf("%d  |   |", i - 1);
        }
        for (j = 3; j < cols - 2; j++)
        {
            printf("   |");
        }
        printf("\n");
        printf("   | %d |", board1[i][2]);
        for (j = 3; j < cols - 2; j++)
        {
            printf(" %d |", board1[i][j]);
        }
        printf("\n");
        printf("   |___|");
        for (j = 3; j < cols - 2; j++)
        {
            printf("___|");
        }
        printf("\n");
    }
}


int  win(int board2[ROWS][COLS], int rows, int cols)  //判断玩家是否扫雷成功
{
    int i = 0;
    int j = 0;
    int count = 0;
    for (i = 2; i <= rows - 3; i++)
    {
        for (j = 2; j <= cols - 3; j++)
        {
            if (board2[i][j] == 'Y')
                count++;
        }
    }
    return count;
}



void  pai_lei(int board1[ROWS][COLS], int  board2[ROWS][COLS], int rows, int cols)    //玩家是否排雷
{
    int x = 0;
    int y = 0;
    printf("请输入要排雷的坐标：");
    while (1)
    {
        scanf("%d%d", &x, &y);
        x++;
        y++;
        if ((x >= 2) && (x <= rows - 3) && (y >= 2) && (y <= cols - 3))
        {
            if ((board1[x][y] == 1) && (board2[x][y] == '*'))
            {
                board2[x][y] = 'Y';
                break;
            }
            else if ((board1[x][y] == 0) && (board2[x][y] == '*'))
            {
                board2[x][y] = 'N';
                break;
            }
        }
        printf("\n输入错误,请重新输入坐标：");
    }
}

int  error_sweep(int board2[ROWS][COLS], int rows, int cols)
{
    int i = 0;
    int j = 0;
    int count = 0;
    for (i = 2; i <= rows - 3; i++)
    {
        for (j = 2; j <= cols - 3; j++)
        {
            if (board2[i][j] == 'N')
                count++;
        }
    }
    return count;
}


int  check_sweep(int board2[ROWS][COLS], int rows, int cols)
{
    int i = 0;
    int j = 0;
    for (i = 2; i <= rows - 3; i++)
    {
        for (j = 2; j <= cols - 3; j++)
        {
            if (board2[i][j] == '*')
                return 0;
        }
    }
    return 1;
}

test.c代码：

#include <stdio.h>
#include "game.h"
enum 
{
    EXIT, /*枚举元素本身由系统定义了一个表示序号的数值，从0开始顺序定义为0，1，2…。EXIT的值为0,PLAY的值为1*/
    PLAY
};
void menu()
{
    printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
    printf("☆☆☆☆☆    1.PLAY      ☆☆☆☆☆\n");
    printf("☆☆☆☆☆    0.EXIT      ☆☆☆☆☆\n");
    printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
}
void game()
{
    int ret = 0;
    int k = 0;   //用来判断玩家是否输入雷的坐标
    int board1[ROWS][COLS] = { 0 };   //第一张棋盘作为埋好雷的棋盘
    int board2[ROWS][COLS] = { 0 };   //第二张棋盘作为统计雷的棋盘
    Init_Interface(board1, board2, ROWS, COLS);  //初始化扫雷棋盘
    while (1)
    {
        int ret1 = play_move(board1, board2, ROWS, COLS);   //玩家输入坐标
        {
            if (ret1 == -1)
            {
                printf("\n踩雷成功,光荣牺牲.\n");
                sweep_board(board1, ROWS, COLS); //打印布雷棋盘
                break;
            }
            display_board(board2, ROWS, COLS);
            //排雷过程
            k = 0;
            printf("☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
            printf("☆☆☆ 输入0: 排雷  ☆☆☆\n");
            printf("☆☆☆ 输入1: 不排雷☆☆☆\n");
            printf("☆☆☆☆☆☆☆☆☆☆☆☆☆\n");
            printf("请选择：\n");
            while (k == 0)
            {
                scanf("%d", &k);
                switch (k)      //判断是否需要排雷
                {
                case 0:
                    pai_lei(board1, board2, ROWS, COLS);
                    break;
                case 1:
                    break;
                default:
                    k = 0;
                    printf("输入错误\n");
                    break;
                }
                if (k == 0)
                {
                    printf("请选择是否继续排雷：");
                }
            }
            //结束
            int ret2 = win(board2, ROWS, COLS);
            {
                if (ret2 == sweep)  //返回的值为雷的个数则成功
                {
                    printf("恭喜扫雷成功.\n");
                    sweep_board(board1, ROWS, COLS); //打印布雷棋盘
                    break;
                }
                else
                {
                    printf("您已经成功的扫出%d颗雷\n", ret2);
                }
            }
            int ret3 = error_sweep(board2, ROWS, COLS);    //判断扫错雷的个数
            {
                printf("您已经错误的扫出%d颗雷\n", ret3);
            }
            int ret4 = check_sweep(board2, ROWS, COLS);   //检查雷阵是否填满
            if (ret4 == 1)
            {
                printf("没能成功找出所有的雷,很遗憾");
                break;
            }
        }
        display_board(board2, ROWS, COLS);
    }

}
int main()
{
    int  input = 0;
    do
    {
        menu();
        printf("请输入你的选择：");
        scanf("%d", &input);  //
        switch (input)
        {
        case PLAY:
            game();
            break;
        case  EXIT:
            break;
        default:
            printf("您的输入有误,请重新输入.\n");
            break;
        }
    } while (input);
    return 0;
}

部分游戏运行界面：
这里写图片描述

sky_Mata
关注
专栏目录
Java课程设计---扫 雷 小 游 戏
01-06
【Java课程设计---扫雷小游戏】是一门针对Java编程初学者的实践项目，旨在通过实现经典的游戏“扫雷”来提升学生对Java编程语言的理解和应用能力。扫雷游戏是Windows操作系统自带的一个小型益智游戏，深受用户喜爱，...
扫地雷javaSE控制台
08-09
最近用使用java基础+控制台做一个扫雷的小游戏，利用输入坐标模拟扫雷游戏。
扫地雷c++ 示例代码
01-24
扫地雷c++ 示例代码 供各位同学参考 O(∩_∩)O哈哈~ 调试平台VS2012
扫码点餐java后台+小程序源码
03-28
扫码点餐java后台+小程序源码
微信小程序-扫码购物源码
06-12
在这个“微信小程序-扫码购物源码”项目中，我们可以深入探讨微信小程序的开发技术，以及如何实现扫码购物的功能。 首先，我们需要了解微信小程序的基础架构。它采用的是基于JavaScript的WXML（Weixin Markup ...
多层循环的跳出（return goto break continue 的用法与区别）
热门推荐
sky_Mata的博客
11-05 2万+
多层循环的跳出 return 语句 goto 语句 break 语句 continue 语句的用法与区别。
编程找出1000以内的所有完数
sky_Mata的博客
11-12 1万+
找出1000之内的完数，并输出它们
sizeof计算对象所占内存的大小详解
sky_Mata的博客
11-17 1万+
sizeof 怎样计算整型数组、字符数组、二维数组、类（是否为菱形继承、是否为虚继承等各种情况）的大小，非常详细的解释！！！
输入一个整型变量，求它二进制位中含有1的个数
sky_Mata的博客
11-05 2089
C语言基础编程 &按位与操作符的应用 求一个整型变量的二进制表示中1的个数三种方法
malloc、calloc、realloc的区别
sky_Mata的博客
03-11 1043
malloc realloc calloc的区别和联系
编译与链接过程详解
sky_Mata的博客
12-10 938
常见预定义符号的含义 ；宏和函数的区别；.编译链接的整个过程和详细的每个过程
写一个宏可以将一个数字的奇数位和偶数位交换。
sky_Mata的博客
12-04 833
通过一个简洁的宏函数将一个数二进制序列奇数位和偶数位互换。
冒泡法与选择法对数据排序
sky_Mata的博客
11-17 544
选择法 冒泡法 数据排序
编写一个函数实现n^k，使用递归实现
sky_Mata的博客
01-03 523
编写一个函数实现n^k，使用递归实现
猜数字游戏
sky_Mata的博客
11-10 491
猜数字游戏 用C语言编写小游戏
内存对齐
sky_Mata的博客
03-10 442
结构体、位域、联合体对齐，求结构体、位域、联合体的大小，以及为什么要内存对齐。
用C语言实现三子棋
sky_Mata的博客
11-22 398
用C语言实现三子棋，并可以选择难度，最难玩不过电脑哦，只能打平局！！！
获取一个数二进制序列中所有的偶数位和奇数位，分别输出二进制序列
sky_Mata的博客
11-19 351
怎样 获取二进制序列中的奇数位和偶数位？ 常见操作符的使用，如：>>、&
全新旅游小程序模板免费下载
小程序是一种不需要下载安装即可使用的应用，它实现了应用“触手可及”的梦想，用户扫一扫或搜一下即可打开应用。旅游小程序是专为旅游行业设计的，它可以帮助用户快速浏览旅游目的地信息、预订酒店、机票、门票等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值