QT笔记

经过漫长的假期，开学了。第二周实训QT。

首先是介绍，什么是QT。

QT：是一个跨平台C++图形用户界面应用程序开发框架。可以开发GUI程序，非GUI程序。

实训主要是写一个俄罗斯方块。未学过C++,前两天先介绍QT的基本使用，后两天老师带着敲俄罗斯方块代码，第四天直接根据给好的代码修改，实现给定的功能。

习题:

 1) 给游戏添加得分功能，消掉一行就得 100分

 2) 给游戏添加暂停，继续功能;

 3) 给游戏添加显示下一个方块组的功能

 4) 给游戏增加等级功能

 5) 发现重大BUG并解决掉，也给加分

 6) 自己增加其他特色功能，也给加分

完成功能1，2，4。

附上代码。

grpbox.h

#ifndef GRPBOX_H
#define GRPBOX_H

#include <QObject>
#include <QVector>
#include <QPoint>

#include <QPainter>

#define  COL_NUM        15   //列数，X方向方块的个数
#define  ROW_NUM        25   //行数，Y方向方块的个数
#define  BOX_WIDTH      20   //方块的宽度

#define  AREA_WIDTH    (COL_NUM*BOX_WIDTH) //定义游戏区域的宽度
#define  AREA_HEIGHT   (ROW_NUM*BOX_WIDTH) //定义游戏区域的高度

//定义方块组的类型
enum ITEM_TYPE
{
    ITEM_1 = 0,		//长条
    ITEM_2,			//山字形
    ITEM_3,			//手枪形1
    ITEM_4,			//手枪形2
    ITEM_5,			//田
    ITEM_6,			//Z字形1
    ITEM_MAX,
};


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

    ~GrpBox();  //声明析构函数

    //在当前位置绘制方块组
    void DrawBoxGrp(QPainter& painter);
    void InitBoxGrp(ITEM_TYPE item, int style);

    //申明移动方块组的函数
    void MoveLeft(void);
    void MoveRight(void);
    void MoveDown(void);

    void CancelMoveDown(void); //取消方块组下移

    //改变方块组的形状
    void ChangeShape(void);

    //判断方块组是否左右越界
    bool HitSide(void);

    //判断方块组是否到达游戏底部
    bool HitBottom(void);

    //判断方块组是否碰到游戏区域的顶部
    bool HitTop(void);



public:
    QVector<QPoint>  mPoints;  //方块组包含的方块的坐标
    QPoint mCurPos;   //当前方块组位置，单位小方块个数

    ITEM_TYPE  mType; //保存方块组的类型
    int mCurStyle;    //保存方块组的样式,旋转角度 0 ~ 3

private:
    //声明创建不同类型的方块组的函数，nStyle 表示方块组的旋转角度
    void SetupItem1(int nStyle);  //长条型
    void SetupItem2(int nStyle);  //山字形
    void SetupItem3(int nStyle);  //手枪形1
    void SetupItem4(int nStyle);  //手枪形2
    void SetupItem5(int nStyle);  //田
    void SetupItem6(int nStyle);  //Z字形1


signals:

public slots:


};

#endif // GRPBOX_H

russboxwigdet.h

#ifndef RUSSBOXWIGDET_H
#define RUSSBOXWIGDET_H

#include <QWidget>

#include "grpbox.h"

#include <QVector>
#include <QPoint>

#include <QTimer>


#define  COL_NUM        15   //列数，X方向方块的个数
#define  ROW_NUM        25   //行数，Y方向方块的个数
#define  BOX_WIDTH      20   //方块的宽度

#define  AREA_WIDTH    (COL_NUM*BOX_WIDTH) //定义游戏区域的宽度
#define  AREA_HEIGHT   (ROW_NUM*BOX_WIDTH) //定义游戏区域的高度



namespace Ui {
class RussBoxWigdet;
}

