《中国象棋开发》QT

- 日理万妓 2023-07-13 04:13 126阅读 0赞

### 文章目录 ###

*  QT使用学习
 *   *  QPainter绘图部分：
     *  鼠标事件（需要和绘图结合）
     *  按钮设置
 *  象棋程序
 *   *  main.cpp
     *  选择框部分
     *   *  chooseDlg.cpp
         *  ChooseDig.h
     *  主窗体部分
     *   *  MainWind.cpp
         *  MainWind.h
     *  棋盘(核心)
     *   *  Board.cpp
         *  Board.h
     *  人机对战部分
     *   *  SingleGame.cpp
         *  SingleGame.h
     *  人人对战部分
     *   *  MultiGame.cpp
         *  MultiGame.h
     *  网络对战部分
     *   *  NetGame.cpp
         *  NetGame.h
     *  棋子部分
     *   *  Stone.cpp
         *  Stone.h
     *  走棋部分
     *   *  Step.cpp
         *  Step.h
     *  关于人工智能走法
 *  补充：QT核心：信号与槽机制学习
 *   *  Q\_OBJECT
     *   *  1.1 信号与槽
         *  1.2 信号
         *  1.3 槽
         *  1.4 信号与槽的关联
         *  2.一个小例子
         *  3.关于元对象工具MOC
 *  补充：剪枝算法学习

# QT使用学习 #

QApplication 抽象了QT的应用程序；  
QWidgt抽象窗口；  
exec()函数 进入消息循环，等待用户输入；

## QPainter绘图部分： ##

void MyWidge::paintEvent(QPaintEvent *)
    {
        
        //绘制类，参数：绘制对象
        //绘制打印机、绘制图画、拷屏
        QPainter painter(this);//this代指这个类
    
        painter.setPen(QColor(255,0,0));//设置线条的颜色，外延
    
        painter.setBrush(QBrush(QColor(255,0,255)));//设置填涂的颜色，封闭图形
    
        painter.drawLine(QPoint(0,0),QPoint(100,100));//在某两点之间画直线
    
        painter.drawText(200,200,"Hello");//在某位置输入文本
    
        painter.drawEllipse(QPoint(200,300),50,50);//在某位置画椭圆，需要输入两个方向的半径
    }

## 鼠标事件（需要和绘图结合） ##

void MyWidge::paintEvent(QPaintEvent *)
    {
        
        //绘制类，参数：绘制对象
        //绘制打印机、绘制图画、拷屏
        QPainter painter(this);//this代指这个类
    # if 0
        painter.setPen(QColor(255,0,0));
    
        painter.setBrush(QBrush(QColor(255,0,255)));
    
        painter.drawLine(QPoint(0,0),QPoint(100,100));
    
        painter.drawText(200,200,"Hello");
    
        painter.drawEllipse(QPoint(200,300),50,50);
    # endif
        painter.drawEllipse(_ptClick,30,30);//点击的位置效果
    }
    void MyWidge::mousePressEvent(QMouseEvent *ev)//前置声明
    {
        
        //得到鼠标点击的地方
        _ptClick = ev -> pos();
        update();//强制程序重新绘制界面
    
    
    }

## 按钮设置 ##

MyWidge::MyWidge(QWidget *parent) : QWidget(parent)
    {
        
        _button = new QPushButton("button",this);//名字和this指针
        //_button -> show();可省
    }

# 象棋程序 #

ChessBY.pro

HEADERS += \
        Board.h \
        Stone.h \
        MainWnd.h \
        CtrlPanel.h \
        Step.h \
        ChooseDlg.h \
        SingleGame.h \
        MultiGame.h \
        NetGame.h
    
    SOURCES += \
        Board.cpp \
        main.cpp \
        Stone.cpp \
        MainWnd.cpp \
        CtrlPanel.cpp \
        Step.cpp \
        ChooseDlg.cpp \
        SingleGame.cpp \
        MultiGame.cpp \
        NetGame.cpp
    
    QT += widgets gui network  //QT图形界面

## main.cpp ##

#include <QApplication>
    #include "ChooseDlg.h"
    #include "MainWnd.h"
    #include <QTime>
    int main(int argc, char* argv[])
    {
        
        QApplication app(argc, argv);
    
        QTime t = QTime::currentTime();
        qsrand(t.msec()+t.second()*1000);
    
        ChooseDlg dlg; //选择框
        if(dlg.exec() != QDialog::Accepted)
            return 0;
    
        MainWnd wnd(dlg._selected);//根据选择框的选择创建主窗体
        wnd.show();
    
    
    
    
        return app.exec();
    }

（之后，函数定义在cpp文件中，类成员变量 和类成员函数声明在h文件中）

## 选择框部分 ##

### chooseDlg.cpp ###

创建四个按钮并根据选择进入哪个窗口；

#include "ChooseDlg.h"
    #include <QVBoxLayout>
    
    ChooseDlg::ChooseDlg(QWidget *parent) : QDialog(parent)
    {
        
        QVBoxLayout* lay = new QVBoxLayout(this);
        lay->addWidget(_buttons[0] = new QPushButton("人机对战"));
        lay->addWidget(_buttons[1] = new QPushButton("人人对战"));
        lay->addWidget(_buttons[2] = new QPushButton("网络对战(服务端)"));
        lay->addWidget(_buttons[3] = new QPushButton("网络对战(客户端)"));
    
        for(int i=0; i<4; ++i)
        {
        
            connect(_buttons[i], SIGNAL(clicked()), this, SLOT(slotClicked()));
        }
    }
    
    void ChooseDlg::slotClicked()
    {
        
        QObject* s = sender();
        for(int i=0; i<4; ++i)
        {
        
            if(_buttons[i] == s)
            {
        
                this->_selected = i;
                break;
            }
        }
        accept();
    }
    
    ChooseDlg::~ChooseDlg()
    {
        
    
    }

### ChooseDig.h ###

#ifndef ChooseDlg_H
    #define ChooseDlg_H
    
    #include <QDialog>
    #include <QPushButton>
    
    class ChooseDlg : public QDialog
    {
        
        Q_OBJECT
    public:
        explicit ChooseDlg(QWidget *parent = 0);
        ~ChooseDlg();
    
        QPushButton* _buttons[4];
        int _selected;//成员变量，决定是哪个选择
    signals:
    
    public slots:
        void slotClicked();
    };
    
    #endif // ChooseDlg_H

## 主窗体部分 ##

### MainWind.cpp ###

