Linux系统下QT九宫格拼图小游戏

原项目百度网盘下载提取码在文章末尾：
链接：https://pan.baidu.com/s/1RkhyjXSSUtXqHX6bNyGj4A

部分源代码

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include"qtimer.h"
#include<qevent.h>
#include<iostream>
#include<vector>
#include <algorithm>
#include <random>
#include<time.h>
#include<qimage.h>
#include<map>
#include<QList>
#include<qmessagebox.h>
#include <QtCore>
#include<QPushButton>
#include<dialog.h>
using namespace std;

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

    QPixmap pixmap;
    QPixmap pixmap1;
    QImage  imags;
    QPixmap beijing;
    QVector<QPixmap> pixmaps;
     // QVector<QImage> image;
//QVector<int> buf2;
        //SelectImage *selet;
        QTimer *timer;

        static int M_height;
        static int M_weight;
        static int o_x;
        static int o_y;
        int n;
        int m;
        int dushu;
        int *buf;//图片位置
        int *buf2;//图片旋转
        int *buf3;//图片水平
        int *buf4;//图片垂直
        int *buf5;//图片水平垂直
       static int child_w;
      static  int child_h;
        int tag;
        int x1;
        int x2;
        int y1;
        int y2;
        int position;
        int step;
        int count;//90度旋转块树
        int num;
        bool is;
        int select=1;
         int isr=1;
         bool  startif=false;
         int num1;
                 int num2;
                 int num3;
                 bool hangchang=false;
         QString path=":/img/新一小兰.png";

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
void paintEvent(QPaintEvent *event);
void mousePressEvent(QMouseEvent *event);
   void mouseReleaseEvent(QMouseEvent *event);

private slots:
    void on_pushButton_clicked();
    void divide();
    void check();
    void change();
void random(int*, int);
    void on_spinBox_valueChanged(int arg1);

void xytimerUpDate();


    void on_pushButton_2_clicked();

    void on_pushButton_3_clicked();

    void on_MainWindow_customContextMenuRequested(const QPoint &pos);
void onTaskBoxContextMenuEvent();
//void on_spinBox_2_valueChanged(int arg1);

void on_pushButton_5_clicked();

void on_pushButton_4_clicked();

void on_spinBox_3_valueChanged(int arg1);

void on_spinBox_4_valueChanged(int arg1);

void on_spinBox_5_valueChanged(int arg1);

void on_spinBox_2_valueChanged(int arg1);

void on_radioButton_clicked();

void on_radioButton_2_clicked();

void on_radioButton_3_clicked();

private:
    Ui::MainWindow *ui;
public:
    QPushButton *button_skip;

public slots:
    void login();

signals:
    void sendStr(QString);
private:
    Dialog *newDialog;
};
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include"dialog.h"

#include<QPainter>
#include<QPixmap>
#include<QImage>
#include<QPainter>
#include<QMessageBox>
#include<QFileDialog>
#include<QTimer>
#include<QDebug>
#include <QtCore>
#include<QPushButton>
#include<dialog.h>
int MainWindow::M_height = 540;
int MainWindow::M_weight = 540;
int MainWindow::o_x = 50;
int MainWindow::o_y = 50;
int MainWindow::child_h = 50;
int MainWindow::child_w = 50;
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    button_skip = new QPushButton("查看原图",this);
        button_skip->setGeometry(860,467,83,28);
        connect(button_skip,SIGNAL(clicked(bool)),this,SLOT(login()));

count=0;
    pixmap1.load(":/kbimage/kongbai.png");
    pixmap.load(":/img/xinyi.jpg");
    pixmap.load(":/img/新一小兰.png");
    beijing.load(":/imgs/a.jpg");
    QImage image(":/img/xinyi.jpg");
    imags.load(":/img/xinyi.jpg");
    beijing.load(":imgs/fenqu.jpg");
 //   ui->radioButton->setCheckable(true);
    ui->radioButton_3->setChecked(1);
    ui->label->setText(QString::number(0));
    ui->label_11->setText(QString::number(0));
    dushu=0;
     step=0;
    QMatrix matrix;
    matrix.rotate(180);
    pixmap.transformed(matrix);
    n = 3;
    m=3;
        buf = new int[n*n];
        buf2=new int[n*n];
        buf3=new int[n*n];
        buf4=new int[n*n];
        buf5=new int[n*n];
        ui->spinBox->setValue(3);
        ui->spinBox_2->setValue(3);
        //connect(pic,SIGNAL(is_ok()),this,SLOT(change()));
        timer=new QTimer(this);
        connect(timer,SIGNAL(timeout()),this,SLOT(xytimerUpDate()));
         pixmaps.append(pixmap);
         //image.load();
         pixmaps.append(pixmap1);

}

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

