[easyx]扫雷游戏试制作经历分享（低完成度）

最新推荐文章于 2023-12-25 10:35:39 发布
最新推荐文章于 2023-12-25 10:35:39 发布
阅读量104 收藏 1
点赞数
文章标签： 游戏 单片机 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81091000/article/details/134471054
版权

制作说明

本项目是基于学校校内新生挑战赛所制作的一个已完成任务为目标的项目，故而从产品和再现的角度上来看，都存在巨大的不足。主要思路是将操作界面的划分区块，通过给区块赋值来控制图片加载，和完成程序的判定。希望这一次分享能够帮到你

分模块说明

包含的头文件,变量和宏定义

#include<stdio.h>
#include<iostream>
#include<graphics.h>
#include "gameplay.h"
#include<time.h>
#include<Windows.h>
#include "gamestart.h"
#define ROW 10
#define COL 10
#define MINE_NUM 99//雷数
#define GRID_W 16//边框大小
​
int map[ROW][COL];//核心二维数据数组，储存数据值
IMAGE img[16];//图片数组
IMAGE pic[11];//checknum数组
int cnt = 0;//当前点开的非雷的数量
bool t2 = 1;//初见杀标志
bool t5 = 1;//开启t7标志
bool t6 = 0;///开启初见杀标志
int fla=0;//旗数
int tic = 0;//旗-雷数
int num[3];//checknum三取值
bool t4 = 1;//重来标志
bool t7 = 0;//close结束标志
​
#pragma once
#define ROW 10
#define COL 10
#define MINE_NUM 99//雷数
#define GRID_W 16
​

处女作难免有重复定义，和部分头文件没有使用的地方，多多包涵。愿意剔出就剔除

主函数

//底层数字显示
void show()
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            printf(" %2d", map[i][j]);
        }
        printf("\n");
    }
}
​
​
//点击开盒
//计旗雷数
int main()
{
    gamestart();
    initgraph(COL*GRID_W, ROW*GRID_W + 50);
    setfillcolor(YELLOW);
    rectangle(60, 20, 80, 40);
    LPCSTR arrt2 = { "re" };
    int text1 = 60 + 20 / 2 - textwidth(arrt2) / 2;
    int text2 = 20 + 20 / 2 - textheight(arrt2) / 2;
    outtextxy(text1, text2, arrt2);//re方块加载
    gameinit();
    show();
​
    while (1)
    {
        gameDraw();
        mousehit();
        if (t6)
        {
            if (t2 == 1)//初见杀标志
            {
                cnt = 0;
                fla = 0;
                gameinit();
                show();
            }
            t6 = 0;
        }
        if (t4 == 0)//重来标志
        {
            cnt = 0;
            fla = 0;
            gameinit();
            t4 = 1;
        }
        if (t7 == 1)//close结束标志
        {
            break;
        }
​
        checknum();
        
    }
​
    return 0;
}

包含一个底层数字显示函数，即打印数组到窗口方便调试的函数，以及游戏进程和由标志位控制的初始化函数，下文会详细介绍

游戏启动界面（gamestart）

void gamestart()
{
    ExMessage msg1;//获取鼠标消息
    bool t1 = 1;
    //开始
    initgraph(200, 100);
    cleardevice();
    setbkcolor(BLUE);
    setfillcolor(YELLOW);
​
    rectangle(50, 20, 150, 80);
    LPCSTR arrt1 = { "START" };
    int text1 = 50 + 100 / 2 - textwidth(arrt1) / 2;
    int text2 = 20 + 60 / 2 - textheight(arrt1) / 2;
    outtextxy(text1, text2, arrt1);
    while (t1)
    {
        while (peekmessage(&msg1))
        {
​
            switch (msg1.message)
            {
            case WM_LBUTTONDOWN:
​
                if (msg1.x < 150 && msg1.x>50 && msg1.y > 20 && msg1.y < 80)
                {
                    closegraph();
                    t1 = 0;
                    break;
                }
            defaultxg:break;
            }
        }
    }
}

较为基础的easyx运用，可以在官网上查到，上述函数的详细内容，主要就是在界面上绘制图形，然后运用ExMesssge创建一个有关鼠标信息的结构体，使用peekmessage()函数对鼠标所在区域判定达到点击开始的目的。

效果如下图所示：

初始化（gameinit）

