设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 非技术区 › 电子工程师杂谈 › 象棋的一个弱智级的AI程序
返回列表 发新帖
查看: 2835|回复: 0
打印 上一主题 下一主题
收起左侧

象棋的一个弱智级的AI程序

[复制链接]
跳转到指定楼层
楼主
ID:72008 发表于 2015-1-11 20:02 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式

  2. 这个就是AI的主要部分，实现原理是枚举当前棋盘状况下的所有可走棋步然后随机输出一个棋步，
  3. 因为没有任何其他的判断所以是很原始的AI，象棋NB的童鞋可在此基础上加上更多的判断技巧使
  4. 它显的更智能。
  5. package xq;
  6. import java.util.ArrayList;//引入相关包
  7. import java.util.List;
  8. /**
  9. *
  10. * 该类是象棋的规则类，其他类通过调用canMove方法给出起始位置与结束位置
  11. * 其他类通过调用searchAGoodMove方法得到最当然棋局最好的走法
  12. * 而其中的allPossibleMoves方法得到的是当前棋局的所有的走法
  13. *
  14. */
  15. public class GuiZe {
  16. boolean isRedGo = false;//是不是红方走棋
  17. public boolean canMove(int[][] qizi, int fromX ,int fromY, int toX, int toY ){
  18.   int i = 0;
  19.   int j = 0;
  20.   int moveChessID;//起始位置是什么棋子
  21.   int targetID;//目的地是什么棋子或空地
  22.   if(toX<0){//当左边出界时
  23.    return false;
  24.   }
  25.   if(toX>8){//当右边出界时
  26.    return false;
  27.   }
  28.   if(toY<0){//当上边出界时
  29.    return false;
  30.   }
  31.   if(toY>9){//当下边出界时
  32.    return false;
  33.   }
  34.   if(fromX==toX && fromY==toY){//目的地与出发点相同，
  35.    return false;
  36.   }
  37.   moveChessID = qizi[fromY][fromX];//得到起始棋子
  38.   targetID = qizi[toY][toX];//得带终点棋子
  39.   if(isSameSide(moveChessID,targetID)){//如果是同一阵营的
  40.    return false;
  41.   }
  42.   switch(moveChessID){
  43.    case 1://黑帅
  44.     if(toY>2||toX<3||toX>5){//出了九宫格
  45.      return false;
  46.     }
  47.     if((Math.abs(fromY-toY)+Math.abs(toX-fromX))>1){//只能走一步
  48.      return false;
  49.     }
  50.     break;
  51.    case 5://黑士
  52.     if(toY>2||toX<3||toX>5){//出了九宫格
  53.      return false;
  54.     }
  55.     if(Math.abs(fromY-toY) != 1 || Math.abs(toX-fromX) != 1){//走斜线
  56.      return false;
  57.     }
  58.     break;
  59.    case 6://黑象
  60.     if(toY>4){//不能过河
  61.      return false;
  62.     }
  63.     if(Math.abs(fromX-toX) != 2 || Math.abs(fromY-toY) != 2){//相走“田”字
  64.      return false;
  65.     }
  66.     if(qizi[(fromY+toY)/2][(fromX+toX)/2] != 0){
  67.      return false;//相眼处有棋子
  68.     }
  69.     break;
  70.    case 7://黑兵
  71.     if(toY < fromY){//不能回头
  72.      return false;
  73.     }
  74.     if(fromY<5 && fromY == toY){//过河前只能直走
  75.      return false;
  76.     }
  77.     if(toY - fromY + Math.abs(toX-fromX) > 1){//只能走一步，并且是直线
  78.      return false;
  79.     }
  80.     break;
  81.    case 8://红将
  82.     if(toY<7||toX>5||toX<3){//出了九宫格
  83.      return false;
  84.     }
  85.     if((Math.abs(fromY-toY)+Math.abs(toX-fromX))>1){//只能走一步
  86.      return false;
  87.     }
  88.     break;
  89.    case 2://黑车
  90.    case 9://红车
  91.     if(fromY != toY && fromX != toX){//只能走直线
  92.      return false;
  93.     }
  94.     if(fromY == toY){//走横线
  95.      if(fromX < toX){//向右走
  96.       for(i = fromX + 1; i < toX; i++){//循环
  97.        if(qizi[fromY][i] != 0){
  98.         return false;//返回false
  99.        }
  100.       }
  101.      }
  102.      else{//向左走
  103.       for(i = toX + 1; i < fromX; i++){//循环
  104.        if(qizi[fromY][i] != 0){
  105.         return false;//返回false
  106.        }
  107.       }
  108.      }
  109.     }
  110.     else{//走的是竖线
  111.      if(fromY < toY){//向右走
  112.       for(j = fromY + 1; j < toY; j++){
  113.        if(qizi[j][fromX] != 0)
  114.        return false;//返回false      
  115.       }
  116.      }
  117.      else{//想左走
  118.       for(j= toY + 1; j < fromY; j++){
  119.        if(qizi[j][fromX] != 0)
  120.        return false;//返回false      
  121.       }
  122.      }
  123.     }
  124.     break;
  125.    case 10://红马
  126.    case 3://黑马
  127.     if(!((Math.abs(toX-fromX)==1 && Math.abs(toY-fromY)==2)
  128.       || (Math.abs(toX-fromX)==2 && Math.abs(toY-fromY)==1))){
  129.      return false;//马走的不是日字时
  130.     }
  131.     if(toX-fromX==2){//向右走
  132.      i=fromX+1;//移动
  133.      j=fromY;
  134.     }
  135.     else if(fromX-toX==2){//向左走
  136.      i=fromX-1;//移动
  137.      j=fromY;
  138.     }
  139.     else if(toY-fromY==2){//向下走
  140.      i=fromX;//移动
  141.      j=fromY+1;
  142.     }
  143.     else if(fromY-toY==2){//向上走
  144.      i=fromX;//移动
  145.      j=fromY-1;
  146.     }
  147.     if(qizi[j][i] != 0)
  148.      return false;//绊马腿
  149.     break;
  150.    case 11://红砲
  151.    case 4://黑炮
  152.     if(fromY!=toY && fromX!=toX){//炮走直线
  153.      return false;//返回false
  154.     }
  155.     if(qizi[toY][toX] == 0){//不吃子时
  156.      if(fromY == toY){//横线
  157.       if(fromX < toX){//想右走
  158.        for(i = fromX + 1; i < toX; i++){
  159.         if(qizi[fromY][i] != 0){
  160.          return false;//返回false
  161.         }
  162.        }
  163.       }
  164.       else{//向走走
  165.        for(i = toX + 1; i < fromX; i++){
  166.         if(qizi[fromY][i]!=0){
  167.          return false;//返回false
  168.         }
  169.        }
  170.       }
  171.      }
  172.      else{//竖线
  173.       if(fromY < toY){//向下走
  174.        for(j = fromY + 1; j < toY; j++){
  175.         if(qizi[j][fromX] != 0){
  176.          return false;//返回false
  177.         }
  178.        }
  179.       }
  180.       else{//向上走
  181.        for(j = toY + 1; j < fromY; j++){
  182.         if(qizi[j][fromX] != 0){
  183.          return false;//返回false
  184.         }
  185.        }
  186.       }
  187.      }
  188.     }
  189.     else{//吃子时
  190.      int count=0;
  191.      if(fromY == toY){//走的是横线
  192.       if(fromX < toX){//向右走
  193.        for(i=fromX+1;i<toX;i++){
  194.         if(qizi[fromY][i]!=0){
  195.          count++;
  196.         }
  197.        }
  198.        if(count != 1){
  199.         return false;//返回false
  200.        }
  201.       }
  202.       else{//向左走
  203.        for(i=toX+1;i<fromX;i++){
  204.         if(qizi[fromY][i] != 0){
  205.          count++;
  206.         }
  207.        }
  208.        if(count!=1){
  209.         return false;//返回false
  210.        }
  211.       }
  212.      }
  213.      else{//走的是竖线
  214.       if(fromY<toY){//向下走
  215.        for(j=fromY+1;j<toY;j++){
  216.         if(qizi[j][fromX]!=0){
  217.          count++;//返回false
  218.         }
  219.        }
  220.        if(count!=1){
  221.         return false;//返回false
  222.        }
  223.       }
  224.       else{//向上走
  225.        for(j=toY+1;j<fromY;j++){
  226.         if(qizi[j][fromX] != 0){
  227.          count++;//返回false
  228.         }
  229.        }
  230.        if(count!=1){
  231.         return false;//返回false
  232.        }
  233.       }
  234.      }
  235.     }
  236.     break;
  237.    case 12://红仕
  238.     if(toY<7||toX>5||toX<3){//出了九宫格
  239.      return false;
  240.     }
  241.     if(Math.abs(fromY-toY) != 1 || Math.abs(toX-fromX) != 1){//走斜线
  242.      return false;
  243.     }
  244.     break;
  245.    case 13://红相
  246.     if(toY<5){//不能过河
  247.      return false;//返回false
  248.     }
  249.     if(Math.abs(fromX-toX) != 2 || Math.abs(fromY-toY) != 2){//相走“田”字
  250.      return false;//返回false
  251.     }
  252.     if(qizi[(fromY+toY)/2][(fromX+toX)/2] != 0){
  253.      return false;//相眼处有棋子
  254.     }
  255.     break;
  256.    case 14://红卒
  257.     if(toY > fromY){//不能回头
  258.      return false;
  259.     }
  260.     if(fromY > 4 && fromY == toY){
  261.      return false;//不让走
  262.     }
  263.     if(fromY - toY + Math.abs(toX - fromX) > 1){//只能走一步，并且是直线
  264.      return false;//返回false不让走
  265.     }
  266.     break;
  267.    default:
  268.     return false;
  269.   }
  270.   return true;
  271. }
  272. /**
  273.   *
  274.   * 电脑是通过该方法得到当前棋局最好的走法
  275.   */
  276. public ChessMove searchAGoodMove(int[][] qizi){//查询一个好的走法
  277.   List<ChessMove> ret = allPossibleMoves(qizi);//产生所有走法
  278.   try {
  279.    Thread.sleep(2000);//睡眠四秒钟，以便调试
  280.   } catch (InterruptedException e) {//捕获异常
  281.    e.printStackTrace();//打印堆栈信息
  282.   }
  283.   return ret.get((int)(Math.random()*ret.size()));
  284. }
  285. public List<ChessMove> allPossibleMoves(int qizi[][]){//产生所有可能的走法
  286.    List<ChessMove> ret = new ArrayList<ChessMove>();//用来装所有可能的走法
  287.    for (int y = 0; y < 10; y++){
  288.     for (int x = 0; x < 9; x++){//循环所有的棋牌位置
  289.      int chessman = qizi[y][x];
  290.      if (chessman != 0){//当次位置不为空时，即有棋子时
  291.       if(chessman > 7){//是红方，即是玩家棋子时跳过
  292.        continue;
  293.       }
  294.       switch (chessman){
  295.        case 1://黑帅
  296.         if(canMove(qizi, x, y, x, y+1)){//向下走一格
  297.                        ret.add(new ChessMove(chessman, x, y, x, y+1, 0));
  298.                       }
  299.                       if(canMove(qizi, x, y, x, y-1)){//向上走一格
  300.                        ret.add(new ChessMove(chessman, x, y, x, y-1, 0));
  301.                       }
  302.                       if(canMove(qizi, x, y, x+1, y)){//向左走一格
  303.                        ret.add(new ChessMove(chessman, x, y, x+1, y, 0));
  304.                       }
  305.                       if(canMove(qizi, x, y, x-1, y)){//向右走一格
  306.                        ret.add(new ChessMove(chessman, x, y, x-1, y, 0));
  307.                       }
  308.                       break;
  309.       case 5://黑士
  310.       case 12://红仕
  311.        if(canMove(qizi, x, y, x-1, y+1)){//左下走
  312.         ret.add(new ChessMove(chessman, x, y, x-1, y+1, 1));
  313.        }
  314.        if(canMove(qizi, x, y, x-1, y-1)){//左上走
  315.         ret.add(new ChessMove(chessman, x, y, x-1, y-1, 1));
  316.        }
  317.        if(canMove(qizi, x, y, x+1, y+1)){//右下走
  318.         ret.add(new ChessMove(chessman, x, y, x+1, y+1, 1));
  319.        }
  320.        if(canMove(qizi, x, y, x+1, y-1)){//右上走
  321.         ret.add(new ChessMove(chessman, x, y, x+1, y-1, 1));
  322.        }
  323.        break;
  324.              case 6://黑象
  325.              case 13://红相
  326.        if(canMove(qizi, x, y, x-2, y+2)){//左上走
  327.         ret.add(new ChessMove(chessman, x, y, x-2, y+2, 1));
  328.        }
  329.        if(canMove(qizi, x, y, x-2, y-2)){//左下走
  330.         ret.add(new ChessMove(chessman, x, y, x-2, y-2, 1));
  331.        }
  332.        if(canMove(qizi, x, y, x+2, y+2)){//右下走
  333.         ret.add(new ChessMove(chessman, x, y, x+2, y+2, 1));
  334.        }
  335.        if(canMove(qizi, x, y, x+2, y-2)){//右上走
  336.         ret.add(new ChessMove(chessman, x, y, x+2, y-2, 1));
  337.        }
  338.               break;
  339.              case 7://黑兵
  340.               if(canMove(qizi, x, y, x, y+1)){//直走
  341.                ret.add(new ChessMove(chessman, x, y, x, y+1, 2));
  342.               }
  343.               if(y >= 5){//过河了
  344.                                 if (canMove(qizi, x, y, x - 1, y)) {//过河后向左走
  345.                                     ret.add(new ChessMove(chessman, x, y, x - 1, y, 2));
  346.                                 }
  347.                                 if (canMove(qizi, x, y, x + 1, y)) {//过河走向右走
  348.                                     ret.add(new ChessMove(chessman, x, y, x + 1, y, 2));
  349.                                 }
  350.               }
  351.               break;
  352.              case 14://红兵
  353.               if(canMove(qizi, x, y, x, y-1)){//向前走
  354.                ret.add(new ChessMove(chessman, x, y, x, y-1, 2));
  355.               }
  356.               if(y <=4 ){//过河了
  357.                                 if (canMove(qizi, x, y, x - 1, y)) {//过河后向左走
  358.                                     ret.add(new ChessMove(chessman, x, y, x - 1, y, 2));
  359.                                 }
  360.                                 if (canMove(qizi, x, y, x + 1, y)) {//过河走向右走
  361.                                     ret.add(new ChessMove(chessman, x, y, x + 1, y, 2));
  362.                                 }
  363.               }
  364.               break;
  365.              case 8://红将
  366.                       if(canMove(qizi, x, y, x, y+1)){//向下走一格
  367.                        ret.add(new ChessMove(chessman, x, y, x, y+1, 0));
  368.                       }
  369.                       if(canMove(qizi, x, y, x, y-1)){//向上走一格
  370.                        ret.add(new ChessMove(chessman, x, y, x, y-1, 0));
  371.                       }
  372.                       if(canMove(qizi, x, y, x+1, y)){//向右走一格
  373.                        ret.add(new ChessMove(chessman, x, y, x+1, y, 0));
  374.                       }
  375.                       if(canMove(qizi, x, y, x-1, y)){//向左走一格
  376.                        ret.add(new ChessMove(chessman, x, y, x-1, y, 0));
  377.                       }
  378.                       break;
  379.              case 2://黑车
  380.              case 9://红车
  381.               for(int i=y+1; i<10; i++){//向下走
  382.                if(canMove(qizi, x, y, x, i)){ //可以走时
  383.                 ret.add(new ChessMove(chessman, x, y, x, i, 0));
  384.                }else{//不可以走时直接 break
  385.                 break;
  386.                }
  387.               }
  388.               for(int i=y-1; i>-1; i++){//向上走
  389.                if(canMove(qizi, x, y, x, i)){//可以走时
  390.                 ret.add(new ChessMove(chessman, x, y, x, i, 0));
  391.                }else{//不可以走时
  392.                 break;
  393.                }
  394.               }
  395.               for(int j=x-1; j>-1; j++){//向走走
  396.                if(canMove(qizi, x, y, j, y)){//可以走时
  397.                 ret.add(new ChessMove(chessman, x, y, j, y, 0));
  398.                }else{//不可以走时
  399.                 break;
  400.                }
  401.               }
  402.               for(int j=x+1; j<9; j++){//向右走
  403.                if(canMove(qizi, x, y, j, y)){//可以走时
  404.                 ret.add(new ChessMove(chessman, x, y, j, y, 0));
  405.                }else{//不可以走时
  406.                 break;
  407.                }
  408.               }
  409.               break;
  410.              case 10://红马
  411.              case 3://黑马
  412.                       if(canMove(qizi, x, y, x-1, y-2)){//向上左走“日”字
  413.                        ret.add(new ChessMove(chessman, x, y, x-1, y-2, 0));
  414.                       }
  415.                       if(canMove(qizi, x, y, x-1, y+2)){//向下走“日”字
  416.                        ret.add(new ChessMove(chessman, x, y, x-1, y+2, 0));
  417.                       }
  418.                       if(canMove(qizi, x, y, x+1, y-2)){//向上右走“日”字
  419.                        ret.add(new ChessMove(chessman, x, y, x+1, y-2, 0));
  420.                       }
  421.                       if(canMove(qizi, x, y, x+1, y+2)){//向下右走“日”字
  422.                        ret.add(new ChessMove(chessman, x, y, x+1, y+2, 0));
  423.                       }
  424.                       if(canMove(qizi, x, y, x-2, y-1)){//向上右走“日”字
  425.                        ret.add(new ChessMove(chessman, x, y, x-2, y-1, 0));
  426.                       }
  427.                       if(canMove(qizi, x, y, x-2, y+1)){//向下右走“日”字
  428.                        ret.add(new ChessMove(chessman, x, y, x-2, y+1, 0));
  429.                       }
  430.                       if(canMove(qizi, x, y, x+2, y-1)){//向上右走“日”字
  431.                        ret.add(new ChessMove(chessman, x, y, x+2, y-1, 0));
  432.                       }
  433.                       if(canMove(qizi, x, y, x+2, y+1)){//向下右走“日”字
  434.                        ret.add(new ChessMove(chessman, x, y, x+2, y+1, 0));
  435.                       }
  436.               break;
  437.              case 11://红砲
  438.              case 4://黑炮
  439.               for(int i=y+1; i<10; i++){//向下走时
  440.                if(canMove(qizi, x, y, x, i)){//当可以走时
  441.                 ret.add(new ChessMove(chessman, x, y, x, i, 0));
  442.                }
  443.               }
  444.               for(int i=y-1; i>-1; i--){//向上走时
  445.                if(canMove(qizi, x, y, x, i)){//当可以走时
  446.                 ret.add(new ChessMove(chessman, x, y, x, i, 0));
  447.                }
  448.               }
  449.               for(int j=x-1; j>-1; j--){//向左走时
  450.                if(canMove(qizi, x, y, j, y)){//当可以走时
  451.                 ret.add(new ChessMove(chessman, x, y, j, y, 0));
  452.                }
  453.               }
  454.               for(int j=x+1; j<9; j++){//向右走时
  455.                if(canMove(qizi, x, y, j, y)){//当可以走时
  456.                 ret.add(new ChessMove(chessman, x, y, j, y, 0));
  457.                }
  458.               }
  459.               break;
  460.      }
  461.      }
  462.     }
  463.    }
  464.    return ret.isEmpty() ? null : ret;//当ret中没有走法时，返回空，有时返回ret
  465. }
  466. public boolean isSameSide(int moveChessID, int targetID){//判断两个子是否为同一阵营
  467.   if(targetID == 0){// 当目标地位空地时
  468.    return false;
  469.   }
  470.   if(moveChessID>7&&targetID>7){//当都为红色棋子时
  471.    return true;
  472.   }
  473.   else if(moveChessID<=7&&targetID<=7){//都为黑色棋子时
  474.    return true;
  475.   }
  476.   else{//其他情况
  477.    return false;
  478.   }
  479. }
  480. }
复制代码


中国象棋
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表