void MainWindow::login()
{
    //跳转到另一个窗口
    Dialog *win = new Dialog(this);
    QObject::connect(this,SIGNAL(sendStr(QString)),win,SLOT(getStr(QString)));
    QString oldStr=path;
    emit sendStr(oldStr);
    win->show();

}

void MainWindow::on_pushButton_clicked()
{
    QString name = QFileDialog::getOpenFileName(this,tr("打开新图片"),"./",tr("(*.png *.jpg *.bmp)"));
    path=name;
        if(name.isEmpty())
            return;
        pixmap.load(name);
        step=0;
       divide();

}
void MainWindow::mousePressEvent(QMouseEvent *event)
{
    ui->label->setText(QString::number(step));
    if(event->button() == Qt::LeftButton){
        int x = event->x();
        int y = event->y();
        if(x<=800&&x>=50&&y<=800&&y>=50){
            tag = (x-50)/child_w + ((y-50)/child_h)*n;
            is = true;
            select=1;
        }
    }

}
void MainWindow::mouseReleaseEvent(QMouseEvent *event)
{
//    if(hangchang){
//        timer->stop();
//    }
    ui->label->setText(QString::number(step));
    if(event->button() == Qt::LeftButton){
        int x = event->x();
        int y = event->y();

        if(x<=540&&x>=50&&y<=540&&y>=50&&is){
            int tag1 = (x-50)/child_w + ((y-50)/child_h)*n;
            x1=tag/n;
            x2=tag1/n;
            y1=tag%n;
            y2=tag1%n;
            if(ui->radioButton->isChecked()==true){
                if(startif){
                    std::swap(buf[tag],buf[tag1]);
                    step++;
                }else{
                    QMessageBox::information(this,"通知","请点击开始！","确定");
                }

            }else
            if(ui->radioButton_2->isChecked()==true){
                if(buf[tag]==n*m-1||buf[tag1]==n*m-1){
                    if(startif){
                        std::swap(buf[tag],buf[tag1]);
                        step++;
                    }else{
                        QMessageBox::information(this,"通知","请点击开始！","确定");
                    }
                }else{
                    QMessageBox::information(this,"通知","只能与空白格进行交换！","确定");
                }
            }else
            if(ui->radioButton_3->isChecked()==true){

if(startif){
            if(buf[tag]==n*m-1||buf[tag1]==n*m-1){
                if(x1==x2){
                    if(y1-y2==1||y2-y1==1){
                        if(startif){
                            std::swap(buf[tag],buf[tag1]);
                            step++;
                        }else{
                            QMessageBox::information(this,"通知","请点击开始！","确定");
                        }
                    }
                }else
                if(y1==y2){
                    if(x1-x2==1||x2-x1==1){
                        if(startif){
                            std::swap(buf[tag],buf[tag1]);
                            step++;
                        }else{
                            QMessageBox::information(this,"通知","请点击开始！","确定");
                        }
                    }
                }

            }else{
                QMessageBox::information(this,"通知","只能与空白格相邻的图片进行交换！","确定");
            }
}else{
    QMessageBox::information(this,"通知","请点击开始！","确定");
}
            }

//std::swap(buf[tag],buf[tag1]);
            update();
            is = false;
            select=1;
            if(tag!=tag1){
                //step++;
                //ui->label_show->setText(QString::number(step));
ui->label->setText(QString::number(step));

            }
        }
update();
    }

}


