首页 > 其他分享 >QT翻金币小游戏

QT翻金币小游戏

时间:2024-08-15 09:54:08浏览次数:13  
标签:QT int back 金币 ++ 小游戏 按钮 push include

目录

QT翻金币小游戏

效果展示

图片

视频

实现代码

main.cpp

 mymainwindow.h

mymainwindow.cpp

 startscene.h

startscene.cpp

selectscene.cpp

playscene.h

playscene.cpp

 mypushbutton.h

 mypushbutton.cpp

dataconfig.h

dataconfig.cpp


QT翻金币小游戏

效果展示

图片

 

视频

实现代码

main.cpp

#include "mymainwindow.h"  // 引入自定义的 MyMainWindow 类头文件
#include "startscene.h"    // 引入自定义的 StartScene 类头文件

#include <QApplication>    // 引入 Qt 应用程序类的头文件

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);  // 创建 QApplication 对象,初始化应用程序,处理命令行参数

    StartScene sc;               // 创建 StartScene 对象,作为应用程序的主场景或窗口
    sc.show();                   // 显示 StartScene 对象,即显示窗口

    return a.exec();             // 进入 Qt 事件循环,等待并处理事件
}

 mymainwindow.h

#ifndef MYMAINWINDOW_H  // 如果没有定义 MYMAINWINDOW_H
#define MYMAINWINDOW_H  // 定义 MYMAINWINDOW_H,防止头文件被多次包含

#include <QMainWindow>  // 引入 QMainWindow 类
#include <QSoundEffect>  // 引入 QSoundEffect 类用于播放声音
#include <QUrl>  // 引入 QUrl 类用于处理 URL
#include <QCoreApplication>  // 引入 QCoreApplication 类用于应用程序的核心功能

QT_BEGIN_NAMESPACE  // 开始 Qt 命名空间

namespace Ui {
class MyMainWindow;  // 前向声明 Ui::MyMainWindow 类
}

QT_END_NAMESPACE  // 结束 Qt 命名空间

class MyMainWindow : public QMainWindow  // 定义 MyMainWindow 类,继承自 QMainWindow
{
    Q_OBJECT  // 使得类可以使用 Qt 的信号和槽机制

public:
    MyMainWindow(QWidget *parent = nullptr);  // 构造函数,接受一个可选的父窗口参数
    ~MyMainWindow();  // 析构函数

    void playSoundEffect(const QString& filePath);  // 声明播放声音效果的成员函数

protected:
    void paintEvent(QPaintEvent *event);  // 声明绘制事件的重写函数

private:
    Ui::MyMainWindow *ui;  // 指向自动生成的 UI 类的指针
};

#endif // MYMAINWINDOW_H  // 结束头文件保护宏

mymainwindow.cpp

#include "mymainwindow.h"  // 引入自定义的 MyMainWindow 类头文件
#include "./ui_mymainwindow.h"  // 引入自动生成的 UI 文件头文件
#include <QPainter>  // 引入 Qt 的绘图类头文件

MyMainWindow::MyMainWindow(QWidget *parent)
    : QMainWindow(parent)  // 调用基类 QMainWindow 的构造函数
    , ui(new Ui::MyMainWindow)  // 初始化 UI 对象
{
    ui->setupUi(this);  // 设置 UI 组件

    ui->actionQuit->setIcon(QIcon(":/image/Quit.png"));  // 为“退出”动作设置图标
    this->setWindowIcon(QPixmap(":/image/Coin0001.png"));  // 设置主窗口图标
    this->setWindowTitle("翻金币小游戏");  // 设置主窗口标题
    this->setFixedSize(320,588);  // 设置窗口固定大小,宽320高588
}

MyMainWindow::~MyMainWindow()
{
    delete ui;  // 删除 UI 对象以释放内存
}

void MyMainWindow::playSoundEffect(const QString &filePath)
{
    QSoundEffect *sound = new QSoundEffect;  // 创建 QSoundEffect 对象
    sound->setSource(QUrl::fromLocalFile(filePath));  // 设置音频文件路径
    sound->setVolume(0.5f);  // 可选:设置音量为 0.5
    sound->play();  // 播放声音
    // 连接信号槽,当播放完成时自动删除对象
    QObject::connect(sound, &QSoundEffect::playingChanged, [sound]() {
        if (!sound->isPlaying()) {
            delete sound;  // 播放完成后删除声音对象
        }
    });
}

void MyMainWindow::paintEvent(QPaintEvent *event)
{
    // 绘制背景图片
    QPainter painter(this);  // 创建 QPainter 对象用于绘图
    painter.translate(0,this->menuBar()->height());  // 将画家的原点移动到菜单栏下方
    QPixmap pix(":/image/MenuSceneBg.png");  // 加载背景图片
    painter.drawPixmap(0, 0, this->width(), this->height(), pix);  // 绘制背景图,填充整个窗口
}

 startscene.h

