Qt C++ 飞机大战

最新推荐文章于 2023-03-28 12:39:52 发布
最新推荐文章于 2023-03-28 12:39:52 发布
阅读量2.5k 收藏 55
点赞数 8
分类专栏： Qt 文章标签： 游戏 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuvolewalker/article/details/107416678
版权

飞机大战初步功能实现:

1.开始菜单界面(可更改地图)

2.游戏界面(移动飞机、发射子弹、击毁敌机、撞毁)

3.结束界面(可返回开始菜单)

功能截图如下:

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

程序代码如下:

项目工程组成

在这里插入图片描述

mainscene.h:
#ifndef MAINSCENE_H
#define MAINSCENE_H

#include <QWidget>
#include"config.h"
#include<QIcon>
#include<QTimer>
#include<QPaintEvent>
#include"map.h"
#include<QPainter>
#include"heroplane.h"
#include<QMouseEvent>
#include"bullet.h"
#include"enemyplane.h"
#include"bomb.h"
#include<QMessageBox>
#include<QMutex>  //暂停
#include<QThread>
#include"mythread.h"
#include"dickmenu.h"
#include<QDebug>

class mainScene : public QWidget
{
    Q_OBJECT

public:
    mainScene(QWidget *parent = nullptr);
    ~mainScene();
    void InitScene();

    QMutex m_mutex; //互斥量

    QTimer m_timer;

    bool StartPaintBullet=true; //是否绘制子弹 本机撞毁后
    bool StartCheckEnemy=true; //是否检测子弹与敌机碰撞 本机撞毁后

    //启动游戏
    void playGame();

    //更新游戏坐标
    void updatePosition();

    //绘制到屏幕中  函数名不可更改
    void paintEvent(QPaintEvent *);

    //地图对象
    map M_map;

    //飞机对象
    HeroPlane hero_plane;

    //重写鼠标移动事件  函数名不可更改
    void mouseMoveEvent(QMouseEvent *);

    //捕捉键盘事件
    //void keyPressEvent(QKeyEvent *event);

    //敌机出场
    void enemyToscreen();
    //敌机数组
    EnemyPlane m_enemyplanes[7];

    EnemyPlane m_enemies[ENEMY_NUM];
    int enemy_recorder;

    //碰撞检测
    void collisionDetection();

    //爆炸数组
    Bomb m_bombs[Bomb_NUM];

    MyThread *thread;


//    void Done();
signals:
    void ReturnMenu();

};
#endif // MAINSCENE_H
heroplane.h:
#ifndef HEROPLANE_H
#define HEROPLANE_H
#include<QPixmap>
#include<QRect>
#include"bullet.h"

class HeroPlane
{
public:
    HeroPlane();

    //发射子弹
    void shoot();

    //设置飞机位置
    void setPlanePosition(int x,int y);

    bool hero_free;


    //飞机资源 对象
    QPixmap m_Plane;

    //飞机坐标
    int plane_x;
    int plane_y;

    //飞机矩形边框
    QRect plane_rect;

    bullet m_bullets[bullet_num];//弹夹
    int m_recorder; //发射间隔记录
};

#endif // HEROPLANE_H
enemyplane.h:
#ifndef ENEMYPLANE_H
#define ENEMYPLANE_H
#include<QPixmap>
#include"config.h"
#include<QVector>

class EnemyPlane
{
public:
    EnemyPlane();

    //更新坐标
    void updateEnemyPosition();

    //敌机资源对象
    QPixmap m_enemy;

    //位置
    int enemy_x;
    int enemy_y;



    //敌机矩形边框
    QRect enemy_rect;

    //是否空闲
    bool enemy_free;

    //敌机速度
    int enemy_speed;


};

#endif // ENEMYPLANE_H
startgame.h:
#ifndef STARTGAME_H
#define STARTGAME_H
#include<QString>
#include <QDialog>
#include"mainscene.h"

namespace Ui {
class StartGame;
}

class StartGame : public QDialog
{
    Q_OBJECT

public:
    explicit StartGame(QWidget *parent = nullptr);
    ~StartGame();