void MainWindow::paintEvent(QPaintEvent *) //绘图
{
    QPainter p(this);
    //p.rotate(180);
    QMatrix matrix;
    p.drawPixmap(0, 0, 1081, 644,beijing);
    QImage image;
    if(select==2){
        matrix.rotate(90);
    //image=pixmap[buf[tag]];
   pixmaps[buf[position]]=pixmaps[buf[position]].transformed(matrix, Qt::SmoothTransformation);
//p.drawPixmap(470, 60, child_w, child_h,pixmaps[buf[position]]);
     buf2[buf[position]]=buf2[buf[position]]+1;
     if(buf2[buf[position]]>3){
         buf2[buf[position]]=buf2[buf[position]]-4;
     }
     //buf2[buf[position]]=buf2[buf[position]];

    }else if(select==3){
        matrix.rotate(180);
        //image=pixmap[buf[tag]];
       pixmaps[buf[position]]=pixmaps[buf[position]].transformed(matrix, Qt::SmoothTransformation);
    //p.drawPixmap(470, 60, child_w, child_h,pixmaps[buf[position]]);
    buf2[buf[position]]=buf2[buf[position]]+2;
    if(buf2[buf[position]]>3){
        buf2[buf[position]]=buf2[buf[position]]-4;
    }
    }else if(select==4){
        matrix.rotate(270);
        //image=pixmap[buf[tag]];
       pixmaps[buf[position]]=pixmaps[buf[position]].transformed(matrix, Qt::SmoothTransformation);
    //p.drawPixmap(470, 60, child_w, child_h,pixmaps[buf[position]]);
    buf2[buf[position]]=buf2[buf[position]]+3;
    if(buf2[buf[position]]>3){
        buf2[buf[position]]=buf2[buf[position]]-4;
    }
    }else if(select==5){
        image=pixmaps[buf[position]].toImage();
        QImage mirroredImage = image.mirrored(true, false);
        pixmaps[buf[position]]=QPixmap::fromImage(mirroredImage);
        //p.drawPixmap(470, 60, child_w, child_h,pixmaps[buf[position]]);
        buf3[buf[position]]=buf3[buf[position]]+1;
        if(buf3[buf[position]]==2){
            buf3[buf[position]]=0;
        }
    }
    else if(select==6){
            image=pixmaps[buf[position]].toImage();
            QImage mirroredImage = image.mirrored(false, true);
            pixmaps[buf[position]]=QPixmap::fromImage(mirroredImage);
            //p.drawPixmap(470, 60, child_w, child_h,pixmaps[buf[position]]);
            buf4[buf[position]]=buf4[buf[position]]+1;
            if(buf4[buf[position]]==2){
                buf4[buf[position]]=0;
            }
        }
    else if(select==7){
            image=pixmaps[buf[position]].toImage();
            QImage mirroredImage = image.mirrored(true, true);
            pixmaps[buf[position]]=QPixmap::fromImage(mirroredImage);
           // p.drawPixmap(470, 60, child_w, child_h,pixmaps[buf[position]]);
            buf3[buf[position]]=buf3[buf[position]]+1;
            if(buf3[buf[position]]==2){
                buf3[buf[position]]=0;
            }
            buf4[buf[position]]=buf4[buf[position]]+1;
            if(buf4[buf[position]]==2){
                buf4[buf[position]]=0;
            }
            buf5[buf[position]]=buf5[buf[position]]+2;
            if(buf5[buf[position]]>3){
                buf5[buf[position]]=buf5[buf[position]];
            }
        }

//p.rotate(-180);
    int i=0;

    for(int y=0;y<m;y++){

        for(int x=0;x<n;x++){

            p.drawPixmap(o_x+x*child_w, o_y+y*child_h, child_w, child_h,pixmaps[buf[i++]]);


        }
    }
//    for(int y=0;y<m;y++){

//        for(int x=0;x<n;x++){

//            p.drawPixmap(470+x*child_w, o_y+y*child_h, child_w, child_h,pixmap1);


//        }
//    }




        select=1;

}
void MainWindow::change()
{
    //pixmap.load(":/img/xinyi.jpg");
    ui->spinBox->setValue(3);
    ui->spinBox_2->setValue(3);
    on_spinBox_valueChanged(3);
    on_spinBox_2_valueChanged(3);
}
void MainWindow::divide()   //分割图片
{
   step=0;
    QPixmap pix;
    QImage img;
    pixmaps.clear();
   // image.clear();
    int h = pixmap.height()/m;
    int w = pixmap.width()/n;
    for(int y=0;y<m;y++)
        for(int x=0;x<n;x++){
            pix=pixmap.copy(x*w,y*h,w,h);
         //img=imags.copy(x*w,y*h,w,h);
            if(y==(m-1)&&x==(n-1)){
                pixmaps.append(pixmap1);
            }else{
            pixmaps.append(pix);}
        }
    //旋转
       if((ui->checkBox->isChecked()==true))
       {
           num1=ui->spinBox_3->value();
           int ro[10];

           for(int i=0;i<num1;i++)
           {
            ro[i]=rand()%num1+1;//生成随机数
            for(int x=0;x<i;x++)
               {
                   if(ro[x]==ro[i])
                  {
                      ro[i]=rand()%num1+1;
                       x=0;

                  }
               }
               QMatrix matrix;
               int angle=(rand() % (3-1))+ 1;
               matrix.rotate(90*angle);
               pixmaps[buf[ro[i]]]=pixmaps[buf[ro[i]]].transformed((matrix));
               buf2[buf[ro[i]]]+=angle;
               if(buf2[buf[ro[i]]]>3)
               {
                    buf2[buf[ro[i]]]=buf2[buf[ro[i]]]-4;
               }
           }
       }

       //水平翻转
       if((ui->checkBox_2->isChecked()==true))
          {
              num2=ui->spinBox_4->value();
              int ro[10];

              for(int i=0;i<num2;i++)
              {
               ro[i]=rand()%num2+1;//生成随机数
               for(int x=0;x<i;x++)
                  {
                      if(ro[x]==ro[i])
                     {
                         ro[i]=rand()%num2+1;
                          x=0;

                     }
                  }
                 QImage img=pixmaps[buf[ro[i]]].toImage();
                 img= img.mirrored(true, false);
                 pixmaps[buf[ro[i]]]=QPixmap::fromImage(img);
                 buf3[buf[ro[i]]]+=1;
                 if(buf3[buf[ro[i]]]==2)
                 {
                     buf3[buf[ro[i]]]=0;
                 }
              }
          }

           //垂直翻转

       if((ui->checkBox_3->isChecked()==true))
          {
              num3=ui->spinBox_5->value();
              int ro[10];

              for(int i=0;i<num3;i++)
              {
               ro[i]=rand()%num3+1;//生成随机数
               for(int x=0;x<i;x++)
                  {
                      if(ro[x]==ro[i])
                     {
                         ro[i]=rand()%num3+1;
                          x=0;

                     }
                  }
                 QImage img=pixmaps[buf[ro[i]]].toImage();
                 img= img.mirrored(false, true);
                 pixmaps[buf[ro[i]]]=QPixmap::fromImage(img);
                 buf4[buf[ro[i]]]+=1;
                 if(buf4[buf[ro[i]]]==2)
                 {
                     buf4[buf[ro[i]]]=0;
                 }
              }
          }
}
void MainWindow::check()    //检查是否成功
{

    for(int i=0;i<n*m-1;i++){
        if(buf[i]!=i||buf2[i]!=0||buf3[i]!=0||buf4[i]!=0){
            if(!((buf3[i]+buf4[i]==2)&&(buf2[i]==2)))
            {
             QMessageBox::information(this,"通知","你失败了！","确定");
            return;
            }
        }
    }
    //timer->stop();
    QMessageBox::information(this,"通知","恭喜！你成功了！","确定");


}