#include "MainWnd.h"
    #include <QHBoxLayout>
    #include "SingleGame.h"
    #include "MultiGame.h"
    #include "NetGame.h"
    
    MainWnd::MainWnd(int gameType, QWidget *parent) : QWidget(parent)
    {
        
        _gameType = gameType;
    
        if(_gameType == 0)//人机对战
        {
        
            SingleGame* game = new SingleGame;
            CtrlPanel* panel = new CtrlPanel;
    
            QHBoxLayout* hLay = new QHBoxLayout(this);
            hLay->addWidget(game, 1);
            hLay->addWidget(panel);
            connect(panel, SIGNAL(sigBack()), game, SLOT(slotBack()));
        }
        else if(_gameType == 1)//人人对战
        {
        
            MultiGame* game = new MultiGame;
            CtrlPanel* panel = new CtrlPanel;
    
            QHBoxLayout* hLay = new QHBoxLayout(this);
            hLay->addWidget(game, 1);
            hLay->addWidget(panel);
            connect(panel, SIGNAL(sigBack()), game, SLOT(slotBack()));
        }
        else if(_gameType == 2)//网络对战（服务端）
        {
        
            NetGame* game = new NetGame(true);
            CtrlPanel* panel = new CtrlPanel;
    
            QHBoxLayout* hLay = new QHBoxLayout(this);
            hLay->addWidget(game, 1);
            hLay->addWidget(panel);
            connect(panel, SIGNAL(sigBack()), game, SLOT(slotBack()));
        }
        else if(_gameType == 3)//网络对战（客户端）
        {
        
            NetGame* game = new NetGame(false);
            CtrlPanel* panel = new CtrlPanel;
    
            QHBoxLayout* hLay = new QHBoxLayout(this);
            hLay->addWidget(game, 1);
            hLay->addWidget(panel);
            connect(panel, SIGNAL(sigBack()), game, SLOT(slotBack()));
        }
    }
    
    MainWnd::~MainWnd()
    {
        
    
    }

### MainWind.h ###

#ifndef MAINWND_H
    #define MAINWND_H
    
    #include <QWidget>
    #include "Board.h"
    #include "CtrlPanel.h"
    
    class MainWnd : public QWidget
    {
        
        Q_OBJECT
    public:
        explicit MainWnd(int gameType, QWidget *parent = 0);//gameType就是_selected
        ~MainWnd();
    
        int _gameType;
    
    signals:
    
    public slots:
    };
    
    #endif // MAINWND_H

## 棋盘(核心) ##

### Board.cpp ###

