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

内容：走法产生

中国象棋基础搜索AI，

　　　极大值，极小值剪枝搜索，

　　　静态估值函数

理论基础：

　　　（一）人机博弈走法产生：

　　　 先遍历某一方的所有棋子，再遍历整个棋盘，得到每个棋子的所有走棋情况（效率不高，可以改进）

 void SingleGame::getAllPossibleMove(QVector<Step *> &steps)
 {
     int min, max;
     if(this->_bRedTurn)
     {
         min = , max = ;
     }
     else
     {
         min = , max = ;
     }

     for(int i=min;i<max; i++)
     {
         if(this->_s[i]._dead) continue;
         for(int row = ; row<=; ++row)
         {
             for(int col=; col<=; ++col)
             {
                 int killid = this->getStoneId(row, col);
                 if(sameColor(i, killid)) continue;

                 if(canMove(i, killid, row, col))
                 {
                     saveStep(i, killid, row, col, steps);
                 }
             }
         }
     }
 }

　　　（二）棋局博弈树理论：

　　　 名词：对抗性搜索（Adversarial Search）：敌对双方交替动作的搜索

　　　 博弈树：树的根部是棋局的初始局面，根的若干子节点是有甲的每一种可能走法生成的局面，

　　　　　　　 这些节点的子节点则是由乙的每一种可能走法生成的局面，如此交替直到棋局结束。

　　　 

博弈树形象表示

　　　　

　　　基于博弈树的游戏：

　　　　 计甲胜为WIN，乙胜为LOST，和局为DRAW；

　　　　 轮到甲走时，甲选择通向WIN或DRAW的节点；换言之，turn 甲，选择所有子节点中最好的（对甲）;

　　　　 轮到乙走时，乙选择通向LOST或DRAW的节点；turn 乙，选择所有子节点中最差的（对甲）；

　　（三）极大极小值算法

　　　　在上述博弈树基础上，令甲胜的局面值为1，乙胜的局面值为-1，和局的局面值为0；

　　　　轮到甲走时，选择子节点值最大的走法，轮到乙走时，选择子节点值最小的走法；

　　　　中间节点的值的确定：该局面轮到甲走，选择其子节点中的最大值，

　　　　　　　　　　　　　　该局面轮到乙走，选择其子节点中的最小值。

　　　　问题：实际的棋局不能简单的以1，-1，0三种状态表示，

　　　　　　　需要加入评估棋局局面分数的估值函数，配合博弈树的搜索来确定局面分数。

　　　　实际解决方案：

　　　　　　　估值函数：暂时以静态估值的方式形成估值函数（评估较为粗糙），

　　　　　　　　　　　　将棋局中的每个棋子按照重要程度赋一个值，

　　　　　　　　　　　　估值函数通过计算一方现存棋子的总分数来确定局面优劣情况。

　　　　　　　代码示例：

 int SingleGame::score()
 {
     enum TYPE{CHE, MA, PAO, BING, JIANG, SHI, XIANG};
     int s[] = {, , , , , , , , , , , , , , , };
     //int s[] = {1000,450,501,200,15000,200,200};
     /*当头卒比重大*/
     int scoreBlack = ;
     int scoreRed = ;
     /*计算红方分数*/
     for(int i=; i<; ++i)
     {
         if(_s[i]._dead) continue;
         //scoreRed += s[_s[i]._type];
         scoreRed += s[i];
     }
     /*计算黑方分数*/
     for(int i=; i<; ++i)
     {
         if(_s[i]._dead) continue;
         //scoreBlack += s[_s[i]._type];
         scoreBlack += s[i-];
     }
     return scoreBlack - scoreRed;
 }

　　　   极大值极小值搜索方案：

　　　　　　　深度优先搜索，优点是不必在内存中生成整个博弈树，可以将搜索过的部分从内存中去除，

　　　　　　　采用递归形式，依次在min(int level,int curMin),max(int level,int curMax)之间递归调用，

　　　　　　　剪枝以去除不必要的步数，在求极大值时，若下一步的值小于当前极大值，直接删除这一步，不予考虑，

　　　　　　　　　　　　　　　　　　　在求极小值时，若下一步的值大于当前极小值，直接删除这一步，不予考虑。

　　　　　　　在所有子节点中选出值最大的走法，就是电脑的最佳走法。

　　　　　　　代码示例：

 int SingleGame::getMinScore(int level, int curMin)
 {
     if(level == )
         return score();

     QVector<Step*> steps;
     getAllPossibleMove(steps);
     int minInAllMaxScore = ;

     while(steps.count())
     {
         Step* step = steps.last();
         steps.removeLast();

         fakeMove(step);
         int maxScore = getMaxScore(level-, 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::getMaxScore(int level, int curMax)
 {
     if(level == )
         return score();

     QVector<Step*> steps;
     getAllPossibleMove(steps);
     int maxInAllMinScore = -;

     while(steps.count())
     {
         Step* step = steps.last();
         steps.removeLast();

         fakeMove(step);
         int minScore = getMinScore(level-, maxInAllMinScore);
         unfakeMove(step);
         delete step;

         if(minScore >= curMax)
         {
             while(steps.count())
             {
                 Step* step = steps.last();
                 steps.removeLast();
                 delete step;
             }
             return minScore;
         }
         if(minScore > maxInAllMinScore)
         {
             maxInAllMinScore = minScore;
         }

     }
     return maxInAllMinScore;
 }

　　　　        代码示例：

 Step* SingleGame::getBestMove()
 {
     Step* ret = NULL;
     QVector<Step*> steps;
     getAllPossibleMove(steps);
     int maxInAllMinScore = -;

     while(steps.count())
     {
         Step* step = steps.last();
         steps.removeLast();

         fakeMove(step);
         int minScore = getMinScore(this->_level-, maxInAllMinScore);
         unfakeMove(step);

         if(minScore > maxInAllMinScore)
         {
             if(ret) delete ret;

             ret = step;
             maxInAllMinScore = minScore;
         }
         else
         {
             delete step;
         }
     }
     return ret;
 }

　　　　一个简单的象棋AI，还有诸多优化之处，目前搜索深度最大为4，与初级玩家对弈输多胜少。