void MainWindow::on_spinBox_valueChanged(int arg1)//竖
{
    step=0;
    dushu=0;
 //   timer->stop();
   // hangchang=true;
   ui->label->setText(QString::number(step));
    ui->label_11->setText(QString::number(dushu));
    n = arg1;
        child_w = M_weight/n;
        child_h = M_height/m;
        delete [] buf;
        buf = new int[n*m];
        for(int i=0;i<n*m;i++)
        {buf[i] = i;}
        delete [] buf2;
        buf2 = new int[n*m];
        for(int i=0;i<n*m;i++)
        {buf2[i] = 0;}
        delete [] buf3;
        buf3 = new int[n*m];
        for(int i=0;i<n*m;i++)
        {buf3[i] = 0;}
        delete [] buf4;
        buf4 = new int[n*m];
        for(int i=0;i<n*m;i++)
        {buf4[i] = 0;}
        delete [] buf5;
        buf5 = new int[n*m];
        for(int i=0;i<n*m;i++)
        {buf5[i] = 0;}
        random(buf,n*m);
   divide();
   update();
}
void MainWindow::random(int *buf, int len)  //图片随机化
{
    int suiji=0;
    //srand(time(NULL));
    for(int i=0; i<len; i++)
    {
        std::swap(buf[i], buf[rand()%len]);

    }
    for(int i=0;i<n*m-1;i++){
        for(int j=i+1;j<n*m;j++){
            if(buf[i]>buf[j]&&buf[i]!=(n*m-1)&&buf[j]!=(n*m-1))
            suiji=suiji+1;
        }
    }
        if((suiji%2)!=0){
            if(buf[0]!=(n*m-1)&&buf[1]!=(n*m-1)){
                std::swap(buf[0], buf[1]);
            }else{
               std::swap(buf[2], buf[3]);
            }
       }
       // std::swap(buf[i], buf[rand()%len]);
}