#include "Board.h"
    #include <QPainter>
    #include <QMouseEvent>
    #include <QDebug>
    #define GetRowCol(__row, __col, __id) \
        int __row = _s[__id]._row;\
        int __col = _s[__id]._col
    
    Board::Board(QWidget *parent) : QFrame(parent)
    {
        
        this->_r = 20; //棋子半径长度为20
        setMinimumSize(_r*18+1, _r*20+1);
        init(true);
    }
    
    Board::~Board()
    {
        
    
    }
    
    void Board::init(bool bRedSide) //初始化棋子
    {
        
        for(int i=0; i<32; ++i)
        {
        
            _s[i].init(i); //每个都调用初始化函数
        }
        if(bRedSide)
        {
        
            for(int i=0; i<32; ++i)
            {
        
                _s[i].rotate();
            }
        }
    
        _selectid = -1; //被选中的棋子id，默认为-1
        _bRedTurn = true;
        _bSide = bRedSide;
        update();
    }
    
    void Board::paintEvent(QPaintEvent *)
    {
        
        int r = height()/20;
        _r = r;
        _off = QPoint(r+1, r+1);
    
        QPainter p(this); //定义painter对象
        
        p.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
    
        p.save();
        drawPlate(p); //绘制棋盘线
        p.restore();
    
        p.save();
        drawPlace(p);
        p.restore();
    
        p.save();
        drawInitPosition(p);
        p.restore();
    
        p.save();
        drawStone(p);//绘制棋子
        p.restore();
    }
    
    void Board::drawStone(QPainter &p)
    {
        
        for(int i=0; i<32; i++)
        {
        
            drawStone(p, i);
        }
    }
    
    bool Board::isDead(int id)
    {
        
        if(id == -1)return true;
        return _s[id]._dead;
    }
    绘制棋子，参数有绘画对象（引用，因为要改变这个对象的值，不能用引用）以及棋子对应的id
    void Board::drawStone(QPainter &p, int id)
    {
        
        if(isDead(id)) return;
    	
    	//设置颜色
        QColor color;
        if(red(id)) color = Qt::red; //红棋红色
        else color = Qt::black; //黑棋黑色
    
        p.setPen(QPen(QBrush(color), 2));
    
    	//设置填充颜色
        if(id == _selectid) p.setBrush(Qt::gray);//被选中则灰色
        else p.setBrush(Qt::yellow); //否则是黄色
    
        p.drawEllipse(cell(id));//圆心就是该id的行和列
    	
    	//设置字体
        p.setFont(QFont("system", _r*1.2, 700));//设置大小和粗度
        p.drawText(cell(id), name(id), QTextOption(Qt::AlignCenter)); //name是stone里的名字函数，第三个参数对齐方式是中间对齐u
    }
    
    QString Board::name(int id)
    {
        
        return _s[id].name();
    }
    
    bool Board::red(int id)
    {
        
        return _s[id]._red;
    }
    
    void Board::drawInitPosition(QPainter &p, int row, int col)
    {
        
        QPoint pt = center(row, col);
        QPoint off = QPoint(_r/6, _r/6);
        int len = _r/3;
    
        QPoint ptStart;
        QPoint ptEnd;
    
        if(col != 0)
        {
        
            /* 左上角 */
            ptStart = QPoint(pt.x() - off.x(), pt.y() - off.y());
            ptEnd = ptStart + QPoint(-len, 0);
            p.drawLine(ptStart, ptEnd);
            ptEnd = ptStart + QPoint(0, -len);
            p.drawLine(ptStart, ptEnd);
    
            /* 左下角 */
            ptStart = QPoint(pt.x() - off.x(), pt.y() + off.y());
            ptEnd = ptStart + QPoint(-len, 0);
            p.drawLine(ptStart, ptEnd);
            ptEnd = ptStart + QPoint(0, +len);
            p.drawLine(ptStart, ptEnd);
        }
    
        if(col != 8)
        {
        
            /* 右下角 */
            ptStart = QPoint(pt.x() + off.x(), pt.y() + off.y());
            ptEnd = ptStart + QPoint(+len, 0);
            p.drawLine(ptStart, ptEnd);
            ptEnd = ptStart + QPoint(0, +len);
            p.drawLine(ptStart, ptEnd);
    
            /* 右上角 */
            ptStart = QPoint(pt.x() + off.x(), pt.y() - off.y());
            ptEnd = ptStart + QPoint(+len, 0);
            p.drawLine(ptStart, ptEnd);
            ptEnd = ptStart + QPoint(0, -len);
            p.drawLine(ptStart, ptEnd);
        }
    }
    
    void Board::drawInitPosition(QPainter &p)
    {
        
        drawInitPosition(p, 3, 0);
        drawInitPosition(p, 3, 2);
        drawInitPosition(p, 3, 4);
        drawInitPosition(p, 3, 6);
        drawInitPosition(p, 3, 8);
    
        drawInitPosition(p, 6, 0);
        drawInitPosition(p, 6, 2);
        drawInitPosition(p, 6, 4);
        drawInitPosition(p, 6, 6);
        drawInitPosition(p, 6, 8);
    
        drawInitPosition(p, 2, 1);
        drawInitPosition(p, 2, 7);
    
        drawInitPosition(p, 7, 1);
        drawInitPosition(p, 7, 7);
    }
    
    void Board::drawPlace(QPainter &p)
    {
        
        p.drawLine(center(0, 3), center(2, 5));
        p.drawLine(center(2, 3), center(0, 5));
    
        p.drawLine(center(9, 3), center(7, 5));
        p.drawLine(center(7, 3), center(9, 5));
    }
    
    void Board::drawPlate(QPainter &p) //画棋盘线，横10线，竖9线，九宫格
    {
        
        for(int i=0; i<10; ++i) //横10条线
        {
        
            if(i==0 || i==9)
            {
        
                p.setPen(QPen(Qt::black, 3, Qt::SolidLine));
            }
            else
            {
        
                p.setPen(QPen(Qt::black, 1, Qt::SolidLine));
            }
            p.drawLine(center(i, 0), center(i, 8));
        }
    
        for(int i=0; i<9; ++i) //竖着9条线
        {
        
            if(i==0 || i==8)
            {
        
                p.setPen(QPen(Qt::black, 3, Qt::SolidLine));
                p.drawLine(center(0, i), center(9, i));
            }
            else
            {
        
                p.setPen(QPen(Qt::black, 1, Qt::SolidLine));
                p.drawLine(center(0, i), center(4, i));
                p.drawLine(center(5, i), center(9, i));
            }
        }
    }
    
    QPoint Board::center(int row, int col) //将输入的行和列转换成其圆心的位置
    {
        
        QPoint pt(_r*col*2, _r*row*2); //因为是半径所以要乘2
        return pt + _off;
    }
    //重要center函数，函数重载
    QPoint Board::center(int id) //根据输入的棋子的id返回相应的行和列
    {
        
        return center(_s[id]._row, _s[id]._col); //返回的是上面重载函数的返回值即圆心
    }
    
    QPoint Board::topLeft(int row, int col)
    {
        
        return center(row, col) - QPoint(_r, _r);
    }
    
    QPoint Board::topLeft(int id)
    {
        
        return center(id) - QPoint(_r, _r);
    }
    
    QRect Board::cell(int row, int col)
    {
        
        return QRect(topLeft(row, col), QSize(_r*2-1, _r*2-1));
    }
    
    QRect Board::cell(int id)
    {
        
        return QRect(topLeft(id), QSize(_r*2-1, _r*2-1));
    }
    //判断是否点击到了某个棋子的附近（虽然返回的是布尔类型，但是row和col是引用，如果成功则row和col也随之改变）
    bool Board::getClickRowCol(QPoint pt, int &row, int &col)
    {
        
        for(row=0; row<=9; ++row)
        {
        
            for(col=0; col<=8; ++col)
            {
        
                QPoint distance = center(row, col) - pt;
                if(distance.x() * distance.x() + distance.y() * distance.y() < _r* _r)
                    return true;
            }
        }
        return false;
    }
    
    void Board::mouseReleaseEvent(QMouseEvent *ev) //鼠标释放时动作，ev是所点位置
    {
        
        if(ev->button() != Qt::LeftButton)
        {
        
            return;
        }
    
        click(ev->pos());
    }
    
    bool Board::canSelect( int id)
    {
        
        return _bRedTurn == _s[id]._red;
    }
    
    void Board::trySelectStone(int id)
    {
        
        if(id == -1)
            return;
    
        if(!canSelect(id)) return;
    
        _selectid = id;
        update();
    }
    
    bool Board::sameColor(int id1, int id2)
    {
        
        if(id1 == -1 || id2 == -1) return false;
    
        return red(id1) == red(id2);
    }
    
    void Board::tryMoveStone(int killid, int row, int col)
    {
        
        if(killid != -1 && sameColor(killid, _selectid))
        {
        
            trySelectStone(killid);
            return;
        }
    
        bool ret = canMove(_selectid, killid, row, col);
        if(ret)
        {
        
            moveStone(_selectid, killid, row, col);
            _selectid = -1;
            update();
        }
    }
    
    int Board::getStoneCountAtLine(int row1, int col1, int row2, int col2)
    {
        
        int ret = 0;
        if(row1 != row2 && col1 != col2)
            return -1;
        if(row1 == row2 && col1 == col2)
            return -1;
    
        if(row1 == row2)
        {
        
            int min = col1 < col2 ? col1 : col2;
            int max = col1 < col2 ? col2 : col1;
            for(int col = min+1; col<max; ++col)
            {
        
                if(getStoneId(row1, col) != -1) ++ret;
            }
        }
        else
        {
        
            int min = row1 < row2 ? row1 : row2;
            int max = row1 < row2 ? row2 : row1;
            for(int row = min+1; row<max; ++row)
            {
        
                if(getStoneId(row, col1) != -1) ++ret;
            }
        }
    
        return ret;
    }
    
    int Board::relation(int row1, int col1, int row, int col)
    {
        
        return qAbs(row1-row)*10+qAbs(col1-col);
    }
    
    bool Board::canMoveChe(int moveid, int, int row, int col)
    {
        
        GetRowCol(row1, col1, moveid);
        int ret = getStoneCountAtLine(row1, col1, row, col);
        if(ret == 0)
            return true;
        return false;
    }
    
    bool Board::canMoveMa(int moveid, int, int row, int col)
    {
        
        GetRowCol(row1, col1, moveid);
        int r = relation(row1, col1, row, col);
        if(r != 12 && r != 21)
            return false;
    
        if(r == 12)
        {
        
            if(getStoneId(row1, (col+col1)/2) != -1)
                return false;
        }
        else
        {
        
            if(getStoneId((row+row1)/2, col1) != -1)
                return false;
        }
    
        return true;
    }
    
    bool Board::canMovePao(int moveid, int killid, int row, int col)
    {
        
        GetRowCol(row1, col1, moveid);
        int ret = getStoneCountAtLine(row, col, row1, col1);
        if(killid != -1)
        {
        
            if(ret == 1) return true;
        }
        else
        {
        
            if(ret == 0) return true;
        }
        return false;
    }
    
    bool Board::canMoveBing(int moveid, int, int row, int col)
    {
        
        GetRowCol(row1, col1, moveid);
        int r = relation(row1, col1, row, col);
        if(r != 1 && r != 10) return false;
    
        if(isBottomSide(moveid))
        {
        
            if(row > row1) return false;
            if(row1 >= 5 && row == row1) return false;
        }
        else
        {
        
            if(row < row1) return false;
            if(row1 <= 4 && row == row1) return false;
        }
    
        return true;
    }
    
    bool Board::canMoveJiang(int moveid, int killid, int row, int col)
    {
        
        if(killid != -1 && _s[killid]._type == Stone::JIANG)
            return canMoveChe(moveid, killid, row, col);
    
        GetRowCol(row1, col1, moveid);
        int r = relation(row1, col1, row, col);
        if(r != 1 && r != 10) return false;
    
        if(col < 3 || col > 5) return false;
        if(isBottomSide(moveid))
        {
        
            if(row < 7) return false;
        }
        else
        {
        
            if(row > 2) return false;
        }
        return true;
    }
    
    bool Board::canMoveShi(int moveid, int, int row, int col)
    {
        
        GetRowCol(row1, col1, moveid);
        int r = relation(row1, col1, row, col);
        if(r != 11) return false;
    
        if(col < 3 || col > 5) return false;
        if(isBottomSide(moveid))
        {
        
            if(row < 7) return false;
        }
        else
        {
        
            if(row > 2) return false;
        }
        return true;
    }
    
    bool Board::canMoveXiang(int moveid, int, int row, int col)
    {
        
        GetRowCol(row1, col1, moveid);
        int r = relation(row1, col1, row, col);
        if(r != 22) return false;
    
        int rEye = (row+row1)/2;
        int cEye = (col+col1)/2;
        if(getStoneId(rEye, cEye) != -1)
            return false;
    
        if(isBottomSide(moveid))
        {
        
            if(row < 4) return false;
        }
        else
        {
        
            if(row > 5) return false;
        }
        return true;
    }
    
    bool Board::canMove(int moveid, int killid, int row, int col)
    {
        
        if(sameColor(moveid, killid)) return false;
    
        switch (_s[moveid]._type)
        {
        
        case Stone::CHE:
            return canMoveChe(moveid, killid, row, col);
    
        case Stone::MA:
            return canMoveMa(moveid, killid, row, col);
    
        case Stone::PAO:
            return canMovePao(moveid, killid, row, col);
    
        case Stone::BING:
            return canMoveBing(moveid, killid, row, col);
    
        case Stone::JIANG:
            return canMoveJiang(moveid, killid, row, col);
    
        case Stone::SHI:
            return canMoveShi(moveid, killid, row, col);
    
        case Stone::XIANG:
            return canMoveXiang(moveid, killid, row, col);
    
        }
        return false;
    }
    
    void Board::reliveStone(int id)
    {
        
        if(id==-1) return;
        _s[id]._dead = false;
    }
    
    void Board::killStone(int id)
    {
        
        if(id==-1) return;
        _s[id]._dead = true;
    }
    
    bool Board::isBottomSide(int id)
    {
        
        return _bSide == _s[id]._red;
    }
    
    void Board::moveStone(int moveid, int row, int col)
    {
        
        _s[moveid]._row = row;
        _s[moveid]._col = col;
    
        _bRedTurn = !_bRedTurn;
    }
    
    void Board::saveStep(int moveid, int killid, int row, int col, QVector<Step*>& steps)
    {
        
        GetRowCol(row1, col1, moveid);
        Step* step = new Step;
        step->_colFrom = col1;
        step->_colTo = col;
        step->_rowFrom = row1;
        step->_rowTo = row;
        step->_moveid = moveid;
        step->_killid = killid;
    
        steps.append(step);
    }
    
    void Board::moveStone(int moveid, int killid, int row, int col)
    {
        
        saveStep(moveid, killid, row, col, _steps);
    
        killStone(killid);
        moveStone(moveid, row, col);
    }
    
    void Board::click(int id, int row, int col)
    {
        
        if(this->_selectid == -1)
        {
        
            trySelectStone(id);
        }
        else
        {
        
            tryMoveStone(id, row, col);
        }
    }
    //根据点击到的像素返回点击到的棋子，行和列
    void Board::click(QPoint pt)
    {
        
        int row, col;
        bool bClicked = getClickRowCol(pt, row, col); //判断是否满足要求，如果满足要求row和col现在就是满足要求的值
        if(!bClicked) return;
    
        int id = getStoneId(row, col);
        click(id, row, col);
    }
    //根据选中的位置得到该位置棋子id
    int Board::getStoneId(int row, int col)
    {
        
        for(int i=0; i<32; ++i)
        {
        
            if(_s[i]._row == row && _s[i]._col == col && !isDead(i)) //点击到的位置有棋子
                return i;
        }
        return -1;
    }
    
    void Board::back(Step *step)
    {
        
        reliveStone(step->_killid);
        moveStone(step->_moveid, step->_rowFrom, step->_colFrom);
    }
    
    void Board::backOne()
    {
        
        if(this->_steps.size() == 0) return;
    
        Step* step = this->_steps.last();
        _steps.removeLast();
        back(step);
    
        update();
        delete step;
    }
    
    void Board::back()
    {
        
        backOne();
    }
    
    void Board::slotBack()
    {
        
        back();
    }