//初始化
void gameinit()
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            map[i][j] = 0;
        }
​
    }
    //生成随机数种子
    srand((unsigned)time(NULL));
    for (int i = 0; i < MINE_NUM; )
    {
        //随机生成下标
        int r = rand() % ROW;
        int c = rand() % COL;
        if (map[r][c] == 0)
        {
​
            map[r][c] = -1;
            i++;
        }
    }
    //让以-1为中心的九宫格所有数据加一，-1除外
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            if (map[i][j] == -1)
            {
                //遍历九宫格
                for (int p = i - 1; p <= i + 1; p++)
                {
                    for (int q = j - 1; q <= j + 1; q++)
                    {
                        if (p >= 0 && p < ROW&&q >= 0 && q < COL&&map[p][q] != -1)
                        {
                            map[p][q]++;
                        }
                    }
                }
            }
        }
    }
    char str[50] = "";
    for (int i = 0; i < 9; i++)
    {
​
        sprintf_s(str, "./图片素材/images1/%d.gif", i);
        loadimage(&img[i], str, GRID_W, GRID_W);
    }
    loadimage(&img[9], "./图片素材/images1/mine.gif", GRID_W, GRID_W);
    loadimage(&img[10], "./图片素材/images1/blank.gif", GRID_W, GRID_W);
    loadimage(&img[11], "./图片素材/images1/flag.gif", GRID_W, GRID_W);
    loadimage(&img[12], "./图片素材/images1/blood.gif", GRID_W, GRID_W);
    //计旗雷数图片加载
    for (int i = 0; i < 11; i++)
    {
        sprintf_s(str, "./图片素材/images1/d%d.gif", i);
        loadimage(&pic[i], str, GRID_W, GRID_W / 2);
​
    }
    //数据加密 -1~8全部数据+20  -19~28
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            map[i][j] += 20;
        }
    }
}

完成游戏内容初始化，主要分为三个部分：数据加载，图片加载，数据加密.

  1. 数据加载

    通过srand((unsigned)time(NULL));和int r = rand() % ROW; int c = rand() % COL;

随机选定雷区，给雷区赋-1.然后通过for遍历九宫格使周围8格增加1，但注意此时要避开-1处。否则雷区消失。这样我们就完成了10*10的数据初始化

  1. 图片加载

    将两种点开和未点开的方块，以及各种数字块图片通过for加载，另外最好使img编号与图片中数字相匹配，另外checknum图片的pic也是如此

  2. 数据加密

    通过对每一个数据+20以与不同图片相对应，此举大有深意，留待后文。

    • 于是我们得到了这样的数据表

    界面绘制（gamedraw）

    //界面绘制
void gameDraw()
{
    for (int i = 0; i < ROW; i++)//i->y
    {
        for (int j = 0; j < COL; j++)//j->x
        {
            if (map[i][j] >= 0 && map[i][j] <= 10)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[map[i][j]]);
            }
            else if (map[i][j] == -1)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[9]);
            }
            else if (map[i][j] >= 19 && map[i][j] <= 28)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[10]);
            }
            else if (map[i][j] >= 39 && map[i][j] <= 48)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[11]);
            }
            else if (map[i][j] < -1)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[0]);
            }
        }
    }
}

    通过for遍历表格，对值进行判定，将对应图片加载

    于是得到界面

鼠标点击核心程序（mousehit）

//鼠标点击（核心）
void mousehit()
{
    MOUSEMSG msg = GetMouseMsg();//获取鼠标消息
    //把鼠标坐标转到二维数组中
    int row = (msg.y - 50) / GRID_W;
    int col = msg.x / GRID_W;
​
    if (msg.uMsg == WM_LBUTTONDOWN)
    {
        if (msg.y < 50)
        {
            //从头再来
            if (msg.x < 80 && msg.x>60 && msg.y > 20 && msg.y < 40)
            {
                t4 = 0;
                t5 = 1;
                t2 = 1;
                putimage(0, 0, &pic[0]);
            }
            //结束程序
            if (t5 == 0)
            {
                if (msg.x < 150 && msg.x>100 && msg.y > 20 && msg.y < 40)
                {
                    t7 = 1;
​
                }
​
​
            }
        }
        else
        {
            if (map[row][col] >= 19 && map[row][col] <= 28)
            {
                map[row][col] -= 20;
​
                cnt++;
                openNULL(row, col);
                if (t2)
                {
                    if (map[row][col] != -1)
                    {
                        t2 = 0;
​
                    }
                    else
                    {
                        map[row][col] += 20;
                    }
​
                }
​
                show();
                if (t2 == 0)
                {
                    jude(row, col);
                }
            }
        }
        t6 = 1;
    }
    else if (msg.uMsg == WM_RBUTTONDOWN)
    {
        if (map[row][col] >= 19 && map[row][col] <= 28)
        {
​
            map[row][col] += 20;
            if (t2 == 0)
                fla++;
            show();
​
        }
        else if (map[row][col] >= 39 && map[row][col] <= 48)
        {
​
            map[row][col] -= 20;
            if (t2 == 0)
                fla--;
        }
​
    }
​
}
​