void MainWindow::on_pushButton_2_clicked()//完成
{
    timer->stop();
    check();
     timer->stop();
     startif=false;
}
void MainWindow::xytimerUpDate(){
dushu++;
ui->label_11->setText(QString::number(dushu));
}
void MainWindow::on_pushButton_3_clicked()//重置
{
    QDateTime time = QDateTime::currentDateTime();//获取系统现在的时间

        QString strTime = time.toString("yyyy-MM-dd hh:mm:ss");
        timer->stop();
        dushu=0;
        startif=false;
        ui->label_11->setText(QString::number(dushu));
        //ui->label_11->setText(strTime);
   // paintEventmouse(QPaintEvent *);
    step=0;
    ui->label->setText(QString::number(step));
    delete [] buf;
    buf = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf[i] = i;}
    delete [] buf2;
    buf2 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf2[i] = 0;}
    delete [] buf3;
    buf3 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf3[i] = 0;}
    delete [] buf4;
    buf4 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf4[i] = 0;}
    delete [] buf5;
    buf5 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf5[i] = 0;}
    //ui->spinBox_2->setValue(0);
    random(buf,n*m);
divide();
update();
}

void MainWindow::on_MainWindow_customContextMenuRequested(const QPoint &/*pos*/)
{
    //创建菜单对象
        QMenu *pMenu = new QMenu(this);

        QAction *pNewTask = new QAction(tr("顺时针旋转90度"), this);
        QAction *pEditTask = new QAction(tr("顺时针旋转180度"), this);
        QAction *pDeleteTask = new QAction(tr("逆时针旋转90度"), this);

        QAction *pToolRenName = new QAction(tr("水平翻转"), this);
        QAction *pToolEdot = new QAction(tr("垂直翻转"), this);
        QAction *pToolDelete = new QAction(tr("垂直水平翻转"), this);

        //1:新建任务 2:设置任务 3:删除任务 4:改名工具 5:设置工具 6:删除工具
        pNewTask->setData(1);
        pEditTask->setData(2);
        pDeleteTask ->setData(3);
        pToolRenName->setData(4);
        pToolEdot->setData(5);
        pToolDelete ->setData(6);

        //把QAction对象添加到菜单上
        pMenu->addAction(pNewTask);
        pMenu->addAction(pEditTask);
        pMenu->addAction(pDeleteTask);
        pMenu->addAction(pToolRenName);
        pMenu->addAction(pToolEdot);
        pMenu->addAction(pToolDelete);

        //连接鼠标右键点击信号
        connect(pNewTask, SIGNAL(triggered()), this, SLOT(onTaskBoxContextMenuEvent()));
        connect(pEditTask, SIGNAL(triggered()), this, SLOT(onTaskBoxContextMenuEvent()));
        connect(pDeleteTask, SIGNAL(triggered()), SLOT(onTaskBoxContextMenuEvent()));
        connect(pToolRenName, SIGNAL(triggered()), this, SLOT(onTaskBoxContextMenuEvent()));
        connect(pToolEdot, SIGNAL(triggered()), this, SLOT(onTaskBoxContextMenuEvent()));
        connect(pToolDelete, SIGNAL(triggered()), SLOT(onTaskBoxContextMenuEvent()));

        //在鼠标右键点击的地方显示菜单
        for(int i=0;i<n*m;i++){
            if(buf[i]==n*m-1){
                position=i;
            }
        }

        int x,y;

         x = cursor().pos().x();
       // int x=QCursor::pos().x();

        //int y=QCursor::pos().y();
         y = cursor().pos().y();
         pMenu->exec(cursor().pos());
        if(x<=800&&x>=50&&y<=800&&y>=50){
            position =(x-150)/child_w + ((y-150)/child_h)*n; //((x-50)/child_w + ((y-50)/child_h)*(n))-n-1;
          //select=2;
        }else{
            QMessageBox::about(this, "tip", "请点击图片进行操作！");
        }
        //释放内存
        QList<QAction*> list = pMenu->actions();
        foreach (QAction* pAction, list) delete pAction;
        delete pMenu;
}
void MainWindow::onTaskBoxContextMenuEvent()
{
    QAction *pEven = qobject_cast<QAction *>(this->sender()); //this->sender()就是发信号者 QAction

    //获取发送信息类型 1:新建任务 2:设置任务 3:删除任务 4:改名工具 5:设置工具 6:删除工具
    int iType = pEven->data().toInt();

    switch (iType)
    {
    case 1:
        select=2;
        update();

        //QMessageBox::about(this, "tip", pEven->text());
        break;
    case 2:
        select=3;
        update();
        break;
    case 3:
        select=4;
        update();
        break;
    case 4:
        select=5;
        update();
        break;
    case 5:
        select=6;
        update();
        break;
    case 6:
        select=7;
        update();
        break;
    default:
        break;
    }
}



