chineseChess

最近学习了chineseChess的Qt实现，把一些东西总结一下：

实现功能：

1.人人对战

2.人机对战

3.网络版

一、基础性工作：(人人对战)

1、棋盘和棋子的绘制（QPinter,drawLine(QPoint(0,0),QPoint(0,9))）：

　　棋盘: 10行，9列，中间有楚河汉界；九宫格；兵和炮的梅花位置。

　　棋子：32颗棋子都是由圆圈和汉字组成:drawStone(painter, i)

　　　　　注意：1、死棋不画  if(_s[id]._dead)   return;

　　　　　　　　2、线：painter.setPen(Qt::black);   填充：painter.setBrush(QBrush(Qt::gray));  字体：painter.setFont(QFont("system", _r, 700)); 

　　　　　　　　　  字：painter.drawText(rect, _s[id].getText(), QTextOption(Qt::AlignCenter));   getText()可用switch语句实现，返回QString类型。

2、初始化棋盘

　　　　　每个棋子有自己的 _id , _row , _col , _type , _Red, _dead:

　　　　　　　棋子的id可由数组_s[32]存储，由于棋子的中心对称性，棋子的 id 分配红棋从左上角开始是从0到15，黑棋从右下角开始是从16到31； 

                    这么分配的优势，中心对称的两颗棋子，行列和为定值：row(red)+row(black)=9; col(red)+col(black)=8;

　　　　　　  _s[i]._red = id<16;

　　　　　　　_s[i].dead = false;

 　　　　　　 type有七种：车、马、象、士、将、炮、兵

                   红棋的 _row , _col ,_type可定义结构体数组一一初始化，黑棋可利用对称性给出。

       棋子类型可使用枚举方法： enum TYPE{CHE, MA, XIANG, SHI, JIANG, PAO ,BING }_type;

       枚举类型，系统默认第一个元素为0，其后元素依次加1。 不可为枚举类型赋值，但可以在初始化时给其赋值。

　　 eg:       enum TYPE{CHE=2, MA, XIANG, SHI, JIANG, PAO ,BING };  则XIANG为4，SHI为5。

3、走棋规则的定制

七种棋判断是否可以移动，先不判断是否吃棋。

canMove(int moveId, int killedId, int row, int col)

 利用switch(_s[moveId]._type)语句 返回 每种棋子的 canMoveType()函数。

 特点：

　　车走直线，需判断 起始点 之间棋子个数是否为0；

　　马走日，需判断马蹄上是否有棋子；

　　象走田，需判断象眼上是否有棋子；且行走范围只有半边天；顶部和底部的象，规则和而不同。

　　士，活动范围九宫格的斜线；顶部和底部的士，规则和而不同。

　　将，飞将：若killId != -1 && _s[killId]._type == Stone::JIANG，若两将之间棋子个数为0，return ture；九宫格的直线；顶部和底部的将，规则和而不同。

　　炮，计算 起始点 之间棋子个数。棋子个数为1，则killedId != -1;棋子个数为0，则killedId == -1.

　　兵，不能后退，过河后才能横向走。顶部和底部的兵，规则和而不同。

为了实现七种棋子的可走性判断，需要一些辅助函数：起始点的位置关系（利用权重求和即可）、起始点之间的棋子个数、初始化在底部的棋子判断。

 int relation(row1, col1, row, col)
{
　　return qAbs(col1 - col) + qAbs(10*(row1 - row) ); 
}

 int getStoneConutAtLine(int row1, int col1, int row2, int col2)   　//车和炮需要判断，特点：行和列仅有一个相同
{
　　if(row1 != row2 && col1 == col2)
　　{
             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)  ++count;  //遍历非死棋，返回 行列 满足所求的id
             }    　　　　
　　}
      else if(row1 == row2 && col1 != col2)
      {
             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)  ++count;
             }    
      }
      else 
            return -1;

　　return count;
}

bool isBottomSide(int id)
{
        return _bRedSibe == _s[id]._red;   //_bRedSide表示红棋在下边。网络版红黑边不同，初始化利用中心对称，rotate即可
}

 4、走棋

第一步：鼠标点击  到  棋子id  的转换