    QString MapStyle=":/new/prefix1/res/img_bg_level_1.jpg";
    QString EnemyPlaneStyle=QString(":/new/prefix1/res/img-plane_%1.png").arg(rand()%10);

    void changeMap();


public slots:
    void on_pushButtonStart_clicked();

    void on_pushButtonStart_Design_clicked();

    void on_pushButtonStart_Exit_clicked();

    void on_pushButtonSureDeSign_clicked();
private slots:

private:
    Ui::StartGame *ui;
};

#endif // STARTGAME_H
bomb.h:
#ifndef BOMB_H
#define BOMB_H
#include<QVector>
#include<QPixmap>
#include"config.h"


class Bomb
{
public:
    Bomb();

    void updateInfo();//更新信息

    //放爆炸资源数组
    QVector<QPixmap>m_pixArr;

    //爆炸位置
    int Bomb_x;
    int Bomb_y;

    //爆炸状态
    bool Bomb_free;

    //爆炸时间间隔
    int Bomb_recorder;

    //爆炸时加载的图片下标
    int bombing_index;
};

#endif // BOMB_H
bullet.h:
#ifndef BULLET_H
#define BULLET_H
#include"config.h"
#include<QPixmap>


class bullet
{
public:
    bullet();

    //更新子弹坐标
    void updateBulletPosition();

    //子弹资源对象
    QPixmap m_bullet;
    //子弹坐标
    int bullet_x;
    int bullet_y;

    //子弹移动速度
    int bullet_speed;

    //子弹是否闲置
    bool bullet_free;

    //子弹矩形边框
    QRect bullet_rect;


};

#endif // BULLET_H
dickmenu.h:
#ifndef DICKMENU_H
#define DICKMENU_H
#include"startgame.h"
#include <QDialog>

namespace Ui {
class DickMenu;
}

class DickMenu : public QDialog
{
    Q_OBJECT

public:
    explicit DickMenu(QWidget *parent = nullptr);
    ~DickMenu();

public slots:
    void on_pushButton_clicked();

    void on_pushButton_2_clicked();

private:
    Ui::DickMenu *ui;

signals:
    void returnWindow();
};

#endif // DICKMENU_H
map:
#ifndef MAP_H
#define MAP_H
#include<QPixmap>
#include <QWidget>

class map
{
    //Q_OBJECT
public:
    map();

    //地图滚动坐标计算
    void mapPosition();

    //地图图片对象
    QPixmap m_map1;
    QPixmap m_map2;

    //地图Y轴坐标
    int m_map1_posY;
    int m_map2_posY;

    //地图滚动幅度
    int m_scroll_speed;

};

#endif // MAP_H
mythread.h:
#ifndef MYTHREAD_H
#define MYTHREAD_H
#include <QThread>

class MyThread : public QThread
{
    Q_OBJECT
public:
    explicit MyThread(QObject *parent = nullptr);
    void dicked();
protected:
    void run();

signals:
    void isDone();
};

#endif // MYTHREAD_H
config.h:
#ifndef CONFIG_H
#define CONFIG_H

//游戏数据
#define GAME_Width 512  //宽度
#define GAME_Heigth 768  //高度
#define GAME_Title "飞机大战" //窗口标题
#define GAME_ICON ":/new/prefix1/res/app.ico"

#define GAME_Rate 10  //定时器刷新间隔  毫秒

//地图配置数据
#define Map_Path  ":/new/prefix1/res/img_bg_level_2.jpg"  //地图背景图
#define Map_Scroll_Speed 2 //地图滚动速度


//飞机配置数据
#define Plane_Model ":/new/prefix1/res/hero.png"

//子弹数据
#define bullet_model ":/new/prefix1/res/bullet_11.png" //子弹模型
#define BULLET_SPEED 5  //子弹速度
#define bullet_num 30 //子弹数量
#define bullet_interval 20 //子弹发射间隔

//敌机数据
#define  enemyplane_model   ":/new/prefix1/res/img-plane_7.png"
#define ENEMY_SPEED 3
#define ENEMY_NUM 50
#define ENEMY_INTERVAL 30