class RussBoxWigdet : public QWidget
{
    Q_OBJECT

public:
    explicit RussBoxWigdet(QWidget *parent = 0);
    ~RussBoxWigdet();

    //绘制游戏区域
    void DrawGameArea(void);
    void CreateGrpBox(void);  //随机创建一个方块组

    void DrawGameGrpBox(void); //绘制当前方块组

    //将当前方块组添加到背景图案
    void AddCurGrpBack(void);
    void DrawGameBack(void); //绘制游戏背景图案

    //判断当前方块组的方块是否与背景图案重叠,如果重叠返回真，否则返回假
    bool CurBoxCoverBack(void);

    //判断是否满行，如果满行，就返回真，否则返回假 nRow为行号
    bool IsFullLine(int nRow);

    //消除满行的功能
    void DelFullLine(void);

    //删除背景图案中指定的行
    void DeleteLine(int nRow);

    //方块组下移处理
    void GrpMoveDownProcess(void);

    //下一组
    void DrawNextGrp(void);

    //比较成绩显示等级

    void ScoreCompare(void);


public slots:
    void BtnStartSlot(void); //声明开始游戏槽函数
    void RunTimeoutSlot(void); //定时器超时槽函数
    void StopSlot(void);//声明暂停游戏槽函数

private:
    Ui::RussBoxWigdet *ui;

    QTimer *pRunTimer;

    QVector<QPoint>  mBackPoints;  //保存游戏过程中的方块背景

    GrpBox *pCurGrpBox;  //指向当前方块组

    QPixmap *pAreaPixmap;  //保存游戏区域的图片
    QPixmap *pAreaPixmap1;//下一个

protected:
    //重新实现按键事件处理函数
    void keyPressEvent(QKeyEvent *e);
    long score;
    bool Pause;

};

#endif // RUSSBOXWIGDET_H

grpbox.cpp

#include "grpbox.h"

GrpBox::GrpBox(QObject *parent) : QObject(parent)
{

    //初始化方块组的起始位置为0
    mCurPos.setX(0);
    mCurPos.setY(0);
}

GrpBox::~GrpBox()
{

}

//判断当前方块组是超越 左右边界 如果是返回 true,否则返回false
bool GrpBox::HitSide(void)
{
    for (int i = 0; i<mPoints.size(); i++)
    {
        QPoint pt = mPoints[i] + mCurPos ;

        if (pt.x() < 0 || pt.x() > COL_NUM - 1)
        {
            return true;
        }
    }
    return false;
}

//判断当前方块组是否移动到底部，如果是否返回true,否则返回false
bool GrpBox::HitBottom(void)
{
    for (int i = 0; i<mPoints.size(); i++)
    {
        QPoint pt = mPoints[i] + mCurPos;
        if (pt.y() > ROW_NUM - 1)  //到达真正游戏区域底部
        {
            return true;
        }

    }
    return false;
}

//判断方块组是否碰到游戏区域顶部，是就反回true,否则返回false
bool GrpBox::HitTop(void)
{
    for (int i = 0; i<mPoints.size(); i++)
    {
        QPoint pt = mPoints[i] + mCurPos;
        if (pt.y() < 1)  //到达真正游戏区顶部
        {
            return true;
        }

    }
    return false;
}



//方块组左移动
void GrpBox::MoveLeft(void)
{
    mCurPos.setX(mCurPos.x() -1);
    if(HitSide())
    {
        //越界，移回去
        mCurPos.setX(mCurPos.x() +1);
    }
}

//方块组右移动
void GrpBox::MoveRight(void)
{
    mCurPos.setX(mCurPos.x() +1);
    if(HitSide())
    {
        //越界，移回去
        mCurPos.setX(mCurPos.x() -1);
    }
}


//方块组下移动
void GrpBox::MoveDown(void)
{
    mCurPos.setY(mCurPos.y() +1);
   /* if(HitBottom())
    {
        //向下移动越界
        mCurPos.setY(mCurPos.y() -1);
    }*/
}