#ifndef STARTSCENE_H  // 检查是否未定义 STARTSCENE_H
#define STARTSCENE_H  // 定义 STARTSCENE_H,避免头文件重复包含

#include <QMainWindow>  // 引入 QMainWindow 类
#include "mymainwindow.h"  // 引入 MyMainWindow 类的头文件
#include "selectscene.h"  // 引入 SelectScene 类的头文件

class StartScene : public MyMainWindow  // StartScene 类继承自 MyMainWindow
{
    Q_OBJECT  // 使 StartScene 类成为 Qt 的对象模型的一部分,支持信号和槽机制
public:
    explicit StartScene(QWidget *parent = nullptr);  // 构造函数声明,接受一个可选的父窗口指针
private:
    SelectScene msc;  // 定义一个 SelectScene 类型的成员变量 msc
signals:
};

#endif // STARTSCENE_H  // 结束条件编译,确保此头文件只被包含一次

startscene.cpp

#include "startscene.h"  // 引入 StartScene 头文件
#include "mypushbutton.h"  // 引入 MyPushButton 头文件
#include <QTimer>  // 引入 QTimer 类用于定时操作
#include <QSoundEffect>  // 引入 QSoundEffect 类用于播放声音效果

StartScene::StartScene(QWidget *parent)
    : MyMainWindow{parent}  // 调用基类 MyMainWindow 的构造函数
{
    // 开始按钮
    MyPushButton *btnStart = new MyPushButton(":/image/MenuSceneStartButton.png",
                                              ":/image/MenuSceneStartButton.png",
                                              this);  // 创建 MyPushButton 对象,并设置图片和父窗口
    btnStart->resize(114,114);  // 设置按钮的尺寸
    btnStart->move(this->width()/2-btnStart->width()/2,  // 将按钮水平居中
                   this->height()*3/4-btnStart->height()/2);  // 将按钮垂直位置设置为窗口高度的三分之四

    connect(btnStart, &MyPushButton::clicked, [=](){  // 连接按钮的 clicked 信号到槽函数
        this->playSoundEffect(":/music/TapButtonSound.wav");  // 播放按钮点击声音
        btnStart->setEnabled(false);  // 禁用按钮
        btnStart->moveDown();  // 执行下跳动画
        QTimer::singleShot(150, [=](){  // 在 150ms 后执行
            btnStart->moveUp();  // 执行上跳动画
        });
        QTimer::singleShot(300, [=](){  // 在 300ms 后执行
            btnStart->setEnabled(true);  // 启用按钮
            // 场景转换
            this->msc.move(this->pos());  // 移动 SelectScene 到当前窗口位置
            this->msc.show();  // 显示 SelectScene
            this->hide();  // 隐藏当前窗口
        });
    });

    connect(&this->msc, &SelectScene::backBtnClicked, [=](){  // 连接 SelectScene 的 backBtnClicked 信号到槽函数
        this->playSoundEffect(":/music/BackButtonSound.wav");  // 播放返回按钮声音
        this->move(this->msc.pos());  // 移动当前窗口到 SelectScene 的位置
        this->show();  // 显示当前窗口
        this->msc.hide();  // 隐藏 SelectScene
    });
}

 selectscene.h

#ifndef SELECTSCENE_H  // 检查是否未定义 SELECTSCENE_H
#define SELECTSCENE_H  // 定义 SELECTSCENE_H,避免头文件重复包含

#include <QMainWindow>  // 引入 QMainWindow 类
#include "mymainwindow.h"  // 引入 MyMainWindow 类的头文件

class SelectScene : public MyMainWindow  // SelectScene 类继承自 MyMainWindow
{
    Q_OBJECT  // 使 SelectScene 类成为 Qt 的对象模型的一部分,支持信号和槽机制
public:
    explicit SelectScene(QWidget *parent = nullptr);  // 构造函数声明,接受一个可选的父窗口指针

protected:
    void paintEvent(QPaintEvent *event);  // 声明重写的 paintEvent 方法,用于绘制界面

signals:
    void backBtnClicked();  // 声明信号 backBtnClicked,当点击back按钮事件时信号发出
};

#endif // SELECTSCENE_H  // 结束条件编译,确保此头文件只被包含一次

selectscene.cpp

#include "selectscene.h"  // 引入 SelectScene 类的头文件
#include <QPushButton>  // 引入 QPushButton 类
#include <QPainter>  // 引入 QPainter 类,用于绘图
#include "./ui_mymainwindow.h"  // 引入 MyMainWindow 的用户界面头文件
#include "mypushbutton.h"  // 引入 MyPushButton 类的头文件
#include "playscene.h"  // 引入 PlayScene 类的头文件

