Qt版本中国象棋开发（三）

实现功能：棋子初始化及走棋规则

棋子类：

#ifndef STONE_H
#define STONE_H

#include <QString>

class Stone
{
public:
    Stone();
    ~Stone();

    enum TYPE{JIANG, CHE, PAO, MA, BING, SHI, XIANG};

    int _row;    //棋子所在行
    int _col;    //棋子所在列
    TYPE _type;  //棋子类型（JIANG,CHE...）


    int _id;     //棋子id（0-31）
    bool _dead;  //棋子是否死亡
    bool _red;   //是否为红方

    void 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},
            };

        _id = id;
        _dead = false;
        _red = id<16;

        if(id < 16)
        {
            _row = pos[id].row;
            _col = pos[id].col;
            _type = pos[id].type;
        }
        else
        {
            _row = 9-pos[id-16].row;
            _col = 8-pos[id-16].col;
            _type = pos[id-16].type;
        }

    }

    QString getText()  //返回棋子类型对应的汉字，便于绘制棋面汉字
    {
        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 "错误";
    }
};

#endif // STONE_H

棋盘类：

#ifndef BOARD_H
#define BOARD_H

#include <QWidget>
#include "Stone.h"

class Board : public QWidget
{
    Q_OBJECT
public:
    explicit Board(QWidget *parent = 0);

    Stone _s[32];   //32枚棋子
    int _r;         //棋子的半径
    int _selectid;  //记录选中的棋子id
    bool _bRedTurn; //记录是否轮到红方走棋

    /* 返回象棋棋盘行列对应的像素坐标 */
    QPoint center(int row, int col);
    QPoint center(int id);

    /* 返回象棋棋盘上某个坐标对应的行，列 */
    bool getRowCol(QPoint pt, int& row, int& col);

    /* 绘制棋子*/
    void drawStone(QPainter& painter, int id);

    void paintEvent(QPaintEvent *);

    /* 鼠标释放事件 */
    void mouseReleaseEvent(QMouseEvent *);

    /* 根据要移动的棋子moveid，将要移动到的位置（row，col），将被吃掉的棋子killid判断能否走棋 */
    bool canMove(int moveid, int row, int col, int killid);
    /* 将 */
    bool canMove1(int moveid, int row, int col, int killid);
    /* 车 */
    bool canMove2(int moveid, int row, int col, int killid);
    bool canMove3(int moveid, int row, int col, int killid);
    bool canMove4(int moveid, int row, int col, int killid);
    bool canMove5(int moveid, int row, int col, int killid);
    bool canMove6(int moveid, int row, int col, int killid);
    bool canMove7(int moveid, int row, int col, int killid);

signals:

public slots:

};

#endif // BOARD_H

判断走棋函数：

bool Board::canMove(int moveid, int row, int col, int killid)
{
    if(_s[moveid]._red == _s[killid]._red)//moveid和killid颜色相同)
    {
        //换选择
        _selectid = killid;
        update();

        return false;
    }

    switch(_s[moveid]._type)
    {
    case Stone::JIANG:
        return canMove1(moveid, row, col, killid);
        break;
    case Stone::SHI:
        return canMove2(moveid, row, col, killid);
        break;
    case Stone::XIANG:
        return canMove3(moveid, row, col, killid);
        break;
    case Stone::CHE:
        return canMove4(moveid, row, col, killid);
        break;
    case Stone::MA:
        return canMove5(moveid, row, col, killid);
        break;
    case Stone::PAO:
        return canMove6(moveid, row, col, killid);
        break;
    case Stone::BING:
        return canMove7(moveid, row, col, killid);
        break;
    }

    return true;
}

“将” 的走棋规则说明：

bool Board::canMove1(int moveid, int row, int col, int killid)
{
    /*
        1.首先目标位置在九宫内
        2.移动的步长是一个格子
    */
    if(_s[moveid]._red)
    {
        if(row > 2)return false;
    }
    else
    {
        if(row < 7)return false;
    }

    if(col < 3) return false;
    if(col > 5) return false;

    int dr = _s[moveid]._row - row;
    int dc = _s[moveid]._col - col;
    int d = abs(dr)*10 + abs(dc); // 12, 21   22   10, 1
    if(d == 1 || d == 10)
        return true;

    return false;
}

判断 “将” 要移动的位置与原来位置相差一步的处理：

int dr = _s[moveid]._row - row;
    int dc = _s[moveid]._col - col;
    int d = abs(dr)*10 + abs(dc); // 12, 21   22   10, 1
    if(d == 11)
        return true;

鼠标点击释放事件：

void Board::mouseReleaseEvent(QMouseEvent *ev)
{
    QPoint pt = ev->pos();
    // 将pt转化成象棋的行列值
    // 判断这个行列值上面有没有棋子
    int row, col;
    bool bRet = getRowCol(pt, row, col);
    if(bRet == false) // 点到棋盘外
        return;

    int i;
    int clickid = -1;
    for(i=0;i<32;++i)
    {
        if(_s[i]._row == row && _s[i]._col == col && _s[i]._dead== false)
        {
            break;
        }
    }

    if(i<32)
    {
        clickid = i;
    }

    if(_selectid == -1)
    {
        if(clickid != -1)
        {
            if(_bRedTurn == _s[clickid]._red)
            {
                _selectid = clickid;
                update();
            }
        }
    }
    else
    {
        if(canMove(_selectid, row, col, clickid))
        {
            /*走棋*/
            _s[_selectid]._row = row;
            _s[_selectid]._col = col;
            if(clickid != -1)
            {
                _s[clickid]._dead = true;
            }
            _selectid = -1;
            _bRedTurn = !_bRedTurn;
            update();
        }
    }
}

效果图：