//爆炸效果
#define Bomb_model ":/new/prefix1/res/bomb-%1.png"
#define Bomb_NUM 20 //爆炸数量
#define Bomb_max 7 //爆炸图片最大索引
#define Bomb_Interval 10//爆炸切图时间间隔

//#define BombHero  1000

//音效
#define Sound_backgroud "‪D:/qt/PlaneWar/res/bg.wav" //‪D:\qt\PlaneWar\res\bg.wav中斜杠反向
#define Sound_bomb "D:/qt/PlaneWar/res/bomb.wav"

#endif // CONFIG_H
mainscene.cpp:
#include "mainscene.h"
#include<ctime>
#include<QSound>
#include<QApplication>
mainScene::mainScene(QWidget *parent)
    : QWidget(parent)
{

    InitScene();//初始化

    playGame();//开始

//    DickMenu *dick;
//    dick=new DickMenu;
    thread=new MyThread();
    connect(thread,&MyThread::isDone,[=]()
    {
        this->close();
    });


}

mainScene::~mainScene()
{
}

void mainScene::InitScene()
{
    //设置窗口固定
    setFixedSize(GAME_Width,GAME_Heigth);
    //设置标题
    setWindowTitle(GAME_Title);
    //设置窗口图标
    setWindowIcon(QIcon(GAME_ICON));

    //定时器
    m_timer.setInterval(GAME_Rate);

    enemy_recorder=0;//敌机出场时间间隔记录

    //随机数种子
    srand((unsigned int)time(NULL));
}

void mainScene::playGame()
{
    m_timer.start(); //启动定时器

    //背景音乐
    QSound::play("D:/qt/PlaneWar/res/bg.wav");

    //监听定时器发出信号
    connect(&m_timer,&QTimer::timeout,[=](){
        //敌机出场
        enemyToscreen();
            //更新坐标
            updatePosition();
            //刷新绘制到屏幕中)
            update();
            //碰撞检测
            collisionDetection();
    });

//    connect(this,&mainScene::stoptime,this,&mainScene::Done);
}

void mainScene::updatePosition()
{
    //更新地图坐标
    M_map.mapPosition();

    //发射子弹
    hero_plane.shoot();

    //计算所有非空闲子弹坐标
    for(int i=0;i<bullet_num;i++)
    {
        //如果非空闲 计算发射位置
        if(hero_plane.m_bullets[i].bullet_free==false)
        {
            hero_plane.m_bullets[i].updateBulletPosition();
        }
    }

    //敌机
    for(int i=0;i<ENEMY_NUM;i++)
    {
        if(m_enemies[i].enemy_free==false)
        {
            m_enemies[i].updateEnemyPosition();
        }
    }

    //计算爆炸的播放图片
    for(int i=0;i<Bomb_NUM;i++)
    {
        if(m_bombs[i].Bomb_free==false)
        {
            m_bombs[i].updateInfo();
        }
    }
}

void mainScene::paintEvent(QPaintEvent *)
{
    QPainter painter(this);

    //绘制地图
    painter.drawPixmap(0,M_map.m_map1_posY,M_map.m_map1);
    painter.drawPixmap(0,M_map.m_map2_posY,M_map.m_map2);

    //绘制飞机
    if(hero_plane.hero_free==false)
    {
        painter.drawPixmap(hero_plane.plane_x,hero_plane.plane_y,hero_plane.m_Plane);
    }



    //绘制子弹
    if(StartPaintBullet==true)
    {
        for(int i=0;i<bullet_num;i++)
        {
            //如果非空闲 绘制
            if(hero_plane.m_bullets[i].bullet_free==false)
            {
                painter.drawPixmap(hero_plane.m_bullets[i].bullet_x,hero_plane.m_bullets[i].bullet_y,
                                   hero_plane.m_bullets[i].m_bullet);
            }
        }
    }



    //绘制敌机
    for(int i=0;i<ENEMY_NUM;i++)
    {
        //如果非空闲 绘制
        if(m_enemies[i].enemy_free==false)
        {
            painter.drawPixmap(m_enemies[i].enemy_x,
                               m_enemies[i].enemy_y,
                               m_enemies[i].m_enemy);
        }
    }

    //绘制爆炸
    for(int i=0;i<Bomb_NUM;i++)
    {
        if(m_bombs[i].Bomb_free==false)
        {
            painter.drawPixmap(m_bombs[i].Bomb_x,m_bombs[i].Bomb_y,
                               m_bombs[i].m_pixArr[m_bombs[i].bombing_index]);
        }
    }

}