通过GetMouseMsg来获取鼠标信息，其中在鼠标左键和右键点击时进行判定，通过对x，y的值来确定所属区域，左键点击使区域解密，右键点击使区域增加20，到达插旗状态，同时封锁左键对区域的效果（通过if实现）。

  • 初见杀模块

    包含在其中，t6和t2为两个核心标志位，

                   if (t2)
                {
                    if (map[row][col] != -1)
                    {
                        t2 = 0;
​
                    }
                    else
                    {
                        map[row][col] += 20;
                    }
​
                }
                 show();
                if (t2 == 0)
                {
                    jude(row, col);
                }

这一部分即初见杀判断，初始为1的t2在进行第一次点击判断后，未初见杀置0，若初见杀置1，主函数中有这样一段代码

if (t6)
        {
            if (t2 == 1)//初见杀标志
            {
                cnt = 0;
                fla = 0;
                gameinit();
                show();
            }
            t6 = 0;
        }

将一切初始化函数不能初始化的变量复原后，再初始化，从而使程序近乎重新开始，表现上为左击一次无法打开，不会太影响游戏体验。而t6的作用是在鼠标未在方格区点击时，关闭初始化判断，因为t2初为1，以避免不断初始化。

  • replay模块

        initgraph(COL*GRID_W, ROW*GRID_W + 50);
    setfillcolor(YELLOW);
    rectangle(60, 20, 80, 40);
    LPCSTR arrt2 = { "re" };
    int text1 = 60 + 20 / 2 - textwidth(arrt2) / 2;
    int text2 = 20 + 20 / 2 - textheight(arrt2) / 2;
    outtextxy(text1, text2, arrt2);//re方块加载
    gameinit();
    show();

    此为界面绘制，在mousehit中进行执行

    if (msg.y < 50)
        {
            //从头再来
            if (msg.x < 80 && msg.x>60 && msg.y > 20 && msg.y < 40)
            {
                t4 = 0;
                t5 = 1;
                t2 = 1;
                putimage(0, 0, &pic[0]);
            }
            //结束程序
            if (t5 == 0)
            {
                if (msg.x < 150 && msg.x>100 && msg.y > 20 && msg.y < 40)
                {
                    t7 = 1;
​
                }
​
​
            }

    将诸多标志位复原后，开启另一个初始化标志位，完成replay

    递归模块（OPENNULL）

    //利用递归炸开方格
void openNULL(int row, int col)
{
    if (map[row][col] == 0)
    {
        for (int i = row - 1; i <= row + 1; i++)
        {
            for (int j = col - 1; j <= col + 1; j++)
            {
                if (i >= 0 && i < ROW&&j >= 0 && j < COL && map[i][j] >19 && map[i][j] < 39)
                {
                    map[i][j] -= 20;
                    cnt++;
                    openNULL(i, j);//递归
                }
            }
        }
    }
​
}

    当点击的区块附近8格没有雷时，进入此模块，对九宫格进行遍历，如果不是雷再打开解密，同时在openNULL中套openNULL，如果打开该格也满足条件，以他为核心进行新的遍历，完成后继续执行上一个遍历的一个区块，当然这样的嵌套可以有多层，但注意遍历时避开初始格以防重复，故条件冗杂，效果见前图‘’界面绘制‘’时炸开的方块部分

    判断模块（jude）

    void jude(int row, int col)
{
    
    if (map[row][col] == -1)
    {
        MessageBox(GetHWnd(), "you lose", "再接再厉", MB_OK);
        for (int i = 0; i < ROW; i++)
        {
            for (int j = 0; j < COL; j++)
            {
                if (map[i][j] == 19)//不是雷
                {
                    map[i][j] -= 20;
​
                }
                else if (map[i][j] == 39)
                {
                    map[i][j] -= 40;
                }
            }
        }
        gameDraw();
        Sleep(1000);
        //重来/结束
        for (int i = 0; i < ROW; i++)
        {
            for (int j = 0; j < COL; j++)
            {
                map[i][j] -= 100;
            }
        }
        rectangle(100, 20, 150, 40);
        LPCSTR arrt2 = { "close" };
        int text3 = 100 + 50 / 2 - textwidth(arrt2) / 2;
        int text4 = 20 + 20 / 2 - textheight(arrt2) / 2;
        outtextxy(text3, text4, arrt2);
        t5 = 0;
        //ind = 0;
​
    }
​
​
    if (cnt == COL * ROW - MINE_NUM)
    {
        gameDraw();
        MessageBox(GetHWnd(), "you win", "不错", MB_OK);
        
        Sleep(1000);
        //重来/结束
        for (int i = 0; i < ROW; i++)
        {
            for (int j = 0; j < COL; j++)
            {
                map[i][j] -= 100;
            }
        }
        rectangle(100, 20, 150, 40);
        LPCSTR arrt2 = { "close" };
        int text3 = 100 + 50 / 2 - textwidth(arrt2) / 2;
        int text4 = 20 + 20 / 2 - textheight(arrt2) / 2;
        outtextxy(text3, text4, arrt2);
        t5 = 1;
​
​
    
    }
​
}

    关于胜负判断的模块，分两种情况当一个区域解密后，判断其中数值，若=-1，进入失败程序，将所有区域-100，成为空白格，，同时，界面绘制出close键，此时t5标志位置0，开启close判断，但此时replay模块依然有效，达到可以选择重来或者结束的目的

    效果如下图

这一步是我失败后，选择遍历方格，解密所有雷区，使使用者明败，的效果

而胜利判断条件为除了雷之外的方格全部点开，主要由cnt变量实现，当一个格子解密后，cnt即跟随其加一，当cnt=总格数-雷数后，开始胜利程序，t5标志位也开启，与失败模块差别不大。但其实最好加一个判断：当cnt=总格数-雷数后，遍历格子，如果=19和=39的区域数=雷数再开启胜利模块，可以避免最后两个格子，即使点到雷也判断胜利的情况，但我添加时出了点bug，但应该没问题的

旗-雷数（checknum）

//旗-雷数
void checknum()
{
​
    tic = MINE_NUM - fla;
    if (tic < 0)
    {
        putimage(0, 0, &pic[10]);
        tic = 0 - tic;
    }
    num[0] = tic % 10;
    num[1] = (tic / 10) % 10;
    num[2] = tic / 100;
    putimage(GRID_W * 3, 0, &pic[num[0]]);
    putimage(GRID_W * 2, 0, &pic[num[1]]);
    putimage(GRID_W, 0, &pic[num[2]]);
​
}

这是复原原版扫雷的显示实时可差旗总数-已插旗数的模块，主要由fla变量计数实现，fla的改变在mousehit模块中鼠标右击时跟随插旗撤旗增减。而num数组则完成对tic变量的十位个位取数，将相应的图片put上去，较创新的点是使之能显示负数，但注意在负号位置于replay和重回正数时用图片覆盖

结语

对于这一次结果不能称之为产品，毕竟太不完善，比如计时器我没能通过sleep实现，初见杀也不完美，如果用结构体做应该会更简洁，也不是一个完整的游戏。但希望给你帮助

下附源代码：

hong.h

#pragma once
#define ROW 10
#define COL 10
#define MINE_NUM 10//雷数
#define GRID_W 16
​

gamestart.h

#pragma once
#ifndef _GAMESTART_H_
#define _GAMESTART_H_
void gamestart();
​
#endif

gameplay.h

#pragma once
#ifndef _GAMEPLAY_H_
#define _GAMEPLAY_H_
void jude(int row, int col);
void openNULL(int row, int col);
void gameinit();
void gameDraw();
void mousehit();
void checknum();
#endif

main.cpp

#include<stdio.h>
#include<iostream>
#include<graphics.h>
#include "gameplay.h"
#include<time.h>
#include<Windows.h>
#include "gamestart.h"
#define ROW 10
#define COL 10
#define MINE_NUM 99//雷数
#define GRID_W 16
​
int map[ROW][COL];
IMAGE img[16];
IMAGE pic[11];
int cnt = 0;//当前点开的非雷的数量
bool t2 = 1;//初见杀标志
bool t5 = 1;
bool t6 = 0;
int fla=0;//旗数
int tic = 0;//旗-雷数
int num[3];
bool t4 = 1;//重来标志
bool t7 = 0;//close结束标志
void gameDraw();
​
​
//底层数字显示
void show()
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            printf(" %2d", map[i][j]);
        }
        printf("\n");
    }
}
​
​
//点击开盒
//计旗雷数
int main()
{
    gamestart();
    initgraph(COL*GRID_W, ROW*GRID_W + 50);
    setfillcolor(YELLOW);
    rectangle(60, 20, 80, 40);
    LPCSTR arrt2 = { "re" };
    int text1 = 60 + 20 / 2 - textwidth(arrt2) / 2;
    int text2 = 20 + 20 / 2 - textheight(arrt2) / 2;
    outtextxy(text1, text2, arrt2);//re方块加载
    gameinit();
    show();
​
    while (1)
    {
        gameDraw();
        mousehit();
        if (t6)
        {
            if (t2 == 1)//初见杀标志
            {
                cnt = 0;
                fla = 0;
                gameinit();
                show();
            }
            t6 = 0;
        }
        if (t4 == 0)//重来标志
        {
            cnt = 0;
            fla = 0;
            gameinit();
            t4 = 1;
        }
        if (t7 == 1)//close结束标志
        {
            break;
        }
​
        checknum();
        
    }
​
    return 0;
}

