欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標(biāo)題: 博弈樹加上α-β剪枝算法做出來的五子棋AI往前推6步無壓力 [打印本頁]

---

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

AI棋力已經(jīng)非常叼了我反正是一次都贏不了它，所有棋類AI基本都是一個原理只需要根據(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. //這個宏用以檢查某一坐標(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;         //取得此值時的層次
    
32. short eval;         //節(jié)點(diǎn)的值
    
33. }HashItem;
    
34. 
    
35. typedef struct Node
    
36. {
    
37. int x;
    
38. int y;
    
39. }POINT;
    
40. 
    
41. //用以表示棋子位置的結(jié)構(gòu)
    
42. typedef struct _stoneposition
    
43. {
    
44. unsigned char x;
    
45. unsigned char y;
    
46. }STONEPOS;
    
47. 
    
48. typedef struct _movestone
    
49. {
    
50. unsigned char nRenjuID;
    
51. POINT ptMovePoint;
    
52. }MOVESTONE;
    
53. //這個結(jié)構(gòu)用以表示走法
    
54. 
    
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ù)組,有三個維度,用于存放水平、垂直、左斜、右斜 4 個方向上所有棋型分析結(jié)果
     
104. int TypeCount[2][20];          //存放統(tǒng)記過的分析結(jié)果的數(shù)組
     
105. int m_nMoveCount;//此變量用以記錄走法的總數(shù)
     
106. unsigned char CurPosition[GRID_NUM][GRID_NUM];//搜索時用于當(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. //位置重要性價值表,此表從中間向外,越往外價值越低
     
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. };
     
136. 
     
137. //全局變量,用以統(tǒng)計(jì)估值函數(shù)的執(zhí)行遍數(shù)
     
138. int count=0;
     
139. 
     
140. int Eveluate(unsigned char position[][GRID_NUM],bool bIsWhiteTurn)
     
141. {
     
142. int i,j,k;
     
143. unsigned char nStoneType;
     
144. count++;//計(jì)數(shù)器累加
     
145. 
     
146. //清空棋型分析結(jié)果
     
147. memset(TypeRecord,TOBEANALSIS,GRID_COUNT*4*4);
     
148. memset(TypeCount,0,40*4);
     
149. 
     
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);
     
158. 
     
159. //如果垂直方向上沒有分析過
     
160. if(TypeRecord[i][j][1]==TOBEANALSIS)
     
161. AnalysisVertical(position,i,j);
     
162. 
     
163. //如果左斜方向上沒有分析過
     
164. if(TypeRecord[i][j][2]==TOBEANALSIS)
     
165. AnalysisLeft(position,i,j);
     
166. 
     
167. //如果右斜方向上沒有分析過
     
168. if(TypeRecord[i][j][3]==TOBEANALSIS)
     
169. AnalysisRight(position,i,j);
     
170. }
     
171. }
     
172. 
     
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. }
     
209. 
     
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. //兩個沖四等于一個活四
     
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;
     
251. 
     
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;//黑的活三多于一個,而白無四和三,黑勝返回極值
     
289.         }
     
290. if(TypeCount[WHITE][THREE]>1)
     
291. WValue+=2000;//白活三多于一個,白棋價值加2000
     
292. else
     
293. //否則白棋價值加200
     
294. if(TypeCount[WHITE][THREE])
     
295. WValue+=200;
     
296. if(TypeCount[BLACK][THREE]>1)
     
297. BValue+=500;//黑的活三多于一個,黑棋價值加500
     
298. else
     
299. //否則黑棋價值加100
     
300. if(TypeCount[BLACK][THREE])
     
301. BValue+=100;
     
302. //每個眠三加10
     
303. if(TypeCount[WHITE][STHREE])
     
304. WValue+=TypeCount[WHITE][STHREE]*10;
     
305. //每個眠三加10
     
306. if(TypeCount[BLACK][STHREE])
     
307. BValue+=TypeCount[BLACK][STHREE]*10;
     
308. //每個活二加4
     
309. if(TypeCount[WHITE][TWO])
     
310. WValue+=TypeCount[WHITE][TWO]*4;
     
311. //每個活二加4
     
312. if(TypeCount[BLACK][STWO])
     
313. BValue+=TypeCount[BLACK][TWO]*4;
     
314. //每個眠二加1
     
315. if(TypeCount[WHITE][STWO])
     