// SelectScene 的构造函数
SelectScene::SelectScene(QWidget *parent)
    : MyMainWindow{parent}  // 调用基类构造函数,初始化 parent
{
    this->setWindowTitle("选择关卡");  // 设置窗口标题为 "选择关卡"

    // 创建返回按钮
    MyPushButton *btnBack = new MyPushButton(":/image/BackButton.png",
                                             ":/image/BackButtonSelected.png",
                                             this);
    btnBack->resize(72, 32);  // 设置按钮大小
    btnBack->move(this->width() - btnBack->width(),  // 设置按钮位置,使其靠右下角
                  this->height() - btnBack->height());

    // 连接返回按钮的点击信号到 backBtnClicked 槽
    connect(btnBack, &QPushButton::clicked, this, &SelectScene::backBtnClicked);

    // 设置每个关卡按钮的尺寸和位置参数
    const int colwidth = 70;  // 列宽
    const int rowheight = 70;  // 行高
    const int xoffset = 25;  // X 偏移量
    const int yoffset = 130;  // Y 偏移量

    // 创建 20 个关卡按钮
    for(int i = 0; i < 20; i++){
        MyPushButton *btn = new MyPushButton(":/image/LevelIcon.png", ":/image/LevelIcon.png", this);
        btn->setText(QString::number(i + 1));  // 设置按钮上的文本为关卡号
        int col = i % 4;  // 计算列索引
        int row = i / 4;  // 计算行索引
        int x = col * colwidth + xoffset;  // 计算按钮的 X 坐标
        int y = row * rowheight + yoffset;  // 计算按钮的 Y 坐标
        btn->resize(57, 57);  // 设置按钮大小
        btn->move(x, y);  // 设置按钮位置

        // 连接按钮的点击信号到一个 lambda 表达式
        connect(btn, &MyPushButton::clicked, [=](){
            this->playSoundEffect(":/music/TapButtonSound.wav");  // 播放点击按钮的声音
            PlayScene *ps = new PlayScene(i + 1);  // 创建一个新的 PlayScene 实例
            ps->setAttribute(Qt::WA_DeleteOnClose);  // 设置属性,确保关闭时自动删除
            ps->move(this->pos());  // 将 PlayScene 窗口移动到当前窗口的位置
            ps->show();  // 显示 PlayScene 窗口
            this->hide();  // 隐藏当前窗口

            // 连接 PlayScene 的 backBtnClicked 信号到一个 lambda 表达式
            connect(ps, &PlayScene::backBtnClicked, [=](){
                this->playSoundEffect(":/music/BackButtonSound.wav");  // 播放返回按钮的声音
                this->move(ps->pos());  // 将当前窗口移动到 PlayScene 窗口的位置
                this->show();  // 显示当前窗口
                ps->close();  // 关闭 PlayScene 窗口
            });
        });
    }
}

// 重写 paintEvent 方法,用于自定义绘图
void SelectScene::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);  // 创建 QPainter 对象
    painter.translate(0, this->menuBar()->height());  // 移动画家到菜单栏下面

    QPixmap pix(":/image/OtherSceneBg.png");  // 加载背景图片
    painter.drawPixmap(0, 0, this->width(), this->height(), pix);  // 绘制背景图片

    pix.load(":/image/Title.png");  // 加载标题图片
    painter.drawPixmap(0, 0, pix);  // 绘制标题图片
}

playscene.h

#ifndef PLAYSCENE_H
#define PLAYSCENE_H

#include <QMainWindow>  // 引入 QMainWindow 类
#include "mymainwindow.h"  // 引入 MyMainWindow 类
#include "coinbutton.h"  // 引入 CoinButton 类

class PlayScene : public MyMainWindow  // PlayScene 继承自 MyMainWindow
{
    Q_OBJECT  // 使 PlayScene 成为 Qt 对象,支持信号和槽机制
public:
    PlayScene(int level, QWidget *parent = nullptr);  // 构造函数,接受关卡数和父窗口指针

    void flip(int row, int col);  // 翻转指定位置的硬币
    void judgeWin();  // 判断是否赢得游戏

protected:
    void paintEvent(QPaintEvent *event);  // 重写 paintEvent 方法,用于自定义绘图

signals:
    void backBtnClicked();  // 声明返回按钮点击的信号

private:
    CoinButton *mCoins[4][4];  // 4x4 硬币按钮数组
    bool winFlag;  // 游戏胜利标志
};

#endif // PLAYSCENE_H

playscene.cpp

#include "playscene.h" // 包含 PlayScene 类的头文件
#include "mypushbutton.h" // 包含 MyPushButton 类的头文件
#include "./ui_mymainwindow.h" // 包含 MyMainWindow 的 UI 头文件
#include <QPainter> // 包含 QPainter 用于绘制
#include <QLabel> // 包含 QLabel 用于文本显示
#include "coinbutton.h" // 包含 CoinButton 类
#include "dataconfig.h" // 包含 DataConfig 类
#include <QTimer> // 包含 QTimer 用于定时事件
#include <QPropertyAnimation> // 包含 QPropertyAnimation 用于动画