void MainWindow::on_pushButton_5_clicked()//开始
{
    timer->start(1000);
    startif=true;
    //dushu=0;
}

void MainWindow::on_pushButton_4_clicked()//暂停
{
    timer->stop();
    startif=false;
    //dushu=0;
}

void MainWindow::on_spinBox_3_valueChanged(int arg1)
{
         isr=1;

       if((ui->checkBox->isChecked()==true))
       {
           num1=arg1;
           num1=ui->spinBox_3->value();
           int ro[10];
          // srand(time(nullptr));
           for(int i=0;i<num1;i++)
           {
            ro[i]=rand()%num1+1;//生成随机数
            for(int x=0;x<i;x++)
               {
                   if(ro[x]==ro[i])
                  {
                      ro[i]=rand()%num1+1;
                       x=0;

                  }
               }
               QMatrix matrix;
               int angle=(rand() % (3-1))+ 1;
               matrix.rotate(90*angle);
               pixmaps[buf[ro[i]]]=pixmaps[buf[ro[i]]].transformed((matrix));
               buf2[buf[ro[i]]]+=angle;
               if(buf2[buf[ro[i]]]>3)
               {
                   buf2[buf[ro[i]]]=buf2[buf[ro[i]]]-4;
               }
           }
       }
}

void MainWindow::on_spinBox_4_valueChanged(int arg1)
{
    if((ui->checkBox_2->isChecked()==true))
        {
        num2=arg1;
            num2=ui->spinBox_4->value();
            int ro[10];

            for(int i=0;i<num2;i++)
            {
             ro[i]=rand()%num2+1;//生成随机数
             for(int x=0;x<i;x++)
                {
                    if(ro[x]==ro[i])
                   {
                       ro[i]=rand()%num2+1;
                        x=0;

                   }
                }
               QImage img=pixmaps[buf[ro[i]]].toImage();
               img= img.mirrored(true, false);
               pixmaps[buf[ro[i]]]=QPixmap::fromImage(img);
               buf3[buf[ro[i]]]+=1;
               if(buf3[buf[ro[i]]]==2)
               {
                   buf3[buf[ro[i]]]=0;
               }
            }
        }
}

void MainWindow::on_spinBox_5_valueChanged(int arg1)
{

    if((ui->checkBox_3->isChecked()==true))
          {
        num3=arg1;
              num3=ui->spinBox_5->value();
              int ro[10];

              for(int i=0;i<num3;i++)
              {
               ro[i]=rand()%num3+1;//生成随机数
               for(int x=0;x<i;x++)
                  {
                      if(ro[x]==ro[i])
                     {
                         ro[i]=rand()%num3+1;
                          x=0;

                     }
                  }
                 QImage img=pixmaps[buf[ro[i]]].toImage();
                 img= img.mirrored(false, true);
                 pixmaps[buf[ro[i]]]=QPixmap::fromImage(img);
                 buf4[buf[ro[i]]]+=1;
                 if(buf4[buf[ro[i]]]==2)
                 {
                     buf4[buf[ro[i]]]=0;
                 }
              }
          }
}