316. WValue+=TypeCount[WHITE][STWO];
     
317. //每個眠二加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;//沖四并活三,白勝返回極值
     
338. 
     
339. if(TypeCount[BLACK][THREE] && TypeCount[WHITE][SFOUR]==0)
     
340. return 9950;//黑活三,白無四。黑勝返回極值
     
341. 
     
342. if(TypeCount[WHITE][THREE]>1 && TypeCount[BLACK][SFOUR]==0 && TypeCount[BLACK][THREE]==0 && TypeCount[BLACK][STHREE]==0)
     
343. return -9940;//白的活三多于一個,而黑無四和三,白勝返回極值
     
344. 
     
345. //黑的活三多于一個,黑棋價值加2000
     
346. if(TypeCount[BLACK][THREE]>1)
     
347. BValue+=2000;
     
348. else
     
349. //否則黑棋價值加200
     
350. if(TypeCount[BLACK][THREE])
     
351. BValue+=200;
     
352. 
     
353. //白的活三多于一個,白棋價值加 500
     
354. if(TypeCount[WHITE][THREE]>1)
     
355. WValue+=500;
     
356. else
     
357. //否則白棋價值加100
     
358. if(TypeCount[WHITE][THREE])
     
359. WValue+=100;
     
360. 
     
361. //每個眠三加10
     
362. if(TypeCount[WHITE][STHREE])
     
363. WValue+=TypeCount[WHITE][STHREE]*10;
     
364. //每個眠三加10
     
365. if(TypeCount[BLACK][STHREE])
     
366. BValue+=TypeCount[BLACK][STHREE]*10;
     
367. 
     
368. //每個活二加4
     
369. if(TypeCount[WHITE][TWO])
     
370. WValue+=TypeCount[WHITE][TWO]*4;
     
371. //每個活二加4
     
372. if(TypeCount[BLACK][STWO])
     
373. BValue+=TypeCount[BLACK][TWO]*4;
     
374. 
     
375. //每個眠二加1
     
376. if(TypeCount[WHITE][STWO])
     
377. WValue+=TypeCount[WHITE][STWO];
     
378. //每個眠二加1
     
379. if(TypeCount[BLACK][STWO])
     
380. BValue+=TypeCount[BLACK][STWO];
     
381. }
     
382. 
     
383. //加上所有棋子的位置價值
     
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. }
     
394. 
     
395. //返回估值
     
396. if(!bIsWhiteTurn)
     
397. return BValue-WValue;
     
398. else
     
399. return WValue-BValue;
     
400. }
     
401. 
     
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];
     
411. 
     
412. return TypeRecord[i][j][0];
     
413. }
     
414. 
     
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];
     
428. 
     
429. return TypeRecord[i][j][1];
     
430. }
     
431. 
     
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];
     
461. 
     
462. return TypeRecord[i][j][2];
     
463. }
     
464. 
     
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];
     
496. 
     
497. return TypeRecord[i][j][3];
     
498. }
     
499. 
     
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;
     
507. 
     
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. }
     
530. 
     
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. //下面兩個循環(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. }
     
569. 
     
570. if(RightEdge-LeftEdge== 3)
     
571. {
     
572. //如待分析棋子棋型為四連
     
573. bool Leftfour=false;
     
574. if(LeftEdge>0)
     
575. if(AnalyLine[LeftEdge-1]==NOSTONE)
     
576. Leftfour=true;//左邊有氣
     
577. 
     
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;//沖四
     
592. 
     
593. return m_LineRecord[nAnalyPos];
     
594. }
     
595. 
     
596. if(RightEdge-LeftEdge==2)
     
597. {
     
598. //如待分析棋子棋型為三連
     
599. bool LeftThree=false;
     
600. 
     
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;
     
612. 
     
613. if(RightEdge<GridNum)
     
614. if(AnalyLine[RightEdge+1]==NOSTONE)
     
615. //右邊有氣
     
616. if(RightEdge<GridNum-1 && AnalyLine[RightEdge+2]==AnalyLine[RightEdge])
     
617. {
     
618. //右邊隔1個己方棋子
     
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];//返回
     
631. 
     
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. }
     
642. 
     
643. return m_LineRecord[nAnalyPos];
     
644. }
     
645. 
     
646. if(RightEdge-LeftEdge==1)
     