// 取消方块组下移
void GrpBox::CancelMoveDown(void)
{
     mCurPos.setY(mCurPos.y() -1);
}

//改变方块组的旋转角度
void GrpBox::ChangeShape(void)
{
    int Stylex = mCurStyle;  //备份改变之前的形状

    mCurStyle = (mCurStyle+1)%4;
    InitBoxGrp(mType, mCurStyle);

    if(HitSide() || HitBottom())
    {
        //变形之后发生了越界,恢复变形之前的形状
        mCurStyle = Stylex;
        InitBoxGrp(mType, mCurStyle);
    }

}

/*
 * 根据方块组的形状和样式，创建方块组
 *
 * */

void GrpBox::InitBoxGrp(ITEM_TYPE item, int style)
{
    mCurStyle = style;
    mType = item;

    mPoints.clear();  //清除方块组的所有方块

    switch(item)
    {
         case ITEM_1: //初始化长条型方块组
            style = style%2;
            SetupItem1(style);
            break;
         case ITEM_2: //初始化山字型方块组
            SetupItem2(style);
            break;

         case ITEM_3: //初始化手枪1型方块组
            SetupItem3(style);
            break;

         case ITEM_4: //初始化手枪2型方块组
            SetupItem4(style);
            break;

         case ITEM_5: //初始化田字型方块组
           SetupItem5(style);
           break;

         case ITEM_6: //初始化Z字型方块组
           SetupItem6(style);
           break;

        default:
            break;

    }
}


/*
 * 所谓的创建方块组的形状，本质就是确定组成方块组的4个小方块的位置(坐标)
 * 也就是 往 mPoints 添加组成方块组小方块的位置
*/

/*
 创建长条型方块组  nStyle 0 -->水平长条
                       1 -->垂直长条

*/
void GrpBox::SetupItem1(int nStyle)
{
    if(nStyle == 0)
    {
        //创建水平型 长条方块组
        for(int i = 0; i < 4; i++)
        {
           mPoints.append(QPoint(i,1));
        }
    }
    else if(nStyle == 1)
    {
        //创建垂直型 长条方块组
        for(int i = 0; i < 4; i++)
        {
           mPoints.append(QPoint(2,i));
        }
    }

}