void mainScene::mouseMoveEvent(QMouseEvent *event) //鼠标拖拽 飞机随之移动
{
    int x=event->x()-hero_plane.plane_rect.width()*0.5;
    int y=event->y()-hero_plane.plane_rect.height()*0.5;

    //边界检测
    if(x<=0)
    {
        x=0;
    }
    if(x>GAME_Width-hero_plane.plane_rect.width())
    {
        x=GAME_Width-hero_plane.plane_rect.width();
    }
    if(y<=0)
    {
        y=0;
    }
    if(y>=GAME_Heigth-hero_plane.plane_rect.height())
    {
        y=GAME_Heigth-hero_plane.plane_rect.height();
    }
    hero_plane.setPlanePosition(x,y);
}

void mainScene::enemyToscreen()   //敌机出场
{
    enemy_recorder++;
    if(enemy_recorder<ENEMY_INTERVAL)
    {
        return;
    }
    enemy_recorder=0;
    for(int i=0;i<ENEMY_NUM;i++)
    {
        if(m_enemies[i].enemy_free)
        {
            m_enemies[i].enemy_free=false;

            //坐标
            m_enemies[i].enemy_x=rand()%(GAME_Width-m_enemies[i].enemy_rect.width());
            m_enemies[i].enemy_y=-m_enemies[i].enemy_rect.height();
            break;
        }
    }
}

void mainScene::collisionDetection()
{
    //遍历所有非空闲的敌机
    for(int i=0;i<ENEMY_NUM;i++)
    {
        if(m_enemies[i].enemy_free)
        {
            continue;//空闲飞机 跳转到下一次循环
        }

        if(hero_plane.plane_rect.intersects(m_enemies[i].enemy_rect))//本方飞机爆炸
        {
            hero_plane.hero_free=true;
            StartPaintBullet=false;  //不绘制子弹
            StartCheckEnemy=false;  //不检测子弹与敌机碰撞
            hero_plane.plane_rect.setHeight(0);
            hero_plane.plane_rect.setWidth(0);
            for(int k=0;k<Bomb_NUM;k++)
            {
                if(m_bombs[k].Bomb_free)
                {
                    //QSound::play(Sound_bomb); //爆炸音效

                    //空闲的爆炸 可以播放爆炸了
                    m_bombs[k].Bomb_free=false;
                    //更新爆炸坐标
                    m_bombs[k].Bomb_x=hero_plane.plane_x;
                    m_bombs[k].Bomb_y=hero_plane.plane_y;

                    //emit stoptime();
                    break;
                }
            }
            thread->start();

        }


        if(StartCheckEnemy==true)
        {
            for(int j=0;j<bullet_num;j++) //遍历子弹
            {
                if(hero_plane.m_bullets[j].bullet_free)
                {
                    continue;
                }

                //如果子弹框和敌机框相交
                if(m_enemies[i].enemy_rect.intersects(hero_plane.m_bullets[j].bullet_rect))
                {
                    m_enemies[i].enemy_free=true;
                    hero_plane.m_bullets[j].bullet_free=true;

                    //爆炸效果播放
                    for(int k=0;k<Bomb_NUM;k++)
                    {
                        if(m_bombs[k].Bomb_free)
                        {
                            //QSound::play(Sound_bomb); //爆炸音效

                            //空闲的爆炸 可以播放爆炸了
                            m_bombs[k].Bomb_free=false;
                            //更新爆炸坐标
                            m_bombs[k].Bomb_x=m_enemies[i].enemy_x;
                            m_bombs[k].Bomb_y=m_enemies[i].enemy_y;
                            break;
                        }
                    }
                }
            }
        }
    }
}