647. {
     
648. //如待分析棋子棋型為二連
     
649. bool Lefttwo=false;
     
650. bool Leftthree=false;
     
651. 
     
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個己方棋子
     
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個己方棋子
     
667. m_LineRecord[LeftEdge-2]=ANALSISED;
     
668. m_LineRecord[LeftEdge]=STHREE;//眠三
     
669. }
     
670. else
     
671. Lefttwo=true;
     
672. 
     
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. //右邊隔兩個己方棋子
     
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 個己方棋子
     
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];//返回
     
695. 
     
696. if(m_LineRecord[LeftEdge]==STHREE)//左邊眠三       
     
697. return m_LineRecord[LeftEdge];
     
698. 
     
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];
     
708. 
     
709. if(Lefttwo==true)//眠二
     
710. m_LineRecord[nAnalyPos]=STWO;
     
711. }
     
712. 
     
713. return m_LineRecord[nAnalyPos];
     
714. }
     
715. 
     
716. return 0;
     
717. }
     
718. 
     
719. //將歷史記錄表中所有項(xiàng)目全置為初值
     
720. void ResetHistoryTable()
     
721. {
     
722.     memset(m_HistoryTable,10,GRID_COUNT*sizeof(int));
     
723. }
     
724. 
     
725. //從歷史得分表中取給定走法的歷史得分
     
726. int GetHistoryScore(STONEMOVE* move)
     
727. {
     
728. return m_HistoryTable[move->StonePos.x][move->StonePos.y];
     
729. }
     
730. 
     
731. //將一最佳走法匯入歷史記錄
     
732. void EnterHistoryScore(STONEMOVE* move,int depth)
     
733. {
     
734. m_HistoryTable[move->StonePos.x][move->StonePos.y]+=2<<depth;
     
735. }
     
736. 
     
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. }
     
759. 
     
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. }
     
778. 
     
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)//剩余的元素個數(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. }
     
804. 
     
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. }
     
816. 
     
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. }
     
827. 
     
828. //使用歷史啟發(fā)類中的靜態(tài)歸并排序函數(shù)對走法隊(duì)列進(jìn)行排序
     
829. //這是為了提高剪枝效率
     
830. //        CHistoryHeuristic history;
     
831. MergeSort(m_MoveList[nPly],m_nMoveCount,0);
     
832. 
     
833. return m_nMoveCount;//返回合法走法個數(shù)
     
834. }
     
835. 
     
836. //在m_MoveList中插入一個走法
     
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;
     
844. 
     
845. m_nMoveCount++;
     
846. m_MoveList[nPly][m_nMoveCount].Score=PosValue[nToY][nToX];//使用位置價值表評估當(dāng)前走法的價值
     
847. return m_nMoveCount;
     
848. }
     
849. 
     
850. void CNegaScout_TT_HH()
     
851. {
     
852. ResetHistoryTable();
     
853. //        m_pThinkProgress=NULL;
     
854. }
     
855. 
     
856. void SearchAGoodMove(unsigned char position[][GRID_NUM],int Type)
     
857. {
     
858. int Score;
     
859. 
     
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. }
     
870. 
     
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. }
     
880. 
     
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);//將估值存入置換表
     
903. 
     
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]);
     
909. 
     
910. MergeSort(m_MoveList[depth],Count,0);
     
911. int bestmove=-1;
     
912.     a=alpha;
     
913.     b=beta;
     
914. 
     
915.     int eval_is_exact=0;
     
916. 
     
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 個節(jié)點(diǎn)是全窗口，其后是空窗探測
     
922. if(t>a && t<beta && i>0)
     
923. {
     
924. //對于第一個后的節(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);
     
954. 
     
955. return a;
     
956. }
     
957. 
     
958. unsigned char MakeMove(STONEMOVE* move,int type)
     
959. {
     
960. CurPosition[move->StonePos.y][move->StonePos.x]=type;
     
961. return 0;
     
962. }
     
963. 
     
964. void UnMakeMove(STONEMOVE* move)
     
965. {
     
966. CurPosition[move->StonePos.y][move->StonePos.x]=NOSTONE;
     
967. }
     
968. 
     
969. __int64 rand64(void)
     
970. {
     
971.     return rand()^((__int64)rand()<<15)^((__int64)rand()<<30)^
     
972. ((__int64)rand()<<45)^((__int64)rand()<<60);
     
973. }
     
974. 
     
975. //生成32位隨機(jī)數(shù)
     