### Board.h ###

#ifndef BOARD_H
    #define BOARD_H
    
    #include <QFrame>
    #include "Stone.h"
    #include "Step.h"
    #include <QVector>
    
    class Board : public QFrame
    {
        
        Q_OBJECT
    public:
        explicit Board(QWidget *parent = 0);
        ~Board();
    
        /* game data */
        Stone _s[32]; //对应32个棋子
        int _r; //棋子的半径
        QPoint _off;
        bool _bSide;
    
        QVector<Step*> _steps;//记录
    
        /* game status */
        int _selectid;//选中的棋子
        bool _bRedTurn;//红走黑走
        void init(bool bRedSide);
    
        /* draw functions */   //绘制的函数
        void paintEvent(QPaintEvent *);
        void drawPlate(QPainter& p);
        void drawPlace(QPainter& p);
        void drawInitPosition(QPainter& p);//位置
        void drawInitPosition(QPainter& p, int row, int col);
        void drawStone(QPainter& p);//棋子
        void drawStone(QPainter& p, int id);
    
        /* function for coordinate */  //位置转换
        QPoint center(int row, int col);
        QPoint center(int id);
        QPoint topLeft(int row, int col);
        QPoint topLeft(int id);
        QRect cell(int row, int col);
        QRect cell(int id);
    
        bool getClickRowCol(QPoint pt, int& row, int& col);//点击获得行和列
    
        /* help function */  //帮助函数
        QString name(int id);
        bool red(int id);
        bool sameColor(int id1, int id2);
        int getStoneId(int row, int col);
        void killStone(int id); //杀掉棋子
        void reliveStone(int id); //悔棋
        void moveStone(int moveid, int row, int col); //移动棋子
        bool isDead(int id); //判断是否死了
    
        /* move stone */
        void mouseReleaseEvent(QMouseEvent *); //鼠标松开
        void click(QPoint pt); //点击
        virtual void click(int id, int row, int col);  //重载
        void trySelectStone(int id); 
        void tryMoveStone(int killid, int row, int col);
        void moveStone(int moveid, int killid, int row, int col); //移动棋子
        void saveStep(int moveid, int killid, int row, int col, QVector<Step*>& steps); //记录
        void backOne(); //悔棋一步
        void back(Step* step); 
        virtual void back();
    
        /* rule */ //规则相关
        bool canMove(int moveid, int killid, int row, int col);
        bool canMoveChe(int moveid, int killid, int row, int col);
        bool canMoveMa(int moveid, int killid, int row, int col);
        bool canMovePao(int moveid, int killid, int row, int col);
        bool canMoveBing(int moveid, int killid, int row, int col);
        bool canMoveJiang(int moveid, int killid, int row, int col);
        bool canMoveShi(int moveid, int killid, int row, int col);
        bool canMoveXiang(int moveid, int killid, int row, int col);
    
        bool canSelect(int id); //控制
    
        /* rule helper */
        int getStoneCountAtLine(int row1, int col1, int row2, int col2);
        int relation(int row1, int col1, int row, int col);
        bool isBottomSide(int id);
    
    signals:
    
    public slots:
        void slotBack();
    
    };
    
    #endif // BOARD_H

## 人机对战部分 ##

### SingleGame.cpp ###

加了一些人工智能的算法

