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[] = {
             {, , Stone::CHE},
             {, , Stone::MA},
             {, , Stone::XIANG},
             {, , Stone::SHI},
             {, , Stone::JIANG},
             {, , Stone::SHI},
             {, , Stone::XIANG},
             {, , Stone::MA},
             {, , Stone::CHE},

             {, , Stone::PAO},
             {, , Stone::PAO},
             {, , Stone::BING},
             {, , Stone::BING},
             {, , Stone::BING},
             {, , Stone::BING},
             {, , Stone::BING},
             };

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

         if(id < )
         {
             _row = pos[id].row;
             _col = pos[id].col;
             _type = pos[id].type;
         }
         else
         {
             _row = -pos[id-].row;
             _col = -pos[id-].col;
             _type = pos[id-].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 = );

     Stone _s[];   //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 > )return false;
     }
     else
     {
         if(row < )return false;
     }

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

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

     return false;
 }

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

 int dr = _s[moveid]._row - row;
     int dc = _s[moveid]._col - col;
     int d = abs(dr)* + abs(dc); // 12, 21   22   10, 1
     if(d == )
         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 = -;
     for(i=;i<;++i)
     {
         if(_s[i]._row == row && _s[i]._col == col && _s[i]._dead== false)
         {
             break;
         }
     }

     if(i<)
     {
         clickid = i;
     }

     if(_selectid == -)
     {
         if(clickid != -)
         {
             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 != -)
             {
                 _s[clickid]._dead = true;
             }
             _selectid = -;
             _bRedTurn = !_bRedTurn;
             update();
         }
     }
 }

效果图：