中国象棋游戏Chess（3） - 实现走棋规则

棋盘的绘制和走棋参看博文：中国象棋游戏Chess（1） - 棋盘绘制以及棋子的绘制，中国象棋游戏Chess（2）
- 走棋

现在重新整理之前写的代码，并且对于每个棋子的走棋规则都进行了限制，不像之前那样每个棋子都可以走到任意位置。

也实现了红先黑后，并且每一方走一步，交替走棋的功能。

直接看代码：

// Board.h
// Board类实现了棋盘的绘制以及显示
//
 
#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();
 
    /*===> 游戏数据 <===*/
    Stone _s[32]; // 定义32个棋子
    int _r; // 棋子的半径
    QPoint _off;
    bool _bSide;
 
    QVector<Step*> _steps; // 悔棋时使用
 
    /*===> 游戏状态 <===*/
    int _selectid;
    bool _bRedTurn;
    void init(bool bRedSide);
 
    /*===> 绘图函数 <===*/
    virtual void paintEvent(QPaintEvent *);
    void DrawBackground(); // 设置背景颜色
    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);
 
    /*===> 坐标转换相关函数 <===*/
    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);
 
    /*===> 帮助函数 <===*/
    QString name(int id);
    bool red(int id);
    bool sameColor(int id1, int id2);
    int getStoneId(int row, int col); // 获取行row列col上的棋子id
    void killStone(int id);
    void reliveStone(int id);
    void moveStone(int moveid, int row, int col);
    bool isDead(int id); // 判断id棋子是否死亡
 
    /*===> 移动相关函数 <===*/
    virtual void mouseReleaseEvent(QMouseEvent *ev); // 鼠标点击象棋并释放鼠标时候触发
    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();
 
    /*===> 移动规则 <===*/
    bool canMove(int moveid, int killid, int row, int col);
    bool canMoveJiang(int moveid, int killid, int row, int col);
    bool canMoveShi(int moveid, int, int row, int col);
    bool canMoveXiang(int moveid, int, int row, int col);
    bool canMoveChe(int moveid, int, 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 canSelect(int id);
 
    /*===> 移动规则相关的几个帮助函数 <===*/
    int relation(int row1, int col1, int row, int col); // 得到两点之间的关系值
    bool isBottomSide(int id); // 判断id棋子是否在棋盘下方
    // 判断两个点是否在同一条直线上，炮和车走棋的时候需要用到
    int getStoneCountAtLine(int row1, int col1, int row2, int col2);
 
signals:
 
public slots:
    void slotBack();
};
 
#endif // BOARD_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;
    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;
    _bRedTurn = true;
    _bSide = bRedSide;
    update();
}
 
// 绘制棋盘
void Board::paintEvent(QPaintEvent *)
{
    DrawBackground(); // 绘制背景颜色
 
    int r = height() / 20;
    _r = r;
    _off = QPoint(r + 1, r + 1);
 
    QPainter p(this);
    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::DrawBackground()
{
    QPalette p = this->palette();
    p.setColor(QPalette::Window, QColor(224, 255, 255));
    this->setPalette(p);
}
 
// 绘制棋盘
void Board::drawPlate(QPainter &p)
{
    // 绘制10条横线
    for (int i = 0; i < 10; ++i) {
        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));
    }
 
    // 绘制9条竖线
    for (int i = 0; i < 9; ++i) {
        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));
        }
    }
}
 
// 绘制九宫格
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::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::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::drawStone(QPainter &p)
{
    for (int i = 0; i < 32; ++i) {
        drawStone(p, i);
    }
}
 
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));
 
    p.setFont(QFont("system", _r * 1.2, 700)); // 设置字体大小和类型
    p.drawText(cell(id), name(id), QTextOption(Qt::AlignCenter));
}
 
// 返回棋盘行列对应的像素坐标
QPoint Board::center(int row, int col)
{
    QPoint pt(_r * col * 2, _r * row * 2);
    return pt + _off;
}
 
// 重载center函数，方便调用
QPoint Board::center(int 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));
}
 
// 判断点击位置属于哪个顶点
// 返回值为bool类型是为了处理点击在棋盘外的情况
bool Board::getClickRowCol(QPoint pt, int &row, int &col)
{
    row = pt.y() / (2 * _r) - 1;
    col = pt.x() / (2 * _r) - 1;
 
    QPoint c = center(row, col);
    int dx = c.x() - pt.x();
    int dy = c.y() - pt.y();
    int dist = dx * dx + dy * dy; // 和鼠标所处矩形左上顶点的距离
    if (dist < _r * _r) {
        return true;
    }
 
    row += 1;
    c = center(row, col);
    dx = c.x() - pt.x();
    dy = c.y() - pt.y();
    dist = dx * dx + dy * dy; // 和鼠标所处矩形左下顶点的距离
    if (dist < _r * _r) {
        return true;
    }
 
    row -= 1;
    col += 1;
    c = center(row, col);
    dx = c.x() - pt.x();
    dy = c.y() - pt.y();
    dist = dx * dx + dy * dy; // 和鼠标所处矩形右上顶点的距离
    if (dist < _r * _r) {
        return true;
    }
 
    row += 1;
    c = center(row, col);
    dx = c.x() - pt.x();
    dy = c.y() - pt.y();
    dist = dx * dx + dy * dy; // 和鼠标所处矩形右下顶点的距离
    if (dist < _r * _r) {
        return true;
    }
 
    return false;
}
 
QString Board::name(int id)
{
    return _s[id].name();
}
 