//void mainScene::Done()
//{
//    QMessageBox::information(this,"defeat","游戏失败");
//    exit(0);
//}


//void mainScene::keyPressEvent(QKeyEvent *event)
//{
//    setFocusPolicy(Qt::StrongFocus);
//    installEventFilter(this);


//    if(event->type()==QEvent::KeyPress)
//    {
//        QKeyEvent *keyEvent=static_cast<QKeyEvent*>(event);
//        if(keyEvent->key()==Qt::Key_Space)
//        {
//            qDebug()<<1;
//            this->m_mutex.lock();
//            return;
//        }
//        if(keyEvent->key()==Qt::Key_0)
//        {
//            qDebug()<<0;
//            this->m_mutex.unlock();
//            return;
//        }
//    }
//}
heroplane.cpp:
#include "heroplane.h"
#include"config.h"
#include"map.h"

HeroPlane::HeroPlane()
{
    m_Plane.load(Plane_Model);//设置飞机模型

    //初始化飞机坐标
    plane_x=(GAME_Width-m_Plane.width())*0.5;
    plane_y=GAME_Heigth-m_Plane.height();

    //初始化矩形边框
    plane_rect.setWidth(m_Plane.width());
    plane_rect.setHeight(m_Plane.height());

    plane_rect.moveTo(plane_x,plane_y);

    hero_free=false;

    m_recorder=0;
}

void HeroPlane::shoot()
{
    //累加时间间隔记录变量
    m_recorder++;
    //如果记录的数字未达到子弹发射的间隔
    if(m_recorder<bullet_interval)
    {
        return;//不发射
    }
    m_recorder=0;
    //发射子弹
    for(int i=0;i<bullet_num;i++)
    {
        //如果子弹空闲 则发射
        if(m_bullets[i].bullet_free)
        {
            //将空闲状态改为假
            m_bullets[i].bullet_free=false;
            //设置子弹坐标
            m_bullets[i].bullet_x=plane_x+plane_rect.width()*0.5-10;
            m_bullets[i].bullet_y=plane_y-25;
            break;
        }
    }
}

void HeroPlane::setPlanePosition(int x, int y)
{
    plane_x=x;
    plane_y=y;
    plane_rect.moveTo(plane_x,plane_y);
}
enemyplane.cpp:
#include "enemyplane.h"
#include"startgame.h"
#include<QDebug>
EnemyPlane::EnemyPlane()
{
    StartGame *str;
    str=new StartGame();
    m_enemy.load(str->EnemyPlaneStyle);
    //m_enemy.load(enemyplane_model);


    //敌机位置
    enemy_x=0;
    enemy_y=0;

    //敌机状态
    enemy_free=true;

    //敌机速度
    enemy_speed=ENEMY_SPEED;

    //敌机矩形
    enemy_rect.setWidth(m_enemy.width());
    enemy_rect.setHeight(m_enemy.height());
    enemy_rect.moveTo(enemy_x,enemy_y);
}

void EnemyPlane::updateEnemyPosition()
{
    //空闲敌机 不计算坐标
    if(enemy_free)
    {
        return;
    }
    enemy_y+=enemy_speed;
    enemy_rect.moveTo(enemy_x,enemy_y);

    //如果超出屏幕
    if(enemy_y>GAME_Heigth)
    {
        enemy_free=true;
    }
}
startgame.cpp:
#include "startgame.h"
#include "ui_startgame.h"
#include"QDebug"

static int  Map=1;  //静态全局变量 程序退出前一直保持最新值

StartGame::StartGame(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::StartGame)
{
    ui->setupUi(this);
    this->setWindowTitle("飞机大战");
    //ui->pushButtonStart->setStyleSheet("font-size:15px;color:rgb(0,255,0,255)");

    ui->stackedWidget->setCurrentWidget(ui->pageStart);
    ui->spinBox->setMaximum(5);
    ui->spinBox->setValue(5);


//    mainScene *m;

//    //m=new mainScene();

//    connect(m,&mainScene::ReturnMenu,[=]()
//    {
//        this->show();
//        m->close();
//    });
}