gamestart.cpp

#include<stdio.h>
#include<iostream>
#include<graphics.h>
#include "hong.h"
//开始界面
void gamestart()
{
    ExMessage msg1;//获取鼠标消息
    bool t1 = 1;
    //开始
    initgraph(200, 100);
    cleardevice();
    setbkcolor(BLUE);
    setfillcolor(YELLOW);
​
    rectangle(50, 20, 150, 80);
    LPCSTR arrt1 = { "START" };
    int text1 = 50 + 100 / 2 - textwidth(arrt1) / 2;
    int text2 = 20 + 60 / 2 - textheight(arrt1) / 2;
    outtextxy(text1, text2, arrt1);
    while (t1)
    {
        while (peekmessage(&msg1))
        {
​
            switch (msg1.message)
            {
            case WM_LBUTTONDOWN:
​
                if (msg1.x < 150 && msg1.x>50 && msg1.y > 20 && msg1.y < 80)
                {
                    closegraph();
                    t1 = 0;
                    break;
                }
            default:break;
            }
        }
    }
}

gameplay.cpp

#include<stdio.h>
#include<iostream>
#include<graphics.h>
#include "hong.h"
extern int map[ROW][COL];
extern IMAGE img[16];
extern bool t2 ;
extern bool t5;//开启t7标志
extern bool t7;
extern bool t6;
extern int cnt;
void show();
extern int fla;
extern IMAGE pic[11];
extern bool t4;
extern int tic;
extern int num[3];
//int ind = 0;
#include<time.h>
#include<Windows.h>
//胜负判断，同时重来
void gameDraw();
void jude(int row, int col)
{
    
    if (map[row][col] == -1)
    {
        MessageBox(GetHWnd(), "you lose", "再接再厉", MB_OK);
        for (int i = 0; i < ROW; i++)
        {
            for (int j = 0; j < COL; j++)
            {
                if (map[i][j] == 19)//不是雷
                {
                    map[i][j] -= 20;
​
                }
                else if (map[i][j] == 39)
                {
                    map[i][j] -= 40;
                }
            }
        }
        gameDraw();
        Sleep(1000);
        //重来/结束
        for (int i = 0; i < ROW; i++)
        {
            for (int j = 0; j < COL; j++)
            {
                map[i][j] -= 100;
            }
        }
        rectangle(100, 20, 150, 40);
        LPCSTR arrt2 = { "close" };
        int text3 = 100 + 50 / 2 - textwidth(arrt2) / 2;
        int text4 = 20 + 20 / 2 - textheight(arrt2) / 2;
        outtextxy(text3, text4, arrt2);
        t5 = 0;
        //ind = 0;
​
    }
​
​
    if (cnt == COL * ROW - MINE_NUM)
    {
        gameDraw();
        MessageBox(GetHWnd(), "you win", "不错", MB_OK);
        
        Sleep(1000);
        //重来/结束
        for (int i = 0; i < ROW; i++)
        {
            for (int j = 0; j < COL; j++)
            {
                map[i][j] -= 100;
            }
        }
        rectangle(100, 20, 150, 40);
        LPCSTR arrt2 = { "close" };
        int text3 = 100 + 50 / 2 - textwidth(arrt2) / 2;
        int text4 = 20 + 20 / 2 - textheight(arrt2) / 2;
        outtextxy(text3, text4, arrt2);
        t5 = 1;
​
​
    
    }
​
}
​
//利用递归炸开方格
void openNULL(int row, int col)
{
    if (map[row][col] == 0)
    {
        for (int i = row - 1; i <= row + 1; i++)
        {
            for (int j = col - 1; j <= col + 1; j++)
            {
                if (i >= 0 && i < ROW&&j >= 0 && j < COL && map[i][j] >19 && map[i][j] < 39)
                {
                    map[i][j] -= 20;
                    cnt++;
                    openNULL(i, j);//递归
                }
            }
        }
    }
​
}
//初始化
void gameinit()
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            map[i][j] = 0;
        }
