码迷，mamicode.com
首页 > 其他好文 > 详细

chineseChess

时间：2016-07-11 18:44:20      阅读：291      评论：0      收藏：0      [点我收藏+]

标签：

最近学习了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);
}

 

chineseChess

标签：

原文地址：http://www.cnblogs.com/Lunais/p/5648591.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！