标题: 象棋的一个弱智级的AI程序 [打印本页]

---

作者: liuyy    时间: 2015-1-11 20:02
标题: 象棋的一个弱智级的AI程序

1. 
   
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. }
     

复制代码

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1