bool Board::red(int id)
{
    return _s[id]._red;
}
 
bool Board::sameColor(int id1, int id2)
{
    if (id1 == -1 || id2 == -1) {
        return false;
    }
    return red(id1) == red(id2);
}
 
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; // 如果不是棋子返回-1
}
 
void Board::killStone(int id)
{
    if (id == -1) {
        return;
    }
    _s[id]._dead = true;
}
 
void Board::reliveStone(int id)
{
    if (id == -1) {
        return;
    }
    _s[id]._dead = false;
}
 
void Board::moveStone(int moveid, int row, int col)
{
    _s[moveid]._row = row;
    _s[moveid]._col = col;
 
    _bRedTurn = !_bRedTurn;
}
 
bool Board::isDead(int id)
{
    if (id == -1) {
        return true;
    }
    return _s[id]._dead;
}
 
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::backOne()
{
    if (this->_steps.size() == 0) {
        return;
    }
 
    Step* step = this->_steps.last();
    _steps.removeLast();
    back(step);
 
    update();
    delete step;
}
 
void Board::back(Step* step)
{
    reliveStone(step->_killid);
    moveStone(step->_moveid, step->_rowFrom, step->_colFrom);
}
 
void Board::back()
{
    backOne();
}
 
void Board::mouseReleaseEvent(QMouseEvent *ev)
{
    if (ev->button() != Qt::LeftButton) { // 排除鼠标右键点击
        return;
    }
 
    click(ev->pos());
}
 
void Board::click(QPoint pt)
{
    // 看有没有点中象棋
    // 将pt转化成象棋的行列值
    // 判断这个行列值上面有没有棋子
    int row, col;
    bool bClicked = getClickRowCol(pt, row, col);
    if (!bClicked) {
        return;
    }
 
    int id = getStoneId(row, col);
    click(id, row, col);
 
}
 
void Board::click(int id, int row, int col)
{
    if (this->_selectid == -1) { // 如果点中的棋子之前未被选中
        trySelectStone(id);
    }
    else {
        tryMoveStone(id, row, col);
    }
}
 
void Board::trySelectStone(int id)
{
    if (id == -1) {
        return;
    }
 
    if (!canSelect(id)) {
        return;
    }
 
    _selectid = id;
    update();
}
 
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();
    }
}
 
void Board::moveStone(int moveid, int killid, int row, int col)
{
    saveStep(moveid, killid, row, col, _steps);
 
    killStone(killid);
    moveStone(moveid, row, col);
}
 
bool Board::canMove(int moveid, int killid, int row, int col)
{
    // 如果moveid和killid颜色相同，则不能移动，还需要换选择
    if (_s[moveid]._red == _s[killid]._red) {
        _selectid = killid;
        update();
        return false;
    }
 
    switch (_s[moveid]._type) {
    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);
 
    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);
    }
 
    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) { // 象走田，所以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::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) { // 列相差等于2
        if (getStoneId(row1, (col + col1) / 2) != -1) {
            return false;
        }
    }
    else { // 行相差等于2
        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 (row1 > row) { // 如果目标行小于原始行，相当于兵在后退
            return false;
        }
        if (row <= 4 && row == row1) { // 还没有过河就想横着走
            return false;
        }
    }
    return true;
}
 
bool Board::canSelect(int id)
{
    return _bRedTurn == _s[id]._red;
}
 
int Board::relation(int row1, int col1, int row, int col)
{
    return qAbs(row1 - row) * 10 + qAbs(col1 - col);
}
 
bool Board::isBottomSide(int id)
{
    return _bSide == _s[id]._red;
}
 
int Board::getStoneCountAtLine(int row1, int col1, int row2, int col2)
{
    int ret = 0;
 
    // 首先判断两个棋子是否在同一条直线上，如果不在同一条直线上，直接返回-1
    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 ? col1 : col2;
        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 ? row1 : row2;
        for (int row = min + 1; row < max; ++row) {
            if (getStoneId(row, col1) != -1) {
                ++ret;
            }
        }
    }
 
    return ret;
}
 
void Board::slotBack()
{
    back();
}

#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

// Stone.h
// 棋子类，存储了棋子的基础信息
 
#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;
 
    int _id;
    bool _dead;
    bool _red;
 
    // 棋子的初始化
    void init(int id);
 
    // 判断_type返回相应字符串
    QString name();
 
    void rotate(); // 翻转棋盘
 
};
 
#endif // STONE_H

// Stone.cpp
 
#include "Stone.h"
#include <QDebug>
 
Stone::Stone()
{
 
}
 
Stone::~Stone()
{
 
}
 
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},
    };
 
    //_id = id;
    _dead = false;
    _red = id < 16;
 
    if (id < 16) { // 上方的棋子
        this->_row = pos[id].row;
        this->_col = pos[id].col;
        this->_type = pos[id].type;
    }
    else { // 下方的棋子
        this->_row = 9 - pos[id - 16].row;
        this->_col = 8 - pos[id - 16].col;
        this->_type = pos[id - 16].type;
    }
}
 
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::rotate()
{
    this->_col = 8 - this->_col;
    this->_row = 9 - this->_row;
}

// main.cpp
// Chess游戏主程序
//
// Created by Lucifer Zhang on 2015-07-21.
// Copyright (c) 2015 Lucifer Zhang. All rights reserved.
 
#include <QApplication>
#include "Board.h"
 
int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    Board board;
    board.show();
    return app.exec();
}

工程代码详情：Github