#include "SingleGame.h"
    #include <QTimer>
    #include <QDebug>
    SingleGame::SingleGame(QWidget *parent) : Board(parent)
    {
        
        _level = 4;
    }
    
    SingleGame::~SingleGame()
    {
        
    
    }
    
    void SingleGame::back()
    {
        
        if(_bRedTurn)
        {
        
            backOne();
            backOne();
        }
    }
    
    void SingleGame::click(int id, int row, int col)
    {
        
        if(_bRedTurn)
        {
        
            Board::click(id, row, col);
            if(!_bRedTurn)
            {
        
                QTimer::singleShot(100, this, SLOT(computerMove()));
            }
        }
    }
    
    void SingleGame::computerMove()
    {
        
        Step* step = getBestMove();
        moveStone(step->_moveid, step->_killid, step->_rowTo, step->_colTo);
        delete step;
        update();
    }
    
    Step* SingleGame::getBestMove()
    {
        
        Step* ret = NULL;
        QVector<Step*> steps;
        getAllPossibleMove(steps);
        int maxInAllMinScore = -300000;
    
        while(steps.count())
        {
        
            Step* step = steps.last();
            steps.removeLast();
    
            fakeMove(step);
            int minScore = getMinScore(this->_level-1, maxInAllMinScore);
            unfakeMove(step);
    
            if(minScore > maxInAllMinScore)
            {
        
                if(ret) delete ret;
    
                ret = step;
                maxInAllMinScore = minScore;
            }
            else
            {
        
                delete step;
            }
        }
        return ret;
    }
    
    int SingleGame::score()
    {
        
      //  enum TYPE{CHE, MA, PAO, BING, JIANG, SHI, XIANG};
        static int s[] = {
        1000, 499, 501, 200, 15000, 100, 100};
        int scoreBlack = 0;
        int scoreRed = 0;
        for(int i=0; i<16; ++i)
        {
        
            if(_s[i]._dead) continue;
            scoreRed += s[_s[i]._type];
        }
        for(int i=16; i<32; ++i)
        {
        
            if(_s[i]._dead) continue;
            scoreBlack += s[_s[i]._type];
        }
        return scoreBlack - scoreRed;
    }
    
    int SingleGame::getMinScore(int level, int curMin)
    {
        
        if(level == 0)
            return score();
    
        QVector<Step*> steps;
        getAllPossibleMove(steps);
        int minInAllMaxScore = 300000;
    
        while(steps.count())
        {
        
            Step* step = steps.last();
            steps.removeLast();
    
            fakeMove(step);
            int maxScore = getMaxScore(level-1, minInAllMaxScore);
            unfakeMove(step);
            delete step;
    
            if(maxScore <= curMin)
            {
        
                while(steps.count())
                {
        
                    Step* step = steps.last();
                    steps.removeLast();
                    delete step;
                }
                return maxScore;
            }
    
            if(maxScore < minInAllMaxScore)
            {
        
                minInAllMaxScore = maxScore;
            }
    
    
        }
        return minInAllMaxScore;
    }
    int SingleGame::getMaxScore(int level, int curMax)
    {
        
        if(level == 0)
            return score();
    
        QVector<Step*> steps;
        getAllPossibleMove(steps);
        int maxInAllMinScore = -300000;
    
        while(steps.count())
        {
        
            Step* step = steps.last();
            steps.removeLast();
    
            fakeMove(step);
            int minScore = getMinScore(level-1, maxInAllMinScore);
            unfakeMove(step);
            delete step;
    
            if(minScore >= curMax)
            {
        
                while(steps.count())
                {
        
                    Step* step = steps.last();
                    steps.removeLast();
                    delete step;
                }
                return minScore;
            }
            if(minScore > maxInAllMinScore)
            {
        
                maxInAllMinScore = minScore;
            }
    
    
        }
        return maxInAllMinScore;
    }
    
    
    void SingleGame::fakeMove(Step *step)
    {
        
        killStone(step->_killid);
        moveStone(step->_moveid, step->_rowTo, step->_colTo);
    }
    
    void SingleGame::unfakeMove(Step *step)
    {
        
        reliveStone(step->_killid);
        moveStone(step->_moveid, step->_rowFrom, step->_colFrom);
    }
    
    void SingleGame::getAllPossibleMove(QVector<Step *> &steps)
    {
        
        int min, max;
        if(this->_bRedTurn)
        {
        
            min = 0, max = 16;
        }
        else
        {
        
            min = 16, max = 32;
        }
    
        for(int i=min;i<max; i++)
        {
        
            if(this->_s[i]._dead) continue;
            for(int row = 0; row<=9; ++row)
            {
        
                for(int col=0; col<=8; ++col)
                {
        
                    int killid = this->getStoneId(row, col);
                    if(sameColor(i, killid)) continue;
    
                    if(canMove(i, killid, row, col))
                    {
        
                        saveStep(i, killid, row, col, steps);
                    }
                }
            }
        }
    }

### SingleGame.h ###

#ifndef SINGLEGAME_H
    #define SINGLEGAME_H
    
    #include "Board.h"
    
    class SingleGame : public Board
    {
        
        Q_OBJECT
    public:
        explicit SingleGame(QWidget *parent = 0);
        ~SingleGame();
    
        int _level;
    
        void back();
        void click(int id, int row, int col);
    
        Step* getBestMove();
        void getAllPossibleMove(QVector<Step*>& steps);
        int getMinScore(int level, int curMin);
        int getMaxScore(int level, int curMax);
        int score();
    
        void fakeMove(Step* step);
        void unfakeMove(Step* step);
    
    signals:
    
    public slots:
        void computerMove();
    };
    
    #endif // SINGLEGAME_H

## 人人对战部分 ##

### MultiGame.cpp ###

跟Board逻辑一样

#include "MultiGame.h"
    
    MultiGame::MultiGame(QWidget *parent) : Board(parent)
    {
        
    
    }
    
    MultiGame::~MultiGame()
    {
        
    
    }

### MultiGame.h ###

#ifndef MAINWND_H
    #define MAINWND_H
    
    #include <QWidget>
    #include "Board.h"
    #include "CtrlPanel.h"
    
    class MainWnd : public QWidget
    {
        
        Q_OBJECT
    public:
        explicit MainWnd(int gameType, QWidget *parent = 0);
        ~MainWnd();
    
        int _gameType;
    
    signals:
    
    public slots:
    };
    
    #endif // MAINWND_H

## 网络对战部分 ##

### NetGame.cpp ###

#include "NetGame.h"
    
    NetGame::NetGame(bool server, QWidget *parent) : Board(parent)
    {
        
        _server = NULL;
        _socket = NULL;
        _bServer = server;
    
        if(_bServer)
        {
        
            _server = new QTcpServer(this);
            _server->listen(QHostAddress::Any, 9899);
            connect(_server, SIGNAL(newConnection()), this, SLOT(slotNewConnection()));
        }
        else
        {
        
            _socket = new QTcpSocket(this);
            _socket->connectToHost(QHostAddress("127.0.0.1"), 9899);
            connect(_socket, SIGNAL(readyRead()), this, SLOT(slotDataArrive()));
        }
    }
    
    void NetGame::slotNewConnection()
    {
        
        if(_socket) return;
    
        _socket = _server->nextPendingConnection();
        connect(_socket, SIGNAL(readyRead()), this, SLOT(slotDataArrive()));
    
        /* 产生随机数来决定谁走红色 */
        bool bRedSide = qrand()%2>0;
        init(bRedSide);
    
        /* 发送给对方 */
        QByteArray buf;
        buf.append(1);
        buf.append(bRedSide?0:1);
        _socket->write(buf);
    }
    
    void NetGame::back()
    {
        
        if(_bRedTurn != _bSide)
            return;
        backOne();
        backOne();
    
        QByteArray buf;
        buf.append(3);
        _socket->write(buf);
    }
    
    void NetGame::click(int id, int row, int col)
    {
        
        if(_bRedTurn != _bSide)
            return;
    
        Board::click(id, row, col);
    
        /* 发送给对方 */
        QByteArray buf;
        buf.append(2);
        buf.append(id);
        buf.append(row);
        buf.append(col);
        _socket->write(buf);
    }
    
    void NetGame::backFromNetwork(QByteArray)
    {
        
        backOne();
        backOne();
    }
    void NetGame::clickFromNetwork(QByteArray buf)
    {
        
        Board::click(buf[1], 9-buf[2], 8-buf[3]);
    }
    void NetGame::initFromNetwork(QByteArray buf)
    {
        
        bool bRedSide = buf.at(1)>0?true:false;
        init(bRedSide);
    }
    
    void NetGame::slotDataArrive()
    {
        
        QByteArray buf = _socket->readAll();
        switch (buf.at(0)) {
        
        case 1:
            initFromNetwork(buf);
            break;
        case 2:
            clickFromNetwork(buf);
            break;
        case 3:
            backFromNetwork(buf);
            break;
        default:
            break;
        }
    }
    
    NetGame::~NetGame()
    {
        
    
    }