　　利用mouseReleaseEvent(QMouseEvent *ev)事件将鼠标点击像素位置传给 ev，调用ev->pos()即可返回点击点的像素坐标；

　　利用帮助函数（下面有实现）getClickRowCol( QPoint pt, int &row, int &col)可获取行列坐标；

　　利用getStoneId(row, col)可获取棋子id，从而实现了由鼠标点击到棋子id的转换。

　　利用virtual void click(int id, int row, int col)来实现棋子的移动；虚函数：可以在其他类型的作战中重新实现click函数，实现其多态性。

 注：

void Board::click(int id, int row, int col)
{
     trySelectStone(id);       //与执棋方颜色一致，可选。连续选择执棋方，换棋。选后，this->_selectid == id
     else if(this->_selectid != -1) //轮到执棋方走时，选择空白地或是对方棋子无效 
     { 
             tryMove(id, row, col); 
     }
}

void trySelect(int id)  
{
     if(canSelect(id))
     {
         _selectId = id;
         update();
         rerurn;
     }
} 
bool canSelect(id)
{
     return _bRedTurn == _s[id].red;
}

尝试走棋。分两种情况，点击无棋处尝试走棋，点击异色尝试吃棋。

void tryMove(int killid, int row, int col)
{
bool ret = canMove(_selectId, killId, row, col);
    if(ret)
    {
        moveStone(_selectId, killId, row, col);
        _selectId = -1;     //_selectId初始化
        update();
    }
}

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::moveStone(int moveId, int row, int col)
{
    _s[moveId]._row = row;
    _s[moveId]._col = col;
    _bRedTurn = !_bRedTurn;    //轮换走棋
}
void Board::killStone(int id)
{
    if(id==-1) return;
    _s[id]._dead = true;
}
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);
}

help function:

1、_id可以通过_s[_id]._row获取行坐标:设棋盘一格为d，简单起见，设棋盘与边界距离也为d（注意d为棋盘像素坐标）根据棋盘行列与d的关系

                          不难推出id对应的棋盘像素坐标。 eg.  point.rx() = (col + 1)*_r*2;

2、由棋盘上的 点击点QPoint 确定属于那个棋位(row,col)。

                       一种可行的方法是：遍历棋盘各个行列坐标，由行列坐标转化为棋盘像素坐标，并求取与 点击点的像素坐标 的距离dist，若dist<_r，则改点行列式即为所求行列值。其中 _r 为棋盘一格长度的一半。

                       改进1：只需要遍历点击点附近的坐标，无需遍历整个棋盘。

     　　　　　　 改进2：利用浮点型，整型转换直接找到  

　　　　　　　　bool Board::getClickRowCol( QPoint pt, int &row, int &col)

　　　　　　　　{　 col = d * (   int ( pt.x()/(d*1.0) - 0.5 )  );

　　　　　　　   　　row = d * (   int ( pt.y()/(d*1.0) - 0.5 )  );

                       　　if(row < 0 || row > 9 || col < 0 || col > 8)

　　　　　　　　   　　rerurn false;  

　　　　　　　　　　 else  

                         　　return true;

                       }

                        注：返回值可用于判断行列式是否成功得到；利用引用将行列值传递进去，可以在成功获取行列值后进行保存，用法挺好，学习一下。    

二、人机对战（最大最小值算法，减枝优化算法）

利用虚函数的性质，实现click(int id, int row, int col)函数的多态性。

红棋走就调用父类的click(int id, int row, int col)函数，走完后转换走棋方，让电脑走棋。由于电脑在考虑多步时，时间很久容易阻塞主进程，所以在电脑走棋前可以调用定时器0.1s，让红旗完成走棋，重绘棋盘。

电脑利用最大最小值算法按评分最大值的步骤进行移动，即：

void SingleGame::computerMove()
{
    Step* step = getBestMove();
    moveStone(step->_moveid, step->_killid, step->_rowTo, step->_colTo);
    delete step;   //防止内存泄露
    update();
}

最大最小值算法：在你选择的箱子中，找到每个箱子最小值中最大的那个箱子。

步骤：

1、找到所有可以走的步骤

2、尝试走一步（选箱子）

3、计算这一步中最小的分数