//构建山字型方块组
 void GrpBox::SetupItem2(int nStyle)
 {
     if (nStyle == 0)
     {
         mPoints.append( QPoint( 1,0));
         mPoints.append( QPoint( 0,1));
         mPoints.append( QPoint( 1,1));
         mPoints.append( QPoint( 2,1));
     }
     else if (nStyle == 1)
     {
         mPoints.append( QPoint( 1,0));
         mPoints.append( QPoint( 1,2));
         mPoints.append( QPoint( 1,1));
         mPoints.append( QPoint( 2,1));
     }
     else if (nStyle == 2)
     {
         mPoints.append( QPoint( 0,1));
         mPoints.append( QPoint( 1,2));
         mPoints.append( QPoint( 1,1));
         mPoints.append( QPoint( 2,1));
     }
     else if (nStyle == 3)
     {
         mPoints.append( QPoint( 1,0));
         mPoints.append( QPoint( 0,1));
         mPoints.append( QPoint( 1,1));
         mPoints.append( QPoint( 1,2));
     }

 }

 //创建手枪型1方块组
 void GrpBox::SetupItem3(int nStyle)
  {
      if (nStyle == 0)
      {
          mPoints.append(QPoint( 1,0));
          mPoints.append(QPoint( 1,1));
          mPoints.append(QPoint( 1,2));
          mPoints.append(QPoint( 2,2));
      }
      else if (nStyle == 1)
      {
          mPoints.append(QPoint( 1,1));
          mPoints.append(QPoint( 2,1));
          mPoints.append(QPoint( 3,1));
          mPoints.append(QPoint( 1,2));
      }
      else if (nStyle == 2)
      {
          mPoints.append(QPoint( 1,1));
          mPoints.append(QPoint( 2,1));
          mPoints.append(QPoint( 2,2));
          mPoints.append(QPoint( 2,3));
      }
      else
      {
          mPoints.append(QPoint( 2,1));
          mPoints.append(QPoint( 2,2));
          mPoints.append(QPoint( 1,2));
          mPoints.append(QPoint( 0,2));
      }

  }

  //创建手枪型2方块组
 void GrpBox::SetupItem4(int nStyle)
  {
      if (nStyle == 0)
      {
          mPoints.append( QPoint( 2,0));
          mPoints.append( QPoint( 2,1));
          mPoints.append( QPoint( 2,2));
          mPoints.append( QPoint( 1,2));
      }
      else if (nStyle == 1)
      {
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 1,2));
          mPoints.append( QPoint( 2,2));
          mPoints.append( QPoint( 3,2));
      }
      else if (nStyle == 2)
      {
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 2,1));
          mPoints.append( QPoint( 1,2));
          mPoints.append( QPoint( 1,3));
      }
      else if (nStyle == 3)
      {
          mPoints.append( QPoint( 0,1));
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 2,1));
          mPoints.append( QPoint( 2,2));
      }

  }


  //创建田型方块组
  void GrpBox::SetupItem5(int nStyle)
  {
      mPoints.append( QPoint( 0,0));
      mPoints.append( QPoint( 0,1));
      mPoints.append( QPoint( 1,0));
      mPoints.append( QPoint( 1,1));

  }

  //创建Z字型方块组
  void GrpBox::SetupItem6(int nStyle)
  {
      if (nStyle == 0)
      {
          mPoints.append( QPoint( 1,0));
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 2,1));
          mPoints.append( QPoint( 2,2));
      }
      else if (nStyle == 1)
      {
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 2,1));
          mPoints.append( QPoint( 0,2));
          mPoints.append( QPoint( 1,2));
      }
      else if (nStyle == 2)
      {
          mPoints.append( QPoint( 2,0));
          mPoints.append( QPoint( 2,1));
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 1,2));
      }
      else if (nStyle == 3)
      {
          mPoints.append( QPoint( 0,1));
          mPoints.append( QPoint( 1,1));
          mPoints.append( QPoint( 1,2));
          mPoints.append( QPoint( 2,2));
      }

  }



/*

在绘图设备上
在当前位置画当前方块组
painter 绘图工具

*/

void GrpBox::DrawBoxGrp(QPainter& painter)
{
    for (int i = 0; i< mPoints.size(); i++)
    {
        QPoint pt = mPoints[i];
        pt += mCurPos; //将方块组中小方块的坐标换算成基于游戏区域的坐标

        //绘制方块组中的小方块
        painter.drawRect(QRect(pt.x() * BOX_WIDTH,  pt.y() * BOX_WIDTH,
                               BOX_WIDTH,BOX_WIDTH));
    }
}

 

main.cpp

#include "russboxwigdet.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    RussBoxWigdet w;
    w.show();

    return a.exec();
}

#include "russboxwigdet.h"
#include "ui_russboxwigdet.h"

#include <QPainter>
#include <QTime>

#include <QDebug>
#include <QKeyEvent>

#include <QMessageBox>

RussBoxWigdet::RussBoxWigdet(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::RussBoxWigdet)
{
    ui->setupUi(this);



    mBackPoints.clear();

    pAreaPixmap = new QPixmap(AREA_WIDTH,AREA_HEIGHT);

    //创建当前方块组对象
    pCurGrpBox = new GrpBox;

    DrawGameArea(); //绘制游戏区域

    pRunTimer = new QTimer(this);

    pRunTimer->setInterval(1000); //设置定时时间间隔为 1000ms

    connect(ui->BtnStart,SIGNAL(clicked(bool)),this,SLOT(BtnStartSlot()));
    connect(pRunTimer,SIGNAL(timeout()),this,SLOT(RunTimeoutSlot()));
    connect(ui->pushButton,SIGNAL(clicked(bool)),this,SLOT(StopSlot()));


}

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