### NetGame.h ###

#ifndef NETGAME_H
    #define NETGAME_H
    
    #include "Board.h"
    #include <QTcpServer>
    #include <QTcpSocket>
    
    /*
     * 报文格式定义
     * 1.初始化    两个字节
     * 2.鼠标点击   四个字节
     * 3.悔棋      一个字节
     *
    */
    
    class NetGame : public Board
    {
        
        Q_OBJECT
    public:
        explicit NetGame(bool server, QWidget *parent = 0);
        ~NetGame();
    
        bool _bServer;
        QTcpServer* _server;
        QTcpSocket* _socket;
    
        void back();
        void click(int id, int row, int col);
    
        void backFromNetwork(QByteArray buf);
        void clickFromNetwork(QByteArray buf);
        void initFromNetwork(QByteArray buf);
    
    signals:
    
    public slots:
        void slotNewConnection();
        void slotDataArrive();
    };
    
    #endif // NETGAME_H

## 棋子部分 ##

### Stone.cpp ###

#include "Stone.h"
    #include <QDebug>
    
    Stone::Stone() //构造
    {
        
    
    }
    
    Stone::~Stone() //析构
    {
        
    
    }
    
    QString Stone::name() //根据枚举类型返回名字
    {
        
        switch(this->_type)
        {
        
        case CHE:
            return "车";
        case MA:
            return "马";
        case PAO:
            return "炮";
        case BING:
            return "兵";
        case JIANG:
            return "将";
        case SHI:
            return "士";
        case XIANG:
            return "相";
        }
        return "错误";
    }
    
    void Stone::init(int id) //棋子初始化函数
    {
        
        struct {
                        //定义了一个结构体数组
            int row, col;
            Stone::TYPE type;
        } pos[16] = {
        
        {
        0, 0, Stone::CHE},
        {
        0, 1, Stone::MA},
        {
        0, 2, Stone::XIANG},
        {
        0, 3, Stone::SHI},
        {
        0, 4, Stone::JIANG},
        {
        0, 5, Stone::SHI},
        {
        0, 6, Stone::XIANG},
        {
        0, 7, Stone::MA},
        {
        0, 8, Stone::CHE},
    
        {
        2, 1, Stone::PAO},
        {
        2, 7, Stone::PAO},
        {
        3, 0, Stone::BING},
        {
        3, 2, Stone::BING},
        {
        3, 4, Stone::BING},
        {
        3, 6, Stone::BING},
        {
        3, 8, Stone::BING},
        };
    
        if(id < 16) //红棋
        {
        
            this->_col = pos[id].col;  //this是类对象，代表该棋子
            this->_row = pos[id].row;
            this->_type = pos[id].type;
        }
        else  //黑棋
        {
        
            this->_col = 8-pos[id-16].col; //对称结构，列相加等于8，行相加等于9
            this->_row = 9-pos[id-16].row;
            this->_type = pos[id-16].type;
        }
    
        this->_dead = false;
        this->_red = id<16;
    }
    
    void Stone::rotate()
    {
        
        this->_col = 8-this->_col;
        this->_row = 9-this->_row;
    }

### Stone.h ###

#ifndef STONE_H
    #define STONE_H
    
    #include <QRect>
    #include <QPainter>
    
    class Stone
    {
        
    public:
        Stone();
        ~Stone();
    	
    	//枚举类型
        enum TYPE{
        CHE, MA, PAO, BING, JIANG, SHI, XIANG};
    
        void init(int id);
    
        int _row; //行
        int _col;//列
        TYPE _type; //类型，枚举类型
        bool _dead;//被杀
        bool _red;//红黑
        int _id; //id
    
        QString name(); //象棋名字
    
        void rotate();//旋转，用在网络对战中
    };
    
    #endif // STONE_H

## 走棋部分 ##

### Step.cpp ###

#include "Step.h"
    
    Step::Step(QObject *parent) : QObject(parent)
    {
        
    
    }
    
    Step::~Step()
    {
        
    
    }

### Step.h ###

#ifndef STEP_H
    #define STEP_H
    
    #include <QObject>
    
    class Step : public QObject
    {
        
        Q_OBJECT
    public:
        explicit Step(QObject *parent = 0);
        ~Step();
    
        int _moveid; //移动的棋
        int _killid;
        int _rowFrom;
        int _colFrom;
        int _rowTo;
        int _colTo;
    
    signals:
    
    public slots:
    };
    
    #endif // STEP_H

## 关于人工智能走法 ##

关于极大极小值算法：

极大极小值算法是一种找出**失败的最大可能性中的最小值的算法**（**即最小化对手的最大得益**）。举个例子，电脑为A，人类为B，A在走棋之前需要思考，A走了某一步后，看看B有哪些走法，B又不傻，所以B肯定是要选择让A得分最少的走法走棋，**而A就是在A的所有走法中选择B给出的让A得分最少的走法中得分最多的走法**。听起来大概会比较抽象比较绕吧，试着多读几遍，多理解理解。

给电脑配置极大极小值算法让电脑选择走棋路径大概分3步走（还是电脑为A，人类为B）：

1.**在当前局面下获取A的所有走棋路径，并试着走一下**。

2.**在上一步（A已经试着走了一下）的基础上获取B的所有走棋路径，并以B的视角试着走一下，然后评估局面分（因为A是电脑，所以局面分是以A的角度计算的，即A的总分-B的总分），遍历完B的所有走棋路径后返回这些局面分中的最小值（对A最不利而对B最有利）。**

3.**在上一步返回的局面分的最小值中，找到最大值，并锁定与该最大值对应的走棋路径作为返回值返回。**

为什么要考虑B所有走法最大值？：人被认为是会选择收益最大的，由于分数是在机器阵营的，所以最大收益是最小分数，当求出所有走法的最大收益都被求出后，要最小化这些收益，所以要找出这些分数的最大值。  
**最小化人的最大收益=求机器分数里最小值中的最大值；**

# 补充：QT核心：信号与槽机制学习 #

## Q\_OBJECT ##

只有加入了Q\_OBJECT，才能使用QT中的signal和slot机制，而且Q\_OBJECT要放在类的最前面  
1.QT的信号与槽机制介绍

### 1.1 信号与槽 ###