void MainWindow::on_spinBox_2_valueChanged(int arg1)//行数
{
    m=arg1;
    step=0;
    dushu=0;
//    timer->stop();
   ui->label->setText(QString::number(step));
    ui->label_11->setText(QString::number(dushu));
    child_w = M_weight/n;
    child_h = M_height/m;
    delete [] buf;
    buf = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf[i] = i;}
    delete [] buf2;
    buf2 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf2[i] = 0;}
    delete [] buf3;
    buf3 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf3[i] = 0;}
    delete [] buf4;
    buf4 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf4[i] = 0;}
    delete [] buf5;
    buf5 = new int[n*m];
    for(int i=0;i<n*m;i++)
    {buf5[i] = 0;}
    random(buf,n*m);
     divide();
     update();
     //timer->stop();
}

void MainWindow::on_radioButton_clicked()
{
    timer->stop();
    dushu=0;
    startif=false;
    ui->label_11->setText(QString::number(dushu));
    //ui->label_11->setText(strTime);
// paintEventmouse(QPaintEvent *);
step=0;
ui->label->setText(QString::number(step));
delete [] buf;
buf = new int[n*m];
for(int i=0;i<n*m;i++)
{buf[i] = i;}
delete [] buf2;
buf2 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf2[i] = 0;}
delete [] buf3;
buf3 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf3[i] = 0;}
delete [] buf4;
buf4 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf4[i] = 0;}
delete [] buf5;
buf5 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf5[i] = 0;}
//ui->spinBox_2->setValue(0);
random(buf,n*m);
divide();
update();
}

void MainWindow::on_radioButton_2_clicked()
{
    timer->stop();
    dushu=0;
    startif=false;
    ui->label_11->setText(QString::number(dushu));
    //ui->label_11->setText(strTime);
// paintEventmouse(QPaintEvent *);
step=0;
ui->label->setText(QString::number(step));
delete [] buf;
buf = new int[n*m];
for(int i=0;i<n*m;i++)
{buf[i] = i;}
delete [] buf2;
buf2 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf2[i] = 0;}
delete [] buf3;
buf3 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf3[i] = 0;}
delete [] buf4;
buf4 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf4[i] = 0;}
delete [] buf5;
buf5 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf5[i] = 0;}
//ui->spinBox_2->setValue(0);
random(buf,n*m);
divide();
update();
}

void MainWindow::on_radioButton_3_clicked()
{
    timer->stop();
    dushu=0;
    startif=false;
    ui->label_11->setText(QString::number(dushu));
    //ui->label_11->setText(strTime);
// paintEventmouse(QPaintEvent *);
step=0;
ui->label->setText(QString::number(step));
delete [] buf;
buf = new int[n*m];
for(int i=0;i<n*m;i++)
{buf[i] = i;}
delete [] buf2;
buf2 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf2[i] = 0;}
delete [] buf3;
buf3 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf3[i] = 0;}
delete [] buf4;
buf4 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf4[i] = 0;}
delete [] buf5;
buf5 = new int[n*m];
for(int i=0;i<n*m;i++)
{buf5[i] = 0;}
//ui->spinBox_2->setValue(0);
random(buf,n*m);
divide();
update();
}