//定时器超时槽函数

void RussBoxWigdet::RunTimeoutSlot(void)
{
      qDebug()<<"timeout"<<endl;

      GrpMoveDownProcess();
      DrawGameArea(); //绘制游戏区域
      DrawGameGrpBox();
      DrawGameBack(); //绘制背景图案
      //DrawNextGrp();
}

//将下一组显示
/*void RussBoxWigdet::DrawNextGrp(void)
{
    QPainter  p(pAreaPixmap1);
    //设置画刷
    QBrush myBrush(Qt::SolidPattern);
    myBrush.setColor(QColor(200,100,60));

    //设置画笔
    QPen myPen(Qt::SolidLine);
    myPen.setWidth(1);
    myPen.setColor(QColor(100,200,80));

    p.setPen(myPen);
    p.setBrush(myBrush);

    pCurGrpBox->DrawBoxGrp(p);

    //在Label显示当前方块组
    ui->label_next->setPixmap(*pAreaPixmap1);

    qDebug()<<"DrawNext"<<endl;

}*/
//将当前方块组添加到背景图案
void RussBoxWigdet::AddCurGrpBack(void)
{
    for(int i=0; i<pCurGrpBox->mPoints.size();i++)
    {
        mBackPoints.append(pCurGrpBox->mPoints[i]+pCurGrpBox->mCurPos);
    }

}

//判断第 nRow 行 背景图案是否满行
bool RussBoxWigdet::IsFullLine(int nRow)
{
    QPoint pt;
    pt.setY(nRow);
    for(int i = 0; i < COL_NUM; i++)
    {   //扫描第 nRow行所有的点是否在背景图案中
        pt.setX(i);
        if(!mBackPoints.contains(pt))
        {
           return false;
        }

    }
    return true;
}

//删除背景图案中指定的行
void RussBoxWigdet::DeleteLine(int nRow)
{
    QPoint pt;
    pt.setY(nRow);
    //将背景图案中该行的点全部删除
    for(int i = 0; i< COL_NUM -1;i++)
    {
        pt.setX(i);
        mBackPoints.removeOne(pt);
    }

    //将该上面的所有小方块下移
    for(int i=0; i<mBackPoints.size(); i++)
    {
        if(mBackPoints[i].y() < nRow)
        {
           mBackPoints[i].setY(mBackPoints[i].y()+1);
        }
    }
}

//消除满行的功能
void RussBoxWigdet::DelFullLine(void)
{
    for(int i = ROW_NUM-1;i >=0; i--)
    {
        if(IsFullLine(i))
        {
            //如何满行 消除该行
            DeleteLine(i);
            score=score+100;
            QString s = QString::number(score, 10);
            ui->label_score->setText(s);
           ScoreCompare();
            i++;
        }
    }

}
//显示分数  等级
void RussBoxWigdet::ScoreCompare(void){
    if(score>100){
        if(score>=500){
            if(score>=1000){
                ui->label_level->setText("叫兽");
                    pRunTimer->stop();
                    pRunTimer->start();
                    pRunTimer->setInterval(400);
                    return;
            }
            ui->label_level->setText("砖家");
            pRunTimer->stop();
            pRunTimer->start();
            pRunTimer->setInterval(800);
            return;
        }
       ui->label_level->setText("学渣");
    }

}
//判断当前方块组的方块是否与背景图案重叠,如果重叠返回真，否则返回假
bool RussBoxWigdet::CurBoxCoverBack(void)
{
    QPoint pt;

    for(int i = 0; i<pCurGrpBox->mPoints.size();i++ )
    {
        pt = pCurGrpBox->mPoints[i] + pCurGrpBox->mCurPos;
        if(mBackPoints.contains(pt))
        {
            return true;
        }
    }

    return false;
}

