標(biāo)題: 博弈樹加上α-β剪枝算法做出來的五子棋AI往前推6步無壓力 [打印本頁]
作者: liuyy    時(shí)間: 2015-1-11 19:56
標(biāo)題: 博弈樹加上α-β剪枝算法做出來的五子棋AI往前推6步無壓力

AI棋力已經(jīng)非常叼了我反正是一次都贏不了它，所有棋類AI基本都是一個(gè)原理只需要根據(jù)游戲規(guī)則來改寫自己的局面評分函數(shù)就歐了
以下代碼是在博弈樹加上α-β剪枝算法做出來的五子棋AI往前推6步無壓力在DEV環(huán)境下編譯的
  1. #include <cstdlib>
  2. #include <iostream.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5. #include<time.h>
  6. #define GRID_NUM    15 //每一行(列)的棋盤交點(diǎn)數(shù)
  7. #define GRID_COUNT  225//棋盤上交點(diǎn)總數(shù)
  8. #define BLACK        0 //黑棋用0表示
  9. #define WHITE        1 //白棋用1表示
  10. #define NOSTONE     '+'  //沒有棋子
  11. //這組宏定義了用以代表幾種棋型的數(shù)字
  12. #define STWO        1  //眠二
  13. #define STHREE        2  //眠三
  14. #define SFOUR        3  //沖四
  15. #define TWO        4  //活二
  16. #define THREE        5  //活三
  17. #define FOUR        6  //活四
  18. #define FIVE        7  //五連
  19. #define NOTYPE        11 //未定義
  20. #define ANALSISED   255//已分析過的
  21. #define TOBEANALSIS 0  //已分析過的
  22. //這個(gè)宏用以檢查某一坐標(biāo)是否是棋盤上的有效落子點(diǎn)
  23. #define IsValidPos(x,y) ((x>=0 && x<GRID_NUM) && (y>=0 && y<GRID_NUM)
  24. //定義了枚舉型的數(shù)據(jù)類型，精確，下邊界，上邊界
  25. enum ENTRY_TYPE{exact,lower_bound,upper_bound};
  26. //哈希表中元素的結(jié)構(gòu)定義
  27. typedef struct HASHITEM
  28. {
  29. __int64 checksum;         //64位校驗(yàn)碼
  30. ENTRY_TYPE entry_type;//數(shù)據(jù)類型
  31. short depth;         //取得此值時(shí)的層次
  32. short eval;         //節(jié)點(diǎn)的值
  33. }HashItem;

  35. typedef struct Node
  36. {
  37. int x;
  38. int y;
  39. }POINT;

  41. //用以表示棋子位置的結(jié)構(gòu)
  42. typedef struct _stoneposition
  43. {
  44. unsigned char x;
  45. unsigned char y;
  46. }STONEPOS;

  48. typedef struct _movestone
  49. {
  50. unsigned char nRenjuID;
  51. POINT ptMovePoint;
  52. }MOVESTONE;
  53. //這個(gè)結(jié)構(gòu)用以表示走法

  55. typedef struct _stonemove
  56. {
  57. STONEPOS StonePos;//棋子位置
  58. int Score;         //走法的分?jǐn)?shù)
  59. }STONEMOVE;
  60. //=================================================================//
  61. int AnalysisLine(unsigned char* position,int GridNum,int StonePos);
  62. int AnalysisRight(unsigned char position[][GRID_NUM],int i,int j);
  63. int AnalysisLeft(unsigned char position[][GRID_NUM],int i,int j);
  64. int AnalysisVertical(unsigned char position[][GRID_NUM],int i,int j);
  65. int AnalysisHorizon(unsigned char position[][GRID_NUM],int i,int j);
  66. int Eveluate(unsigned int position[][GRID_NUM],bool bIsWhiteTurn);
  67. int AddMove(int nToX, int nToY, int nPly);
  68. int CreatePossibleMove(unsigned char position[][GRID_NUM], int nPly, int nSide);
  69. void MergeSort(STONEMOVE* source,int n,bool direction);
  70. void MergePass(STONEMOVE* source,STONEMOVE* target,const int s,const int n,const bool direction);
  71. void Merge_A(STONEMOVE* source,STONEMOVE* target,int l,int m,int r);
  72. void Merge(STONEMOVE* source,STONEMOVE* target,int l,int m,int r);
  73. void EnterHistoryScore(STONEMOVE* move,int depth);
  74. int GetHistoryScore(STONEMOVE* move);
  75. void ResetHistoryTable();
  76. int NegaScout(int depth,int alpha,int beta);
  77. void SearchAGoodMove(unsigned char position[][GRID_NUM],int Type);
  78. int IsGameOver(unsigned char position[][GRID_NUM],int nDepth);
  79. void UnMakeMove(STONEMOVE* move);
  80. unsigned char MakeMove(STONEMOVE* move,int type);
  81. void _CSearchEngine();
  82. void InitializeHashKey();
  83. void EnterHashTable(ENTRY_TYPE entry_type, short eval, short depth, int TableNo);
  84. int LookUpHashTable(int alpha, int beta, int depth, int TableNo);
  85. void Hash_UnMakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM]);
  86. void Hash_MakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM]);
  87. void CalculateInitHashKey(unsigned char CurPosition[][GRID_NUM]);
  88. __int64 rand64();
  89. long rand32();
  90. void CTranspositionTable();
  91. void _CTranspositionTable();
  92. bool OnInitDialog();
  93. //=================================================================//
  94. int m_HistoryTable[GRID_NUM][GRID_NUM];//歷史得分表
  95. STONEMOVE m_TargetBuff[225];    //排序用的緩沖隊(duì)列
  96. unsigned int m_nHashKey32[15][10][9];          //32位隨機(jī)樹組，用以生成32位哈希值
  97. unsigned __int64 m_ulHashKey64[15][10][9];//64位隨機(jī)樹組，用以生成64位哈希值
  98. HashItem *m_pTT[10];          //置換表頭指針
  99. unsigned int m_HashKey32;          //32位哈希值
  100. __int64 m_HashKey64;          //64 位哈希值
  101. STONEMOVE m_MoveList[10][225];//用以記錄走法的數(shù)組
  102. unsigned char m_LineRecord[30];          //存放AnalysisLine分析結(jié)果的數(shù)組
  103. int TypeRecord[GRID_NUM ][GRID_NUM][4];//存放全部分析結(jié)果的數(shù)組,有三個(gè)維度,用于存放水平、垂直、左斜、右斜 4 個(gè)方向上所有棋型分析結(jié)果
  104. int TypeCount[2][20];          //存放統(tǒng)記過的分析結(jié)果的數(shù)組
  105. int m_nMoveCount;//此變量用以記錄走法的總數(shù)
  106. unsigned char CurPosition[GRID_NUM][GRID_NUM];//搜索時(shí)用于當(dāng)前節(jié)點(diǎn)棋盤狀態(tài)的數(shù)組
  107. STONEMOVE m_cmBestMove;        //記錄最佳走法的變量       
  108. //CMoveGenerator* m_pMG;        //走法產(chǎn)生器指針       
  109. //CEveluation* m_pEval;        //估值核心指針       
  110. int m_nSearchDepth;        //最大搜索深度
  111. int m_nMaxDepth;        //當(dāng)前搜索的最大搜索深度
  112. unsigned char m_RenjuBoard[GRID_NUM][GRID_NUM];//棋盤數(shù)組，用于顯示棋盤
  113. int m_nUserStoneColor;         //用戶棋子的顏色
  114. //CSearchEngine* m_pSE;         //搜索引擎指針
  115. int X,Y;                               //AI輸出落子位置
  116. int SL;                                  //勝利標(biāo)記
  117. //位置重要性價(jià)值表,此表從中間向外,越往外價(jià)值越低
  118. int PosValue[GRID_NUM][GRID_NUM]=
  119. {
  120. {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  121. {0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
  122. {0,1,2,2,2,2,2,2,2,2,2,2,2,1,0},
  123. {0,1,2,3,3,3,3,3,3,3,3,3,2,1,0},
  124. {0,1,2,3,4,4,4,4,4,4,4,3,2,1,0},
  125. {0,1,2,3,4,5,5,5,5,5,4,3,2,1,0},
  126. {0,1,2,3,4,5,6,6,6,5,4,3,2,1,0},
  127. {0,1,2,3,4,5,6,7,6,5,4,3,2,1,0},
  128. {0,1,2,3,4,5,6,6,6,5,4,3,2,1,0},
  129. {0,1,2,3,4,5,5,5,5,5,4,3,2,1,0},
  130. {0,1,2,3,4,4,4,4,4,4,4,3,2,1,0},
  131. {0,1,2,3,3,3,3,3,3,3,3,3,2,1,0},
  132. {0,1,2,2,2,2,2,2,2,2,2,2,2,1,0},
  133. {0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
  134. {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
  135. };

  137. //全局變量,用以統(tǒng)計(jì)估值函數(shù)的執(zhí)行遍數(shù)
  138. int count=0;

  140. int Eveluate(unsigned char position[][GRID_NUM],bool bIsWhiteTurn)
  141. {
  142. int i,j,k;
  143. unsigned char nStoneType;
  144. count++;//計(jì)數(shù)器累加

  146. //清空棋型分析結(jié)果
  147. memset(TypeRecord,TOBEANALSIS,GRID_COUNT*4*4);
  148. memset(TypeCount,0,40*4);

  150. for(i=0;i<GRID_NUM;i++)
  151. for(j=0;j<GRID_NUM;j++)
  152. {
  153. if(position[i][j]!=NOSTONE)
  154. {
  155. //如果水平方向上沒有分析過
  156. if(TypeRecord[i][j][0]==TOBEANALSIS)
  157. AnalysisHorizon(position,i,j);

  159. //如果垂直方向上沒有分析過
  160. if(TypeRecord[i][j][1]==TOBEANALSIS)
  161. AnalysisVertical(position,i,j);

  163. //如果左斜方向上沒有分析過
  164. if(TypeRecord[i][j][2]==TOBEANALSIS)
  165. AnalysisLeft(position,i,j);

  167. //如果右斜方向上沒有分析過
  168. if(TypeRecord[i][j][3]==TOBEANALSIS)
  169. AnalysisRight(position,i,j);
  170. }
  171. }

  173. //對分析結(jié)果進(jìn)行統(tǒng)計(jì),得到每種棋型的數(shù)量
  174. for(i=0;i<GRID_NUM;i++)
  175. for(j=0;j<GRID_NUM;j++)
  176. for(k =0;k<4;k++)
  177. {
  178. nStoneType=position[i][j];
  179. if(nStoneType!=NOSTONE)
  180. {
  181. switch(TypeRecord[i][j][k])
  182. {
  183. case FIVE://五連
  184. TypeCount[nStoneType][FIVE]++;
  185. break;
  186. case FOUR://活四
  187. TypeCount[nStoneType][FOUR]++;
  188. break;
  189. case SFOUR://沖四
  190. TypeCount[nStoneType][SFOUR]++;
  191. break;
  192. case THREE://活三
  193. TypeCount[nStoneType][THREE]++;
  194. break;
  195. case STHREE://眠三
  196. TypeCount[nStoneType][STHREE]++;
  197. break;
  198. case TWO://活二
  199. TypeCount[nStoneType][TWO]++;
  200. break;
  201. case STWO://眠二
  202. TypeCount[nStoneType][STWO]++;
  203. break;
  204. default:
  205. break;
  206. }  
  207. }
  208. }

  210. //如果已五連,返回極值
  211. if(bIsWhiteTurn)
  212. {
  213. if(TypeCount[BLACK][FIVE])
  214. {
  215.             
  216.          
  217.                  
  218. return -9999;
  219.         }
  220. if(TypeCount[WHITE][FIVE])
  221. {
  222.                
  223.             
  224.                         
  225. return 9999;
  226.         }
  227. }
  228. else
  229. {
  230. if(TypeCount[BLACK][FIVE])
  231. {
  232.               
  233.          
  234.                                 
  235. return 9999;
  236.         }
  237. if(TypeCount[WHITE][FIVE])
  238. {
  239.             
  240.      
  241.                              
  242. return -9999;
  243.         }
  244. }
  245. //兩個(gè)沖四等于一個(gè)活四
  246. if(TypeCount[WHITE][SFOUR]>1)
  247. TypeCount[WHITE][FOUR]++;
  248. if(TypeCount[BLACK][SFOUR]>1)
  249. TypeCount[BLACK][FOUR]++;
  250. int WValue=0,BValue=0;

  252. if(bIsWhiteTurn)//輪到白棋走
  253. {       
  254. if(TypeCount[WHITE][FOUR])       
  255.         {       
  256.             
  257.          
  258. return 9990;//活四,白勝返回極值
  259.          }
  260. if(TypeCount[WHITE][SFOUR])       
  261.         {       
  262.             
  263.          
  264. return 9980;//沖四,白勝返回極值
  265.         }
  266. if(TypeCount[BLACK][FOUR])       
  267. {
  268.            
  269.             
  270. return -9970;//白無沖四活四,而黑有活四,黑勝返回極值
  271.         }
  272. if(TypeCount[BLACK][SFOUR] && TypeCount[BLACK][THREE])
  273. {
  274.             
  275.                      
  276. return -9960;//而黑有沖四和活三,黑勝返回極值
  277.         }
  278. if(TypeCount[WHITE][THREE] && TypeCount[BLACK][SFOUR]== 0)       
  279.         {       
  280.            
  281.             
  282. return 9950;//白有活三而黑沒有四,白勝返回極值
  283.         }
  284. if(TypeCount[BLACK][THREE]>1 && TypeCount[WHITE][SFOUR]==0 && TypeCount[WHITE][THREE]==0 && TypeCount[WHITE][STHREE]==0)
  285.         {       
  286.             
  287.             
  288. return -9940;//黑的活三多于一個(gè),而白無四和三,黑勝返回極值
  289.         }
  290. if(TypeCount[WHITE][THREE]>1)
  291. WValue+=2000;//白活三多于一個(gè),白棋價(jià)值加2000
  292. else
  293. //否則白棋價(jià)值加200
  294. if(TypeCount[WHITE][THREE])
  295. WValue+=200;
  296. if(TypeCount[BLACK][THREE]>1)
  297. BValue+=500;//黑的活三多于一個(gè),黑棋價(jià)值加500
  298. else
  299. //否則黑棋價(jià)值加100
  300. if(TypeCount[BLACK][THREE])
  301. BValue+=100;
  302. //每個(gè)眠三加10
  303. if(TypeCount[WHITE][STHREE])
  304. WValue+=TypeCount[WHITE][STHREE]*10;
  305. //每個(gè)眠三加10
  306. if(TypeCount[BLACK][STHREE])
  307. BValue+=TypeCount[BLACK][STHREE]*10;
  308. //每個(gè)活二加4
  309. if(TypeCount[WHITE][TWO])
  310. WValue+=TypeCount[WHITE][TWO]*4;
  311. //每個(gè)活二加4
  312. if(TypeCount[BLACK][STWO])
  313. BValue+=TypeCount[BLACK][TWO]*4;
  314. //每個(gè)眠二加1
  315. if(TypeCount[WHITE][STWO])
  316. WValue+=TypeCount[WHITE][STWO];
  317. //每個(gè)眠二加1
  318. if(TypeCount[BLACK][STWO])
  319. BValue+=TypeCount[BLACK][STWO];
  320. }
  321. else//輪到黑棋走
  322. {       
  323. if(TypeCount[BLACK][FOUR])       
  324.         {       
  325.    
  326. return 9990;//活四,黑勝返回極值
  327.           }
  328. if(TypeCount[BLACK][SFOUR])       
  329.         {       
  330.            
  331. return 9980;//沖四,黑勝返回極值
  332.         }
  333. if(TypeCount[WHITE][FOUR])
  334. return -9970;//活四,白勝返回極值
  335.       
  336. if(TypeCount[WHITE][SFOUR] && TypeCount[WHITE][THREE])       
  337. return -9960;//沖四并活三,白勝返回極值

  339. if(TypeCount[BLACK][THREE] && TypeCount[WHITE][SFOUR]==0)
  340. return 9950;//黑活三,白無四。黑勝返回極值

  342. if(TypeCount[WHITE][THREE]>1 && TypeCount[BLACK][SFOUR]==0 && TypeCount[BLACK][THREE]==0 && TypeCount[BLACK][STHREE]==0)
  343. return -9940;//白的活三多于一個(gè),而黑無四和三,白勝返回極值

  345. //黑的活三多于一個(gè),黑棋價(jià)值加2000
  346. if(TypeCount[BLACK][THREE]>1)
  347. BValue+=2000;
  348. else
  349. //否則黑棋價(jià)值加200
  350. if(TypeCount[BLACK][THREE])
  351. BValue+=200;

  353. //白的活三多于一個(gè),白棋價(jià)值加 500
  354. if(TypeCount[WHITE][THREE]>1)
  355. WValue+=500;
  356. else
  357. //否則白棋價(jià)值加100
  358. if(TypeCount[WHITE][THREE])
  359. WValue+=100;

  361. //每個(gè)眠三加10
  362. if(TypeCount[WHITE][STHREE])
  363. WValue+=TypeCount[WHITE][STHREE]*10;
  364. //每個(gè)眠三加10
  365. if(TypeCount[BLACK][STHREE])
  366. BValue+=TypeCount[BLACK][STHREE]*10;

  368. //每個(gè)活二加4
  369. if(TypeCount[WHITE][TWO])
  370. WValue+=TypeCount[WHITE][TWO]*4;
  371. //每個(gè)活二加4
  372. if(TypeCount[BLACK][STWO])
  373. BValue+=TypeCount[BLACK][TWO]*4;

  375. //每個(gè)眠二加1
  376. if(TypeCount[WHITE][STWO])
  377. WValue+=TypeCount[WHITE][STWO];
  378. //每個(gè)眠二加1
  379. if(TypeCount[BLACK][STWO])
  380. BValue+=TypeCount[BLACK][STWO];
  381. }

  383. //加上所有棋子的位置價(jià)值
  384. for(i=0;i<GRID_NUM;i++)
  385. for(j=0;j<GRID_NUM;j++)
  386. {
  387. nStoneType=position[i][j];
  388. if(nStoneType!=NOSTONE)
  389. if(nStoneType==BLACK)
  390. BValue+=PosValue[i][j];
  391. else
  392. WValue+=PosValue[i][j];
  393. }

  395. //返回估值
  396. if(!bIsWhiteTurn)
  397. return BValue-WValue;
  398. else
  399. return WValue-BValue;
  400. }

  402. //分析棋盤上某點(diǎn)在水平方向上的棋型
  403. int AnalysisHorizon(unsigned char position[][GRID_NUM],int i,int j)
  404. {
  405. //調(diào)用直線分析函數(shù)分析
  406. AnalysisLine(position[i],15,j);
  407. //拾取分析結(jié)果
  408. for(int s=0;s<15;s++)
  409. if(m_LineRecord[s]!=TOBEANALSIS)
  410. TypeRecord[i][s][0]= m_LineRecord[s];

  412. return TypeRecord[i][j][0];
  413. }

  415. //分析棋盤上某點(diǎn)在垂直方向上的棋型
  416. int AnalysisVertical(unsigned char position[][GRID_NUM],int i,int j)
  417. {
  418. unsigned char tempArray[GRID_NUM];
  419. //將垂直方向上的棋子轉(zhuǎn)入一維數(shù)組
  420. for(int k=0;k<GRID_NUM;k++)
  421. tempArray[k]=position[k][j];
  422. //調(diào)用直線分析函數(shù)分析
  423. AnalysisLine(tempArray,GRID_NUM,i);
  424. //拾取分析結(jié)果
  425. for(int s=0;s<GRID_NUM;s++)
  426. if(m_LineRecord[s]!=TOBEANALSIS)
  427. TypeRecord[s][j][1]=m_LineRecord[s];

  429. return TypeRecord[i][j][1];
  430. }

  432. //分析棋盤上某點(diǎn)在左斜方向上的棋型
  433. int AnalysisLeft(unsigned char position[][GRID_NUM],int i,int j)
  434. {
  435. unsigned char tempArray[GRID_NUM];
  436. int x,y;
  437. int k;
  438. if(i<j)
  439. {
  440. y=0;
  441. x=j-i;
  442. }
  443. else
  444. {
  445. x=0;
  446. y=i-j;
  447. }
  448. //將斜方向上的棋子轉(zhuǎn)入一維數(shù)組
  449. for(k=0;k<GRID_NUM;k++)
  450. {
  451. if(x+k>14 || y+k>14)
  452. break;
  453. tempArray[k]=position[y+k][x+k];
  454. }
  455. //調(diào)用直線分析函數(shù)分析
  456. AnalysisLine(tempArray,k,j-x);
  457. //拾取分析結(jié)果
  458. for(int s=0;s<k;s++)
  459. if(m_LineRecord[s]!=TOBEANALSIS)
  460. TypeRecord[y+s][x+s][2]=m_LineRecord[s];

  462. return TypeRecord[i][j][2];
  463. }

  465. //分析棋盤上某點(diǎn)在右斜方向上的棋型
  466. int AnalysisRight(unsigned char position[][GRID_NUM],int i,int j)
  467. {
  468. unsigned char tempArray[GRID_NUM];
  469. int x,y,realnum;
  470. int k;
  471. if(14-i<j)
  472. {
  473. y=14;
  474. x=j-14+i;
  475. realnum=14-i;
  476. }
  477. else
  478. {
  479. x=0;
  480. y=i+j;
  481. realnum=j;
  482. }
  483. //將斜方向上的棋子轉(zhuǎn)入一維數(shù)組
  484. for(k=0;k<GRID_NUM;k++)
  485. {
  486. if(x+k>14 || y-k<0)
  487. break;
  488. tempArray[k]=position[y-k][x+k];
  489. }
  490. //調(diào)用直線分析函數(shù)分析
  491. AnalysisLine(tempArray,k,j-x);
  492. //拾取分析結(jié)果
  493. for(int s=0;s<k;s++)
  494. if(m_LineRecord[s]!=TOBEANALSIS)
  495. TypeRecord[y-s][x+s][3]=m_LineRecord[s];

  497. return TypeRecord[i][j][3];
  498. }

  500. int AnalysisLine(unsigned char* position,int GridNum,int StonePos)
  501. {
  502. unsigned char StoneType;
  503. unsigned char AnalyLine[30];
  504. int nAnalyPos;
  505. int LeftEdge,RightEdge;
  506. int LeftRange,RightRange;

  508. if(GridNum<5)
  509. {
  510. //數(shù)組長度小于5沒有意義
  511. memset(m_LineRecord,ANALSISED,GridNum);
  512. return 0;
  513. }
  514. nAnalyPos=StonePos;
  515. memset(m_LineRecord,TOBEANALSIS,30);
  516. memset(AnalyLine,0x0F,30);
  517. //將傳入數(shù)組裝入AnalyLine;
  518. memcpy(&AnalyLine,position,GridNum);
  519. GridNum--;
  520. StoneType=AnalyLine[nAnalyPos];
  521. LeftEdge=nAnalyPos;
  522. RightEdge=nAnalyPos;
  523. //算連續(xù)棋子左邊界
  524. while(LeftEdge>0)
  525. {
  526. if(AnalyLine[LeftEdge-1]!=StoneType)
  527. break;
  528. LeftEdge--;
  529. }

  531. //算連續(xù)棋子右邊界
  532. while(RightEdge<GridNum)
  533. {
  534. if(AnalyLine[RightEdge+1]!=StoneType)
  535. break;
  536. RightEdge++;
  537. }
  538. LeftRange=LeftEdge;
  539. RightRange=RightEdge;
  540. //下面兩個(gè)循環(huán)算出棋子可下的范圍
  541. while(LeftRange>0)
  542. {
  543. if(AnalyLine[LeftRange -1]==!StoneType)
  544. break;
  545. LeftRange--;
  546. }
  547. while(RightRange<GridNum)
  548. {
  549. if(AnalyLine[RightRange+1]==!StoneType)
  550. break;
  551. RightRange++;
  552. }
  553. //如果此范圍小于4則分析沒有意義
  554. if(RightRange-LeftRange<4)
  555. {
  556. for(int k=LeftRange;k<=RightRange;k++)
  557. m_LineRecord[k]=ANALSISED;
  558. return false;
  559. }
  560. //將連續(xù)區(qū)域設(shè)為分析過的,防止重復(fù)分析此一區(qū)域
  561. for(int k=LeftEdge;k<=RightEdge;k++)
  562. m_LineRecord[k]=ANALSISED;
  563. if(RightEdge-LeftEdge>3)
  564. {
  565. //如待分析棋子棋型為五連
  566. m_LineRecord[nAnalyPos]=FIVE;
  567. return FIVE;
  568. }

  570. if(RightEdge-LeftEdge== 3)
  571. {
  572. //如待分析棋子棋型為四連
  573. bool Leftfour=false;
  574. if(LeftEdge>0)
  575. if(AnalyLine[LeftEdge-1]==NOSTONE)
  576. Leftfour=true;//左邊有氣

  578. if(RightEdge<GridNum)
  579. //右邊未到邊界
  580. if(AnalyLine[RightEdge+1]==NOSTONE)
  581. //右邊有氣
  582. if(Leftfour==true)//如左邊有氣
  583. m_LineRecord[nAnalyPos]=FOUR;//活四
  584. else
  585. m_LineRecord[nAnalyPos]=SFOUR;//沖四
  586. else
  587. if(Leftfour==true)//如左邊有氣
  588. m_LineRecord[nAnalyPos]=SFOUR;//沖四
  589. else
  590. if(Leftfour==true)//如左邊有氣
  591. m_LineRecord[nAnalyPos]=SFOUR;//沖四

  593. return m_LineRecord[nAnalyPos];
  594. }

  596. if(RightEdge-LeftEdge==2)
  597. {
  598. //如待分析棋子棋型為三連
  599. bool LeftThree=false;

  601. if(LeftEdge>1)
  602. if(AnalyLine[LeftEdge-1]==NOSTONE)
  603. //左邊有氣
  604. if(LeftEdge>1 && AnalyLine[LeftEdge-2]==AnalyLine[LeftEdge])
  605. {
  606. //左邊隔一空白有己方棋子
  607. m_LineRecord[LeftEdge]=SFOUR;//沖四
  608. m_LineRecord[LeftEdge-2]=ANALSISED;
  609. }
  610. else
  611. LeftThree=true;

  613. if(RightEdge<GridNum)
  614. if(AnalyLine[RightEdge+1]==NOSTONE)
  615. //右邊有氣
  616. if(RightEdge<GridNum-1 && AnalyLine[RightEdge+2]==AnalyLine[RightEdge])
  617. {
  618. //右邊隔1個(gè)己方棋子
  619. m_LineRecord[RightEdge]=SFOUR;//沖四
  620. m_LineRecord[RightEdge+2]=ANALSISED;
  621. }
  622. else
  623. if(LeftThree==true)//如左邊有氣
  624. m_LineRecord[RightEdge]=THREE;//活三
  625. else
  626. m_LineRecord[RightEdge]=STHREE; //沖三
  627. else
  628. {
  629. if(m_LineRecord[LeftEdge]==SFOUR)//如左沖四
  630. return m_LineRecord[LeftEdge];//返回

  632. if(LeftThree==true)//如左邊有氣
  633. m_LineRecord[nAnalyPos]=STHREE;//眠三
  634. }
  635. else
  636. {
  637. if(m_LineRecord[LeftEdge]==SFOUR)//如左沖四
  638. return m_LineRecord[LeftEdge];//返回
  639. if(LeftThree==true)//如左邊有氣
  640. m_LineRecord[nAnalyPos]=STHREE;//眠三
  641. }

  643. return m_LineRecord[nAnalyPos];
  644. }

  646. if(RightEdge-LeftEdge==1)
  647. {
  648. //如待分析棋子棋型為二連
  649. bool Lefttwo=false;
  650. bool Leftthree=false;

  652. if(LeftEdge>2)
  653. if(AnalyLine[LeftEdge-1]==NOSTONE)
  654. //左邊有氣
  655. if(LeftEdge-1>1 && AnalyLine[LeftEdge-2]==AnalyLine[LeftEdge])
  656. if(AnalyLine[LeftEdge-3]==AnalyLine[LeftEdge])
  657. {
  658. //左邊隔2個(gè)己方棋子
  659. m_LineRecord[LeftEdge-3]=ANALSISED;
  660. m_LineRecord[LeftEdge-2]=ANALSISED;
  661. m_LineRecord[LeftEdge]=SFOUR;//沖四
  662. }
  663. else
  664. if(AnalyLine[LeftEdge-3]==NOSTONE)
  665. {
  666. //左邊隔1個(gè)己方棋子
  667. m_LineRecord[LeftEdge-2]=ANALSISED;
  668. m_LineRecord[LeftEdge]=STHREE;//眠三
  669. }
  670. else
  671. Lefttwo=true;

  673. if(RightEdge<GridNum-2)
  674. if(AnalyLine[RightEdge+1]==NOSTONE)
  675. //右邊有氣
  676. if(RightEdge+1<GridNum-1 && AnalyLine[RightEdge+2]==AnalyLine[RightEdge])
  677. if(AnalyLine[RightEdge+3]==AnalyLine[RightEdge])
  678. {
  679. //右邊隔兩個(gè)己方棋子
  680. m_LineRecord[RightEdge+3]=ANALSISED;
  681. m_LineRecord[RightEdge+2]=ANALSISED;
  682. m_LineRecord[RightEdge]=SFOUR;//沖四
  683. }
  684. else
  685. if(AnalyLine[RightEdge+3]==NOSTONE)
  686. {
  687. //右邊隔 1 個(gè)己方棋子
  688. m_LineRecord[RightEdge+2]=ANALSISED;
  689. m_LineRecord[RightEdge]=STHREE;//眠三
  690. }
  691. else
  692. {
  693. if(m_LineRecord[LeftEdge]==SFOUR)//左邊沖四
  694. return m_LineRecord[LeftEdge];//返回

  696. if(m_LineRecord[LeftEdge]==STHREE)//左邊眠三       
  697. return m_LineRecord[LeftEdge];

  699. if(Lefttwo==true)
  700. m_LineRecord[nAnalyPos]=TWO;//返回活二
  701. else
  702. m_LineRecord[nAnalyPos]=STWO;//眠二
  703. }
  704. else
  705. {
  706. if(m_LineRecord[LeftEdge]==SFOUR)//沖四返回
  707. return m_LineRecord[LeftEdge];

  709. if(Lefttwo==true)//眠二
  710. m_LineRecord[nAnalyPos]=STWO;
  711. }

  713. return m_LineRecord[nAnalyPos];
  714. }

  716. return 0;
  717. }

  719. //將歷史記錄表中所有項(xiàng)目全置為初值
  720. void ResetHistoryTable()
  721. {
  722.     memset(m_HistoryTable,10,GRID_COUNT*sizeof(int));
  723. }

  725. //從歷史得分表中取給定走法的歷史得分
  726. int GetHistoryScore(STONEMOVE* move)
  727. {
  728. return m_HistoryTable[move->StonePos.x][move->StonePos.y];
  729. }

  731. //將一最佳走法匯入歷史記錄
  732. void EnterHistoryScore(STONEMOVE* move,int depth)
  733. {
  734. m_HistoryTable[move->StonePos.x][move->StonePos.y]+=2<<depth;
  735. }

  737. //對走法隊(duì)列從小到大排序
  738. //STONEMOVE* source原始隊(duì)列
  739. //STONEMOVE* target目標(biāo)隊(duì)列
  740. //合并source[l…m]和 source[m +1…r]至target[l…r]
  741. void Merge(STONEMOVE* source,STONEMOVE* target,int l,int m,int r)
  742. {
  743. //從小到大排序
  744. int i=l;
  745. int j=m+1;
  746. int k=l;
  747. while(i<=m && j<=r)
  748. if(source[i].Score<=source[j].Score)
  749. target[k++]=source[i++];
  750. else
  751. target[k++]=source[j++];
  752. if(i>m)
  753. for(int q=j;q<=r;q++)
  754. target[k++]=source[q];
  755. else
  756. for(int q=i;q<=m;q++)
  757. target[k++]=source[q];
  758. }

  760. void Merge_A(STONEMOVE* source,STONEMOVE* target,int l,int m,int r)
  761. {
  762. //從大到小排序
  763. int i=l;
  764. int j=m+1;
  765. int k=l;
  766. while(i<=m &&j<=r)
  767. if(source[i].Score>=source[j].Score)
  768. target[k++]=source[i++];
  769. else
  770. target[k++]=source[j++];
  771. if(i>m)
  772. for(int q=j;q<=r;q++)
  773. target[k++]=source[q];
  774. else
  775. for(int q=i;q<=m;q++)
  776. target[k++]=source[q];
  777. }

  779. //合并大小為 S 的相鄰子數(shù)組
  780. //direction 是標(biāo)志,指明是從大到小還是從小到大排序
  781. void MergePass(STONEMOVE* source,STONEMOVE* target,const int s,const int n,const bool direction)
  782. {
  783. int i=0;
  784. while(i<=n-2*s)
  785. {
  786. //合并大小為 s的相鄰二段子數(shù)組
  787. if(direction)
  788. Merge(source,target,i,i+s-1,i+2*s-1);
  789. else
  790. Merge_A(source,target,i,i+s-1,i+2*s-1);
  791. i=i+2*s;
  792. }
  793. if(i+s<n)//剩余的元素個(gè)數(shù)小于2s
  794. {
  795. if(direction)
  796. Merge(source,target,i,i+s-1,n-1);
  797. else
  798. Merge_A(source,target,i,i+s-1,n-1);
  799. }
  800. else
  801. for(int j=i;j<=n-1;j++)
  802. target[j]=source[j];
  803. }

  805. void MergeSort(STONEMOVE* source,int n,bool direction)
  806. {
  807. int s=1;
  808. while(s<n)
  809. {
  810. MergePass(source,m_TargetBuff,s,n,direction);
  811. s+=s;
  812. MergePass(m_TargetBuff,source,s,n,direction);
  813. s+=s;
  814. }
  815. }

  817. int CreatePossibleMove(unsigned char position[][GRID_NUM], int nPly, int nSide)
  818. {
  819. int i,j;
  820. m_nMoveCount=0;
  821. for(i=0;i<GRID_NUM;i++)
  822. for(j=0;j<GRID_NUM;j++)
  823. {
  824. if(position[i][j]==(unsigned char)NOSTONE)
  825. AddMove(j,i,nPly);
  826. }

  828. //使用歷史啟發(fā)類中的靜態(tài)歸并排序函數(shù)對走法隊(duì)列進(jìn)行排序
  829. //這是為了提高剪枝效率
  830. //        CHistoryHeuristic history;
  831. MergeSort(m_MoveList[nPly],m_nMoveCount,0);

  833. return m_nMoveCount;//返回合法走法個(gè)數(shù)
  834. }

  836. //在m_MoveList中插入一個(gè)走法
  837. //nToX是目標(biāo)位置橫坐標(biāo)
  838. //nToY是目標(biāo)位置縱坐標(biāo)
  839. //nPly是此走法所在的層次
  840. int AddMove(int nToX, int nToY, int nPly)
  841. {
  842. m_MoveList[nPly][m_nMoveCount].StonePos.x=nToX;
  843. m_MoveList[nPly][m_nMoveCount].StonePos.y=nToY;

  845. m_nMoveCount++;
  846. m_MoveList[nPly][m_nMoveCount].Score=PosValue[nToY][nToX];//使用位置價(jià)值表評估當(dāng)前走法的價(jià)值
  847. return m_nMoveCount;
  848. }

  850. void CNegaScout_TT_HH()
  851. {
  852. ResetHistoryTable();
  853. //        m_pThinkProgress=NULL;
  854. }

  856. void SearchAGoodMove(unsigned char position[][GRID_NUM],int Type)
  857. {
  858. int Score;

  860. memcpy(CurPosition,position,GRID_COUNT);
  861. m_nMaxDepth=m_nSearchDepth;
  862. CalculateInitHashKey(CurPosition);
  863. ResetHistoryTable();
  864. Score=NegaScout(m_nMaxDepth,-20000,20000);
  865. X=m_cmBestMove.StonePos.y;
  866. Y=m_cmBestMove.StonePos.x;
  867. MakeMove(&m_cmBestMove,Type);
  868. memcpy(position,CurPosition,GRID_COUNT);
  869. }

  871. int IsGameOver(unsigned char position[][GRID_NUM],int nDepth)
  872. {
  873. int score,i;//計(jì)算要下的棋子顏色
  874. i=(m_nMaxDepth-nDepth)%2;
  875. score=Eveluate(position,i);//調(diào)用估值函數(shù)
  876. if(abs(score)>8000)//如果估值函數(shù)返回極值，給定局面游戲結(jié)束
  877. return score;//返回極值
  878. return 0;//返回未結(jié)束
  879. }

  881. int NegaScout(int depth,int alpha,int beta)
  882. {
  883. int Count,i;
  884. unsigned char type;
  885. int a,b,t;
  886. int side;
  887. int score;
  888. /*        if(depth>0)
  889. {
  890. i= IsGameOver(CurPosition,depth);
  891. if(i!=0)
  892. return i;  //已分勝負(fù)，返回極值
  893. }
  894. */
  895. side=(m_nMaxDepth-depth)%2;//計(jì)算當(dāng)前節(jié)點(diǎn)的類型,極大0/極小1
  896. score=LookUpHashTable(alpha,beta,depth,side);
  897. if(score!=66666)
  898. return score;
  899. if(depth<=0)//葉子節(jié)點(diǎn)取估值
  900. {
  901. score=Eveluate(CurPosition,side);
  902. EnterHashTable(exact,score,depth,side);//將估值存入置換表

  904. return score;
  905. }
  906. Count=CreatePossibleMove(CurPosition,depth,side);
  907. for(i=0;i<Count;i++)
  908. m_MoveList[depth][i].Score=GetHistoryScore(&m_MoveList[depth][i]);

  910. MergeSort(m_MoveList[depth],Count,0);
  911. int bestmove=-1;
  912.     a=alpha;
  913.     b=beta;

  915.     int eval_is_exact=0;

  917.     for(i=0;i<Count;i++)
  918. {
  919. type=MakeMove(&m_MoveList[depth][i],side);
  920. Hash_MakeMove(&m_MoveList[depth][i],CurPosition);
  921. t=-NegaScout(depth-1,-b,-a);//遞歸搜索子節(jié)點(diǎn)，對第 1 個(gè)節(jié)點(diǎn)是全窗口，其后是空窗探測
  922. if(t>a && t<beta && i>0)
  923. {
  924. //對于第一個(gè)后的節(jié)點(diǎn),如果上面的搜索failhigh
  925. a=-NegaScout(depth-1,-beta,-t);//re-search
  926. eval_is_exact=1;//設(shè)數(shù)據(jù)類型為精確值
  927. if(depth==m_nMaxDepth)
  928. m_cmBestMove=m_MoveList[depth][i];
  929. bestmove=i;
  930. }
  931. Hash_UnMakeMove(&m_MoveList[depth][i],CurPosition);
  932. UnMakeMove(&m_MoveList[depth][i]);
  933. if(a<t)
  934. {
  935. eval_is_exact=1;
  936. a=t;
  937. if(depth==m_nMaxDepth)
  938. m_cmBestMove=m_MoveList[depth][i];
  939. }
  940. if(a>= beta)
  941. {
  942. EnterHashTable(lower_bound,a,depth,side);
  943. EnterHistoryScore(&m_MoveList[depth][i],depth);
  944. return a;
  945. }
  946. b=a+1;                      /* set new null window */
  947. }
  948. if(bestmove!=-1)
  949. EnterHistoryScore(&m_MoveList[depth][bestmove], depth);
  950. if(eval_is_exact)
  951. EnterHashTable(exact,a,depth,side);
  952. else
  953. EnterHashTable(upper_bound,a,depth,side);

  955. return a;
  956. }

  958. unsigned char MakeMove(STONEMOVE* move,int type)
  959. {
  960. CurPosition[move->StonePos.y][move->StonePos.x]=type;
  961. return 0;
  962. }

  964. void UnMakeMove(STONEMOVE* move)
  965. {
  966. CurPosition[move->StonePos.y][move->StonePos.x]=NOSTONE;
  967. }

  969. __int64 rand64(void)
  970. {
  971.     return rand()^((__int64)rand()<<15)^((__int64)rand()<<30)^
  972. ((__int64)rand()<<45)^((__int64)rand()<<60);
  973. }

  975. //生成32位隨機(jī)數(shù)
  976. long rand32(void)
  977. {
  978.     return rand()^((long)rand()<<15)^((long)rand()<<30);
  979. }

  981. void CTranspositionTable()
  982. {
  983. InitializeHashKey();//建立哈希表，創(chuàng)建隨機(jī)數(shù)組
  984. }

  986. void _CTranspositionTable()
  987. {
  988. //釋放哈希表所用空間
  989. delete m_pTT[0];
  990. delete m_pTT[1];
  991. }

  993. void CalculateInitHashKey(unsigned char CurPosition[][GRID_NUM])
  994. {
  995. int j,k,nStoneType;

  997. m_HashKey32=0;
  998. m_HashKey32=0;
  999. //將所有棋子對應(yīng)的哈希數(shù)加總
  1000. for(j=0;j<GRID_NUM;j++)
  1001. for(k=0;k<GRID_NUM;k++)
  1002. {
  1003. nStoneType=CurPosition[j][k];
  1004. if(nStoneType!=0xFF)
  1005. {
  1006. m_HashKey32=m_HashKey32^m_nHashKey32[nStoneType][j][k];
  1007. m_HashKey64=m_HashKey64^m_ulHashKey64[nStoneType][j][k];
  1008. }
  1009. }
  1010. }

  1012. void Hash_MakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM])
  1013. {
  1014. int type;

  1016. type=CurPosition[move->StonePos.y][move->StonePos.x];//將棋子在目標(biāo)位置的隨機(jī)數(shù)添入
  1017. m_HashKey32=m_HashKey32^m_nHashKey32[type][move->StonePos.y][move->StonePos.x];
  1018. m_HashKey64=m_HashKey64^m_ulHashKey64[type][move->StonePos.y][move->StonePos.x];
  1019. }

  1021. void Hash_UnMakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM])
  1022. {
  1023. int type;
  1024. type=CurPosition[move->StonePos.y][move->StonePos.x];//將棋子現(xiàn)在位置上的隨機(jī)數(shù)從哈希值當(dāng)中去除
  1025. m_HashKey32=m_HashKey32^m_nHashKey32[type][move->StonePos.y][move->StonePos.x];
  1026. m_HashKey64=m_HashKey64^m_ulHashKey64[type][move->StonePos.y][move->StonePos.x];
  1027. }

  1029. int LookUpHashTable(int alpha, int beta, int depth, int TableNo)
  1030. {
  1031. int x;
  1032. HashItem* pht;

  1034. //計(jì)算二十位哈希地址，如果讀者設(shè)定的哈希表大小不是 1M*2 的,
  1035. //而是 TableSize*2，TableSize為讀者設(shè)定的大小
  1036. //則需要修改這一句為m_HashKey32% TableSize
  1037. //下一個(gè)函數(shù)中這一句也一樣
  1038. x=m_HashKey32 & 0xFFFFF;
  1039. pht=&m_pTT[TableNo][x];//取到具體的表項(xiàng)指針

  1041.     if(pht->depth>=depth && pht->checksum==m_HashKey64)
  1042. {
  1043. switch(pht->entry_type)//判斷數(shù)據(jù)類型
  1044. {
  1045. case exact://確切值
  1046. return pht->eval;

  1048. case lower_bound://下邊界
  1049. if(pht->eval>=beta)
  1050. return pht->eval;
  1051. else
  1052. break;

  1054. case upper_bound://上邊界
  1055. if (pht->eval<=alpha)
  1056. return pht->eval;
  1057. else
  1058. break;
  1059.         }
  1060. }

  1062. return 66666;
  1063. }

  1065. void EnterHashTable(ENTRY_TYPE entry_type, short eval, short depth, int TableNo)
  1066. {
  1067. int x;
  1068. HashItem* pht;

  1070. x=m_HashKey32 & 0xFFFFF;//計(jì)算二十位哈希地址
  1071. pht=&m_pTT[TableNo][x]; //取到具體的表項(xiàng)指針

  1073. //將數(shù)據(jù)寫入哈希表
  1074. pht->checksum=m_HashKey64; //64位校驗(yàn)碼
  1075. pht->entry_type=entry_type;//表項(xiàng)類型
  1076. pht->eval=eval;          //要保存的值
  1077. pht->depth=depth;          //層次
  1078. }

  1080. void InitializeHashKey()
  1081. {
  1082. int i,j,k;
  1083. srand((unsigned)time(NULL));
  1084. //填充隨機(jī)數(shù)組
  1085. for(i=0;i<15;i++)
  1086. for(j=0;j<10;j++)
  1087. for(k=0;k<9;k++)
  1088. {
  1089. m_nHashKey32[i][j][k]=rand32();
  1090. m_ulHashKey64[i][j][k]=rand64();
  1091. }

  1093. //申請置換表所用空間。1M "2 個(gè)條目，讀者也可指定其他大小
  1094. m_pTT[0]=new HashItem[1024*1024];//用于存放取極大值的節(jié)點(diǎn)數(shù)據(jù)
  1095. m_pTT[1]=new HashItem[1024*1024];//用于存放取極小值的節(jié)點(diǎn)數(shù)據(jù)
  1096. }


  1099. //using namespace std;

  1101. int main(int argc, char *argv[])
  1102. {
  1103. SL=0;
  1104. int colour;
  1105. char command[10]; //用于保存命令的字符串
  1106. for (int i = 0; i < GRID_NUM; i++)
  1107. for (int j = 0; j < GRID_NUM; j++)
  1108. m_RenjuBoard[i][j] = NOSTONE; //棋盤初始化

  1110.     int XS;
  1111.     printf("請選擇先手棋手：1表示AI先手 0表示棋手先手\n");
  1112. cin >> XS; //是否電腦先手
  1113. colour=BLACK;
  1114. m_nUserStoneColor=WHITE;
  1115. while (!SL)
  1116. {
  1117.         printf("\n請輸入落子坐標(biāo)：\n");
  1118. int rival_x, rival_y; //用于保存對手上一步落子點(diǎn)
  1119. cin >> rival_x >> rival_y; //讀入對手上一步落子點(diǎn)  
  1120. if(XS == 1 && rival_x == -1 && rival_y == -1) //如果己方執(zhí)黑且是第一步，則占據(jù)棋盤中心位置
  1121. {
  1122. m_RenjuBoard[GRID_NUM / 2][GRID_NUM / 2] = colour; //更新棋盤信息
  1123. //cout << GRID_NUM / 2 << ' ' << GRID_NUM / 2 << endl; //輸出
  1124. //cout << flush; //刷新緩沖區(qū)  
  1125. }
  1126. else
  1127. {
  1128. m_RenjuBoard[rival_x][rival_y] =m_nUserStoneColor;
  1129. //更新棋盤信息
  1130.            for (int i = 0; i < GRID_NUM; i++)
  1131.       {
  1132. for (int j = 0; j < GRID_NUM; j++)
  1133. {
  1134.             if(m_RenjuBoard[i][j]==WHITE)
  1135. printf("O "); else  if(m_RenjuBoard[i][j]==BLACK)printf("X "); else printf("+ ");
  1136.         }
  1137.           printf("\n");
  1138.         }
  1139. m_nSearchDepth=4;//AI難度等級設(shè)置
  1140. //最大搜索深度       
  1141. do
  1142. {
  1143. CNegaScout_TT_HH();         //創(chuàng)建NegaScout_TT_HH搜索引擎
  1144. CTranspositionTable();
  1145. SearchAGoodMove(m_RenjuBoard,colour);
  1146. m_RenjuBoard[X][Y]=colour;
  1147. printf("\nAI落子坐標(biāo)為：");
  1148. cout << X << ' ' << Y << endl; //輸出
  1149. cout << flush; //刷新緩沖區(qū)
  1150. _CTranspositionTable();
  1151. break; //結(jié)束循環(huán)
  1152. }
  1153. while (!SL);
  1154. //循環(huán)直至隨機(jī)得到一個(gè)空位置
  1155. for (int i = 0; i < GRID_NUM; i++)
  1156.     {
  1157. for (int j = 0; j < GRID_NUM; j++)
  1158. {
  1159.             if(m_RenjuBoard[i][j]==WHITE)
  1160. printf("O "); else  if(m_RenjuBoard[i][j]==BLACK)printf("X "); else printf("+ ");
  1161.         }
  1162.           printf("\n");
  1163.         }
  1164.         
  1165.         if(SL==1)printf("很遺憾AI勝利了繼續(xù)努力吧少年！\n");else if(SL==2)printf("少年你太叼了居然打敗了AI！\n");
  1166.         
  1167.         
  1168.      }
  1169. }
  1170.    
  1171.     system("PAUSE");
  1172.     return EXIT_SUCCESS;
  1173. }