PlayScene::PlayScene(int level, QWidget *parent) // PlayScene 构造函数
    : MyMainWindow{parent} // 初始化基类 MyMainWindow
{
    winFlag = false; // 初始化 winFlag 为 false 失败

    this->setWindowTitle(QString("关卡%1").arg(level)); // 设置窗口标题为当前关卡几
    MyPushButton *btnBack = new MyPushButton(":/image/BackButton.png", 
                                             ":/image/BackButtonSelected.png",
                                             this); // 设置第一张图为未按下时的状态,第二张图为按下时的状态,父级为当前窗口
    btnBack->resize(72,32); // 设置返回按钮的大小
    btnBack->move(this->width()-btnBack->width(), 
                  this->height()-btnBack->height());// 将返回按钮移动到右下角

    connect(btnBack,&QPushButton::clicked,this,&PlayScene::backBtnClicked); // 连接返回按钮的点击信号到 backBtnClicked 槽

    QLabel *label = new QLabel(this); // 创建一个 QLabel 显示关卡信息
    label->resize(150,50); // 设置标签的大小
    label->setText(QString("Level:%1").arg(level)); // 设置标签文本为当前关卡几
    label->setFont(QFont("华文新魏",20)); // 设置标签字体和大小
    label->move(30,this->height()-label->height()); // 将标签移动到底部左侧

    const int colwidth = 50; // 每列的宽度
    const int rowheight = 50; // 每行的高度
    const int xoffset = 57; // 硬币按钮的 x 偏移量
    const int yoffset = 200; // 硬币按钮的 y 偏移量

    dataConfig data; // 创建 dataConfig 对象
    QVector <QVector <int >> dataArray = data.mData[level]; // 获取当前关卡的数据

    for(int row = 0; row < 4; row ++) // 遍历行
    {
        for(int col = 0; col < 4; col ++) // 遍历列
        {
            CoinButton *btn = new CoinButton(this); // 创建新的 CoinButton
            mCoins[row][col] = btn; // 将按钮存储在 mCoins 数组中
            int x = col * colwidth + xoffset; // 计算 x 位置
            int y = row * rowheight + yoffset; // 计算 y 位置
            btn->setGeometry(x,y,50,50); // 设置按钮的大小和位置
            btn->setMstat(dataArray[row][col]); // 根据数据设置金币状态1为金币0为银币

            connect(btn,&CoinButton::clicked,[=](){ // 连接按钮点击信号到 flip 函数
                this->flip(row,col); // 调用 flip 函数处理金币翻转
            });
        }
    }
}

void PlayScene::flip(int row, int col) // 处理硬币翻转的函数
{
    if(winFlag) // 如果已经赢了
        return; // 直接结束函数
    this->mCoins[row][col]->flip(); // 翻转点击位置的硬币
    this->playSoundEffect(":/music/ConFlipSound.wav"); // 播放翻转音效
    QTimer::singleShot(250,[=](){ // 250ms后翻转相邻的硬币
        if(row + 1 < 4) // 检查下方是否有硬币
            this->mCoins[row + 1][col]->flip(); // 翻转下方的硬币
        if(row - 1 >= 0) // 检查上方是否有硬币
            this->mCoins[row - 1][col]->flip(); // 翻转上方的硬币
        if(col - 1 >= 0) // 检查左侧是否有硬币
            this->mCoins[row][col - 1]->flip(); // 翻转左侧的硬币
        if(col + 1 < 4) // 检查右侧是否有硬币
            this->mCoins[row][col + 1]->flip(); // 翻转右侧的硬币
        this->judgeWin(); // 判断是否胜利
    });
}

void PlayScene::judgeWin() // 判断是否完成关卡
{
    for(int row = 0; row < 4; row ++) // 遍历行
    {
        for(int col = 0; col < 4; col ++) // 遍历列
        {
            if(!this->mCoins[row][col]->getMstat()) // 如果有银币不是胜利状态
                return ; // 直接结束函数
        }
    }
    winFlag = true; // 设置 winFlag 为 true 胜利
    this->playSoundEffect(":/music/LevelWinSound.wav"); // 播放胜利音效
    QLabel *labelWin = new QLabel(this); // 创建 QLabel 显示胜利信息
    QPixmap pix = QPixmap(":/image/LevelCompletedDialogBg.png"); // 加载胜利对话框图片
    labelWin->setPixmap(pix); // 设置标签的图片
    labelWin->resize(pix.size()); // 设置标签的大小
    labelWin->show(); // 显示胜利信息
    labelWin->move(this->width()/2-labelWin->width()/2,-labelWin->height()); // 初始位置设在屏幕外

    QPropertyAnimation *animation = new QPropertyAnimation(labelWin, "geometry",this); // 创建胜利标签动画
    animation->setStartValue(labelWin->geometry());  // 设置动画的起始位置
    animation->setEndValue(QRect(labelWin->x(),  labelWin->y()+180,  labelWin->width(), labelWin->height())); // 设置动画的结束位置
    animation->setDuration(1000);  // 设置动画的持续时间
    animation->setEasingCurve(QEasingCurve::OutBounce); // 设置动画的缓动曲线
    animation->start(QPropertyAnimation::DeleteWhenStopped); // 启动动画并在结束时删除
}