//绘制背景图案
void  RussBoxWigdet::DrawGameBack(void)
{
    QPainter  p(pAreaPixmap);
    //设置画刷
    QBrush myBrush(Qt::SolidPattern);
    myBrush.setColor(QColor(80,200,100));

    //设置画笔
    QPen myPen(Qt::SolidLine);
    myPen.setWidth(1);
    myPen.setColor(QColor(200,10,10));

    p.setPen(myPen);
    p.setBrush(myBrush);

    QPoint pt;
    for (int i = 0; i< mBackPoints.size(); i++)
    {
         pt = mBackPoints[i];

         //绘制方块组中的小方块
         p.drawRect(QRect(pt.x() * BOX_WIDTH,  pt.y() * BOX_WIDTH,
                                BOX_WIDTH,BOX_WIDTH));
    }

      ui->LabelArea->setPixmap(*pAreaPixmap);

      qDebug()<<"DrawGameBack"<<endl;
}



//绘制游戏区域
void RussBoxWigdet::DrawGameArea(void)
{
    QPainter  p(pAreaPixmap);
    //设置画刷
    QBrush myBrush(Qt::SolidPattern);
    myBrush.setColor(QColor(200,200,200));

    //设置画笔
    QPen myPen(Qt::SolidLine);
    myPen.setWidth(8);
    myPen.setColor(QColor(200,10,10));

    p.setPen(myPen);
    p.setBrush(myBrush);

    //绘制游戏区域的外框
    p.drawRect(0,0,AREA_WIDTH,AREA_HEIGHT);

    //画游戏区域里面小方格
    myPen.setStyle(Qt::DashLine);
    myPen.setWidth(1);
    myPen.setColor(QColor(60,100,80));
    p.setPen(myPen);

    //画水平线
    for(int i = 0; i< ROW_NUM-1;i++)
    {
        p.drawLine(0,(i+1)*BOX_WIDTH,AREA_WIDTH,(i+1)*BOX_WIDTH);
    }

    //绘制垂直线
    for(int i = 0; i <COL_NUM-1;i++)
    {
        p.drawLine((i+1)*BOX_WIDTH,0,(i+1)*BOX_WIDTH,AREA_HEIGHT);
    }

    //在Label显示游戏界面
    ui->LabelArea->setPixmap(*pAreaPixmap);

    qDebug()<<"DrawGameArea"<<endl;

}

//随机设置当前方块组的形状和样式
void  RussBoxWigdet::CreateGrpBox(void)
{
    qsrand(QTime::currentTime().msec()); //设置随机数种子

    ITEM_TYPE t1 =(ITEM_TYPE)(qrand()%ITEM_MAX);
    int s1 = qrand()%4;

    pCurGrpBox->mCurPos.setX(6);
    pCurGrpBox->mCurPos.setY(0);

    qDebug()<<"x:"<<pCurGrpBox->mCurPos.x()<<endl;
    qDebug()<<"y:"<<pCurGrpBox->mCurPos.y()<<endl;

    pCurGrpBox->InitBoxGrp(t1,s1); //产生一个方块组

}

//在游戏区域绘制并显示当前方块组
void RussBoxWigdet::DrawGameGrpBox(void)
{
    QPainter  p(pAreaPixmap);
    //设置画刷
    QBrush myBrush(Qt::SolidPattern);
    myBrush.setColor(QColor(200,100,60));

    //设置画笔
    QPen myPen(Qt::SolidLine);
    myPen.setWidth(1);
    myPen.setColor(QColor(100,200,80));

    p.setPen(myPen);
    p.setBrush(myBrush);

    pCurGrpBox->DrawBoxGrp(p);

    //在Label显示当前方块组
    ui->LabelArea->setPixmap(*pAreaPixmap);

    qDebug()<<"DrawGameGrpBox"<<endl;

}