**信号和槽机制是 QT 的核心机制**，要精通 QT 编程就必须对信号和槽有所了解。信号和槽是一种高级接口，应用于对象之间的通信，它是 QT 的核心特性，也是 QT 区别于其它工具包的重要地方。信号和槽是 QT 自行定义的一种通信机制，它独立于标准的 C/C++ 语言，因此要正确的处理信号和槽，必须借助一个称为 **moc（Meta Object Compiler）的 QT 工具，该工具是一个 C++ 预处理程序，它为高层次的事件处理自动生成所需要的附加代码。**  
在我们所熟知的很多 GUI 工具包中，**窗口小部件 (widget) 都有一个回调函数用于响应它们能触发的每个动作，这个回调函数通常是一个指向某个函数的指针**。但是，在 QT 中信号和槽取代了这些凌乱的函数指针，使得我们编写这些通信程序更为简洁明了。 信号和槽能携带任意数量和任意类型的参数，他们是类型完全安全的，不会像回调函数那样产生 core dumps。  
**所有从 QObject 或其子类 ( 例如 Qwidget) 派生的类都能够包含信号和槽**。当对象改变其状态时，信号就由该对象发射 (emit) 出去，这就是对象所要做的全部事情，它不知道另一端是谁在接收这个信号。这就是真正的信息封装，它确保对象被当作一个真正的软件组件来使用。槽用于接收信号，但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且，对象并不了解具体的通信机制。  
可以将很多信号与单个的槽进行连接，也可以将单个的信号与很多的槽进行连接，甚至于将一个信号与另外一个信号相连接也是可能的，这时无论第一个信号什么时候发射系统都将立刻发射第二个信号。总之，信号与槽构造了一个强大的部件编程机制。

### 1.2 信号 ###

当某个信号对其客户或所有者发生的内部状态发生改变，信号被一个对象发射。只有定义过这个信号的类及其派生类能够发射这个信号。当一个信号被发射时，与其相关联的槽将被立刻执行，就象一个正常的函数调用一样。信号 - 槽机制完全独立于任何 GUI 事件循环。只有当所有的槽返回以后发射函数（emit）才返回。 如果存在多个槽与某个信号相关联，那么，当这个信号被发射时，这些槽将会一个接一个地执行，但是它们执行的顺序将会是随机的、不确定的，我们不能人为地指定哪个先执行、哪 个后执行。  
信号的声明是在头文件中进行的，QT 的 signals 关键字指出进入了信号声明区，随后即可声明自己的信号。例如，下面定义了三个信号：

signals: 
      voiySignd mal(); 
      void mySignal(int x); 
      void mySignalParam(int x,int y);

在上面的定义中，signals 是 QT 的关键字，而非 C/C++ 的。接下来的一行 void mySignal() 定义了信号 mySignal，这个信号没有携带参数；接下来的一行 void mySignal(int x) 定义 了重名信号 mySignal，但是它携带一个整形参数，这有点类似于 C++ 中的虚函数。从形式上 讲信号的声明与普通的 C++ 函数是一样的，但是信号却没有函数体定义，另外，信号的返回类型都是 void，不要指望能从信号返回什么有用信息。  
信号由moc自动产生，它们不应该在 .cpp 文件中实现。

### 1.3 槽 ###

**槽是普通的 C++ 成员函数，可以被正常调用，它们唯一的特殊性就是很多信号可以与其相关联**。当与其关联的信号被发射时，这个槽就会被调用。槽可以有参数，但槽的参数不能有缺省值。  
既然槽是普通的成员函数，因此与其它的函数一样，它们也有存取权限。槽的存取权限决定了谁能够与其相关联。同普通的 C++ 成员函数一样，槽函数也分为三种类型，即 public slots、private slots 和 protected slots。

public slots：在这个区内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程非常有用，可以创建彼此互不了解的对象，将它们的信号与槽进行连接以便信息能够正确的传递。  
protected slots：在这个区内声明的槽意味着当前类及其子类可以将信号与之相连接。适用于那些槽，它们是类实现的一部分，但是其界面接口却面向外部。  
private slots：在这个区内声明的槽意味着只有类自己可以将信号与之相连接。适用于联系非常紧密的类。  
槽也能够声明为虚函数，这也是非常有用的。  
槽的声明也是在头文件中进行的。例如，下面声明了三个槽：

public slots: 
      void mySlot(); 
      void mySlot(int x); 
      void mySignalParam(int x,int y);

### 1.4 信号与槽的关联 ###

通过调用 QObject 对象的 connect 函数来将某个对象的信号与另外一个对象的槽函数相关联，这样当发射者发射信号时，接收者的槽函数将被调用。该函数的定义如下：

bool QObject::connect ( const QObject * sender, const char * signal, 
    		 const QObject * receiver, const char * member ) [static]

这个函数的作用就是将发射者 sender 对象中的信号 signal 与接收者 receiver 中的 member 槽函数联系起来。**当指定信号 signal 时必须使用 QT 的宏 SIGNAL()，当指定槽函数时必须使用宏 SLOT()**。如果发射者与接收者属于同一个对象的话，那么在 connect 调用中接收者参数可以省略。  
例如，下面定义了两个对象：标签对象 label 和滚动条对象 scroll，并将 valueChanged() 信号与标签对象的 setNum() 相关联，另外信号还携带了一个整形参数，这样标签总是显示滚动条所处位置的值。

QLabel     *label  = new QLabel; 
    QScrollBar *scroll = new QScrollBar; 
    QObject::connect( scroll, SIGNAL(valueChanged(int)), label,  SLOT(setNum(int)) );

### 2.一个小例子 ###