StartGame::~StartGame()
{
    delete ui;

}

void StartGame::on_pushButtonStart_clicked()
{
    this->close();
    mainScene *m;
    m=new mainScene();
    m->show();
}



    // 下列方法会导致窗口一闪而过mainScene创建在stack上，生命期是大括号内
    //    mainScene *m;
    //  m=new mainScene();
    // mainScene 通过new创建在heap上， 在程序退出时才会被析构

//    this->hide();
//    mainScene m;
//    m->show();

void StartGame::on_pushButtonStart_Design_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->page_2);
}

void StartGame::on_pushButtonStart_Exit_clicked()
{
    exit(0);
}

void StartGame::on_pushButtonSureDeSign_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->pageStart);
    Map=ui->spinBox->text().toInt();   //Map的值为spinBox的当前值并保持不变直到下次在此页面修改spinBox的值并确定

    //MapStyle=QString(":/new/prefix1/res/img_bg_level_%1.jpg").arg(Map);
}

void StartGame::changeMap()
{
    MapStyle=QString(":/new/prefix1/res/img_bg_level_%1.jpg").arg(Map);
}
bomb.cpp:
#include "bomb.h"
#include<QDebug>
Bomb::Bomb()
{
    //将所有爆炸pixmap放入数组中
    for(int i=1;i<=Bomb_max;i++)
    {
        QString str=QString(Bomb_model).arg(i);
        m_pixArr.push_back(QPixmap(str));
    }

    //坐标
    Bomb_x=0;
    Bomb_y=0;

    Bomb_free=true;
    bombing_index=0;
    Bomb_recorder=0;
}

void Bomb::updateInfo()
{
    //空闲状态下的爆炸效果直接return
    if(Bomb_free)
    {
        return;
    }
    Bomb_recorder++;
    if(Bomb_recorder<Bomb_Interval)
    {
        return;
    }
    Bomb_recorder=0;

    bombing_index++;//切换爆炸显示图片下标
    if(bombing_index>Bomb_max-1)//数组下标从0开始计算
    {
        bombing_index=0;
        Bomb_free=true;
    }
}
bullet.cpp:
#include "bullet.h"
#include<QDebug>

bullet::bullet()
{
    //加载资源
    m_bullet.load(bullet_model);

    //子弹坐标
    bullet_x=(GAME_Width-m_bullet.width())*0.5;
    bullet_y=GAME_Heigth;

    //子弹状态
    bullet_free=true;
    //子弹速度
    bullet_speed=BULLET_SPEED;
    //子弹矩形边框
    bullet_rect.setWidth(m_bullet.width());
    bullet_rect.setHeight(m_bullet.height());
    bullet_rect.moveTo(bullet_x,bullet_y);
}

void bullet::updateBulletPosition()
{
    //空闲状态下的子弹无需计算坐标
    if(bullet_free)
    {
        return;
    }
    bullet_y-=bullet_speed;//子弹向上移动
    bullet_rect.moveTo(bullet_x,bullet_y);

    if(bullet_y<=0)//子弹位置超出屏幕状态为为空闲
    {
        bullet_free=true;
    }
}
dickmenu.cpp:
#include "dickmenu.h"
#include "ui_dickmenu.h"
#include<QDebug>

DickMenu::DickMenu(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DickMenu)
{
    ui->setupUi(this);
    this->setWindowTitle("游戏失败");
}

DickMenu::~DickMenu()
{
    delete ui;
}

void DickMenu::on_pushButton_clicked()
{
    StartGame *st;
    st=new StartGame();
    st->show();
    this->close();
    emit returnWindow();
}