//方块组下移处理
 void RussBoxWigdet::GrpMoveDownProcess(void)
 {
     //按下 down键，向下移动一个方格
     qDebug()<<"down"<<endl;
     pCurGrpBox->MoveDown();
     if(pCurGrpBox->HitBottom() || CurBoxCoverBack())
     {

         //如果底部越界，取消下移动
         pCurGrpBox->CancelMoveDown();

         //将当前方块组添加到游戏背景图案
         AddCurGrpBack();

         //判断是否有满行需要消除
         DelFullLine();

         if(pCurGrpBox->HitTop())
         {
             //游戏结束
             QMessageBox::information(NULL, "GAME OVER", "GAME OVER", QMessageBox::Yes , QMessageBox::Yes);
             pRunTimer->stop();
         }
         else
         {
             pCurGrpBox->mPoints.clear(); //清除当前方块组
             CreateGrpBox();
         }

     }

 }


 void RussBoxWigdet::keyPressEvent(QKeyEvent *e)
 {
    if(Pause)return;
     qDebug()<<"enter keyPressEvent"<<endl;
     switch(e->key())
     {
            case Qt::Key_Left:
                    //按下左键，向左移动一个方格
                qDebug()<<"left"<<endl;
                pCurGrpBox->MoveLeft();
                if(CurBoxCoverBack())
                {
                    //与背景图案发生重叠
                    pCurGrpBox->MoveRight();
                }

                 break;

            case Qt::Key_Up: //变形 改变样式
                pCurGrpBox->ChangeShape();
                 break;
            case Qt::Key_Right:
                    //按下右键 向右移动一个方格
                qDebug()<<"right"<<endl;
                pCurGrpBox->MoveRight();
                if(CurBoxCoverBack())
                {
                    //向右移动发生重叠，移回去
                    pCurGrpBox->MoveLeft();
                }

                 break;

            case Qt::Key_Down:
                  GrpMoveDownProcess();
                 break;

            default:
                break;

      }

     DrawGameArea(); //绘制游戏区域

     DrawGameGrpBox();
     DrawGameBack(); //绘制背景图案
     //DrawNextGrp();

 }




//实现开始游戏的槽函数
 void RussBoxWigdet::BtnStartSlot(void)
 {
    qDebug()<<"Start Game"<<endl;
  //  score=0;
    Pause=false;
    pRunTimer->start(); //启动定时器
    mBackPoints.clear();
  //  if(score)score=0;
    score=0;
    QString s = QString::number(score);
    ui->label_score->setText(s);
    ui->label_level->setText("菜鸟");
    CreateGrpBox();

    DrawGameArea();
    DrawGameBack();
    DrawGameGrpBox();


 }
 //声明暂停游戏槽函数
 void RussBoxWigdet::StopSlot(void){
    if(pRunTimer->isActive()){
        pRunTimer->stop();
        Pause=true;
    }else{
        pRunTimer->start();
        Pause=false;
    }
 }

 

 

russboxwigdet.cpp

所有文件都已经贴上。

下一个图像显示这个功能没有完成。

整个项目步骤是：先新建了个项目，在项目下又新建文件。编写画背景，然后编写画图，按键，功能逐渐增加。先是按一个按钮能出现一个方块，按键后能响应。左右上下的碰撞检测，定时器设定，游戏的大致框架完成，后经行修改。

功能一的实现逻辑是在游戏消行的后面增加一个分数处理，然后显示。

功能二的实现逻辑是暂停时关闭定时器，关闭按键处理，再按一次恢复定时器按键处理。

功能三的实现逻辑是在功能一的基础上判断分数是否达到标准，达到标准显示称号，减少定时器定时时间。

第一次接触QT，若有错误，请指正，多谢。