１．切割（ｍ＊ｎ）
获取用户选择切割的行数、列数以及原图的长和宽，计算切割之后的小碎片的长和宽以及每块小碎片的左上角相对原图的坐标，从原图的左上角开始，从左到右，从上到下获取一个小碎片，并且将小碎片依次放入到存放图片的容器中，如果获取的小碎片是原图右下角部分，则将空白碎片添加到存放图片的容器中。
２．绘图
计算每块小碎片在界面上的位置，将切割后的小碎片从左到右，从上往下依次画出
３．随机打乱
用一维数组buf存放每个小碎片的索引，循环调用swap（）函数交换一维数组buf的两个数值，其中有个数值由循环产生，另外一个数值调用rand（）函数随机产生。
４．用户自定义水平、垂直、旋转以及需要的个数
水平：判断用户是否选择了“水平”，若是用户选择了“水平”操作，获取用户选择的数值，调用rand（）函数随机产生一个数值，对与该数值相关的图片调用image接口进行水平翻转，相应图片的水平标志位加一，若标志位为2，则将标志位置为0；否则退出该函数。
垂直：判断用户是否选择了“垂直”，若是用户选择了“垂直”操作，获取用户选择的数值，调用rand（）函数随机产生一个数值，对与该数值相关的图片调用image接口进行垂直翻转，相应图片的垂直标志位加一，若标志位为2，则将标志位置为0；否则退出该函数。
旋转（顺时针）：判断用户是否选择了“旋转”，若是用户选择了“旋转”操作，获取用户选择的数值，调用rand（）函数随机产生一个数值，对与该数值相关的图片进行旋转操作，图片旋转的度数由另外一个rand（）函数随机产生决定，若随机旋转90度，相应图片旋转标志位加一，若随机旋转180度，相应图片旋转标志位加二，若随机旋转270度，相应图片旋转标志位加三，若标志位大于3，则将旋转标志位减四；否则退出该函数。
５．用户鼠标左键移动（三种移动模式）
获取用户鼠标左键点击时和释放时的坐标位置，分别计算点击时和释放时的位置对应的碎片索引在一维数组buf的索引。
简单：调用swap（）函数交换两块碎片，刷新界面，绘制出交换后的碎片界面。
一般：判断用户点击时对应的图片或者是用户释放时对应的图片是否有空白碎片，若有空白碎片，调用swap（）函数交换两块碎片，刷新界面，绘制出交换后的碎片界面。
困难：将一维数组buf的索引转换为与二维数组对应的坐标，判断用户点击时对应的图片或者是用户释放时对应的图片是否有空白碎片，判断两块碎片是否相邻，若同时满足上面两个条件，调用swap（）函数交换两块碎片，刷新界面，绘制出交换后的碎片界面。
判断空白碎片的方法：获取一维数组buf对应的数值，若该数值为空白碎片的索引，则对应空白碎片。
判断图片相邻的方法：分别获取鼠标点击位置和释放位置的二维数组的横坐标与纵坐标，若横坐标相同，且纵坐标数值相差为1，或者纵坐标相同，横坐标数值相差为1，两块图片相邻。
６．判断拼图是否完成
①判断一维数组buf对应的数值是否是图片存放的索引
②判断水平标志位，垂直标志位与旋转标志位是否为0
若满足上面两个条件，拼图完成，否则失败
７．鼠标右键水平翻转、垂直翻转或旋转图片
判断用户选中的图片以及相应的操作，对选中图片进行相应操作，刷新界面，重新绘图。（判断选中图片以及进行相应操作的方法同 5用户鼠标左键移动（三种移动模式）、4用户自定义水平、垂直、旋转以及需要的个数，此处不再赘述）
８．查看原图
新建一个dialog窗口，利用QT中的Signal＆Slot机制进行传值，定义一个全局变量path记录当前图片的路径（有默认图片路径），打开新图片path被重新赋值，该值传递到dialog中，dialog根据此路径打开图片。
９．计时与记步
用户进行一次不同图片之间的交换，步数加一。
使用qt中的计时器类QTimer设置一个计时器；设置定时器的定时周期为 1000 毫秒，每 1000 毫秒就会发射定时器的 timeout() 信号，在信号关联的槽函数里做相应的处理。
１０．重置（重新打乱）
①调用随机打乱函数
②判断用户是否选择了水平、垂直与旋转操作，若是用户选择了相应操作，获取相应操作的数值，执行。（执行方法类同于 4用户自定义水平、垂直、旋转以及需要的个数，此处不再赘述）
③刷新界面重新绘图
１１．选择图片进行切割
调用getOpenFileName（）方法选择一张新图片，将用户选择的图片加载为原图，调用切割函数对原图进行切割。刷新界面，重新绘图。
１２．开始、暂停、继续与完成
若用户点“开始”按钮，打开计时器，将标志“移动”的变量置为真，此时开始计时，用户可以进行移动操作；若用户点击“暂停”按钮，关闭计时器，将标志“移动”的变量置为假，此时停止计时，用户不可以进行移动操作；若用户点击“完成”按钮，关闭计时器，将标志“移动”的变量置为假，调用判断函数，并且将步数以及时间置为0，便于下次游戏开始计时与计步。

提取码：v8bx