void PlayScene::paintEvent(QPaintEvent *event) // 重写 paintEvent 绘制自定义元素
{
    QPainter painter(this); // 创建 QPainter 对象用于绘制
    painter.translate(0,this->menuBar()->height()); // 移动绘制区域到菜单栏下方
    QPixmap pix(":/image/PlayLevelSceneBg.png"); // 加载背景图片
    painter.drawPixmap(0, 0, this->width(), this->height(), pix); // 绘制背景图片填充整个窗口
    pix.load(":/image/Title.png"); // 加载logo图片
    pix = pix.scaled(pix.width()/2,pix.height()/2); // 缩放logo图片50%
    painter.drawPixmap(0,0,pix); // 在窗口左上角绘制标题图片
}

 mypushbutton.h

#ifndef MYPUSHBUTTON_H
#define MYPUSHBUTTON_H

#include <QWidget> // 引入 QWidget 头文件,用于继承 QWidget
#include <QPushButton> // 引入 QPushButton 头文件,用于继承 QPushButton

class MyPushButton : public QPushButton // 定义 MyPushButton 类,继承自 QPushButton
{
    Q_OBJECT // 宏,启用 Qt 的信号与槽机制
public:
    enum MyPushButtonStat // 定义枚举类型 MyPushButtonStat,用于按钮状态
    {
        NORMAL, // 正常状态
        PRESSED // 按下状态
    };
    MyPushButton(QString normalImg, QString pressedImg, QWidget *parent = nullptr); // 构造函数声明,接受正常和按下状态的图片路径,以及父级 widget
    void moveDown(); // 移动按钮向下的函数声明
    void moveUp(); // 移动按钮向上的函数声明

protected:
    void paintEvent(QPaintEvent *event); // 重写 paintEvent 函数,用于自定义绘制
    void mousePressEvent(QMouseEvent *e); // 重写 mousePressEvent 函数,用于处理鼠标按下事件
    void mouseReleaseEvent(QMouseEvent *e); // 重写 mouseReleaseEvent 函数,用于处理鼠标释放事件

signals:

private:
    QString mNormalImg; // 存储正常状态图片路径
    QString mPressedImg; // 存储按下状态图片路径
    MyPushButtonStat mStat; // 存储当前按钮状态
};

#endif // MYPUSHBUTTON_H

 mypushbutton.cpp

#include "mypushbutton.h" // 引入自定义按钮类的头文件
#include <QPainter> // 引入 QPainter 头文件,用于绘图
#include <QPropertyAnimation> // 引入 QPropertyAnimation 头文件,用于动画效果

// 构造函数,初始化按钮的正常图片和按下图片路径
MyPushButton::MyPushButton(QString normalImg, QString pressedImg, QWidget *parent)
    : QPushButton{parent} // 调用基类 QPushButton 的构造函数
    , mNormalImg(normalImg) // 初始化正常状态图片路径
    , mPressedImg(pressedImg) // 初始化按下状态图片路径
{
    mStat = NORMAL; // 设置按钮的初始状态为正常状态
}

// 动画下跳
void MyPushButton::moveDown()
{
    QPropertyAnimation *animation = new QPropertyAnimation(this, "geometry", this); // 创建动画对象,作用于按钮的几何属性
    animation->setStartValue(this->geometry()); // 设置动画起始位置为当前按钮位置
    animation->setEndValue(QRect(this->x(), this->y() + 10, this->width(), this->height())); // 设置动画结束位置为下移10像素后的按钮位置
    animation->setDuration(100); // 设置动画持续时间为100毫秒
    animation->start(QPropertyAnimation::DeleteWhenStopped); // 动画结束后自动删除
}

// 动画上跳
void MyPushButton::moveUp()
{
    QPropertyAnimation *animation = new QPropertyAnimation(this, "geometry", this); // 创建动画对象,作用于按钮的几何属性
    animation->setStartValue(this->geometry()); // 设置动画起始位置为当前按钮位置
    animation->setEndValue(QRect(this->x(), this->y() - 10, this->width(), this->height())); // 设置动画结束位置为上移10像素后的按钮位置
    animation->setDuration(100); // 设置动画持续时间为100毫秒
    animation->start(QPropertyAnimation::DeleteWhenStopped); // 动画结束后自动删除
}