復(fù)制代碼



作者: 1095222570    時(shí)間: 2016-3-6 23:31
本帖最后由 1095222570 于 2016-3-7 11:02 編輯

99999999999999999999999999999999
作者: ccl    時(shí)間: 2016-3-14 00:26
標(biāo)題: RE: 博弈樹加上α-β剪枝算法做出來的五子棋AI往前推6步無壓力
樓主的代碼有個(gè)bug，ai不會(huì)防守眠4，勝局時(shí)也不會(huì)自己連5，希望改全，郵箱1490325170@qq.com
作者: 墮落小CY    時(shí)間: 2018-3-22 09:17
ccl 發(fā)表于 2016-3-14 00:26
**** 作者被禁止或刪除 內(nèi)容自動(dòng)屏蔽 ****

兄弟，樓主有回復(fù)你嗎，有的話，代碼發(fā)我一下，
作者: 墮落小CY    時(shí)間: 2018-3-26 09:22
樓主真大佬，代碼能跑起來，有4個(gè)錯(cuò)誤，改了就好了
作者: zyx132    時(shí)間: 2018-4-24 15:25
墮落小CY 發(fā)表于 2018-3-26 09:22
樓主真大佬，代碼能跑起來，有4個(gè)錯(cuò)誤，改了就好了

請問是哪四個(gè)錯(cuò)誤啊
作者: 55622332    時(shí)間: 2019-7-4 15:09
墮落小CY 發(fā)表于 2018-3-26 09:22
**** 作者被禁止或刪除 內(nèi)容自動(dòng)屏蔽 ****

你好，請問是那幾個(gè)錯(cuò)誤呢
作者: sophon    時(shí)間: 2019-10-13 17:05
我第一局13步就贏了，而且它判勝負(fù)還有問題



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1