//tsignal.h 
     class TsignalApp:public QMainWindow 
     {
         
    	 Q_OBJECT 
    	 ... 
    	 // 信号声明区
    	 signals: 
    		 // 声明信号 mySignal() 
    		 void mySignal(); 
    		 // 声明信号 mySignal(int) 
    		 void mySignal(int x); 
    		 // 声明信号 mySignalParam(int,int) 
    		 void mySignalParam(int x,int y); 
    	 // 槽声明区
    	 public slots: 
    		 // 声明槽函数 mySlot() 
    		 void mySlot(); 
    		 // 声明槽函数 mySlot(int) 
    		 void mySlot(int x); 
    		 // 声明槽函数 mySignalParam (int，int) 
    		 void mySignalParam(int x,int y); 
     } 
     ... 
     //tsignal.cpp 
     ... 
     TsignalApp::TsignalApp() 
     {
         
    	 ... 
    	 // 将信号 mySignal() 与槽 mySlot() 相关联
    	 connect(this,SIGNAL(mySignal()),SLOT(mySlot())); 
    	 // 将信号 mySignal(int) 与槽 mySlot(int) 相关联
    	 connect(this,SIGNAL(mySignal(int)),SLOT(mySlot(int))); 
    	 // 将信号 mySignalParam(int,int) 与槽 mySlotParam(int,int) 相关联
    	 connect(this,SIGNAL(mySignalParam(int,int)),SLOT(mySlotParam(int,int))); 
     } 
     // 定义槽函数 mySlot() 
     void TsignalApp::mySlot() 
     {
         
    	 QMessageBox::about(this,"Tsignal", "This is a signal/slot sample without 
     parameter."); 
     } 
     // 定义槽函数 mySlot(int) 
     void TsignalApp::mySlot(int x) 
     {
         
    	 QMessageBox::about(this,"Tsignal", "This is a signal/slot sample with one 
     parameter."); 
     } 
     // 定义槽函数 mySlotParam(int,int) 
     void TsignalApp::mySlotParam(int x,int y) 
     {
         
    	 char s[256]; 
    	 sprintf(s,"x:%d y:%d",x,y); 
    	 QMessageBox::about(this,"Tsignal", s); 
     } 
     void TsignalApp::slotFileNew() 
     {
         
    	 // 发射信号 mySignal() 
    	 emit mySignal(); 
    	 // 发射信号 mySignal(int) 
    	 emit mySignal(5); 
    	 // 发射信号 mySignalParam(5，100) 
    	 emit mySignalParam(5,100); 
     }

### 3.关于元对象工具MOC ###

**元对象编译器 moc（meta object compiler）对 C++ 文件中的类声明进行分析并产生用于初始化元对象的 C++ 代码，元对象包含全部信号和槽的名字以及指向这些函数的指针。**  
moc 读 C++ 源文件，如果发现有 **Q\_OBJECT 宏声明的类，它就会生成另外一个 C++ 源文件**，这个新生成的文件中包含有该类的元对象代码。例如，假设我们有一个头文件 mysignal.h，在这个文件中包含有信号或槽的声明，那么在编译之前 moc 工具就会根据该文件自动生成一个名为 mysignal.moc.h 的 C++ 源文件并将其提交给编译器；类似地，对应于 mysignal.cpp 文件 moc 工具将自动生成一个名为 mysignal.moc.cpp 文件提交给编译器。  
**元对象代码是 signal/slot 机制所必须的**。用 moc 产生的 C++ 源文件必须与类实现一起进行编译和连接，或者用 \#include 语句将其包含到类的源文件中。moc 并不扩展 \#include 或者 \#define 宏定义 , 它只是简单的跳过所遇到的任何预处理指令。

原文链接：https://blog.csdn.net/shenziheng1/article/details/78055056

# 补充：剪枝算法学习 #

算法思想  
首先要说的是，alpha-beta剪枝建立在两个假设上：

整个博弈过程属于零和博弈，即一方的收益必然意味着另一方的损失，博弈双方的收益和损失相加总和永远是零，双方不存在任何合作的可能。粗俗理解就是你赚了我就亏了。  
博弈双方足够聪明，即每一方在决策时总会选择使自己利益最大化的决策。粗俗理解就是，假设是在下棋，那么大家下棋时大家走的都是固定的且是对自己最好的，下多少局也是这样。  
在满足这样的假设的情况下，整个α-β剪枝的核心思想就是，当你知道你有一个选择A时，此时你知道了B选择不如A选择好，那么你就不需要知道B选择有多坏。

这句话可能有些抽象，看下面我在别的地方偷来的图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70]  
假设我们在玩游戏，我有两个钱包，我们可以依次从钱包里拿一张钱给你去买饮料，我先拿你再拿。钱包A里面装着5毛钱和X块钱，钱包B里面装着2块钱和10块钱，我和你知道的只有这些。问你这时候去哪个钱包拿钱？

当然是从B钱包拿钱了！因为此时你知道我为了让你不拿走我太多的钱，我肯定会先从A钱包拿一张最小的钱（可能是0.5，也可能是X）给你，或者先从B钱包里拿2块钱（最优选择）给你。那么从B钱包里你至少能拿到2块钱，而A钱包里现在最多就能拿出来5毛钱了，因为如果X大于0.5（例如图中的100块）我是不会给你的。因此你不需要再考虑B钱包里放的X块钱到底是多少钱了，和你没关系，最多你只能拿到0.5。

所以这时我们就可以不考虑这个B钱包了，因为无论X是多少钱，选择B都会亏，因为敌人太聪明，永远给你的都是五毛钱。这样我们就可以减少一些考虑的情况，我们称之为剪枝。

算法流程  
整个算法流程的前提是固定深度的搜索，也就是我们平时说的下棋看多少步，同时我们还要有能力推演到达多少步后对我们的有利程度。

假设我们继续玩这个游戏，不过现在我们有了很多钱包和很多面值的钱。正方形代表我们做的决策，圆形代表对手的决策。

首先我们推演走两步之后，对手可以给我们选的是5块钱和6块钱，但是我们知道敌人足够聪明，因此他会给我们选5块，此时我们最少是获得五块  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 1]  
然后我们开始看看第二步选择别的会是什么结果，我们遍历完7块觉得不错，然后遍历到4块的时候，就发现不对了。既然有4块，那么对手给我们的肯定是4块或者后面还没遍历到的那些，如果那些大于4块，对手肯定会给我个4块的，如果小于4块，那给了我岂不是更亏了。因此我不能选这个分支，我只能选上一步那个分支，那后面是多少钱实际上和我都没关系了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 2]  
遍历完这些，我们已经保底知道目前我们最多能拿个5块钱了。同理，在另一条分支我们也可以知道最多可以拿个3块钱。而站在对手的角度，我们也知道，他肯定会选让我们仅仅能拿到3块钱的方案。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 3]  
我们总结出第一条能够剪枝的方案，对手发现可以给我们一个比我们当前可获得最大收益值更小的值时，触发剪枝。另一种情况在图上没有画出，即当我们发现可以获得一个比对手可让我们获得最小收益值更大的值时，触发剪枝（例如下图，蓝字第一行是最少写错了）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 4]  
对手发现可以给我们一个比我们当前可获得最大收益值更小的值时，触发剪枝。

我们发现可以获得一个比我们当前获得最小收益值更大的值时，触发剪枝。

通过仔细研究这两句话和上图，我们发现，对手遍历的结点和我们可获得最大收益的结点都是同一类结点，即方块结点，同理我们遍历的结点和我们可获得最小收益的结点都是圆圈结点。因此我们需要在对手遍历结点时考虑我们的最大收益，在我们遍历结点时考虑我们的最小收益，因此我们才需要了上界和下界两个变量。

下面翻译一下定义：

对于一个结点MIN（敌人结点），若能估计出其倒推值的上界（遍历的值），若这个上界不大于（小于）MIN的父节点（最大收益），及时停止那些已无必要再扩展的结点……  
伪代码几行的事情：

function minimax(node, depth, a, b)
        if node is a terminal node or depth = 0
            return the heuristic value of node
        if #opposite
            foreach child of node
                b := min(a, minimax(child, depth-1, a, b))
                if b <= a 
                      return b
            return b
        else we
            foreach child of node
                a := max(b, minimax(child, depth-1, a, b))
                if b <= a 
                       return a
             return a

实际上，如果记住这个结论会很方便，而且也避免了把自己绕进去的问题发生，好像即使知道了也没有太多的意义，更多的是让自己更舒服一点。

这个问题感觉像是个逻辑上的问题，大概的逻辑就是，我知道你会选那个让我最差的A，那么如果有让我更差B的出现，我会选那个你会选的让我更差A的那个的上一步，让你只能选A，然后无限递归下去。从小到大没接受过逻辑训练，真的把自己绕进去了。

但是我想可能会有几个问题：

第一个是，对方一定会选择使自己最差的思路这个先验知识，在真实情况下本身就不正确的，因为无法确定对方的博弈策略是否和自己一致。如果对方做的策略不是最优，那么我的策略是最优的假设也不复存在。

第二个是，这个和位置的相关性很大，实际上可能和深度优先搜索的复杂度差不了多少。

第三个是，很难确定你评估的上界和下界是否是真实的，如果回溯的深度不够，感觉很容易陷入局部最优。所以我还是更相信概率模型（类似马尔可夫决策以及强化学习，虽然我对他们的了解不多）

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200313100843248.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200313100955628.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020031310102344.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200313101106411.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020031310113520.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ==,size_16,color_FFFFFF,t_70