void MyPushButton::paintEvent(QPaintEvent *event)
{
    // 绘制按钮图片
    QPainter painter(this); // 创建绘图对象
    QPixmap pix; // 创建 QPixmap 对象,用于加载图片
    if (mStat == NORMAL) // 判断当前状态是否为正常
        pix.load(mNormalImg); // 加载正常状态的图片
    if (mStat == PRESSED) // 判断当前状态是否为按下
        pix.load(mPressedImg); // 加载按下状态的图片
    painter.drawPixmap(0, 0, this->width(), this->height(), pix); // 绘制图片
    painter.drawText(0, 0, this->width(), this->height(), // 绘制文本
                     Qt::AlignCenter | Qt::AlignVCenter, // 文本居中对齐
                     this->text()); // 绘制按钮上的文本
}

void MyPushButton::mousePressEvent(QMouseEvent *e)
{
    this->mStat = PRESSED; // 设置按钮状态为按下
    update(); // 触发重绘事件以更新按钮外观
    QPushButton::mousePressEvent(e); // 调用基类的鼠标按下事件处理函数
}

void MyPushButton::mouseReleaseEvent(QMouseEvent *e)
{
    this->mStat = NORMAL; // 设置按钮状态为正常
    update(); // 触发重绘事件以更新按钮外观
    QPushButton::mouseReleaseEvent(e); // 调用基类的鼠标释放事件处理函数
}

 coinbutton.h

 

#ifndef COINBUTTON_H // 如果没有定义 COINBUTTON_H,则继续编译
#define COINBUTTON_H // 定义 COINBUTTON_H,防止重复包含

#include <QWidget> // 引入 QWidget 基类
#include <QPushButton> // 引入 QPushButton 类
#include <QTimer> // 引入 QTimer 类

class CoinButton : public QPushButton // 定义 CoinButton 类,继承自 QPushButton
{
    Q_OBJECT // 使用 Qt 的信号和槽机制

public:
    explicit CoinButton(QWidget *parent = nullptr); // 构造函数,接收父窗口指针

    int getMstat() const; // 获取当前状态
    void setMstat(int newMstat); // 设置新的状态

    void flip(); // 执行翻转动画
    void setStatWithAnimation(int stat); // 设置状态并启动动画

protected:
    void paintEvent(QPaintEvent *event); // 重写绘制事件函数

private:
    int mstat; // 当前状态
    int mframe; // 当前帧数
    QTimer mtimer; // 定时器,用于控制动画帧更新

signals:
};

#endif // COINBUTTON_H // 结束条件编译指令

coinbutton.cpp

#include "coinbutton.h" // 引入自定义 CoinButton 类的头文件
#include <QPainter> // 引入 QPainter 头文件,用于绘图

// 构造函数,初始化 CoinButton 对象
CoinButton::CoinButton(QWidget *parent)
    : QPushButton{parent} // 调用基类 QPushButton 的构造函数
{
    this->setMstat(0); // 设置初始状态为银币
    this->setStyleSheet("QPushButton{border:0px;}"); // 设置按钮样式,去掉边框

    // 连接定时器超时信号到 lambda 函数,用于处理币翻转动画
    connect(&this->mtimer, &QTimer::timeout, [=]() {
        if (this->mstat) // 判断当前状态
            this->mframe--; // 状态为 1 时,银币转金币帧数减少
        else
            this->mframe++; // 状态为 0 时,金币转银币帧数增加

        // 根据当前帧数生成图片路径
        QString frameName = QString(":/image/Coin000%1.png").arg(this->mframe);
        this->setIcon(QIcon(frameName));

        // 如果帧数达到结束帧,即币翻转动画结束,停止定时器
        if (this->mframe == 8 || this->mframe == 1)
        {
            this->mtimer.stop();
        }
    });
}

// 获取当前状态
int CoinButton::getMstat() const
{
    return mstat; // 返回状态
}

// 设置新的状态
void CoinButton::setMstat(int newMstat)
{
    mstat = newMstat; // 更新状态
    // 根据状态设置按钮图标
    if (this->mstat)
        this->setIcon(QIcon(":/image/Coin0001.png")); // 状态为 1 时,显示第 1 帧,为金币
    else
        this->setIcon(QIcon(":/image/Coin0008.png")); // 状态为 0 时,显示第 8 帧,为银币
    this->setIconSize(this->size()); // 设置图标大小为按钮的大小
}

// 执行翻转动画
void CoinButton::flip()
{
    this->setStatWithAnimation(!this->mstat); // 切换状态并启动动画
}

// 设置状态并启动动画
void CoinButton::setStatWithAnimation(int stat)
{
    this->mstat = stat; // 更新状态
    // 根据新的状态设置初始帧数
    if (this->mstat)
        this->mframe = 8; // 状态为 1 时,从第 8 帧开始,银转金
    else
        this->mframe = 1; // 状态为 0 时,从第 1 帧开始,金转银
    this->mtimer.start(30); // 启动定时器,设置帧更新间隔为 30 毫秒
}