​
    }
    //生成随机数种子
    srand((unsigned)time(NULL));
    for (int i = 0; i < MINE_NUM; )
    {
        //随机生成下标
        int r = rand() % ROW;
        int c = rand() % COL;
        if (map[r][c] == 0)
        {
​
            map[r][c] = -1;
            i++;
        }
    }
    //让以-1为中心的九宫格所有数据加一，-1除外
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            if (map[i][j] == -1)
            {
                //遍历九宫格
                for (int p = i - 1; p <= i + 1; p++)
                {
                    for (int q = j - 1; q <= j + 1; q++)
                    {
                        if (p >= 0 && p < ROW&&q >= 0 && q < COL&&map[p][q] != -1)
                        {
                            map[p][q]++;
                        }
                    }
                }
            }
        }
    }
    char str[50] = "";
    for (int i = 0; i < 9; i++)
    {
​
        sprintf_s(str, "./图片素材/images1/%d.gif", i);
        loadimage(&img[i], str, GRID_W, GRID_W);
    }
    loadimage(&img[9], "./图片素材/images1/mine.gif", GRID_W, GRID_W);
    loadimage(&img[10], "./图片素材/images1/blank.gif", GRID_W, GRID_W);
    loadimage(&img[11], "./图片素材/images1/flag.gif", GRID_W, GRID_W);
    loadimage(&img[12], "./图片素材/images1/blood.gif", GRID_W, GRID_W);
    //计旗雷数图片加载
    for (int i = 0; i < 11; i++)
    {
        sprintf_s(str, "./图片素材/images1/d%d.gif", i);
        loadimage(&pic[i], str, GRID_W, GRID_W / 2);
​
    }
    //数据加密 -1~8全部数据+20  -19~28
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            map[i][j] += 20;
        }
    }
}
//界面绘制
void gameDraw()
{
    for (int i = 0; i < ROW; i++)//i->y
    {
        for (int j = 0; j < COL; j++)//j->x
        {
            if (map[i][j] >= 0 && map[i][j] <= 10)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[map[i][j]]);
            }
            else if (map[i][j] == -1)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[9]);
            }
            else if (map[i][j] >= 19 && map[i][j] <= 28)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[10]);
            }
            else if (map[i][j] >= 39 && map[i][j] <= 48)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[11]);
            }
            else if (map[i][j] < -1)
            {
                putimage(j*GRID_W, i*GRID_W + 50, &img[0]);
            }
        }
    }
}
//旗-雷数
void checknum()
{
​
    tic = MINE_NUM - fla;
    if (tic < 0)
    {
        putimage(0, 0, &pic[10]);
        tic = 0 - tic;
    }
    num[0] = tic % 10;
    num[1] = (tic / 10) % 10;
    num[2] = tic / 100;
    putimage(GRID_W * 3, 0, &pic[num[0]]);
    putimage(GRID_W * 2, 0, &pic[num[1]]);
    putimage(GRID_W, 0, &pic[num[2]]);
​
}
//鼠标点击（核心）
void mousehit()
{
    MOUSEMSG msg = GetMouseMsg();//获取鼠标消息
    //把鼠标坐标转到二维数组中
    int row = (msg.y - 50) / GRID_W;
    int col = msg.x / GRID_W;
​
    if (msg.uMsg == WM_LBUTTONDOWN)
    {
        if (msg.y < 50)
        {
            //从头再来
            if (msg.x < 80 && msg.x>60 && msg.y > 20 && msg.y < 40)
            {
                t4 = 0;
                t5 = 1;
                t2 = 1;
                putimage(0, 0, &pic[0]);
            }
            //结束程序
            if (t5 == 0)
            {
                if (msg.x < 150 && msg.x>100 && msg.y > 20 && msg.y < 40)
                {
                    t7 = 1;
​
                }
​
​
            }
        }
        else
        {
            if (map[row][col] >= 19 && map[row][col] <= 28)
            {
                map[row][col] -= 20;
​
                cnt++;
                openNULL(row, col);
                if (t2)
                {
                    if (map[row][col] != -1)
                    {
                        t2 = 0;
​
                    }
                    else
                    {
                        map[row][col] += 20;
                    }
​
                }
​
                show();
                if (t2 == 0)
                {
                    jude(row, col);
                }
            }
        }
        t6 = 1;
    }
    else if (msg.uMsg == WM_RBUTTONDOWN)
    {
        if (map[row][col] >= 19 && map[row][col] <= 28)
        {
​
            map[row][col] += 20;
            if (t2 == 0)
                fla++;
            show();
​
        }
        else if (map[row][col] >= 39 && map[row][col] <= 48)
        {
​
            map[row][col] -= 20;
            if (t2 == 0)
                fla--;
        }
​
    }
​
}
s
辞秋wllw
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于EasyX图形库的扫雷游戏
07-15
基于EasyX图形库的扫雷游戏，效仿系统内置扫雷，有初中高三种等级已经自定义等级
C语言结合Easyx库实现扫雷小游戏
03-26
这个小游戏实现游戏可视化，目前在VS运行正常
扫雷（easyx）
ahui_is_so_cool的博客
05-08 2379
扫雷的easyx简易实现
基于c++和easyx库的扫雷游戏实现
shsj46787944的博客
07-27 236
扫雷是一款经典的单人游戏，玩家需要根据数字提示找出所有的地雷，并标记它们的位置。这个游戏的规则简单易懂，但是却能够考验玩家的观察能力和判断能力。在这篇博客中，我们将介绍如何使用C语言和图形库制作一个简单的扫雷游戏。我们将会使用到图形库中的一些函数和结构体，以及C语言中的数组和递归函数。
图形化界面扫雷(C语言+easyx实现，多图教学)
热门推荐
csdnwqy030429的博客
11-08 2万+
扫雷前言准备工作EasyX的下载一些准备知识头文件的引用图形化界面的创建图形化界面简介鼠标操作提示框 前言 学了那么长时间的C语言，我们所有的一切似乎都被禁锢在黑框框（控制台）里，让人觉得很无趣，学习unity那样的平台又太过困难，那么有没有什么是适合我们这些新手使用的？答案是：有！ EasyX 是针对 C/C++ 的图形库，可以帮助使用C/C++语言的程序员快速上手图形和游戏编程。 这是百度百科上的解释，目前就我的理解，下载并安装Easyx就相当于为我们的VS（或者是别的）增加了一些库函数，以便我们实
c语言小游戏--扫雷
来自计科大一萌新的编程记录本
12-10 662
c语言小游戏--扫雷
用easyx制作一个扫雷游戏
最新发布
02-19
用easyx制作一个扫雷游戏
大一利用C语言+EasyX完成扫雷游戏
01-10
概要：仅利用C语言基础知识（数组，结构体，循环嵌套等），配合EasyX实现扫雷界面化，鼠标定位功能。 开发环境及工具：visual studio2019，EasyX（16.4.0）。注意版本，不同版本的EasyX所使用函数的方法不同。 阅读...
基于EasyX的扫雷小游戏
02-02
EasyX提供了窗口创建、画线、填充、文字显示等功能，这为构建扫雷游戏的用户界面提供了便利。要开始使用EasyX，你需要在项目中包含相关的头文件，并初始化图形窗口。例如： ```cpp #include "easyx.h" void main() ...
基于EasyX的扫雷游戏实现
10-16
基于EasyX的扫雷游戏实现，里面有完整的代码及注释，好东西 不容错过
用EasyX实现扫雷
2301_79202816的博客
12-10 322
为了方便方格中数字的计算，扩充一个外围，采用11*11的数组（均初始化为0）。若不是雷则判断其数字是否为0.若不是0则展示其数字，若是0则递归调用函数，执行过的方格进行标记，直到均不是0或均被标记或遇到边界,每次操作均对剩余方格数减1。计算每个方格周围的雷的个数，有方格为9则数字加1.若右键则标记防护，判断这个方格的状态，若未被操作则在相应的方格绘制并把展示的数组中标记对存在方格数减1。若剩余的方格数等于0在界面中显示计时器的结果，并设置两个按钮判断。若左键按下，则先判断其是否为雷，若是雷则显示游戏失败。
EasyX图形库实现贪吃蛇游戏
qq_75270497的博客
10-13 1794
使用EasyX图形库一步一步实现贪吃蛇小游戏
如何用C语言加上easyx做出一个高逼格的迷宫游戏
weixin_56334307的博客
12-25 899
迷宫游戏有多种类型，例如营救公主类、闯关类等，其他类型就不一一列举了。但无论哪种类型的迷宫游戏，其核心功能始终是迷宫的实现。不同的游戏只会根据自身的性质，在迷宫中加入一些特定元素。我们今天的任务，便是用C语言来实现这一核心功能，确保其原汁原味，不添加任何额外功能。
easyx图形化界面应用——推箱子
m0_74779465的博客
07-26 334
EasyX 是针对 C++ 的图形库，可以帮助 C/C++ 初学者快速上手图形和游戏编程。easyx 可以默认为一个现成的图形化库函数，里面的函数可以直接通过头文件和来调用。这次以简易推箱子游戏为素材为大家讲一下自己的心得：这个游戏的设计思路主要从界面设计，地图加载，贴图，地图刷新来实现。一，界面设计界面设计主要应用loadimage读取图片文件和putimage在当前绘图设备上绘制指定图像。设计界面时可以先设计背景以及旋钮的位置，然后将对应的功能添加。
【c语言】五子棋（EasyX图形库+背景音乐）
yyqzjw的博客
08-21 3094
大家好，有没有觉得写了好多c语言代码，面对的都是黑框框控制台，当我们学习了基础的c语言知识，和EasyX图形库后，终于可以和黑框框saygoodbye,今天要分享给大家的是小游戏五子棋，跟着小张一起学习吧。
扫雷（基于 EasyX 图形库）
melonyzzZ的博客
11-26 1558
基于 EasyX 图像库编写扫雷游戏。
基于easyX制作的C语言小游戏
weixin_42098648的博客
11-05 7418
游戏基于贪吃蛇和飞机大战思想制作，利用easyX实现的纯C语言小游戏
C++结合EasyX写扫雷(new)
m0_61316509的博客
07-12 616
写的过程中，感觉有很多东西忘记了，比如EasyX的一些基础；再就是感觉代码写得更有逻辑了（doge。另外就是添加了一点点花里胡哨的东西，比如说开始屏幕(Splash Screen)大约半年之前的寒假期间，我接触了EasyX这个图形库，于是试着写了一个经典小游戏——扫雷。基本上全都是自己重写，没怎么借鉴之前的代码（主要可能是因为看不懂之前自己写的代码了）基本思路和之前差不多；引用的图片文件也是一样的(图片文件资源在。编写环境仍然是VS2022，记得把项目字符集改为。
Easyx-----c语言实现简易版扫雷
weixin_60569662的博客
01-12 2786
扫雷规则简介 实现思路 设置雷 把以雷为中心的九宫格数据都+1，雷除外 #include<stdio.h> #include<stdlib.h> #include<time.h> #include<easyx.h> #include<mmsystem.h> #pragma comment(lib, "winmm.lib") #define ROW 10 //定义行列的常量 #define COL 10 #define Min..
easyx实现扫雷游戏
03-26
但是，以下是一些可能有用的思路概述，帮助您开始构建基于EasyX的扫雷游戏： 1. 界面设计：使用EasyX的图形库，设计扫雷游戏窗口，绘制矩形格子，并标记已经扫出的雷区和未知的雷区。 2. 游戏逻辑：创建一个扫雷...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值