4、最小分数>预定义的最大值（很小的值）就将该分数保存为当前的最大值。

5、退回尝试走的一步，进行下一步尝试

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::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::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;
}

评分：

由于是电脑判断当前分数来走棋，所以将评分定义为黑棋现有分数-红棋现有分数。

定义一个数组，分别存放相应七类棋的分数，统计一下相应颜色活期的总分，即为该方现有分数。

统计所有可走的步骤:(可优化)

_bRedTurn：遍历id为0到15的活棋子；

!_bRedTurn：遍历id为16到31的活棋子。

遇到死棋，跳过。

走棋时遇到同色棋子跳过，遍历整个棋盘其余可走可吃的位置。

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);
                }
            }
        }
    }
}

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);
}

优化：

可以对棋子分类别进行可行区域的计算。

将：前后左右四个位置，满足：1、九宫格内；2、不杀同类；

士：也是最多四个位置，条件同将；

车：行为当前车的行，列从0到8；&&　列为当前车的列，行从0到9。条件：同类不杀，起始点间棋子个数为0。

马：可走位置最多8个。条件：在棋盘内；马蹄无字；同类不吃。

象：最多四个位置，条件：在棋盘内；象眼无子；同类不吃。

炮：遍历位置同车。

兵：最多三个位置。

除了黑色部分，其余可以使用canMove()进行判断。

三、网络版（客户端与服务器）

 客户端：

连接服务器：connectToHost("host",port);

发送请求：socket->write(" ");

读数据：socket->readAll();

断开连接：socket->close();

服务器：

监听：server->listen(QHostAddress::Any, port);

挑选空闲服务器：socket = server->nextPendingConnection();

服务（写数据）：socket->write(" ");

断开连接：socket->close();

NetGame::NetGame(bool server, QWidget *parent) : Board(parent)
{
    _server = NULL;                //初始化为空
    _socket = NULL;
    _bServer = server;            //在启动服务器和客户端时，初始化为true和false.

    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()));
    }
}

初始化棋盘由服务器发送数据，客户端接收。

1、初始化棋盘（flag为1，随机产生第二个数）

走棋由click(int id, int row, int col)虚函数发送数据，服务器和客户端接收，对方按照棋盘中心对称的性质进行转换。

2、走棋（flag为2，id, row, col）

悔棋由back()虚函数执行，己方棋盘红黑各悔一步后，发送flag为3,对方棋盘红黑也各悔一步，保持同步。

3、悔棋(flag为3)

服务器的槽函数：

void NetGame::slotNewConnection()
{
    if(_socket) return;   //已选到服务器，则返回

    _socket = _server->nextPendingConnection(); //接线员连接下一个空闲服务器
    connect(_socket, SIGNAL(readyRead()), this, SLOT(slotDataArrive()));    //保证click函数调用后，客户端和服务器都可以接受slotDataArrive()槽函数

    /* 产生随机数来决定谁走红色 */
    bool bRedSide = qrand()%2>0;    //主程序使用qsrand()对种子进行了初始化
    init(bRedSide);

    /* 发送给对方 */
    QByteArray buf;
    buf.append(1);
    buf.append(bRedSide>0?0:1);      //若bRedSide为1，就将0存在buf数组的第二个位置，发送给客户端
    _socket->write(buf);
}

客户端的槽函数：

void NetGame::slotDataArrive()
{
    QByteArray buf = _socket->readAll();
    switch (buf.at(0)) {
    case 1:
        initFromNetwork(buf);       //flag为1，初始化棋盘
        break;
    case 2:
        clickFromNetwork(buf);      //flag为2，给对方发送走棋数据，对方需要根据棋盘的中心对称性质进行转换
        break;
    case 3:
        backFromNetwork(buf);       //flag为3，让对方棋盘红黑各悔一步，与己方保持一致
        break;
    default:
        break;
    }
}

flag对应的函数：

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);
}

走棋：虚函数click(int id, int row, int col)的重载：

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); 
}

悔棋：虚函数back()的重载

void NetGame::back()
{
    if(_bRedTurn != _bSide)    
        return;
    backOne();
    backOne();

    QByteArray buf;
    buf.append(3);
    _socket->write(buf);
}