// 绘制事件,重写 QPushButton 的 paintEvent
void CoinButton::paintEvent(QPaintEvent *event)
{
    // 绘制背景图片
    QPainter painter(this); // 创建绘图对象
    QPixmap pix(":/image/BoardNode.png"); // 加载背景图片
    // 指定背景图宽度和高度为按钮的宽度和高度
    painter.drawPixmap(0, 0, this->width(), this->height(), pix);
    QPushButton::paintEvent(event); // 调用基类的绘制事件函数
}

dataconfig.h

#ifndef DATACONFIG_H
#define DATACONFIG_H

#include <QObject>
#include <QMap>
#include <QVector>

class dataConfig : public QObject
{
    Q_OBJECT
public:
    explicit dataConfig(QObject *parent = 0);

public:

    QMap<int, QVector< QVector<int> > >mData;



signals:

public slots:
};

#endif // DATACONFIG_H

dataconfig.cpp

#include "dataconfig.h"
#include <QDebug>
dataConfig::dataConfig(QObject *parent) : QObject(parent)
{

     int array1[4][4] = {{1, 1, 1, 1},
                        {1, 1, 0, 1},
                        {1, 0, 0, 0},
                        {1, 1, 0, 1} } ;

     QVector< QVector<int>> v;
     for(int i = 0 ; i < 4;i++)
     {
         QVector<int>v1;
         for(int j = 0 ; j < 4;j++)
         {

            v1.push_back(array1[i][j]);
         }
         v.push_back(v1);
     }

     mData.insert(1,v);


     int array2[4][4] = { {1, 0, 1, 1},
                          {0, 0, 1, 1},
                          {1, 1, 0, 0},
                          {1, 1, 0, 1}} ;

     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array2[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(2,v);



     int array3[4][4] = {  {0, 0, 0, 0},
                           {0, 1, 1, 0},
                           {0, 1, 1, 0},
                           {0, 0, 0, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array3[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(3,v);


     int array4[4][4] = {   {0, 1, 1, 1},
                            {1, 0, 0, 1},
                            {1, 0, 1, 1},
                            {1, 1, 1, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array4[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(4,v);


     int array5[4][4] = {  {1, 0, 0, 1},
                           {0, 0, 0, 0},
                           {0, 0, 0, 0},
                           {1, 0, 0, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array5[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(5,v);


     int array6[4][4] = {   {1, 0, 0, 1},
                            {0, 1, 1, 0},
                            {0, 1, 1, 0},
                            {1, 0, 0, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array6[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(6,v);


     int array7[4][4] = {   {0, 1, 1, 1},
                            {1, 0, 1, 1},
                            {1, 1, 0, 1},
                            {1, 1, 1, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array7[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(7,v);

     int array8[4][4] = {  {0, 1, 0, 1},
                           {1, 0, 0, 0},
                           {0, 0, 0, 1},
                           {1, 0, 1, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array8[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(8,v);

     int array9[4][4] = {   {1, 0, 1, 0},
                            {1, 0, 1, 0},
                            {0, 0, 1, 0},
                            {1, 0, 0, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array9[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(9,v);



     int array10[4][4] = {  {1, 0, 1, 1},
                            {1, 1, 0, 0},
                            {0, 0, 1, 1},
                            {1, 1, 0, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array10[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(10,v);


     int array11[4][4] = {  {0, 1, 1, 0},
                            {1, 0, 0, 1},
                            {1, 0, 0, 1},
                            {0, 1, 1, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array11[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(11,v);

     int array12[4][4] = {  {0, 1, 1, 0},
                            {0, 0, 0, 0},
                            {1, 1, 1, 1},
                            {0, 0, 0, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array12[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(12,v);


     int array13[4][4] = {    {0, 1, 1, 0},
                              {0, 0, 0, 0},
                              {0, 0, 0, 0},
                              {0, 1, 1, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array13[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(13,v);

     int array14[4][4] = {    {1, 0, 1, 1},
                              {0, 1, 0, 1},
                              {1, 0, 1, 0},
                              {1, 1, 0, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array14[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(14,v);


     int array15[4][4] = {   {0, 1, 0, 1},
                             {1, 0, 0, 0},
                             {1, 0, 0, 0},
                             {0, 1, 0, 1}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array15[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(15,v);


     int array16[4][4] = {   {0, 1, 1, 0},
                             {1, 1, 1, 1},
                             {1, 1, 1, 1},
                             {0, 1, 1, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array16[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(16,v);

     int array17[4][4] = {  {0, 1, 1, 1},
                            {0, 1, 0, 0},
                            {0, 0, 1, 0},
                            {1, 1, 1, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array17[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(17,v);


     int array18[4][4] = { {0, 0, 0, 1},
                           {0, 0, 1, 0},
                           {0, 1, 0, 0},
                           {1, 0, 0, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array18[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(18,v);

     int array19[4][4] = {   {0, 1, 0, 0},
                             {0, 1, 1, 0},
                             {0, 0, 1, 1},
                             {0, 0, 0, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array19[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(19,v);

     int array20[4][4] = {  {0, 0, 0, 0},
                            {0, 0, 0, 0},
                            {0, 0, 0, 0},
                            {0, 0, 0, 0}} ;
     v.clear();
     for(int i = 0 ; i < 4;i++)
     {
          QVector<int>v1;
          for(int j = 0 ; j < 4;j++)
          {
             v1.push_back(array20[i][j]);
          }
          v.push_back(v1);
     }

     mData.insert(20,v);


     //测试数据
//    for( QMap<int, QVector< QVector<int> > >::iterator it = mData.begin();it != mData.end();it++ )
//    {
//         for(QVector< QVector<int> >::iterator it2 = (*it).begin(); it2!= (*it).end();it2++)
//         {
//            for(QVector<int>::iterator it3 = (*it2).begin(); it3 != (*it2).end(); it3++ )
//            {
//                qDebug() << *it3 ;
//            }
//         }
//         qDebug() << endl;
//    }


}

标签:QT,int,back,金币,++,小游戏,按钮,push,include
From: https://blog.csdn.net/2301_82087113/article/details/141188526

相关文章

  • 汉诺塔小游戏
    1publicclasshanoitower{2publicstaticvoidmain(String[]args){34Towertower=newTower();5tower.move(6,'A','B','C');678}9}1011classTower{12//方法13//num表示移......
  • Qt/C++地图坐标纠偏/地球坐标系/火星坐标系/百度坐标系/互相转换/离线函数
    一、前言说明为什么需要地球坐标纠偏这个功能,因为国家安全需要,不允许使用国际标准的地球坐标系,也并不是咱们这边这样,很多国家都是这样处理的,就是本国的地图经纬度坐标都是按照国家标准来的,所以就需要一个转换。国内主要有三种坐标系,国际标准用的地球坐标系WGS-84,国家标准用的火星......
  • 【Qt】QWidget的windowIcon属性
    QWidget的windowIcon属性windowIcon表示窗口的图标当我们使用默认的windowIcon的时候,其窗口的图标如下:API说明windowIcon()获取到控件的窗⼝图标.返回QIcon对象.setWindowIcon(constQIcon&icon)设置控件的窗⼝图标.在Qt中,Qt把涉及到的相关概念,都封装成了类,Q......
  • Qt Socket状态
    在Qt中,QTcpSocket类用于TCP网络编程,它提供了丰富的接口来管理TCP连接。要判断QTcpSocket的连接状态,可以使用state()方法,该方法返回一个QAbstractSocket::SocketState枚举值,表示当前的连接状态。以下是一些常见的连接状态及其对应的枚举值:QAbstractSocket::UnconnectedSta......
  • 按钮(Buttons)-Qt-思维导图-学习笔记
    按钮(Buttons)按钮在Qt中的重要性按钮是Qt中最常用的控件之一通过点击按钮,可以响应事件,实现人机交互效果按钮在嵌入式系统和PC端的界面交互中都是不可或缺的Qt内置的六种按钮部件QPushButton:下压按钮用法示例项目创建与设置项目名称:创建一个名为04_qp......
  • ptqt5 打包把资源文件合进exe文件中 单个exe文件即可
    目录安装PyInstaller项目结构编写spec文件修改代码以嵌入资源打包应用程序解释检查打包结果使用PyQt5开发的应用程序可以通过PyInstaller工具打包成单个可执行文件(exe),并将所有资源文件(如图像、图标、样式表等)嵌入到exe文件中。以下是如何实现这一目标的详......
  • 【python】pygame开发小游戏原来如此简单,掌握这几步就可以快速上手
    ✨✨欢迎大家来到景天科技苑✨✨......
  • QT多线程
    当处理复杂的数据时,此时耗时间,需要多任务处理就需要用到线程了qt中使用线程的方法,自定义一个类继承QThreadQThread类中有个虚函数 voidrun()才是线程中的处理函数我们需要重写该函数但启动线程不能直接调用run函数,需要通过线程类的start()函数来间接调用run函数......
  • windeployqt.exe的使用与避坑(windows平台)
    1.介绍windeployqt.exe是Qt自带的工具,用于创建应用程序发布包。简单来说,这个工具可以自动地将某程序依赖的库、资源拷贝到其所在目录,防止程序在其他电脑上运行报找不到库的错误。这里贴上官方文档:https://doc.qt.io/qt-5/windows-deployment.html本文适用于Windows+Visual......
  • Mqttnet实现的mqtt客户端
    usingSystem.Collections.Concurrent;usingSystem.Text;usingMQTTnet;usingMQTTnet.Client;usingMicrosoft.Extensions.Options;usingMicrosoft.Extensions.Logging;usingMQTTnet.Server;usingMicrosoft.Extensions.Hosting;usingSystem.Net.NetworkInformat......