void DickMenu::on_pushButton_2_clicked()
{
    exit(0);
}
map.cpp:
#include "map.h"
#include"config.h"
#include"startgame.h"
#include<QDebug>
map::map()
{
    //初始化加载地图对象
    StartGame *str;
    str=new StartGame();
    str->changeMap();
    m_map1.load(str->MapStyle);
    m_map2.load(str->MapStyle);


//    m_map1.load(Map_Path);
//    m_map2.load(Map_Path);

    //初始化Y轴坐标
    m_map1_posY=-GAME_Heigth;
    m_map2_posY=0;

    //地图滚动速度
    m_scroll_speed=Map_Scroll_Speed;
}


void map::mapPosition()
{
    //处理第一张图片滚动位置
    m_map1_posY+=m_scroll_speed;
    if(m_map1_posY>=0)
    {
        m_map1_posY=-GAME_Heigth;
    }
    //处理第二张图片滚动位置
    m_map2_posY+=m_scroll_speed;
    if(m_map2_posY>=GAME_Heigth)
    {
        m_map2_posY=0;
    }
}
mythread.cpp:
#include "mythread.h"
#include"QMessageBox"
#include"dickmenu.h"

MyThread::MyThread(QObject *parent) : QThread(parent)
{
    connect(this,&MyThread::isDone,this,&MyThread::dicked);
}

void MyThread::run()
{
    sleep(2);
    emit isDone();
}

