开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 棋牌游戏 > 查看源码
Game.cpp
资源名称：fivesource.zip　[点击查看]
上传用户：kkzhu_0
上传日期：2007-01-05
资源大小：214k
文件大小：28k
源码类别：

棋牌游戏

开发平台：

Visual C++

Game.cpp：源码内容
  1. /////////////////////////////////////////////////////////////////////////////////////
  2. // 五子棋分析程序:
  3. //   1996.4-1997.11  刘国辉
  4. /////////////////////////////////////////////////////////////////////////////////////
  5. //  说明：
  6. // ~~~~~~~
  7. //  约定：
  8. // ~~~~~~~
  9. //  ‘W' 代表白棋
  10. //   'B' 代表黑棋
  11. //   'N' 代表空地
  12. //（1）平分函数:
  13. // ~~~~~~~~~~~~~~
  14. //  int Dump( int x,int Wf )
  15. //  X   在一条线上的子数
  16. //  WF    = 1 两边都没有被堵住  例如   NNWWWNB..
  17. //   = 0 一边被堵住               BWWWNNW..
  18. //   = 2 跨越式的                 WWWNW..
  19. // 返回一个分数
  20. //（2）线扫描函数:
  21. // ~~~~~~~~~~~~~~~~
  22. //  int SreachLine( char *FLine,int M,int MF )
  23. //  FLine 线指针,指向一个字符串    NNNWWWBWWWN...
  24. //  M     字符个数
  25. //  WF ='W'或'B'表示对黑或白进行平分
  26. // 返回一个分数
  27. // (3)面扫描函数:
  28. // ~~~~~~~~~~~~~~~
  29. // long SreachArea( char *Area[15],int M,char WF )
  30. //  ....
  31. /////////////////////////////////////////////////////////////////////////////////////
  32. #include "game.h"
  33. #include <stdlib.h>  // For rand()
  34. /////////////////////////////////////////////////////////////////////////////////////
  35. // 静态成员初始化
  36. // ~~~~~~~~~~~~~~~
  37. int CFive::WF1_1;
  38. int CFive::WF1_2;
  39. int CFive::WF1_3;
  40. int CFive::WF1_4;
  41. int CFive::WF0_1;
  42. int CFive::WF0_2;
  43. int CFive::WF0_3;
  44. int CFive::WF0_4;
  45. int CFive::WF2_3;
  46. int CFive::WF2_4;
  47. int CFive::WF5;
  48. int CFive::DeepMax;
  49. int CFive::BreadthMax;
  50. int CFive::Delta;
  51. int CFive::ThreadDeepMax;
  52. char CFive::Side;
  53. BOOL CFive::PlayStateFlags;
  54. int  CFive::PlayIndex;
  55. char CFive::FiveArea[FIVE_MAX_LINE][FIVE_MAX_LINE];
  56. CList<Step,Step>   CFive::StepList;
  57. CList<Count,Count> CFive::OneCountList;
  58. CArray<int,int>    CFive::ImpList;
  59. CEvent             CFive::KillWzqRun(FALSE,TRUE);
  60. CStatusBar*        CFive::pInfo;
  61. long        CFive::MemoryCount;
  62. int         CFive::ThreadCount;
  63. long        CFive::JingDuCount;
  64. Count       CFive::PiShen;
  65. /////////////////////////////////////////////////////////////////////////////////////
  66. // 顺序化
  67. // ~~~~~~
  68. IMPLEMENT_SERIAL( CFive, CWinThread, 1 )
  69. /////////////////////////////////////////////////////////////////////////////////////
  70. // 构造与析构
  71. // ~~~~~~~~~~~
  72. CFive::CFive():EndEvent( FALSE,TRUE )
  73. {
  74. m_bAutoDelete = FALSE; // 不自动删除CWinThread对象
  76. CurDeep       = DeepMax;
  77. CurBreadth    = BreadthMax;
  78. CurThreadDeep = ThreadDeepMax;
  79. CurSide       = Side;
  80. CurCount      = 0;
  81. PlayStateFlags= FALSE;
  82. }
  84. CFive::CFive( char side,int deep,int breadth,int threaddeep ):EndEvent( FALSE,TRUE )
  85. {
  86.     m_bAutoDelete = FALSE; // 不自动删除CWinThread对象
  87. CurSide = (side == 'B'?'W':'B');
  88. CurDeep       = deep - 1;
  89. if( CurDeep < 0 )
  90. CurDeep = -1;
  91. CurThreadDeep = threaddeep - 1;
  92. if( CurThreadDeep < 0 )
  93. CurThreadDeep = -1;
  95. if( CurSide == Side )
  96. CurBreadth    = BreadthMax - (DeepMax-CurDeep)*Delta;
  97. else
  98. CurBreadth = 1;
  100. if( CurBreadth < 0 )
  101. CurBreadth = -1;
  102. if( CurThreadDeep < 0 )
  103. CurThreadDeep = -1;
  104. CurCount = 0;
  105. }
  107. CFive::~CFive()
  108. {
  109. }
  111. ////////////////////////////////////////////////////////////////////////////////////
  112. // 初始化
  113. // ~~~~~~
  114. void CFive::WzqInit( char side,BOOL flags )
  115. {
  116. int i,j;
  117.     
  118. Side          = side;
  119. CurSide       = side;
  120. CurDeep       = DeepMax;
  121. CurBreadth    = BreadthMax;
  122. CurThreadDeep = ThreadDeepMax;
  123. PlayStateFlags= FALSE;
  124.     PiShen.count  = WZQ_YOU;
  125. StepList.RemoveAll();
  127. for( i = 0;i < FIVE_MAX_LINE;i++ )
  128. for( j = 0;j < FIVE_MAX_LINE;j++ )
  129.      FiveArea[i][j] = 'N';
  131. if( flags == FALSE )
  132. {
  133. Step temp;
  134. int mx,my;
  135. mx = FIVE_MAX_LINE/2 -2;
  136. my = mx;
  137. mx += rand()%4;
  138. my += rand()%4;
  139. FiveArea[mx][my] = Side;
  140. temp.side = Side;
  141. temp.m    = mx;
  142. temp.n    = my;
  143. StepList.AddTail(temp);
  144. }
  145. }
  147. void CFive::SetInfo( CStatusBar*p)
  148. {
  149. pInfo = p;
  150. }
  152. void CFive::SetParam( int breadth,int deep,int thread,int delta )
  153. {
  154. BreadthMax    = breadth;
  155. DeepMax       = deep;
  156. ThreadDeepMax = thread;
  157. Delta         = delta;
  158. }
  160. void CFive::GetParam( int& breadth,int& deep,int& thread,int& delta )
  161. {
  162. breadth = BreadthMax;
  163. deep    = DeepMax;
  164. thread  = ThreadDeepMax;
  165. delta   = Delta;
  166. }
  168. char CFive::GetSide()
  169. {
  170. return Side;
  171. }
  173. char CFive::GetSubPosition( int m,int n )
  174. {
  175. if( m >=0&&n>=0&&m<FIVE_MAX_LINE&&n<FIVE_MAX_LINE )
  176. return FiveArea[m][n];
  177. else
  178. return 'E';
  179. }
  181. int CFive::Dump( int x ,int Wf )
  182. { 
  183. if( Wf == 1 )
  184. {
  185. switch(x)
  186. {
  187. case 1:return WF0_1;
  188. case 2:return WF0_2;
  189. case 3:return WF0_3;
  190. case 4:return WF0_4;
  191. }
  192. }
  193. else if( Wf == 0 )
  194. {
  195. switch(x)
  196. {
  197. case 1:return WF1_1;
  198. case 2:return WF1_2;
  199. case 3:return WF1_3;
  200. case 4:return WF1_4;
  201. }
  202. }
  203. else if( Wf == 2 )
  204. { 
  205. if( x == 4 )
  206. return WF2_4;
  207. if( x == 3 )
  208. return WF2_3;
  209. }
  210.   if( x == 5 )
  211. {
  212. return WF5;
  213. }
  214.   return -1;
  215. }
  217. int CFive::GetDump( int x,int Wf )
  218. {
  219. return Dump( x,Wf );
  220. }
  222. void CFive::SetDump( int x ,int Wf,int c )
  223. { 
  224. if( Wf == 0 )
  225. {
  226. switch(x)
  227. {
  228. case 1:
  229. WF1_1 = c;
  230. return;
  231. case 2:
  232. WF1_2 = c;
  233. return;
  234. case 3:
  235. WF1_3 = c;
  236. return;
  237. case 4:
  238. WF1_4 = c;
  239. return;
  240. }
  241. }
  242. else if( Wf == 1 )
  243. {
  244. switch(x)
  245. {
  246. case 1:
  247. WF0_1 = c;
  248. return;
  249. case 2:
  250. WF0_2 = c;
  251. return;
  252. case 3:
  253. WF0_3 = c;
  254. return;
  255. case 4:
  256. WF0_4 = c;
  257. return;
  258. }
  259. }
  260. else if( Wf == 2 )
  261. { 
  262. if( x == 4 )
  263. {WF2_4 = c;
  264. return;
  265. }
  266. if( x == 3 )
  267. {
  268. WF2_3 = c;
  269. return;
  270. }
  271. }
  273. if( x == 5 )
  274. {
  275. WF5 = c;
  276. return;
  277. }
  278. }
  280. void CFive::KillWzqThread()
  281. {
  282. Step step;
  283. KillWzqRun.SetEvent();
  284. EndEvent.Lock();
  285. WaitForSingleObject( m_hThread,INFINITE );
  286. KillWzqRun.ResetEvent();
  287. step = StepList.GetTail();
  288. StepList.RemoveTail();
  289. FiveArea[step.m][step.n] = 'N';
  290. }
  292. void CFive::NoKillThread()
  293. {
  294. KillWzqRun.ResetEvent();
  295. }
  297. BOOL CFive::HuiOneStep()
  298. {
  299. Step step0,step1;
  300. if( StepList.IsEmpty() )
  301. return FALSE;
  302. step0 = StepList.RemoveTail();
  303. if( StepList.IsEmpty() )
  304. {
  305. StepList.AddTail( step0 );
  306. return FALSE;
  307. }
  308. step1 = StepList.RemoveTail();
  309. FiveArea[step0.m][step0.n] = 'N';
  310. FiveArea[step1.m][step1.n] = 'N';
  312. return TRUE;
  313. }
  315. BOOL CFive::BackEndStep()
  316. {
  317. PlayStateFlags = TRUE;
  318. if( PlayIndex == 0 )
  319. return FALSE;
  320. PlayIndex      = 0;
  321. UpdatePlay();
  322. return TRUE;
  323. }
  325. BOOL CFive::OneStep()
  326. {
  327. PlayStateFlags = TRUE;
  328. if( PlayIndex >= StepList.GetCount() )
  329. return FALSE;
  330. PlayIndex      = StepList.GetCount();
  331. UpdatePlay();
  332. return TRUE;
  333. }
  335. BOOL CFive::BackOneStep()
  336. {
  337. PlayStateFlags = TRUE;
  338. if( PlayIndex > 0 )
  339. {
  340. PlayIndex--;
  341. UpdatePlay();
  342. return TRUE;
  343. }
  344. return FALSE;
  345. }
  347. BOOL CFive::FowardOneStep()
  348. {
  349. PlayStateFlags = TRUE;
  350. if( PlayIndex < StepList.GetCount() )
  351. {
  352. PlayIndex++;
  353. UpdatePlay();
  354. return TRUE;
  355. }
  356. return FALSE;
  357. }
  359. void CFive::UpdatePlay()
  360. {
  361. int i,j;
  362. POSITION pos;
  363. Step step;
  364. for( i = 0;i<FIVE_MAX_LINE;i++ )
  365. for( j = 0;j<FIVE_MAX_LINE;j++ )
  366. FiveArea[i][j] = 'N';
  367. pos = StepList.GetHeadPosition();
  368. i = 0;
  369. while( pos )
  370. {
  371. if( PlayIndex == i )
  372. break;
  373. step = StepList.GetNext(pos);
  374. FiveArea[step.m][step.n] = step.side;
  375. i++;
  376. }
  377. }
  379. void CFive::InListBox( CComboBox& box )
  380. {
  381. POSITION pos;
  382. Step     step;
  383. int      i;
  384. TCHAR    Info[50];
  385. TCHAR    *format = _TEXT("%d.%s  (%d,%d)");
  386. TCHAR    *b = _TEXT("黑");
  387. TCHAR    *w = _TEXT("白");
  389. pos = StepList.GetHeadPosition();
  390. box.ResetContent();
  391. i = 0;
  392. while( pos )
  393. {
  394. step = StepList.GetNext(pos);
  395. i++;
  396. if( step.side == 'W' )
  397. wsprintf(Info,format,i,w,step.m,step.n );
  398. else
  399. wsprintf(Info,format,i,b,step.m,step.n );
  401. box.AddString( Info );
  402. }
  403. }
  404. ///////////////////////////////////////////////////////////////////////////////////////////
  405. // 平分机制
  406. // ~~~~~~~~~
  407. long CFive::SreachLine( char *Fline,int M,char Nf )
  408.  { 
  409. char Wf;
  410. int  i = 0;
  411. int  j = 0;
  412. int  n = 0;
  413. int  k = 0;
  414. long count = 0;
  416. if( Nf == 'B' )
  417. Wf = 'W';
  418. else 
  419. Wf = 'B';
  421. while( M - j >= 5 )
  422. { 
  423. while( Fline[ i+j ] != Wf && i+j < M )
  424. i++;
  425. if( i > 4 )
  426. { 
  427. for( k = 0; k < i; k++ )
  428. {
  429. n = 0;
  430. while( Fline[ j+k ] == Nf && k < i )
  431. { 
  432. n++;
  433. k++; 
  434. }
  435. if( n )
  436. { 
  437. if( n > 4 )
  438. return -1;              //发现5子
  439. if( n == k || k == i )
  440. Wf = 0;
  441. else
  442. Wf = 1;
  443. if( n == 2 && Wf == 1 )
  444. if((k+1<i&&Fline[ j+k+1 ] == Nf)||( k>3&&Fline[ j+k-4 ]==Nf))
  445.        { 
  446.      n++;
  447.          Wf = 2;
  448.        }
  449. if( n == 3 && Wf == 0 )
  450. if((k+1<i&&Fline[ j+k+1 ] == Nf)||( k>4&&Fline[ j+k-5 ]==Nf))
  451.        { 
  452.      n++;
  453.  Wf = 2; 
  454.        }
  455. count = count + Dump( n , Wf );
  456. }
  457. }
  458. }
  459. j = j + i + 1;
  460. i = 0;
  461. }
  462. return count;
  463.  }
  465. long CFive::SreachArea( char Area[][FIVE_MAX_LINE],char Nf )
  466.  { 
  467. int i,j,cbak;
  468. long count = 0;
  469. char Fline[FIVE_MAX_LINE];
  471. for( i = 0; i < FIVE_MAX_LINE; i++ )
  472. { 
  473. for( j = 0; j < FIVE_MAX_LINE; j++ )
  474. Fline[j] = Area[i][j];
  475. cbak = SreachLine( Fline,FIVE_MAX_LINE,Nf );
  476. if( cbak == -1 )
  477. return -1;
  478. else 
  479. count = count + (long)cbak;
  480. }
  482.  for( i = 0; i < FIVE_MAX_LINE; i++ )
  483.  { 
  484.  for( j = 0; j < FIVE_MAX_LINE; j++ )
  485.  Fline[j] = Area[j][i];
  486.  cbak = SreachLine( Fline,FIVE_MAX_LINE,Nf );
  487.  if( cbak == -1 )
  488.  return -1;
  489.  else 
  490.  count = count + (long)cbak;
  491.  }
  493.  for( i = 0; i < FIVE_MAX_LINE - 4; i++ )
  494.   { 
  495.  for( j = 0; j < FIVE_MAX_LINE - i; j++ )
  496.  Fline[j] = Area[i+j][j];
  497.  cbak = SreachLine( Fline, FIVE_MAX_LINE-i, Nf );
  498.  if( cbak == -1 )
  499.  return -1;
  500.  else count = count + (long)cbak;
  501.  }
  503.  for( i = FIVE_MAX_LINE-1; i > 3; i-- )
  504.  { 
  505.  for( j = 0; j < i+1; j++ )
  506.  Fline[j] = Area[i-j][j];
  507.  cbak = SreachLine( Fline, i+1, Nf );
  508.  if( cbak == -1 )
  509.  return -1;
  510.  else 
  511.  count = count + (long)cbak;
  512.  }
  514.  for( i = 0; i < FIVE_MAX_LINE - 5; i++ )
  515.   { 
  516.  for( j = 0; j < FIVE_MAX_LINE - i; j++ )
  517.  Fline[j] = Area[i+j][FIVE_MAX_LINE-j];
  518.  cbak = SreachLine( Fline, FIVE_MAX_LINE-i, Nf );
  519.  if( cbak == -1 )
  520.  return -1;
  521.  else 
  522.  count = count + (long)cbak;
  523.   }
  525.  for( i = FIVE_MAX_LINE-1; i > 4; i-- )
  526.   { 
  527.  for( j = 0; j < i+1; j++ )
  528.  Fline[j] = Area[i-j][FIVE_MAX_LINE-j];
  529.  cbak = SreachLine( Fline, i+1, Nf );
  530.  if( cbak == -1 )
  531.  return -1;
  532.  else 
  533.  count = count + (long)cbak;
  534.   }
  535.  return count;
  536.  }
  537. ////////////////////////////////////////////////////////////////////////////////////////////
  538. // 在Call WzqRun前Call WzqTest以测试当前情况
  539. int CFive::WzqTest( int m,int n )
  540. {
  541. char Nf,Mf;
  542. int  i,j;
  543. Step step_temp;
  544. Nf = Side;
  546. MemoryCount = 0;
  547. ThreadCount = 0;
  548. JingDuCount = 0;
  549. if( PlayStateFlags == TRUE )
  550. {
  551. PlayStateFlags= FALSE;
  552. ResumePlayState();
  553. return WZQ_HAVE;
  554. }
  556. if( Nf == 'B' )
  557. Mf = 'W';
  558. else if( Nf == 'W' )
  559. Mf = 'B';
  560. else
  561. return WZQ_ERROR;
  563. for( i = 0;i<FIVE_MAX_LINE;i++ )
  564. for( j = 0;j<FIVE_MAX_LINE;j++ )
  565.         if( FiveArea[i][j] == 'N' )
  566.     goto NO_PING;
  567. return WZQ_PING;
  569. NO_PING:
  570. if( m < 0||m >= FIVE_MAX_LINE||n < 0||n >= FIVE_MAX_LINE )
  571. return WZQ_HAVE;
  573. if( FiveArea[m][n] != 'N' )
  574. return WZQ_HAVE;
  576. if( SreachArea( FiveArea,Nf ) == -1 )
  577. return WZQ_I;
  578. if( SreachArea( FiveArea,Mf ) == -1 )
  579. return WZQ_YOU;
  581. FiveArea[m][n] = (Side == 'W'?'B':'W');
  582. step_temp.side = (Side == 'W'?'B':'W');
  583. step_temp.m = m;
  584. step_temp.n = n;
  585. StepList.AddTail( step_temp );
  586. PlayIndex = StepList.GetCount();
  588. if( SreachArea( FiveArea,Nf ) == -1 )
  589. return WZQ_I;
  590. if( SreachArea( FiveArea,Mf ) == -1 )
  591. return WZQ_YOU;
  593. return WZQ_RUN;
  594. }
  596. int CFive::WzqEndTest()
  597. {
  598. char Nf,Mf;
  599. int i,j;
  600. Nf = Side;
  602. MemoryCount = 0;
  603. ThreadCount = 0;
  604. JingDuCount = 0;
  605. if( Nf == 'B' )
  606. Mf = 'W';
  607. else if( Nf == 'W' )
  608. Mf = 'B';
  609. else
  610. return WZQ_ERROR;
  612. if( SreachArea( FiveArea,Nf ) == -1 )
  613. return WZQ_I;
  614. if( SreachArea( FiveArea,Mf ) == -1 )
  615. return WZQ_YOU;
  617. for( i = 0;i<FIVE_MAX_LINE;i++ )
  618. for( j = 0;j<FIVE_MAX_LINE;j++ )
  619.         if( FiveArea[i][j] == 'N' )
  620.     goto NO_PING;
  621. return WZQ_PING;
  622. NO_PING:
  623. return WZQ_RUN;
  624. }
  626. BOOL CFive::BiTest( int& mm,int& nn )
  627. {
  628. int i,j;
  629. char Mf;
  630. Mf = (Side =='B'?'W':'B');
  632. for( i=0;i<FIVE_MAX_LINE;i++ )
  633. for( j=0;j<FIVE_MAX_LINE;j++ )
  634. {
  635. if( FiveArea[i][j] == 'N' )
  636. {
  637. FiveArea[i][j] = Side;
  638. if( SreachArea( FiveArea,Side ) == -1 )
  639. {
  640. Step step;
  641. mm = i;
  642. nn = j;
  643. step.m = mm;
  644. step.n = nn;
  645. step.side = Side;
  646. StepList.AddTail( step ); 
  647. return TRUE;
  648. }
  649. FiveArea[i][j] = 'N';
  650. }
  651. }
  652. for( i=0;i<FIVE_MAX_LINE;i++ )
  653. for( j=0;j<FIVE_MAX_LINE;j++ )
  654. {
  655. if( FiveArea[i][j] == 'N' )
  656. {
  657. FiveArea[i][j] = Mf;
  658. if( SreachArea( FiveArea,Mf ) == -1 )
  659. {
  660. Step step;
  661. FiveArea[i][j] = Side;
  662. mm = i;
  663. nn = j;
  664. step.m = mm;
  665. step.n = nn;
  666. step.side = Side;
  667. StepList.AddTail( step );
  668. return TRUE;
  669. }
  670. FiveArea[i][j] = 'N';
  671. }
  672. }
  673. return FALSE;
  674. }
  676. void CFive::ResumePlayState()
  677. {
  678. int i,j;
  679. POSITION pos;
  680. Step step_temp;
  681. for( i=0;i<FIVE_MAX_LINE;i++ )
  682. for( j=0;j<FIVE_MAX_LINE;j++ )
  683. FiveArea[i][j] = 'N';
  684. pos = StepList.GetHeadPosition();
  685. while(pos)
  686. {
  687. step_temp = StepList.GetNext(pos);
  688. FiveArea[step_temp.m][step_temp.n] = step_temp.side;
  689. }
  690. }
  692. int CFive::WzqRun( int &mm, int &nn )
  693. {
  694. int m,n;
  695. double max_count;
  696. Count  temp;
  697. Step   step_temp;
  698. POSITION pos;
  699. m = mm;
  700. n = nn;
  701.     PiShen.count = WZQ_YOU;
  702. if( m < 0||m >= FIVE_MAX_LINE||n < 0||n >= FIVE_MAX_LINE )
  703. return WZQ_HAVE;
  705. // if( FiveArea[m][n] != 'N' )
  706. // return WZQ_HAVE;
  708. if( BiTest( mm,nn ) == FALSE )
  709. {
  710. OneCountList.RemoveAll();
  711. CreateThread();
  712. //------------------------------------------------
  713. // EndEvent.Lock();
  714. // WaitForSingleObject( m_hThread,INFINITE );
  715. // if( OneCountList.IsEmpty() )
  716. // return WZQ_ERROR;
  717. //
  718. // temp = OneCountList.GetHead();
  719. // max_count = temp.count;
  720. // mm = temp.step.m;
  721. // nn = temp.step.n;
  722. //
  723. // pos = OneCountList.GetHeadPosition();
  724. // while( pos != NULL )
  725. // {
  726. // temp = OneCountList.GetNext( pos );
  727. // if( temp.count > max_count )
  728. // {
  729. // max_count = temp.count;
  730. // mm = temp.step.m;
  731. // nn = temp.step.n;
  732. // }
  733. // }
  734. //----------------------------------------------------
  735. }
  736. else
  737. return WZQ_NOTHREAD;
  738. //----------------------------------------------------
  739. // if( mm == m&&nn == n )
  740. // return WZQ_ERROR;
  741. // FiveArea[mm][nn] = Side;
  742. // step_temp.side = Side;
  743. // step_temp.m    = mm;
  744. // step_temp.n    = nn;
  745. // StepList.AddTail( step_temp );
  746. // PlayIndex = StepList.GetCount();
  747. //-----------------------------------------------------
  748. return WZQ_RUN;
  749. }
  751. int CFive::GetCurStep(int &mm,int &nn)
  752. {
  753. int m,n;
  754. POSITION pos;
  755. double   max_count;
  756. Count  temp;
  757. Step   step_temp;
  758.     if( PiShen.count == WZQ_I )
  759. {
  760. step_temp = PiShen.step;
  761. mm = PiShen.step.m;
  762. nn = PiShen.step.n;
  763. step_temp.side = Side;
  764. FiveArea[mm][nn] = Side;
  765. StepList.AddTail( step_temp );
  766. PlayIndex = StepList.GetCount();
  767. return WZQ_RUN;
  768. }
  769. ////////////////////////////////////////////////////////////////////////////////
  770. // if( OneCountList.IsEmpty() )
  771. // return WZQ_ERROR;
  772. ////////////////////////////////////////////////////////////////////////////////
  773. if( CountList.IsEmpty() )
  774. return WZQ_ERROR;
  776. // temp = OneCountList.GetHead();
  777. temp = CountList.GetHead();
  779. max_count = temp.count;
  780. mm = temp.step.m;
  781. nn = temp.step.n;
  782. ///////////////////////////////////////////////////////////////////////////////
  783. // pos = OneCountList.GetHeadPosition();
  784. // while( pos != NULL )
  785. // {
  786. // temp = OneCountList.GetNext( pos );
  787. // if( temp.count > max_count )
  788. // {
  789. // max_count = temp.count;
  790. // mm = temp.step.m;
  791. // nn = temp.step.n;
  792. // }
  793. // }
  794. //////////////////////////////////////////////////////////////////////////////
  795. pos = CountList.GetHeadPosition();
  796. while( pos != NULL )
  797. {
  798. temp = CountList.GetNext( pos );
  799. if( temp.count > max_count )
  800. {
  801. max_count = temp.count;
  802. mm = temp.step.m;
  803. nn = temp.step.n;
  804. }
  805. }
  807. if( mm == m&&nn == n )
  808. return WZQ_ERROR;
  809. FiveArea[mm][nn] = Side;
  810. step_temp.side = Side;
  811. step_temp.m    = mm;
  812. step_temp.n    = nn;
  813. StepList.AddTail( step_temp );
  814. PlayIndex = StepList.GetCount();
  816. return WZQ_RUN;
  817. }
  819. void CFive::Serialize( CArchive& ar )
  820. {
  821. int i,j;
  822. BYTE flags0,flags1;
  823. if (ar.IsStoring())
  824. {
  825. // TODO: add storing code here
  826. ar<<(BYTE)0xfa;
  827. ar<<(BYTE)0x5e;
  828. ar<<WF0_1;
  829. ar<<WF0_2;
  830. ar<<WF0_3;
  831. ar<<WF0_4;
  832. ar<<WF1_1;
  833. ar<<WF1_2;
  834. ar<<WF1_3;
  835. ar<<WF1_4;
  836. ar<<WF2_3;
  837. ar<<WF2_4;
  838. ar<<WF5;
  839. ar<<BreadthMax;
  840. ar<<DeepMax;
  841. ar<<ThreadDeepMax;
  842. ar<<Delta;
  843. ar<<Side;
  844. for( i = 0;i<FIVE_MAX_LINE;i++ )
  845. for( j = 0;j<FIVE_MAX_LINE;j++ )
  846.    ar<<FiveArea[i][j];
  847.         StepList.Serialize( ar );
  848. ImpList.Serialize( ar );
  849. ar<<PlayStateFlags;
  850. ar<<PlayIndex;
  851. }
  852. else
  853. {
  854. // TODO: add loading code here
  855. ar>>flags0;
  856. ar>>flags1;
  857. if( flags0!=0xfa||flags1!=0x5e)
  858.      AfxThrowFileException(CFileException::accessDenied);
  859. StepList.RemoveAll();
  860. ar>>WF0_1;
  861. ar>>WF0_2;
  862. ar>>WF0_3;
  863. ar>>WF0_4;
  864. ar>>WF1_1;
  865. ar>>WF1_2;
  866. ar>>WF1_3;
  867. ar>>WF1_4;
  868. ar>>WF2_3;
  869. ar>>WF2_4;
  870. ar>>WF5;
  871. ar>>BreadthMax;
  872. ar>>DeepMax;
  873. ar>>ThreadDeepMax;
  874. ar>>Delta;
  875. ar>>Side;
  876. for( i = 0;i<FIVE_MAX_LINE;i++ )
  877. for( j = 0;j<FIVE_MAX_LINE;j++ )
  878.    ar>>FiveArea[i][j];
  879.         StepList.Serialize( ar );
  880. ImpList.Serialize( ar );
  881. ar>>PlayStateFlags;
  882. ar>>PlayIndex;
  883. if( PlayStateFlags == TRUE )
  884. UpdatePlay();
  885. }
  886. }
  887. ////////////////////////////////////////////////////////////////////////////////////////////
  888. // 抽象平分函数
  889. // ~~~~~~~~~~~~~
  890. // Nf ----------对那一方平分'B'或'W'
  891. // level--------方法COUNT_INC,COUNT_SUB,COUNT_MID
  892. ///////////////////////////////////////////////////////////////////////////////////////////
  893. void CFive::CalRun( char Nf,LEVE leve )
  894. {
  895. if( CurBreadth <= 0 )
  896. return;
  897. MemoryCount++;
  898. JingDuCount++;
  900. char     Mf;
  901. int      i,j,num;
  902. double   Ncount,Mcount,TempCount,TempCount1,wf5temp;
  903. Count    *pCount,temp;
  904. char     Area[FIVE_MAX_LINE][FIVE_MAX_LINE];
  905. POSITION pos;
  906. Step     steptemp;
  908. Mf = ( Nf == 'B'?'W':'B');
  910. pCount = new Count[CurBreadth];
  912. for( i = 0;i < CurBreadth;i++ )
  913. {
  914. pCount[i].count = -9999999;
  915. pCount[i].step.side = 'E';
  916. }
  918. for( i = 0;i < FIVE_MAX_LINE;i++ )
  919. for( j = 0;j < FIVE_MAX_LINE;j++ )
  920.     Area[i][j] = FiveArea[i][j];        //复制FiveArea数组
  922.     pos = DeepList.GetHeadPosition( );
  923. while(pos != NULL)
  924. {
  925. steptemp = DeepList.GetNext(pos);
  926. Area[steptemp.m][steptemp.n] = steptemp.side;
  927. }
  929. switch( leve )
  930. {
  931. case COUNT_INC:
  932. Ncount = SreachArea( Area,Nf );
  933. for( i = 0;i < FIVE_MAX_LINE;i++ )
  934. {
  935. for( j = 0;j < FIVE_MAX_LINE;j++ )
  936. {
  937.     if( Area[i][j] == 'N' )
  938. {
  939. Area[i][j] = Nf;
  940. wf5temp = SreachArea( Area,Nf );
  941. if( wf5temp == -1 )
  942. wf5temp = 2*Dump( 5,10 ) + Ncount;
  943. TempCount = wf5temp - Ncount;
  944. if( TempCount > pCount[0].count )
  945. {
  946. pCount[0].count     = TempCount;
  947. pCount[0].step.side = Nf;
  948. pCount[0].step.m    = i;
  949. pCount[0].step.n    = j;
  950. for( num = 1;num < CurBreadth;num++ )
  951. if( pCount[0].count > pCount[num].count )
  952.       {
  953.      temp = pCount[num];
  954.  pCount[num] = pCount[0];
  955.  pCount[0] = temp;
  956.       }
  957. }
  958. Area[i][j] = 'N';
  959. }
  960. }
  961. }
  962. break;
  963. case COUNT_SUB:
  964. Mcount = SreachArea( Area,Mf );
  965. for( i = 0;i < FIVE_MAX_LINE;i++ )
  966. {
  967. for( j = 0;j < FIVE_MAX_LINE;j++ )
  968. {
  969.     if( Area[i][j] == 'N' )
  970. {
  971. Area[i][j] = Nf;
  972. TempCount = Mcount - SreachArea( Area,Mf );
  973. if( TempCount > pCount[0].count )
  974. {
  975. pCount[0].count     = TempCount;
  976. pCount[0].step.side = Nf;
  977. pCount[0].step.m    = i;
  978. pCount[0].step.n    = j;
  979. for( num = 1;num < CurBreadth;num++ )
  980. if( pCount[0].count > pCount[num].count )
  981.       {
  982.      temp = pCount[num];
  983.  pCount[num] = pCount[0];
  984.  pCount[0] = temp;
  985.       }
  986. }
  987. Area[i][j] = 'N';
  988. }
  989. }
  990. }
  991. break;
  992. case COUNT_MID:
  993. Mcount = SreachArea( Area,Mf );
  994. Ncount = SreachArea( Area,Nf );
  995. for( i = 0;i < FIVE_MAX_LINE;i++ )
  996. {
  997. for( j = 0;j < FIVE_MAX_LINE;j++ )
  998. {
  999.     if( Area[i][j] == 'N' )
  1000. {
  1001. Area[i][j] = Nf;
  1002. wf5temp = SreachArea( Area,Nf );
  1003. if( wf5temp == -1 )
  1004. wf5temp = Ncount + 2*Dump( 5,10 );
  1005. TempCount1 = wf5temp - Ncount;
  1006. TempCount = Mcount - SreachArea( Area,Mf );
  1007. TempCount = TempCount + TempCount1;
  1008. if( TempCount > pCount[0].count )
  1009. {
  1010. pCount[0].count     = TempCount;
  1011. pCount[0].step.side = Nf;
  1012. pCount[0].step.m    = i;
  1013. pCount[0].step.n    = j;
  1014. for( num = 1;num < CurBreadth;num++ )
  1015. if( pCount[0].count > pCount[num].count )
  1016.       {
  1017.      temp = pCount[num];
  1018.  pCount[num] = pCount[0];
  1019.  pCount[0] = temp;
  1020.       }
  1021. }
  1022. Area[i][j] = 'N';
  1023. }
  1024. }
  1025. }
  1026. break;
  1027. case COUNT_ALPHA:
  1028. Mcount = SreachArea( Area,Mf );
  1029. Ncount = SreachArea( Area,Nf );
  1030. for( i = 0;i<FIVE_MAX_LINE;i++ )
  1031. for( j = 0;j<FIVE_MAX_LINE;j++ )
  1032. {
  1033. if( Area[i][j] == 'N' )
  1034. {
  1035. Area[i][j] = Mf;
  1036. wf5temp = SreachArea( Area,Mf );
  1037. if( wf5temp == -1 )
  1038. {
  1039. wf5temp = Mcount + 2*Dump( 5,10 );
  1040. if( Mf == Side )
  1041. {
  1042. Step le;
  1043. if( !DeepList.IsEmpty() )
  1044. {
  1045. le = DeepList.GetHead();
  1046.     PiShen.step = le;
  1047.     PiShen.count = WZQ_I;
  1048. }
  1049. }
  1050. }
  1051.                 TempCount = wf5temp - Mcount;
  1052. Area[i][j] = Nf;
  1053. wf5temp = SreachArea( Area,Nf );
  1054. if( wf5temp == -1 )
  1055. {
  1056. wf5temp = Ncount + 2*Dump( 5,10 );
  1057. if( Nf == Side )
  1058. {
  1059. Step le;
  1060. if( !DeepList.IsEmpty() )
  1061. {
  1062. le = DeepList.GetHead();
  1063.     PiShen.step = le;
  1064.     PiShen.count = WZQ_I;
  1065. }
  1066. }
  1067. }
  1068. TempCount += wf5temp - Ncount;
  1069. if( TempCount > pCount[0].count )
  1070. {
  1071. pCount[0].count     = TempCount;
  1072. pCount[0].step.side = Nf;
  1073. pCount[0].step.m    = i;
  1074. pCount[0].step.n    = j;
  1075. for( num = 1;num < CurBreadth;num++ )
  1076. if( pCount[0].count > pCount[num].count )
  1077. {
  1078. temp = pCount[num];
  1079. pCount[num] = pCount[0];
  1080. pCount[0] = temp;
  1081. }
  1082. }
  1083. Area[i][j] = 'N';
  1084. }
  1085. }
  1086. break;
  1087. case COUNT_DELTA:
  1088. Mcount = SreachArea( Area,Mf );
  1089. Ncount = SreachArea( Area,Nf );
  1090. for( i = 0;i<FIVE_MAX_LINE;i++ )
  1091. for( j = 0;j<FIVE_MAX_LINE;j++ )
  1092. {
  1093. if( Area[i][j] == 'N' )
  1094. {
  1095. Area[i][j] = Mf;
  1096. wf5temp = SreachArea( Area,Mf );
  1097. if( wf5temp == -1 )
  1098. wf5temp = Mcount + 2*Dump( 5,10 );
  1099.                 TempCount = wf5temp - Mcount;
  1100. Area[i][j] = Nf;
  1101. wf5temp = SreachArea( Area,Nf );
  1102. if( wf5temp == -1 )
  1103. wf5temp = Ncount + 2*Dump( 5,10 );
  1104. TempCount1 = wf5temp - Ncount;
  1105. if( TempCount1 > TempCount )
  1106. TempCount = TempCount1;
  1107. if( TempCount > pCount[0].count )
  1108. {
  1109. pCount[0].count     = TempCount;
  1110. pCount[0].step.side = Nf;
  1111. pCount[0].step.m    = i;
  1112. pCount[0].step.n    = j;
  1113. for( num = 1;num < CurBreadth;num++ )
  1114. if( pCount[0].count > pCount[num].count )
  1115. {
  1116. temp = pCount[num];
  1117. pCount[num] = pCount[0];
  1118. pCount[0] = temp;
  1119. }
  1120. }
  1121. Area[i][j] = 'N';
  1122. }
  1123. }
  1124. break;
  1125. }
  1127. for( num = 0;num < CurBreadth;num++ )
  1128. if( pCount[num].step.side != 'E' )
  1129.     CountList.AddTail( pCount[num] );
  1130. delete pCount;
  1131. MemoryCount--;
  1132. }
  1134. /////////////////////////////////////////////////////////////////////////////////////////////
  1135. // 给下一层次加入深度列表
  1136. // ~~~~~~~~~~~~~~~~~~~~~~~
  1137. void CFive::AddDeepList( Step step )  
  1138. {
  1139. DeepList.AddTail( step );
  1140. }
  1142. Step CFive::GetLastDeepList()
  1143. {
  1144. return DeepList.GetTail();
  1145. }
  1147. double CFive::GetStepCount()
  1148. {
  1149. POSITION pos;
  1150. double   temp;
  1151. Count    steptemp;
  1152. temp = 0;
  1153. pos = CountList.GetHeadPosition();
  1154. while(pos != NULL)
  1155. {
  1156. steptemp = CountList.GetNext(pos);
  1157.         temp = steptemp.count + temp;
  1158. }
  1159. if( CurCount == Side )
  1160. return (temp+CurCount);
  1161. else
  1162. return (-temp+CurCount);
  1163. }
  1164. /////////////////////////////////////////////////////////////////////////////////////////////
  1165. // 搜索安排函数
  1166. // ~~~~~~~~~~~~~
  1168. void CFive::ThreadRun()
  1169. {
  1170. if( WaitForSingleObject( KillWzqRun,0 ) == WAIT_OBJECT_0 )
  1171. return;
  1173. if( CurDeep <= 0 || CurBreadth <= 0 )
  1174. {
  1175. return;
  1176. }
  1177. /////////////////////////////////////////////////////////////////////////////////
  1178. // 显示信息
  1179. // ~~~~~~~~~
  1180. // {
  1181. // TCHAR Buf[50];
  1182. // wsprintf( Buf,"%d",ThreadCount );
  1183. // pInfo->SetPaneText(2,Buf );
  1184. // wsprintf( Buf,"%2fMb",MemoryCount*600/1024/1024 );
  1185. // pInfo->SetPaneText(3,Buf );
  1186. // }
  1187. /////////////////////////////////////////////////////////////////////////////////
  1188. if( CurThreadDeep > 0 )
  1189. {
  1190. POSITION pos,postemp;
  1191. CFive **pFive;
  1192. int i,num;
  1193. i = 0;
  1194. //...........................................................................................
  1195. CalRun( CurSide, COUNT_ALPHA );
  1196. num   = CountList.GetCount();
  1197. pFive = (CFive**)new BYTE[sizeof(CFive*)*num];
  1198. pos = CountList.GetHeadPosition();
  1199. while(pos)
  1200. {
  1201. pFive[i] = new CFive( CurSide,CurDeep,CurBreadth,CurThreadDeep );
  1202. postemp = DeepList.GetHeadPosition();
  1203. while( postemp )
  1204. {
  1205. pFive[i] -> AddDeepList( DeepList.GetNext( postemp ));
  1206. }
  1207. pFive[i] -> AddDeepList( CountList.GetNext( pos ).step );
  1208. pFive[i] -> CreateThread();  //Create thread
  1209. i++;
  1210. }
  1212. for( i=0;i < num;i++ )
  1213. {
  1214. pFive[i]->EndEvent.Lock();
  1215. WaitForSingleObject( pFive[i] -> m_hThread,INFINITE ); 
  1216. CurCount += pFive[i] -> GetStepCount();
  1217. if( CurDeep == DeepMax )
  1218. {
  1219. Count count_temp;
  1220.     count_temp.step  = pFive[i] -> GetLastDeepList();
  1221. count_temp.count = pFive[i] -> GetStepCount();
  1222. OneCountList.AddTail( count_temp );
  1223. }
  1224. delete pFive[i];
  1225. }
  1226. delete pFive;
  1227. }
  1228. else
  1229. {
  1230. int i,num;
  1231. POSITION pos,postemp;
  1232. //...........................................................................................
  1233. CalRun( CurSide,COUNT_ALPHA );
  1234. num = CountList.GetCount();
  1235. pos = CountList.GetHeadPosition();
  1236. while( pos )
  1237. {
  1238. if( WaitForSingleObject( KillWzqRun,0 ) == WAIT_OBJECT_0 )
  1239. return;
  1240. {
  1241. postemp = DeepList.GetHeadPosition();
  1242.         if( CurSide == Side )
  1243. {
  1244. CFive five( CurSide,CurDeep,CurBreadth,CurThreadDeep );
  1245. while( postemp )
  1246. {
  1247. five.AddDeepList( DeepList.GetNext( postemp ));
  1248. }
  1249. five.AddDeepList( CountList.GetNext( pos ).step );
  1250.     i++;
  1251.     five.ThreadRun();
  1252.     CurCount += five.GetStepCount();
  1253.     if( CurDeep == DeepMax )
  1254.     {
  1255. Count count_temp;
  1256.         count_temp.step = five.GetLastDeepList();
  1257.       count_temp.count = five.GetStepCount();
  1258.     OneCountList.AddTail( count_temp );
  1259.     }
  1260. }else
  1261. {
  1262. CFive five( CurSide,CurDeep,CurBreadth,CurThreadDeep );
  1263. while( postemp )
  1264. {
  1265. five.AddDeepList( DeepList.GetNext( postemp ));
  1266. }
  1267. five.AddDeepList( CountList.GetNext( pos ).step );
  1268.     i++;
  1269.     five.ThreadRun();
  1270.     CurCount += five.GetStepCount();
  1271.     if( CurDeep == DeepMax )
  1272.     {
  1273. Count count_temp;
  1274.         count_temp.step = five.GetLastDeepList();
  1275.       count_temp.count = five.GetStepCount();
  1276.     OneCountList.AddTail( count_temp );
  1277.     }
  1278. }
  1279. }
  1280. }
  1281. }
  1282. }
  1284. BOOL CFive::InitInstance()
  1285. {
  1286. ThreadCount++;
  1287. ThreadRun();
  1288. return FALSE;
  1289. }
  1291. int CFive::ExitInstance()
  1292. {
  1293. ThreadCount--;
  1294. EndEvent.SetEvent();
  1295. return CWinThread::ExitInstance();
  1296. }