976. long rand32(void)
     
977. {
     
978.     return rand()^((long)rand()<<15)^((long)rand()<<30);
     
979. }
     
980. 
     
981. void CTranspositionTable()
     
982. {
     
983. InitializeHashKey();//建立哈希表，創(chuàng)建隨機(jī)數(shù)組
     
984. }
     
985. 
     
986. void _CTranspositionTable()
     
987. {
     
988. //釋放哈希表所用空間
     
989. delete m_pTT[0];
     
990. delete m_pTT[1];
     
991. }
     
992. 
     
993. void CalculateInitHashKey(unsigned char CurPosition[][GRID_NUM])
     
994. {
     
995. int j,k,nStoneType;
     
996. 
     
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. }
      
1011. 
      
1012. void Hash_MakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM])
      
1013. {
      
1014. int type;
      
1015. 
      
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. }
      
1020. 
      
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. }
      
1028. 
      
1029. int LookUpHashTable(int alpha, int beta, int depth, int TableNo)
      
1030. {
      
1031. int x;
      
1032. HashItem* pht;
      
1033. 
      
1034. //計(jì)算二十位哈希地址，如果讀者設(shè)定的哈希表大小不是 1M*2 的,
      
1035. //而是 TableSize*2，TableSize為讀者設(shè)定的大小
      
1036. //則需要修改這一句為m_HashKey32% TableSize
      
1037. //下一個函數(shù)中這一句也一樣
      
1038. x=m_HashKey32 & 0xFFFFF;
      
1039. pht=&m_pTT[TableNo][x];//取到具體的表項(xiàng)指針
      
1040. 
      
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;
      
1047. 
      
1048. case lower_bound://下邊界
      
1049. if(pht->eval>=beta)
      
1050. return pht->eval;
      
1051. else
      
1052. break;
      
1053. 
      
1054. case upper_bound://上邊界
      
1055. if (pht->eval<=alpha)
      
1056. return pht->eval;
      
1057. else
      
1058. break;
      
1059.         }
      
1060. }
      
1061. 
      
1062. return 66666;
      
1063. }
      
1064. 
      
1065. void EnterHashTable(ENTRY_TYPE entry_type, short eval, short depth, int TableNo)
      
1066. {
      
1067. int x;
      
1068. HashItem* pht;
      
1069. 
      
1070. x=m_HashKey32 & 0xFFFFF;//計(jì)算二十位哈希地址
      
1071. pht=&m_pTT[TableNo][x]; //取到具體的表項(xiàng)指針
      
1072. 
      
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. }
      
1079. 
      
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. }
      
1092. 
      
1093. //申請置換表所用空間。1M "2 個條目，讀者也可指定其他大小
      
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. }
      
1097. 
      
1098. 
      
1099. //using namespace std;
      
1100. 
      
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; //棋盤初始化
      
1109. 
      
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ī)得到一個空位置
      
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    時間: 2016-3-6 23:31


99999999999999999999999999999999

---

作者: ccl    時間: 2016-3-14 00:26
標(biāo)題: RE: 博弈樹加上α-β剪枝算法做出來的五子棋AI往前推6步無壓力
樓主的代碼有個bug，ai不會防守眠4，勝局時也不會自己連5，希望改全，郵箱1490325170@qq.com

---

作者: 墮落小CY    時間: 2018-3-22 09:17

ccl 發(fā)表于 2016-3-14 00:26
**** 作者被禁止或刪除 內(nèi)容自動屏蔽 ****

兄弟，樓主有回復(fù)你嗎，有的話，代碼發(fā)我一下，

---

作者: 墮落小CY    時間: 2018-3-26 09:22
樓主真大佬，代碼能跑起來，有4個錯誤，改了就好了

---

作者: zyx132    時間: 2018-4-24 15:25

墮落小CY 發(fā)表于 2018-3-26 09:22
樓主真大佬，代碼能跑起來，有4個錯誤，改了就好了

請問是哪四個錯誤啊

---

作者: 55622332    時間: 2019-7-4 15:09

墮落小CY 發(fā)表于 2018-3-26 09:22
**** 作者被禁止或刪除 內(nèi)容自動屏蔽 ****

你好，請問是那幾個錯誤呢

---

作者: sophon    時間: 2019-10-13 17:05
我第一局13步就贏了，而且它判勝負(fù)還有問題

---

歡迎光臨 (http://www.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影