void MyThread::dicked()
{
    DickMenu *dick;
    dick=new DickMenu;
    dick->show();
}
main.cpp:
#include "mainscene.h"
#include <QApplication>
#include"startgame.h"
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    StartGame st;
    st.show();
    return a.exec();
}
天近遥
关注
  • 8
    点赞
  • 踩
  • 55
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
c++实现简单制作飞机大战
Gaily810的博客
02-23 755
结构体，循环，函数，随机数，数组，数据读取。
VS/Qt C++ 入门项目飞机大战（内含全部源代码，素材，项目工程，项目祥解）可直接运行
weixin_42783098的博客
03-26 3811
说在前面 最近做了个qt/c++的小项目飞机大战，主要是边玩边做，主要讲解一下设计思路，各个模块的实现原理，非常适合初学者拿来练手。需要源码、素材、项目详解、打包软件等整个项目用到的全部内容，可以加我wx公众号：酷玩软件乐园，后台回复：飞机大战，即可获取全部资源。话不多说一起来看看吧。 项目目录 1 项目简介 2 创建项目 3 设置主场景 4 资源导入 5 地图滚动 6 英雄飞机 7 子弹制作 8...
好玩的飞机大战（C++版本）
07-02
这是一个有着详细注释的C++版本的飞机大战代码，写的很全面很完整。
基于Qt的飞机大战.7z
08-18
包括可在Qt运行的全部源代码，可执行文件，以及一份实践报告 此外，里面还包括很多素材，可自行添加或替换
Qt飞机大战小游戏源代码
03-05
这是Qt c++实现的飞机大战小游戏的源代码，QT5可以打开，运行效果：https://blog.csdn.net/qq_37629746/article/details/88193008。
Qt游戏编程——飞机大战
07-06
游戏模板，大家可以随意添加自己的元素
本科毕设项目：基于C++和Qt的飞机大战游戏.zip
最新发布
10-24
matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab
飞机大战——QT5.9.8制作
07-13
使用QT5.9.8制作的小游戏，源代码中有详细的注释，目前没发现有什么bug，如果发现了bug我们可以一起讨论
QT阶段项目——飞机大战1.0
qq_52996157的博客
08-06 1359
qt小项目，资源来源于网络
QT实现飞机大战
muLanlh的博客
07-28 1971
在mainscene.h中添加新的成员函数initScene用来初始化游戏场景实现如下地图滚动实际上是两张图片同时向下移动，当两张图片移动到一定的位置再还原，在继续滚动，地图向下滚动，x坐标不变，y坐标改变，地图滚动有相应的速度与函数，定义如下在配置文件中添加地图图片及地图滚动速度在构造函数中初始化成员变量，函数实现在MainScene.h中，创建地图对象，并重写绘图事件绘制地图，在paintEvent中创建画笔，并进行两张地图图片的绘制绘制效果如图。...
Qt项目——飞机大战
razliutos_的博客
08-10 1754
Qt飞机大战
Qt飞机大战小游戏
03-05
这是Qt c++实现的飞机大战小游戏运行的安装文件，并非源代码文件，源代码文件https://download.csdn.net/download/qq_37629746/10998136。
Qt飞机大战
08-07
使用QT写的微信飞机大战，仅供Qt和C++爱好者学习借鉴
C++ QT大作业：飞机大战升级版
fzy2003的博客
05-06 2857
下面将由我来向大家介绍我本学期C++大作业飞机大战的具体内容： 首先，我向大家介绍一下游戏的玩法。点击开始游戏，我们可以通过移动鼠标来操控英雄飞机击杀敌机。击杀敌机后金币数量增加，当英雄战机与敌机碰撞后生命值会减少，生命值小于0时游戏结束。 然后，在击杀一定数量的敌机后，英雄战机触发武器升级，在这里我设置了两次升级：第一次为开启英雄战机的副弹夹； 第二次为增加战机子弹的射速。 在游戏进行的过程中，战机会随机进入流星雨副本，在通过流星雨副本后，英雄战机会被赋予一层保护罩。这个保护罩的功能就是在英雄战机遇
QT练手小项目：飞机大战
m0_70983574的博客
08-06 4627
飞机大战项目实操
Qt实战——飞机大战1.0（全注释）
默示MoS的博客
03-28 1146
鼠标拖拽移动战机，敌方战机随机刷新，具有背景音效和敌人击杀音效，同时具有击败敌机的爆炸特效需要图片等资源的可以留下联系方式，我发给你注意：Qt会由于资源文件太大无法解析而报错，需要改用导入rcc文件解决，解决方法在我另一篇文章中有写Qt报错之OutOfMemoryAllocating。
[原创]基于C++/Qt的附带图形界面的飞机大战小游戏
qq_61798125的博客
07-14 1636
基于C++/Qt的附带图形界面的飞机大战小游戏，使用paintEvent函数和timerEvent函数轻松实现简单的飞机大战
逐步实现一个简易的飞机大战（c++）
小小城序员的博客
06-24 3921
用easy图形库做一个简单的c++小游戏—简单版飞机大战 某大一学生，无奈在家上网课，慌得无聊。无意间认识了easyx图形库，便有了新的想法，搞一个飞机大战。当时每天写一点，日积月累，也就完成了。 以下为某大一学生，学习了半年c++以及一些课外知识所实现的:（其实课上学不了多少东西，很多知识都要课外自学的） 开发环境：visual c++6.0 库：easyx图形库 下载地址>>> (https://easyx.cn/downloads/) 我当初分成6步实现（瞎设计的，其实就是想到啥写啥
Qt之飞机大战
qq_43702629的博客
07-09 1925
由于一个小比赛，写了一个c++的飞机大战，不过个人感觉不太满意 第一是对于Qt的学习还很初步，第二个对于c++的继承的思想没有很好的 理解，第三点便是命名规范不太好。 所以这次的程序仅供参考。 代码如下 工程文件 #------------------------------------------------- # # Project created by QtCreator 20...
c++飞机大战的开发环境
06-02
C++ 飞机大战的开发环境包括以下几个方面： 1. 操作系统：可以是 Windows、Linux、macOS 等常见的操作系统。 2. 开发工具：如前面所述，可以选择 Visual Studio、Code::Blocks、Qt Creator、Eclipse 等 C++ 开发工具。 3. 编译器：C++ 飞机大战需要使用 C++ 编译器进行编译，常用的编译器有 GCC、G++、Clang 等。 4. 图形库：C++ 飞机大战需要使用图形库来绘制游戏界面，常用的有 DirectX、OpenGL、SFML 等。 5. 版本控制工具：如 Git、SVN 等，用于管理程序代码的版本和变更记录。 6. 其他工具：如文本编辑器、图形编辑器、调试器等，可以根据需要进行选择和配置。 以上是 C++ 飞机大战的开发环境，不同的项目需求可能会有所不同，可以根据实际情况进行选择和配置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值