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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
Playing_Cards.cpp
资源名称：斗地主_src.rar　[点击查看]
上传用户：may_xy
上传日期：2007-08-09
资源大小：1519k
文件大小：62k
源码类别：

游戏

开发平台：

C/C++

Playing_Cards.cpp：源码内容
  1. // Playing_Cards.cpp: implementation of the CPlayingCards class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "斗地主.h"
  7. #include "MainFrm.h"
  9. #include "Game.h"
  10. #include "My_DirectInput.h"
  11. #include "My_directdraw.h"
  13. #include "Playing_Cards.h"
  15. //////////////////////////////////////////////////////////////////////
  16. // Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  18. CCard::CCard()
  19. {
  20. m_nColor = 4;   //4表示没有任意花色;
  21. m_nValue = 17;   //17表示还没有牌;
  22. }
  24. CCardsType::CCardsType()
  25. {
  26. m_nTypeNum = 0;
  27. m_nTypeValue = 0;
  28. }
  30. void CPlayingCards::New()
  31. {
  32. m_nCardsCounter      = 0;
  33. m_nDiscardedCounter  = 0;
  34. m_nDiscardingCounter = 0;  
  35. m_nChoosingCardsCounter = 0;
  36. m_cDiscardingType.m_nTypeNum = 0;
  37. m_cDiscardingType.m_nTypeValue = 0;
  38. }
  40. CPlayingCards::CPlayingCards()
  41. {
  42. m_nCardsCounter      = 0;
  43. m_nDiscardedCounter  = 0;
  44. m_nDiscardingCounter = 0;  
  45. m_nChoosingCardsCounter = 0;
  46. }
  48. CPlayingCards::~CPlayingCards()
  49. {
  51. }
  53. int CPlayingCards::CleanUp()
  54. {
  55. CCard temp_card;
  56. for(int i=0; i<m_nCardsCounter - 1; i++)  //整理牌的算法
  57. {
  58. for(int j=i+1; j<m_nCardsCounter; j++)
  59. {
  60. if( (m_cCards[i].m_nValue * 4 + m_cCards[i].m_nColor) > (m_cCards[j].m_nValue * 4 + m_cCards[j].m_nColor) )
  61. {
  62. temp_card = m_cCards[i];
  63. m_cCards[i] =  m_cCards[j];
  64. m_cCards[j] =  temp_card;
  65. }
  66. }//end for;
  67. }//end for;
  68. return 1;
  69. }
  70. //判断是否是单顺(拖拉机),此函数适合5-12张牌情况; 
  71. int CPlayingCards::IsSeries()
  72. {
  73. int m_nTypeValue = 0; //单牌的起始大小;
  74. int counter = 0;  //连续单牌的个数;
  75. int i,j,k;
  77. for(i=15; i<17; i++)
  78. {
  79. if(m_nDiscardingCardsTable[i] != 0)
  80. {
  81. return 0;
  82. }
  83. }
  84. /*
  85. char str[400];
  86. sprintf(str,"m_nDiscardingCardsTable[3] = %dn
  87. m_nDiscardingCardsTable[4] = %dn
  88. m_nDiscardingCardsTable[5] = %dn
  89. m_nDiscardingCardsTable[6] = %dn
  90. m_nDiscardingCardsTable[7] = %dn
  91. m_nDiscardingCardsTable[8] = %dn
  92. m_nDiscardingCardsTable[9] = %dn
  93. m_nDiscardingCardsTable[10] = %dn
  94. m_nDiscardingCardsTable[11] = %dn
  95. m_nDiscardingCardsTable[12] = %dn
  96. m_nDiscardingCardsTable[13] = %dn
  97. m_nDiscardingCardsTable[14] = %dn",
  98. m_nDiscardingCardsTable[3],
  99. m_nDiscardingCardsTable[4],
  100. m_nDiscardingCardsTable[5],
  101. m_nDiscardingCardsTable[6],
  102. m_nDiscardingCardsTable[7],
  103. m_nDiscardingCardsTable[8],
  104. m_nDiscardingCardsTable[9],
  105. m_nDiscardingCardsTable[10],
  106. m_nDiscardingCardsTable[11],
  107. m_nDiscardingCardsTable[12],
  108. m_nDiscardingCardsTable[13],
  109. m_nDiscardingCardsTable[14]);
  110. // pMy_Draw->Text_Out(str,10000);  //调试用;
  111. AfxMessageBox(str);
  112. Sleep(10000);
  113. */
  114. for(i=3;i<15;i++)
  115. {
  116. if(m_nDiscardingCardsTable[i] == 1)   //遇到第一张单牌,接下去扫描;
  117. {
  118. m_nTypeValue = i;
  119. for(j=i;j<17;j++)    //从第i张牌开始扫描;
  120. {
  121. if(m_nDiscardingCardsTable[j] == 1)   //如果接下来的牌为单牌,则给连续单牌数加一;
  122. {
  123. counter++;
  124. }
  125. else if(m_nDiscardingCardsTable[j] == 0)//如果遇到不为单牌,
  126. {
  127. for(k=j;k<17;k++)   //如果之后遇到非空,则返回0;
  128. {
  129. if(m_nDiscardingCardsTable[k] != 0)
  130. {
  131. return 0;
  132. }
  133. }//end for(k=j+1;k<15;k++);
  135. if(counter >= 5)   //如果连续单牌>=5,则为单顺;
  136. {
  137. return m_nTypeValue;
  138. }
  139. else //不为单牌,返回0
  140. {
  141. return 0;
  142. }
  143. }
  144. else      //不为空也不为单牌,返回0;
  145. {
  146. return 0;
  147. }
  148. }//
  149. }
  150. else if(m_nDiscardingCardsTable[i] != 0)
  151. {
  152. return 0;   //遇到其他的数,返回
  153. }
  154. }
  155. /*
  156. char str[300];
  157. sprintf(str,"m_nDiscardingCardsTable[3] = %dn
  158. m_nDiscardingCardsTable[4] = %dn
  159. m_nDiscardingCardsTable[5] = %dn
  160. m_nDiscardingCardsTable[6] = %dn
  161. m_nDiscardingCardsTable[7] = %dn
  162. m_nDiscardingCardsTable[8] = %dn
  163. m_nDiscardingCardsTable[9] = %dn
  164. m_nDiscardingCardsTable[10] = %dn
  165. m_nDiscardingCardsTable[11] = %dn
  166. m_nDiscardingCardsTable[12] = %dn
  167. m_nDiscardingCardsTable[13] = %dn
  168. m_nDiscardingCardsTable[14] = %dn
  169. m_nTypeValue = %d",
  170. m_nDiscardingCardsTable[3],
  171. m_nDiscardingCardsTable[4],
  172. m_nDiscardingCardsTable[5],
  173. m_nDiscardingCardsTable[6],
  174. m_nDiscardingCardsTable[7],
  175. m_nDiscardingCardsTable[8],
  176. m_nDiscardingCardsTable[9],
  177. m_nDiscardingCardsTable[10],
  178. m_nDiscardingCardsTable[11],
  179. m_nDiscardingCardsTable[12],
  180. m_nDiscardingCardsTable[13],
  181. m_nDiscardingCardsTable[14],
  182. m_nTypeValue);
  183. // pMy_Draw->Text_Out(str,10000);  //调试用;
  184. AfxMessageBox(str);
  185. Sleep(10000);
  186. */
  187. return -1;   //见鬼了才会返回这个值;
  188. }
  189. //判断是否是双顺;此函数适合6-20张牌情况;
  190. int CPlayingCards::IsDoubleSeries()
  191. {
  192. int m_nTypeValue = 0; //对牌的起始大小;
  193. int counter = 0;  //连续对牌的个数;
  194. int i,j,k;
  196. for(i=15; i<17; i++)
  197. {
  198. if(m_nDiscardingCardsTable[i] != 0)
  199. {
  200. return 0;
  201. }
  202. }
  204. for(i=3; i<15; i++)
  205. {
  206. if(m_nDiscardingCardsTable[i] == 2)   //遇到第一个对牌,接下去扫描;
  207. {
  208. m_nTypeValue = i;
  209. for(j=i; j<15; j++)    //从第i张牌开始扫描;
  210. {
  211. if(m_nDiscardingCardsTable[j] == 2)   //如果接下来的牌为对牌,则给连续对牌数加一;
  212. {
  213. counter++;
  214. }
  215. else if(m_nDiscardingCardsTable[j] == 0)//如果遇到不为对牌,
  216. {
  217. for(k=j+1; k<15; k++)   //如果之后遇到非空,则返回0;
  218. {
  219. if(m_nDiscardingCardsTable[k] != 0)
  220. {
  221. return 0;
  222. }
  223. }//end for(k=j+1;k<15;k++);
  225. if(counter >= 3)   //如果连续对牌>=3,则为双顺;
  226. {
  227. return m_nTypeValue;
  228. }
  229. else //不为对牌,返回0
  230. {
  231. return 0;
  232. }
  233. }
  234. else      //不为空也不为对牌,返回0;
  235. {
  236. return 0;
  237. }
  238. }//
  239. }
  240. else if(m_nDiscardingCardsTable[i] != 0)
  241. {
  242. return 0;   //遇到其他的数,返回
  243. }
  244. }
  245. return -1;   //见鬼了才会返回这个值;
  246. }
  247. //判断是否是三顺;此函数适合6-18张牌情况;
  248. int CPlayingCards::IsThreeSeries()
  249. {
  250. int m_nTypeValue = 0; //三顺的起始大小;
  251. int counter = 0;  //连续三张的个数;
  252. int i,j,k;
  254. for(i=15; i<17; i++)
  255. {
  256. if(m_nDiscardingCardsTable[i] != 0)
  257. {
  258. return 0;
  259. }
  260. }
  262. for(i=3; i<15; i++)
  263. {
  264. if(m_nDiscardingCardsTable[i] == 3)   //遇到第一个三张,接下去扫描;
  265. {
  266. m_nTypeValue = i;
  267. for(j=i; j<15; j++)    //从表第i项开始扫描;
  268. {
  269. if(m_nDiscardingCardsTable[j] == 3)   //如果接下来的牌为三张,则给连续对牌数加一;
  270. {
  271. counter++;
  272. }
  273. else if(m_nDiscardingCardsTable[j] == 0)//如果遇到不为三张,
  274. {
  275. for(k=j+1;k<15;k++)   //如果之后遇到非空,则返回0;
  276. {
  277. if(m_nDiscardingCardsTable[k] != 0)
  278. {
  279. return 0;
  280. }
  281. }//end for(k=j+1;k<15;k++);
  283. if(counter >= 2)   //如果连续对牌>=2,则为三顺;
  284. {
  285. return m_nTypeValue;
  286. }
  287. else //只有一个三张;
  288. {
  289. return 0;
  290. }
  291. }
  292. else      //不为空也不为对牌,返回0;
  293. {
  294. return 0;
  295. }
  296. }//
  297. }
  298. else if(m_nDiscardingCardsTable[i] != 0)
  299. {
  300. return 0;   //遇到其他的数,返回
  301. }
  302. }
  303. return -1;
  304. }
  305. //判断是否是一对牌;
  306. int CPlayingCards::Is2()
  307. {
  308. for(int i=3;i<17;i++)
  309. {
  310. if(m_nDiscardingCardsTable[i] == 2)
  311. {
  312. return i;
  313. }
  314. else if(m_nDiscardingCardsTable[i] != 0)
  315. {
  316. return 0;
  317. }
  318. }
  319. return -1;    //出错,为空牌表;
  320. }
  321. //判断是否是三张;
  322. int CPlayingCards::Is3()
  323. {
  324. for(int i=3; i<17; i++)
  325. {
  326. if(m_nDiscardingCardsTable[i] == 3)
  327. {
  328. return i;
  329. }
  330. else if(m_nDiscardingCardsTable[i] != 0)
  331. {
  332. return 0;
  333. }
  334. }
  335. return -1;
  336. }
  337. //判断是否是四张(炸弹); 
  338. int CPlayingCards::IsBomb()
  339. {
  340. for(int i=3; i<17; i++)
  341. {
  342. if(m_nDiscardingCardsTable[i] == 4)
  343. {
  344. return i;
  345. }
  346. else if(m_nDiscardingCardsTable[i] != 0)
  347. {
  348. return 0;
  349. }
  350. }
  351. return -1;
  352. }
  353. //判断是否是三带一单;
  354. int CPlayingCards::Is31()
  355. {
  356. for(int i=3; i<17; i++)
  357. {
  358. if(m_nDiscardingCardsTable[i] == 3)
  359. return i;
  360. }
  361. return 0;
  362. }
  363. //判断是否是三带一对;
  364. int CPlayingCards::Is32()
  365. {
  366. int m_nTypeValue = 0;
  367. int Pair = 0;
  368. for(int i=3; i<17; i++)
  369. {
  370. if(m_nDiscardingCardsTable[i] == 3)
  371. {
  372. m_nTypeValue = i;
  373. }
  374. else if(m_nDiscardingCardsTable[i] == 2)
  375. {
  376. Pair = i;
  377. }
  378. else if(m_nDiscardingCardsTable[i] != 0)
  379. {
  380. return 0;
  381. }
  382. }
  383. //如果存在三张,又存在一对,则返回
  384. if(m_nTypeValue && Pair)
  385. {
  386. return m_nTypeValue;
  387. }
  388. return 0;
  389. }
  390. //判断是否是四带两单;
  391. int CPlayingCards::Is411()
  392. {
  393. int m_nTypeValue = 0;
  394. int counter = 0;
  396. for(int i=3; i<17; i++)
  397. {
  398. if(m_nDiscardingCardsTable[i] == 4)
  399. {
  400. m_nTypeValue = i;
  401. }
  402. else if(m_nDiscardingCardsTable[i] == 1)
  403. {
  404. counter++;
  405. }
  406. else if(m_nDiscardingCardsTable[i] != 0)
  407. {
  408. return 0;
  409. }
  410. }
  411. //如果存在三张,又存在一对,则返回
  412. if(m_nTypeValue && counter == 2)
  413. {
  414. return m_nTypeValue;
  415. }
  417. return 0;
  418. }
  419. //判断是否是三顺带两单;
  420. int CPlayingCards::Is3311()
  421. {
  422. int m_nTypeValue = 0;
  423. int counter = 0;
  425. for(int i=3; i<17; i++)
  426. {
  427. if((m_nDiscardingCardsTable[i] == 3) && (i!= 14))   //遇到第一个三张且不等于A;
  428. {
  429. m_nTypeValue = i;
  430. if(m_nDiscardingCardsTable[i+1] != 3)  
  431. {
  432. return 0; //如果下表项不为三张,返回0;
  433. }
  434. else
  435. {
  436. for(int j=i+2; j<17; j++)
  437. {
  438. if(m_nDiscardingCardsTable[j] == 1)
  439. {
  440. counter++;
  441. }
  442. else if(m_nDiscardingCardsTable[j] != 0)
  443. {
  444. return 0; //再出现其它表项,则返回0;
  445. }
  446. }//end for(int j=i+1;j<17;j++)
  447. }
  448. //如果单牌数为2,则匹配成功!
  449. if(counter == 2)
  450. {
  451. return m_nTypeValue;
  452. }
  453. else
  454. {
  455. return 0;
  456. }
  457. }//
  458. else if(m_nDiscardingCardsTable[i] == 1)
  459. {
  460. counter++;
  461. }//
  462. else if(m_nDiscardingCardsTable[i] != 0)
  463. {
  464. return 0;
  465. }//
  466. }
  468. return 0;
  469. }
  470. //判断是否是四带两对;
  471. int CPlayingCards::Is422()
  472. {
  473. int m_nTypeValue = 0;
  474. int counter = 0;
  476. for(int i=3;i<17;i++)
  477. {
  478. if(m_nDiscardingCardsTable[i] == 4)
  479. {
  480. m_nTypeValue = i;
  481. }
  482. else if(m_nDiscardingCardsTable[i] == 2)
  483. {
  484. counter++;
  485. }
  486. else if(m_nDiscardingCardsTable[i] != 0)
  487. {
  488. return 0;
  489. }
  490. }
  491. //如果存在三张,又存在一对,则返回
  492. if(m_nTypeValue && counter == 2)
  493. {
  494. return m_nTypeValue;
  495. }
  496. return 0;
  497. }
  498. //判断是否是三顺带两对;
  499. int CPlayingCards::Is3322()
  500. {
  501. int m_nTypeValue = 0;
  502. int counter = 0;
  504. for(int i=3; i<17; i++)
  505. {
  506. if((m_nDiscardingCardsTable[i] == 3) && (i < 14))   //遇到第一个三张且不等于A;
  507. {
  508. m_nTypeValue = i;
  509. if(m_nDiscardingCardsTable[i+1] != 3)  
  510. {
  511. return 0; //如果下表项不为三张,返回0;
  512. }
  513. else
  514. {
  515. for(int j=i+2; j<17; j++)
  516. {
  517. if(m_nDiscardingCardsTable[j] == 2)
  518. {
  519. counter++;
  520. }
  521. else if(m_nDiscardingCardsTable[j] != 0)
  522. {
  523. return 0; //再出现其它表项,则返回0;
  524. }
  525. }//end for(int j=i+1; j<17; j++)
  526. }
  527. //如果单牌数为2,则匹配成功!
  528. if(counter == 2)
  529. {
  530. return m_nTypeValue;
  531. }
  532. else
  533. {
  534. return 0;
  535. }
  536. }//
  537. else if(m_nDiscardingCardsTable[i] == 2)
  538. {
  539. counter++;
  540. }//
  541. else if(m_nDiscardingCardsTable[i] != 0)
  542. {
  543. return 0;
  544. }//
  545. }
  547. return 0;
  548. }
  549. //判断是否是三顺带三单;
  550. int CPlayingCards::Is333111()
  551. {
  552. int m_nTypeValue = 0;
  553. int counter = 0;
  555. for(int i=3; i<17; i++)
  556. {
  557. if((m_nDiscardingCardsTable[i] == 3) && (i < 13))   //遇到第一个三张且不等于A;
  558. {
  559. m_nTypeValue = i;
  560. if(m_nDiscardingCardsTable[i+1] != 3 || 
  561.    m_nDiscardingCardsTable[i+2] != 3)  
  562. {
  563. return 0; //如果下表项不为三张,返回0;
  564. }
  565. else
  566. {
  567. for(int j=i+3; j<17; j++)
  568. {
  569. if(m_nDiscardingCardsTable[j] == 1)
  570. {
  571. counter++;
  572. }
  573. else if(m_nDiscardingCardsTable[j] != 0)
  574. {
  575. return 0; //再出现其它表项,则返回0;
  576. }
  577. }//end for(int j=i+1;j<17;j++)
  578. }
  579. //如果单牌数为2,则匹配成功!
  580. if(counter == 3)
  581. {
  582. return m_nTypeValue;
  583. }
  584. else
  585. {
  586. return 0;
  587. }
  588. }//
  589. else if(m_nDiscardingCardsTable[i] == 1)
  590. {
  591. counter++;
  592. }//
  593. else if(m_nDiscardingCardsTable[i] != 0)
  594. {
  595. return 0;
  596. }//
  597. }
  598. return 0;
  599. }
  600. //判断是否是三顺带三对;
  601. int CPlayingCards::Is333222()
  602. {
  603. int m_nTypeValue = 0;
  604. int counter = 0;
  606. for(int i=3; i<17; i++)
  607. {
  608. if(m_nDiscardingCardsTable[i] == 3 && i < 13)   //遇到第一个三张且不等于A;
  609. {
  610. m_nTypeValue = i;
  611. if((m_nDiscardingCardsTable[i+1] != 3) || 
  612.    (m_nDiscardingCardsTable[i+2] != 3))  
  613. {
  614. return 0; //如果下表项不为三张,返回0;
  615. }
  616. else
  617. {
  618. for(int j=i+3; j<17; j++)
  619. {
  620. if(m_nDiscardingCardsTable[j] == 2)
  621. {
  622. counter++;
  623. }
  624. else if(m_nDiscardingCardsTable[j] != 0)
  625. {
  626. return 0; //再出现其它表项,则返回0;
  627. }
  628. }//end for(int j=i+1;j<17;j++)
  629. }
  630. //如果单牌数为2,则匹配成功!
  631. if(counter == 3)
  632. {
  633. return m_nTypeValue;
  634. }
  635. else
  636. {
  637. return 0;
  638. }
  639. }//
  640. else if(m_nDiscardingCardsTable[i] == 2)
  641. {
  642. counter++;
  643. }//
  644. else if(m_nDiscardingCardsTable[i] != 0)
  645. {
  646. return 0;
  647. }//
  648. }
  650. return 0;
  651. }
  652. //判断是否是三顺带四单;
  653. int CPlayingCards::Is33331111()
  654. {
  655. int m_nTypeValue = 0;
  656. int counter = 0;
  658. for(int i=3;i<17;i++)
  659. {
  660. if(m_nDiscardingCardsTable[i] == 3 && i < 12)   //遇到第一个三张且不等于A;
  661. {
  662. m_nTypeValue = i;
  663. if((m_nDiscardingCardsTable[i+1] != 3) || 
  664.    (m_nDiscardingCardsTable[i+2] != 3) ||
  665.    (m_nDiscardingCardsTable[i+3] != 3))  
  666. {
  667. return 0; //如果下表项不为三张,返回0;
  668. }
  669. else
  670. {
  671. for(int j=i+4; j<17; j++)
  672. {
  673. if(m_nDiscardingCardsTable[j] == 1)
  674. {
  675. counter++;
  676. }
  677. else if(m_nDiscardingCardsTable[j] != 0)
  678. {
  679. return 0; //再出现其它表项,则返回0;
  680. }
  681. }//end for(int j=i+1;j<17;j++)
  682. }
  683. //如果单牌数为2,则匹配成功!
  684. if(counter == 4)
  685. {
  686. return m_nTypeValue;
  687. }
  688. else
  689. {
  690. return 0;
  691. }
  692. }//
  693. else if(m_nDiscardingCardsTable[i] == 1)
  694. {
  695. counter++;
  696. }//
  697. else if(m_nDiscardingCardsTable[i] != 0)
  698. {
  699. return 0;
  700. }//
  701. }
  702. return 0;
  703. }
  704. /*
  705. * 函数介绍：检查出牌的逻辑合法性;
  706. * 输入参数：无;
  707. * 输出参数：??
  708. * 返回值 ： 匹配成功返回1,不成功返回0;
  709. */
  710. int CPlayingCards::CheckChoosing()
  711. {
  712. int i;
  714. for(i=0; i<17; i++)    //初始化扫描表;
  715. {
  716. m_nDiscardingCardsTable[i] = 0;
  717. }
  718. //扫描进表中;
  719. for(i=0; i<m_nChoosingCardsCounter; i++)
  720. {
  721. m_nDiscardingCardsTable[m_cChoosingCards[i].m_nValue]++;
  722. }
  724. int Table_Index;
  726. switch(m_nChoosingCardsCounter)
  727. {
  728. case 1:
  729. m_cDiscardingType.m_nTypeNum   = 1;
  730. m_cDiscardingType.m_nTypeValue = m_cChoosingCards[0].m_nValue; 
  731. return 1;
  732. case 2://是否是一对牌;
  733. if( (Table_Index = Is2()) != 0 )
  734. {
  735. //是大王,则为炸弹;
  736. if(Table_Index == 16)
  737. {
  738. m_cDiscardingType.m_nTypeNum = 4;   //类型为4表示炸弹;
  739. }
  740. else
  741. {
  742. m_cDiscardingType.m_nTypeNum = 2;
  743. }
  744. m_cDiscardingType.m_nTypeValue = Table_Index; 
  745. return 1;
  746. }
  747. return 0;
  748. case 3:
  749. if( (Table_Index = Is3()) != 0 )
  750. {
  751. m_cDiscardingType.m_nTypeNum   = 3;
  752. m_cDiscardingType.m_nTypeValue = Table_Index; 
  753. return 1;
  754. }
  755. return 0;
  756. case 4:
  757. if( (Table_Index = IsBomb()) != 0 )
  758. {
  759. m_cDiscardingType.m_nTypeNum   = 4;
  760. m_cDiscardingType.m_nTypeValue = Table_Index;
  761. return 1;
  762. }
  763. else if( (Table_Index = Is31()) != 0 )
  764. {
  765. m_cDiscardingType.m_nTypeNum = 31;
  766. m_cDiscardingType.m_nTypeValue = Table_Index;
  767. return 1;
  768. }
  769. return 0;
  770. case 5:
  771. if( (Table_Index = IsSeries()) != 0 )
  772. {
  773. m_cDiscardingType.m_nTypeNum = 5;
  774. m_cDiscardingType.m_nTypeValue = Table_Index;
  775. return 1;
  776. }
  777. else if( (Table_Index = Is32()) != 0 )
  778. {
  779. m_cDiscardingType.m_nTypeNum = 32;
  780. m_cDiscardingType.m_nTypeValue = Table_Index;
  781. return 1;
  782. }
  783. return 0;
  784. case 6:
  785. //单顺:  6 最小牌的Card.m_nValue(面值)    6
  786. //双顺:  222 最小牌的Card.m_nValue(面值)    6
  787. //三顺:      33 最小牌的Card.m_nValue(面值)    6
  788. //四带二单:  411 四张的Card.m_nValue(面值) 6  
  789. if( (Table_Index = IsSeries()) != 0 )
  790. {
  791. m_cDiscardingType.m_nTypeNum = 6;
  792. m_cDiscardingType.m_nTypeValue = Table_Index;
  793. return 1;
  794. }
  795. else if( (Table_Index = IsDoubleSeries()) != 0 )
  796. {
  797. m_cDiscardingType.m_nTypeNum = 222;
  798. m_cDiscardingType.m_nTypeValue = Table_Index;
  799. return 1;
  800. }
  801. else if( (Table_Index = IsThreeSeries()) != 0 )
  802. {
  803. m_cDiscardingType.m_nTypeNum = 33;
  804. m_cDiscardingType.m_nTypeValue = Table_Index;
  805. return 1;
  806. }
  807. else if( (Table_Index = Is411()) != 0 )
  808. {
  809. m_cDiscardingType.m_nTypeNum = 411;
  810. m_cDiscardingType.m_nTypeValue = Table_Index;
  811. return 1;
  812. }
  813. return 0;
  814. case 7:
  815. //单顺
  816. if( (Table_Index = IsSeries()) != 0 )
  817. {
  818. m_cDiscardingType.m_nTypeNum = 7;
  819. m_cDiscardingType.m_nTypeValue = Table_Index;
  820. return 1;
  821. }
  822. return 0;
  823. case 8:
  824. //单顺:  8 最小牌的Card.m_nValue(面值)    8
  825. //双顺  2222 最小牌的Card.m_nValue(面值)    8
  826. //三顺带二单:  3311 最小三张的Card.m_nValue(面值)  8
  827. //四带二对:  422 四张的Card.m_nValue(面值) 8
  828. if( (Table_Index = IsSeries()) != 0 )
  829. {
  830. m_cDiscardingType.m_nTypeNum = 8;
  831. m_cDiscardingType.m_nTypeValue = Table_Index;
  832. return 1;
  833. }
  834. else if( (Table_Index = IsDoubleSeries()) != 0 )
  835. {
  836. m_cDiscardingType.m_nTypeNum = 2222;
  837. m_cDiscardingType.m_nTypeValue = Table_Index;
  838. return 1;
  839. }
  840. else if( (Table_Index = Is3311()) != 0 )
  841. {
  842. m_cDiscardingType.m_nTypeNum = 3311;
  843. m_cDiscardingType.m_nTypeValue = Table_Index;
  844. return 1;
  845. }
  846. else if( (Table_Index = Is422()) != 0 )
  847. {
  848. m_cDiscardingType.m_nTypeNum = 422;
  849. m_cDiscardingType.m_nTypeValue = Table_Index;
  850. return 1;
  851. }
  852. return 0;
  853. case 9:
  854. //单顺:  9 最小牌的Card.m_nValue(面值)    9
  855. //三顺:  333 最小三张的Card.m_nValue(面值)  9
  856. if( (Table_Index = IsSeries()) != 0 )
  857. {
  858. m_cDiscardingType.m_nTypeNum = 9;
  859. m_cDiscardingType.m_nTypeValue = Table_Index;
  860. return 1;
  861. }
  862. else if( (Table_Index = IsThreeSeries()) != 0 )
  863. {
  864. m_cDiscardingType.m_nTypeNum = 333;
  865. m_cDiscardingType.m_nTypeValue = Table_Index;
  866. return 1;
  867. }
  868. return 0;
  869. case 10:
  870. //单顺:  10 最小牌的Card.m_nValue(面值)    10
  871. //双顺:  22222 最小牌的Card.m_nValue(面值)    10
  872. //三顺带二对:  3322 最小三张的Card.m_nValue(面值)  10
  873. if( (Table_Index = IsSeries()) != 0 )
  874. {
  875. m_cDiscardingType.m_nTypeNum = 10;
  876. m_cDiscardingType.m_nTypeValue = Table_Index;
  877. return 1;
  878. }
  879. else if( (Table_Index = IsDoubleSeries()) != 0 )
  880. {
  881. m_cDiscardingType.m_nTypeNum = 22222;
  882. m_cDiscardingType.m_nTypeValue = Table_Index;
  883. return 1;
  884. }
  885. else if( (Table_Index = Is3322()) != 0 )
  886. {
  887. m_cDiscardingType.m_nTypeNum = 3322;
  888. m_cDiscardingType.m_nTypeValue = Table_Index;
  889. return 1;
  890. }
  891. return 0;
  892. case 11:
  893. //单顺:  11 最小牌的Card.m_nValue(面值)    11
  894. if( (Table_Index = IsSeries()) != 0 )
  895. {
  896. m_cDiscardingType.m_nTypeNum = 11;
  897. m_cDiscardingType.m_nTypeValue = Table_Index;
  898. return 1;
  899. }
  900. return 0;
  901. case 12:
  902. //单顺:  12 最小牌的Card.m_nValue(面值)    12
  903. //双顺:  222222 最小对牌的Card.m_nValue(面值)  12
  904. //三顺:  3333 最小三张的Card.m_nValue(面值)  12
  905. //三顺带三:  333111 最小三张的Card.m_nValue(面值)  12
  906. if( (Table_Index = IsSeries()) != 0 )
  907. {
  908. m_cDiscardingType.m_nTypeNum = 12;
  909. m_cDiscardingType.m_nTypeValue = Table_Index;
  910. return 1;
  911. }
  912. else if( (Table_Index = IsDoubleSeries()) != 0 )
  913. {
  914. m_cDiscardingType.m_nTypeNum = 222222;
  915. m_cDiscardingType.m_nTypeValue = Table_Index;
  916. return 1;
  917. }
  918. else if( (Table_Index = IsThreeSeries()) != 0 )
  919. {
  920. m_cDiscardingType.m_nTypeNum = 3333;
  921. m_cDiscardingType.m_nTypeValue = Table_Index;
  922. return 1;
  923. }
  924. else if( (Table_Index = Is333111()) != 0 )
  925. {
  926. m_cDiscardingType.m_nTypeNum = 333111;
  927. m_cDiscardingType.m_nTypeValue = Table_Index;
  928. return 1;
  929. }
  930. return 0;
  931. case 13:
  932. return 0;
  933. case 14:
  934. //双顺  2222222 最小对牌的Card.m_nValue(面值)  14
  935. if( (Table_Index = IsDoubleSeries()) != 0 )
  936. {
  937. m_cDiscardingType.m_nTypeNum = 2222222;
  938. m_cDiscardingType.m_nTypeValue = Table_Index;
  939. return 1;
  940. }
  941. return 0;
  942. case 15:
  943. //三顺带三对:  333222 最小三张的Card.m_nValue(面值)  15
  944. //三顺:  33333 最小三张的Card.m_nValue(面值)  15
  945. if( (Table_Index = IsThreeSeries()) != 0 )
  946. {
  947. m_cDiscardingType.m_nTypeNum = 33333;
  948. m_cDiscardingType.m_nTypeValue = Table_Index;
  949. return 1;
  950. }
  951. else if( (Table_Index = Is333222()) != 0 )
  952. {
  953. m_cDiscardingType.m_nTypeNum = 333222;
  954. m_cDiscardingType.m_nTypeValue = Table_Index;
  955. return 1;
  956. }
  957. return 0;
  958. case 16:
  959. //双顺  22222222 最小对牌的Card.m_nValue(面值)  16
  960. //三顺带四单:  33331111 最小三张的Card.m_nValue(面值)  16
  961. if( (Table_Index = IsDoubleSeries()) != 0 )
  962. {
  963. m_cDiscardingType.m_nTypeNum = 22222222;
  964. m_cDiscardingType.m_nTypeValue = Table_Index;
  965. return 1;
  966. }
  967. else if( (Table_Index = Is33331111()) != 0 )
  968. {
  969. m_cDiscardingType.m_nTypeNum = 33331111;
  970. m_cDiscardingType.m_nTypeValue = Table_Index;
  971. return 1;
  972. }
  973. return 0;
  974. case 17:
  975. return 0;
  976. case 18:
  977. //双顺  222222222 最小对牌的Card.m_nValue(面值)  18
  978. //三顺  333333 最小三张的Card.m_nValue(面值)  18
  979. if( (Table_Index = IsDoubleSeries()) != 0 )
  980. {
  981. m_cDiscardingType.m_nTypeNum = 222222222;
  982. m_cDiscardingType.m_nTypeValue = Table_Index;
  983. return 1;
  984. }
  985. else if( (Table_Index = IsThreeSeries()) != 0 )
  986. {
  987. m_cDiscardingType.m_nTypeNum = 333333;
  988. m_cDiscardingType.m_nTypeValue = Table_Index;
  989. return 1;
  990. }
  991. return 0;
  992. case 19:
  993. return 0;
  994. case 20:
  995. return 0;
  996. //暂时保留;几乎不可能的牌;
  997. //双顺  2222222222 最小对牌的Card.m_nValue(面值)  20
  998. //三顺带五单:  3333311111 最小三张的Card.m_nValue(面值)  20
  999. //三顺带四对:  33332222 最小三张的Card.m_nValue(面值)  20
  1000. }
  1001. return -1;
  1002. }
  1003. //直接选择出牌;
  1004. int CPlayingCards::DirectChoose()
  1005. {
  1006. int i;
  1007. int counter_0 = 0;
  1008. int counter_1 = 0;
  1009. int value_1 = 17;
  1010. int counter_2 = 0;
  1011. int value_2 = 17;
  1012. int counter_3 = 0;
  1013. int value_3 = 17;
  1014. int counter_4 = 0;
  1015. int value_4 = 17;
  1017. CCardsType temp;
  1018. temp.m_nTypeValue = 2;
  1019. //扫描未出牌表;
  1020. for(i=15;i>=3;i--)
  1021. {
  1022. switch(m_nCardsTable[i])
  1023. {
  1024. case 0:
  1025. counter_0++;
  1026. break;
  1027. case 1:
  1028. counter_1++;
  1029. value_1 = i;
  1030. break;
  1031. case 2:
  1032. counter_2++;
  1033. value_2 = i;
  1034. break;
  1035. case 3:
  1036. counter_3++;
  1037. value_3 = i;
  1038. break;
  1039. case 4:
  1040. counter_4++;
  1041. value_4 = i;
  1042. break;
  1043. }
  1044. }
  1046. if( counter_3 >= 2 && counter_1 >= counter_2 )
  1047. {
  1048. //寻找3311;找到返回;
  1049. //如果没找到,则 if(counter_1 <= 5)寻找31;返回
  1050. if( Search3311(temp) )
  1051. {
  1052. return 1;
  1053. }
  1054. }
  1055. else if( counter_3 >= 2 && counter_2 > counter_1 )
  1056. {
  1057. //寻找3322;找到返回;
  1058. //如果没找到,则 if(counter_2 <= 5)寻找32;返回
  1059. if( Search3322(temp) )
  1060. {
  1061. return 1;
  1062. }
  1063. }
  1065. if( counter_1 >= 3 )
  1066. {
  1067. //寻找单顺;从12张到5张的情况;
  1069. if( SearchBeyond10(temp,12) )
  1070. return 1;
  1072. if( SearchBeyond10(temp,11) )
  1073. return 1;
  1075. if( SearchBeyond10(temp,10) )
  1076. return 1;
  1078. if( Search9(temp) )
  1079. return 1;
  1081. if( Search8(temp) )
  1082. return 1;
  1084. if( Search7(temp) )
  1085. return 1;
  1087. if( Search6(temp) )
  1088. return 1;
  1090. if( Search5(temp) )
  1091. return 1;
  1092. }
  1094. if( counter_2 >= 3 )
  1095. {
  1096. //寻找双顺;从5到3;
  1097. if( Search2222(temp) )
  1098. return 1;
  1100. if( Search222(temp) )
  1101. return 1;
  1102. }
  1104. if( counter_4 >= 0 && counter_1 >= 2 && counter_2 >= 2 )
  1105. {
  1106. //寻找411;
  1107. if( value_1 < value_2 )
  1108. {
  1109. if( Search411(temp) )
  1110. return 1;
  1111. }
  1112. else
  1113. {
  1114. if( Search422(temp) )
  1115. return 1;
  1116. }
  1117. }
  1118. else if( counter_4 >= 0 && counter_1 >= 2 )
  1119. {
  1120. if( Search411(temp) )
  1121. return 1;
  1122. }
  1123. else if( counter_4 >= 0 && counter_2 >= 2 )
  1124. {
  1125. if( Search422(temp) )
  1126. return 1;
  1127. }
  1129. if( counter_3 > 0 && value_1 < value_2 && counter_1 > 0 )
  1130. {
  1131. //寻找31;
  1132. if( Search31(temp) )
  1133. return 1;
  1134. }
  1135. else if( counter_3 > 0 && value_2 < value_1 && counter_2 > 0 )
  1136. {
  1137. //寻找31;
  1138. if( Search32(temp) )
  1139. return 1;
  1140. }
  1142. if( value_1 < value_2 )
  1143. {
  1144. //寻找1;
  1145. if( Search1(temp) )
  1146. return 1;
  1147. }
  1148. else
  1149. {
  1150. //寻找2;
  1151. if( Search2(temp) )
  1152. return 1;
  1153. }
  1155. for(i=3;i<=16;i++)
  1156. {
  1157. if( m_nCardsTable[i] == 0 )
  1158. continue;
  1159. else
  1160. {
  1161. m_cDiscardingType.m_nTypeNum   = 4;
  1162. m_cDiscardingType.m_nTypeNum   = m_nCardsTable[i];
  1163. m_cDiscardingType.m_nTypeValue = i;
  1165. for(int j=0;j<m_nCardsTable[i];j++)
  1166. {
  1167. m_nDiscardingCounter++;
  1168. m_cDiscarding[j] = m_cCards[j];
  1170. m_cCards[j] = m_cBLANK_CARD;
  1171. }//end for~
  1172. m_nCardsTable[i] = 0;
  1173. break;
  1174. }
  1175. }//end if
  1177. // CleanUp();
  1178. return 1;
  1179. }
  1180. //工人智能补丁1;
  1181. BOOL CPlayingCards::AI_Patch1()
  1182. {
  1183. //双王
  1184. if( (m_nCardsTable[16] == 2) && (m_nCardsCounter == 2) )
  1185. {
  1186. m_cDiscardingType.m_nTypeNum   = 4;
  1187. m_cDiscardingType.m_nTypeValue = 16;
  1188. m_nDiscardingCounter = 2;
  1190. m_cDiscarding[0]  = m_cCards[0];
  1191. m_cDiscarding[1]  = m_cCards[1];
  1193. m_cCards[0] = m_cBLANK_CARD;
  1194. m_cCards[1] = m_cBLANK_CARD;
  1196. m_nCardsTable[16] = 0;
  1197. return 1;
  1198. }
  1200. int i;
  1201. int counter_1 = 0;
  1202. int value_1 = 17;
  1203. int counter_2 = 0;
  1204. int value_2 = 17;
  1205. int counter_3 = 0;
  1206. int value_3 = 17;
  1207. int counter_4 = 0;
  1208. int value_4 = 17;
  1210. CCardsType temp;
  1211. temp.m_nTypeValue = 2;
  1212. //扫描未出牌表;
  1213. for(i=15;i>=3;i--)
  1214. {
  1215. switch(m_nCardsTable[i])
  1216. {
  1217. case 1:
  1218. counter_1++;
  1219. value_1 = i;
  1220. break;
  1221. case 2:
  1222. counter_2++;
  1223. value_2 = i;
  1224. break;
  1225. case 3:
  1226. counter_3++;
  1227. value_3 = i;
  1228. break;
  1229. case 4:
  1230. counter_4++;
  1231. value_4 = i;
  1232. break;
  1233. }
  1234. }
  1235. //双王加单张;
  1236. if( (m_nCardsTable[16] == 2) && (m_nCardsCounter == 3) )
  1237. {
  1238. m_cDiscardingType.m_nTypeNum   = 4;
  1239. m_cDiscardingType.m_nTypeValue = 16;
  1241. m_nDiscardingCounter = 2;
  1242. m_cDiscarding[0]     = m_cCards[1];
  1243. m_cDiscarding[1]     = m_cCards[2];
  1245. m_cCards[1] = m_cBLANK_CARD;
  1246. m_cCards[2] = m_cBLANK_CARD;
  1248. m_nCardsTable[16] = 0;
  1249. return 1;
  1250. }
  1252. //双王加一对;
  1253. if( (m_nCardsTable[16] == 2) && ((m_nCardsCounter == 4) && (counter_2 == 1)) )
  1254. {
  1255. m_cDiscardingType.m_nTypeNum   = 4;
  1256. m_cDiscardingType.m_nTypeValue = 16;
  1258. m_nDiscardingCounter = 2;
  1259. m_cDiscarding[0]     = m_cCards[2];
  1260. m_cDiscarding[1]     = m_cCards[3];
  1262. m_cCards[2] = m_cBLANK_CARD;
  1263. m_cCards[3] = m_cBLANK_CARD;
  1265. m_nCardsTable[16] = 0;
  1266. return 1;
  1267. }
  1269. //双王加三张;
  1270. if( (m_nCardsTable[16] == 2) && ((m_nCardsCounter == 5) && (counter_3 == 1)) )
  1271. {
  1272. m_cDiscardingType.m_nTypeNum   = 4;
  1273. m_cDiscardingType.m_nTypeValue = 16;
  1275. m_nDiscardingCounter = 2;
  1276. m_cDiscarding[0]     = m_cCards[3];
  1277. m_cDiscarding[1]     = m_cCards[4];
  1279. m_cCards[3] = m_cBLANK_CARD;
  1280. m_cCards[4] = m_cBLANK_CARD;
  1282. m_nCardsTable[16] = 0;
  1283. return 1;
  1284. }
  1285. //双王加四张
  1286. if( (m_nCardsTable[16] == 2) && ((m_nCardsCounter == 6) && (counter_4 == 1)) )
  1287. {
  1288. m_cDiscardingType.m_nTypeNum   = 4;
  1289. m_cDiscardingType.m_nTypeValue = 16;
  1291. m_nDiscardingCounter = 2;
  1292. m_cDiscarding[0]     = m_cCards[4];
  1293. m_cDiscarding[1]     = m_cCards[5];
  1295. m_cCards[4] = m_cBLANK_CARD;
  1296. m_cCards[5] = m_cBLANK_CARD;
  1298. m_nCardsTable[16] = 0;
  1299. return 1;
  1300. }
  1302. //双王加31
  1303. if( (m_nCardsTable[16] == 2) && 
  1304. ((m_nCardsCounter == 6) && (counter_3 == 1)) )
  1305. {
  1306. m_cDiscardingType.m_nTypeNum   = 4;
  1307. m_cDiscardingType.m_nTypeValue = 16;
  1309. m_nDiscardingCounter = 2;
  1310. m_cDiscarding[0]     = m_cCards[4];
  1311. m_cDiscarding[1]     = m_cCards[5];
  1313. m_cCards[4] = m_cBLANK_CARD;
  1314. m_cCards[5] = m_cBLANK_CARD;
  1316. m_nCardsTable[16] = 0;
  1317. return 1;
  1318. }
  1320. //双王加32
  1321. if( (m_nCardsTable[16] == 2) && 
  1322. ((m_nCardsCounter == 7) && (counter_3 == 1 && counter_2 == 1)) )
  1323. {
  1324. m_cDiscardingType.m_nTypeNum   = 4;
  1325. m_cDiscardingType.m_nTypeValue = 16;
  1327. m_nDiscardingCounter = 2;
  1328. m_cDiscarding[0]     = m_cCards[5];
  1329. m_cDiscarding[1]     = m_cCards[6];
  1331. m_cCards[5] = m_cBLANK_CARD;
  1332. m_cCards[6] = m_cBLANK_CARD;
  1334. m_nCardsTable[16] = 0;
  1335. return 1;
  1336. }
  1338. //双王加42
  1339. if( (m_nCardsTable[16] == 2) && 
  1340. ((m_nCardsCounter == 8) && (counter_4 == 1 && counter_1 == 2)) )
  1341. {
  1342. m_cDiscardingType.m_nTypeNum   = 4;
  1343. m_cDiscardingType.m_nTypeValue = 16;
  1345. m_nDiscardingCounter = 2;
  1346. m_cDiscarding[0]     = m_cCards[6];
  1347. m_cDiscarding[1]     = m_cCards[7];
  1349. m_cCards[6] = m_cBLANK_CARD;
  1350. m_cCards[7] = m_cBLANK_CARD;
  1352. m_nCardsTable[16] = 0;
  1353. return 1;
  1354. }
  1356. return 0;
  1357. }
  1358. //寻找单牌出;
  1359. int CPlayingCards::Search1(CCardsType& Cards_Type)
  1360. {
  1361. if( AI_Patch1() )
  1362. {
  1363. return 1;
  1364. }
  1366. int i,j;
  1367. int counter_0 = 0;
  1368. int counter_1 = 0;
  1369. int counter_2 = 0;
  1370. int counter_3 = 0;
  1371. int counter_4 = 0;
  1373. //扫描未出牌表;
  1374. for(i=3;i<15;i++)
  1375. {
  1376. switch(m_nCardsTable[i])
  1377. {
  1378. case 0:
  1379. counter_0++;
  1380. break;
  1381. case 1:
  1382. counter_1++;
  1383. break;
  1384. case 2:
  1385. counter_2++;
  1386. break;
  1387. case 3:
  1388. counter_3++;
  1389. break;
  1390. case 4:
  1391. counter_4++;
  1392. break;
  1393. }
  1394. }
  1395. //补丁:
  1396. if( Cards_Type.m_nTypeValue == 16 && counter_1 > 3 )
  1397. {
  1398. return 0;
  1399. }
  1401. if( m_nCardsTable[16] == 1 
  1402. && m_cCards[m_nCardsCounter - 1].m_nColor == 1 
  1403. && Cards_Type.m_nTypeValue == 16 )  //大王,可以出;
  1404. {
  1405. m_cDiscardingType.m_nTypeNum   = 1;
  1406. m_cDiscardingType.m_nTypeValue = 16;
  1408. m_nDiscardingCounter++;
  1409. m_cDiscarding[0] = m_cCards[m_nCardsCounter - 1];
  1411. m_cCards[m_nCardsCounter - 1] = m_cBLANK_CARD;
  1413. m_nCardsTable[16] = 0;
  1415. return 1;
  1416. }
  1418. //
  1419. for(i=Cards_Type.m_nTypeValue+1;i<=16;i++)
  1420. {
  1421. if( m_nCardsTable[i] == 1)
  1422. {
  1423. m_cDiscardingType.m_nTypeNum   = 1;
  1424. m_cDiscardingType.m_nTypeValue = i;
  1426. for(j=0;j<m_nCardsCounter;j++)
  1427. {
  1428. if( m_cCards[j].m_nValue == i )
  1429. {
  1430. m_nDiscardingCounter++;
  1431. m_cDiscarding[0] = m_cCards[j];
  1433. m_cCards[j] = m_cBLANK_CARD;
  1435. m_nCardsTable[i] = 0;
  1436. return 1;
  1437. }
  1438. }//end for~~
  1439. }//end if~
  1440. } //end for~
  1441. //撤两张的;
  1442. for(i=16;i>=Cards_Type.m_nTypeValue+1;i--)
  1443. {
  1444. if( m_nCardsTable[i] == 2 )
  1445. {
  1446. m_cDiscardingType.m_nTypeNum   = 1;
  1447. m_cDiscardingType.m_nTypeValue = i;
  1449. for(j=0;j<m_nCardsCounter;j++)
  1450. {
  1451. if( m_cCards[j].m_nValue == i )
  1452. {
  1453. m_nDiscardingCounter++;
  1454. m_cDiscarding[0] = m_cCards[j];
  1456. m_cCards[j] = m_cBLANK_CARD;
  1458. m_nCardsTable[i]--;  //应该等于1;
  1459. return 1;
  1460. }
  1461. }//end for~~
  1462. }//end if~
  1463. } //end for~
  1464. //撤三张的;
  1465. for(i=15;i>=Cards_Type.m_nTypeValue+1;i--)
  1466. {
  1467. if( m_nCardsTable[i] == 3 )
  1468. {
  1469. m_cDiscardingType.m_nTypeNum   = 1;
  1470. m_cDiscardingType.m_nTypeValue = i;
  1472. for(j=0;j<m_nCardsCounter;j++)
  1473. {
  1474. if( m_cCards[j].m_nValue == i )
  1475. {
  1476. m_nDiscardingCounter++;
  1477. m_cDiscarding[0] = m_cCards[j];
  1479. m_cCards[j] = m_cBLANK_CARD;
  1481. m_nCardsTable[i]--;  //应该等于1;
  1482. return 1;
  1483. }
  1484. }//end for~~
  1485. }//end if~
  1486. } //end for~
  1488. return 0;
  1489. }
  1490. //寻找对牌出;
  1491. int CPlayingCards::Search2(CCardsType& Cards_Type)
  1492. {
  1493. if( AI_Patch1() )
  1494. {
  1495. return 1;
  1496. }
  1498. int i,j;
  1499. for(i=Cards_Type.m_nTypeValue+1;i<16;i++)
  1500. {
  1501. if( m_nCardsTable[i] == 2 )
  1502. {
  1503. m_cDiscardingType.m_nTypeNum   = 2;
  1504. m_cDiscardingType.m_nTypeValue = i;
  1506. for(j=0;j<m_nCardsCounter;j++)
  1507. {
  1508. if( m_cCards[j].m_nValue == i )
  1509. {
  1510. m_nDiscardingCounter += 2;
  1511. m_cDiscarding[0] = m_cCards[j];
  1512. m_cDiscarding[1] = m_cCards[j + 1];
  1514. m_cCards[j] = m_cBLANK_CARD;
  1515. m_cCards[j + 1] = m_cBLANK_CARD;
  1517. m_nCardsTable[i] = 0;
  1518. return 1;
  1519. }
  1520. }//end for~~
  1521. }//end if~
  1522. } //end for~
  1523. //撤三张的;
  1524. if( Cards_Type.m_nTypeValue >= 12 )   //如果是比较大的牌,才考虑拆牌,而且2不会拆;
  1525. { 
  1526. for(i=14;i>=Cards_Type.m_nTypeValue+1;i--)
  1527. {
  1528. if( m_nCardsTable[i] == 3 )
  1529. {
  1530. m_cDiscardingType.m_nTypeNum   = 2;
  1531. m_cDiscardingType.m_nTypeValue = i;
  1533. for(j=0;j<m_nCardsCounter;j++)
  1534. {
  1535. if( m_cCards[j].m_nValue == i )
  1536. {
  1537. m_nDiscardingCounter += 2;
  1538. m_cDiscarding[0] = m_cCards[j];
  1539. m_cDiscarding[1] = m_cCards[j + 1];
  1541. m_cCards[j] = m_cBLANK_CARD;
  1542. m_cCards[j + 1] = m_cBLANK_CARD;
  1544. m_nCardsTable[i] -= 2;  //应该等于1;
  1545. return 1;
  1546. }
  1547. }//end for~~
  1548. }//end if~
  1549. } //end for~
  1550. }
  1551. return 0;
  1552. }
  1553. //寻找三牌出;
  1554. int CPlayingCards::Search3(CCardsType& Cards_Type)
  1555. {
  1556. if( AI_Patch1() )
  1557. {
  1558. return 1;
  1559. }
  1560. //三张;
  1561. int i,j;
  1562. for(i=Cards_Type.m_nTypeValue+1;i<16;i++)
  1563. {
  1564. if( m_nCardsTable[i] == 3)
  1565. {
  1566. m_cDiscardingType.m_nTypeNum   = 3;
  1567. m_cDiscardingType.m_nTypeValue = i;
  1569. for(j=0;j<m_nCardsCounter;j++)
  1570. {
  1571. if( m_cCards[j].m_nValue == i )
  1572. {
  1573. m_nDiscardingCounter += 3;
  1574. m_cDiscarding[0] = m_cCards[j];
  1575. m_cDiscarding[1] = m_cCards[j + 1];
  1576. m_cDiscarding[2] = m_cCards[j + 2];
  1578. m_cCards[j + 0] = m_cBLANK_CARD;
  1579. m_cCards[j + 1] = m_cBLANK_CARD;
  1580. m_cCards[j + 2] = m_cBLANK_CARD;
  1582. m_nCardsTable[i] = 0;
  1583. return 1;
  1584. }
  1585. }//end for~~
  1586. }//end if~
  1587. } //end for~
  1588. return 0;
  1589. }
  1590. //寻找炸弹出;
  1591. int CPlayingCards::SearchBomb(CCardsType& Cards_Type)
  1592. {
  1593. if( AI_Patch1() )
  1594. {
  1595. return 1;
  1596. }
  1597. //四张;
  1598. //注意加分!!!;
  1599. int i,j;
  1600. for(i=Cards_Type.m_nTypeValue+1;i<16;i++)
  1601. {
  1602. if( m_nCardsTable[i] == 4 )
  1603. {
  1604. m_cDiscardingType.m_nTypeNum   = 4;
  1605. m_cDiscardingType.m_nTypeValue = i;
  1607. for(j=0;j<m_nCardsCounter;j++)
  1608. {
  1609. if( m_cCards[j].m_nValue == i )
  1610. {
  1611. m_nDiscardingCounter += 4;
  1612. m_cDiscarding[0] = m_cCards[j];
  1613. m_cDiscarding[1] = m_cCards[j + 1];
  1614. m_cDiscarding[2] = m_cCards[j + 2];
  1615. m_cDiscarding[3] = m_cCards[j + 3];
  1617. m_cCards[j + 0] = m_cBLANK_CARD;
  1618. m_cCards[j + 1] = m_cBLANK_CARD;
  1619. m_cCards[j + 2] = m_cBLANK_CARD;
  1620. m_cCards[j + 3] = m_cBLANK_CARD;
  1622. m_nCardsTable[i] = 0;
  1623. return 1;
  1624. }
  1625. }//end for~~
  1626. }//end if~
  1627. } //end for~
  1628. return 0;
  1629. }
  1630. //寻找三带2出;
  1631. int CPlayingCards::Search31(CCardsType& Cards_Type)
  1632. {
  1633. if( AI_Patch1() )
  1634. {
  1635. return 1;
  1636. }
  1637. //三张;
  1638. int i,j,k;
  1639. //补丁
  1640. int nMax = 15;
  1641. if( m_nCardsCounter <= 5 )
  1642. {
  1643. nMax = 16;
  1644. }
  1646. for(i=Cards_Type.m_nTypeValue+1;i<nMax;i++)   //三张2一般不出;
  1647. {
  1648. if( m_nCardsTable[i] == 3 )
  1649. {
  1650. for(j=3;j<=15;j++)
  1651. {
  1652. if( m_nCardsTable[j] == 1 )
  1653. {
  1654. m_cDiscardingType.m_nTypeNum   = 31;
  1655. m_cDiscardingType.m_nTypeValue = i;
  1656. m_nDiscardingCounter = 4;
  1657. //三张的;
  1658. for(k=0;k<m_nCardsCounter;k++)
  1659. {
  1660. if( m_cCards[k].m_nValue == i )
  1661. {
  1662. m_cDiscarding[0] = m_cCards[k];
  1663. m_cDiscarding[1] = m_cCards[k + 1];
  1664. m_cDiscarding[2] = m_cCards[k + 2];
  1666. m_cCards[k + 0] = m_cBLANK_CARD;
  1667. m_cCards[k + 1] = m_cBLANK_CARD;
  1668. m_cCards[k + 2] = m_cBLANK_CARD;
  1670. m_nCardsTable[i] = 0;
  1671. }
  1672. }//end for~~
  1673. //单张的;
  1674. for(k=0;k<m_nCardsCounter;k++)
  1675. {
  1676. if( m_cCards[k].m_nValue == j )
  1677. {
  1678. m_cDiscarding[3] = m_cCards[k];
  1680. m_cCards[k] = m_cBLANK_CARD;
  1682. m_nCardsTable[j] = 0;
  1683. return 1;
  1684. }
  1685. }//end for~~
  1687. }//end if~
  1688. } //end for~
  1689. return 0;
  1690. }//end if~
  1691. } //end for~
  1692. return 0;
  1693. }
  1694. //寻找三带2出; 
  1695. int CPlayingCards::Search32(CCardsType& Cards_Type)
  1696. {
  1697. if( AI_Patch1() )
  1698. {
  1699. return 1;
  1700. }
  1701. //三张;
  1702. int i,j,k;
  1704. int nMax = 15;
  1705. if( m_nCardsCounter <= 6 )
  1706. {
  1707. nMax = 16;
  1708. }
  1710. for(i=Cards_Type.m_nTypeValue+1;i<nMax;i++)   //三张2一般不出;
  1711. {
  1712. if( m_nCardsTable[i] == 3 )
  1713. {
  1714. for(j=3; j<=14; j++)
  1715. {
  1716. if( m_nCardsTable[j] == 2 )
  1717. {
  1718. m_cDiscardingType.m_nTypeNum   = 32;
  1719. m_cDiscardingType.m_nTypeValue = i;
  1720. m_nDiscardingCounter = 5;
  1721. //三张的;
  1722. for(k=0;k<m_nCardsCounter;k++)
  1723. {
  1724. if( m_cCards[k].m_nValue == i )
  1725. {
  1726. m_cDiscarding[0] = m_cCards[k];
  1727. m_cDiscarding[1] = m_cCards[k + 1];
  1728. m_cDiscarding[2] = m_cCards[k + 2];
  1730. m_cCards[k + 0] = m_cBLANK_CARD;
  1731. m_cCards[k + 1] = m_cBLANK_CARD;
  1732. m_cCards[k + 2] = m_cBLANK_CARD;
  1734. m_nCardsTable[i] = 0;
  1735. }
  1736. }//end for~~
  1737. //单张的;
  1738. for(k=0; k<m_nCardsCounter; k++)
  1739. {
  1740. if( m_cCards[k].m_nValue == j )
  1741. {
  1742. m_cDiscarding[3] = m_cCards[k];
  1743. m_cDiscarding[4] = m_cCards[k + 1];
  1745. m_cCards[k + 0] = m_cBLANK_CARD;
  1746. m_cCards[k + 1] = m_cBLANK_CARD;
  1748. m_nCardsTable[j] = 0;
  1749. return 1;
  1750. }
  1751. }//end for~~
  1752. }//end if~
  1753. } //end for~
  1754. return 0;
  1755. }//end if~
  1756. } //end for~
  1757. return 0;
  1758. }
  1759. //寻找四带2单;
  1760. int CPlayingCards::Search411(CCardsType& Cards_Type)
  1761. {
  1762. if( AI_Patch1() )
  1763. {
  1764. return 1;
  1765. }
  1766. //四张;
  1767. int i,j,k,l;
  1769. for(i=Cards_Type.m_nTypeValue+1;i<16;i++)
  1770. {
  1771. if( m_nCardsTable[i] == 4)
  1772. {
  1773. for(j=3; j<=14; j++)
  1774. {
  1775. if( m_nCardsTable[j] == 1 )
  1776. {
  1777. //扫描第二张单牌;
  1778. for(k=j+1;k<=14;k++)
  1779. {
  1780. if( m_nCardsTable[k] == 1 )
  1781. {
  1782. m_cDiscardingType.m_nTypeNum   = 411;
  1783. m_cDiscardingType.m_nTypeValue = i;
  1784. m_nDiscardingCounter = 6;
  1786. for(l=0;l<m_nCardsCounter;l++)
  1787. {
  1788. if( m_cCards[l].m_nValue == i )
  1789. {
  1790. m_cDiscarding[0] = m_cCards[l];
  1791. m_cDiscarding[1] = m_cCards[l + 1];
  1792. m_cDiscarding[2] = m_cCards[l + 2];
  1793. m_cDiscarding[3] = m_cCards[l + 3];
  1795. m_cCards[l + 0] = m_cBLANK_CARD;
  1796. m_cCards[l + 1] = m_cBLANK_CARD;
  1797. m_cCards[l + 2] = m_cBLANK_CARD;
  1798. m_cCards[l + 3] = m_cBLANK_CARD;
  1800. m_nCardsTable[i] = 0;
  1801. }
  1802. }//end for~~
  1804. for(l=0;l<m_nCardsCounter;l++)
  1805. {
  1806. if( m_cCards[l].m_nValue == j )
  1807. {
  1808. m_cDiscarding[4] = m_cCards[l];
  1810. m_cCards[l] = m_cBLANK_CARD;
  1812. m_nCardsTable[j] = 0;
  1813. }
  1814. }//end for~~
  1816. for(l=0;l<m_nCardsCounter;l++)
  1817. {
  1818. if( m_cCards[l].m_nValue == k )
  1819. {
  1820. m_cDiscarding[5] = m_cCards[l];
  1822. m_cCards[l] = m_cBLANK_CARD;
  1824. m_nCardsTable[k] = 0;
  1825. }
  1826. }
  1827. return 1;
  1828. }//end if~
  1829. } //end for~
  1830. return 0;
  1831. }//end if~
  1832. } //end for~
  1833. return 0;
  1834. }
  1835. }
  1836. return 0;
  1837. }
  1838. //寻找四带两对;
  1839. int CPlayingCards::Search422(CCardsType& Cards_Type)
  1840. {
  1841. if( AI_Patch1() )
  1842. {
  1843. return 1;
  1844. }
  1845. //四张;
  1846. int i,j,k,l;
  1848. for(i=Cards_Type.m_nTypeValue+1;i<16;i++)
  1849. {
  1850. if( m_nCardsTable[i] == 4 )
  1851. {
  1852. for(j=3;j<=14;j++)
  1853. {
  1854. if( m_nCardsTable[j] == 2 )
  1855. {
  1856. //扫描第二张单牌;
  1857. for(k=j+1;k<=14;k++)
  1858. {
  1859. if( m_nCardsTable[k] == 2 )
  1860. {
  1861. m_cDiscardingType.m_nTypeNum   = 422;
  1862. m_cDiscardingType.m_nTypeValue = i;
  1863. m_nDiscardingCounter = 8;
  1865. for(l=0;l<m_nCardsCounter;l++)
  1866. {
  1867. if( m_cCards[l].m_nValue == i )
  1868. {
  1869. m_cDiscarding[0] = m_cCards[l];
  1870. m_cDiscarding[1] = m_cCards[l + 1];
  1871. m_cDiscarding[2] = m_cCards[l + 2];
  1872. m_cDiscarding[3] = m_cCards[l + 3];
  1874. m_cCards[l + 0] = m_cBLANK_CARD;
  1875. m_cCards[l + 1] = m_cBLANK_CARD;
  1876. m_cCards[l + 2] = m_cBLANK_CARD;
  1877. m_cCards[l + 3] = m_cBLANK_CARD;
  1879. m_nCardsTable[i] = 0;
  1880. }
  1881. }//end for~~
  1883. for(l=0;l<m_nCardsCounter;l++)
  1884. {
  1885. if( m_cCards[l].m_nValue == j )
  1886. {
  1887. m_cDiscarding[4] = m_cCards[l];
  1888. m_cDiscarding[5] = m_cCards[l + 1];
  1890. m_cCards[l + 0] = m_cBLANK_CARD;
  1891. m_cCards[l + 1] = m_cBLANK_CARD;
  1893. m_nCardsTable[j] = 0;
  1894. }
  1895. }//end for~~
  1897. for(l=0;l<m_nCardsCounter;l++)
  1898. {
  1899. if( m_cCards[l].m_nValue == k )
  1900. {
  1901. m_cDiscarding[6] = m_cCards[l];
  1902. m_cDiscarding[7] = m_cCards[l + 1];
  1904. m_cCards[l + 0] = m_cBLANK_CARD;
  1905. m_cCards[l + 1] = m_cBLANK_CARD;
  1907. m_nCardsTable[k] = 0;
  1908. }
  1909. }
  1910. return 1;
  1911. }//end if~
  1912. } //end for~
  1913. return 0;
  1914. }//end if~
  1915. } //end for~
  1916. return 0;
  1917. }
  1918. }
  1919. return 0;
  1920. }
  1921. //寻找三顺带两单;
  1922. int CPlayingCards::Search3311(CCardsType& Cards_Type)
  1923. {
  1924. if( AI_Patch1() )
  1925. {
  1926. return 1;
  1927. }
  1928. //三张;
  1929. int i,j,k,l;
  1930. for(i=Cards_Type.m_nTypeValue+1;i<14;i++)   //2一般不能出在顺子中;
  1931. {
  1932. if( m_nCardsTable[i] == 3 && m_nCardsTable[i + 1] == 3 )
  1933. {
  1934. for(j=3;j<=14;j++)
  1935. {
  1936. if( m_nCardsTable[j] == 1 )
  1937. {
  1938. //扫描第二张单牌;
  1939. for(k=j+1;k<=14;k++)
  1940. {
  1941. if( m_nCardsTable[k] == 1 )
  1942. {
  1943. m_cDiscardingType.m_nTypeNum   = 3311;
  1944. m_cDiscardingType.m_nTypeValue = i;
  1945. m_nDiscardingCounter = 8;
  1947. for(l=0;l<m_nCardsCounter;l++)
  1948. {
  1949. if( m_cCards[l].m_nValue == i )
  1950. {
  1951. m_cDiscarding[0] = m_cCards[l];
  1952. m_cDiscarding[1] = m_cCards[l + 1];
  1953. m_cDiscarding[2] = m_cCards[l + 2];
  1954. m_cDiscarding[3] = m_cCards[l + 3];
  1955. m_cDiscarding[4] = m_cCards[l + 4];
  1956. m_cDiscarding[5] = m_cCards[l + 5];
  1958. m_cCards[l + 0] = m_cBLANK_CARD;
  1959. m_cCards[l + 1] = m_cBLANK_CARD;
  1960. m_cCards[l + 2] = m_cBLANK_CARD;
  1961. m_cCards[l + 3] = m_cBLANK_CARD;
  1962. m_cCards[l + 4] = m_cBLANK_CARD;
  1963. m_cCards[l + 5] = m_cBLANK_CARD;
  1965. m_nCardsTable[i] = 0;
  1966. m_nCardsTable[i + 1] = 0;
  1967. }
  1968. }//end for~~
  1970. for(l=0;l<m_nCardsCounter;l++)
  1971. {
  1972. if( m_cCards[l].m_nValue == j )
  1973. {
  1974. m_cDiscarding[6] = m_cCards[l];
  1976. m_cCards[l + 0] = m_cBLANK_CARD;
  1978. m_nCardsTable[j] = 0;
  1979. }
  1980. }//end for~~
  1982. for(l=0;l<m_nCardsCounter;l++)
  1983. {
  1984. if( m_cCards[l].m_nValue == k )
  1985. {
  1986. m_cDiscarding[7] = m_cCards[l];
  1988. m_cCards[l + 0] = m_cBLANK_CARD;
  1990. m_nCardsTable[k] = 0;
  1991. }
  1992. }
  1993. return 1;
  1995. }//end if~
  1996. } //end for~
  1997. return 0;
  1998. }//end if~
  1999. }
  2000. return 0;
  2001. }
  2002. }
  2003. return 0;
  2004. }
  2005. //寻找三顺带两对;
  2006. int CPlayingCards::Search3322(CCardsType& Cards_Type)
  2007. {
  2008. if( AI_Patch1() )
  2009. {
  2010. return 1;
  2011. }
  2012. //三张;
  2013. int i,j,k,l;
  2014. for(i=Cards_Type.m_nTypeValue+1;i<14;i++)   //2一般不能出在顺子中;
  2015. {
  2016. if( m_nCardsTable[i] == 3 && m_nCardsTable[i + 1] == 3 )
  2017. {
  2018. for(j=3;j<=14;j++)
  2019. {
  2020. if( m_nCardsTable[j] == 2 )
  2021. {
  2022. //扫描第二张单牌;
  2023. for(k=j+1;k<=14;k++)
  2024. {
  2025. if( m_nCardsTable[k] == 2 )
  2026. {
  2027. m_cDiscardingType.m_nTypeNum   = 3322;
  2028. m_cDiscardingType.m_nTypeValue = i;
  2029. m_nDiscardingCounter = 10;
  2031. for(l=0;l<m_nCardsCounter;l++)
  2032. {
  2033. if( m_cCards[l].m_nValue == i )
  2034. {
  2035. m_cDiscarding[0] = m_cCards[l];
  2036. m_cDiscarding[1] = m_cCards[l + 1];
  2037. m_cDiscarding[2] = m_cCards[l + 2];
  2038. m_cDiscarding[3] = m_cCards[l + 3];
  2039. m_cDiscarding[4] = m_cCards[l + 4];
  2040. m_cDiscarding[5] = m_cCards[l + 5];
  2042. m_cCards[l + 0] = m_cBLANK_CARD;
  2043. m_cCards[l + 1] = m_cBLANK_CARD;
  2044. m_cCards[l + 2] = m_cBLANK_CARD;
  2045. m_cCards[l + 3] = m_cBLANK_CARD;
  2046. m_cCards[l + 4] = m_cBLANK_CARD;
  2047. m_cCards[l + 5] = m_cBLANK_CARD;
  2049. m_nCardsTable[i] = 0;
  2050. m_nCardsTable[i + 1] = 0;
  2051. }
  2052. }//end for~~
  2054. for(l=0;l<m_nCardsCounter;l++)
  2055. {
  2056. if( m_cCards[l].m_nValue == j )
  2057. {
  2058. m_cDiscarding[6] = m_cCards[l];
  2059. m_cDiscarding[7] = m_cCards[l + 1];
  2061. m_cCards[l + 0] = m_cBLANK_CARD;
  2062. m_cCards[l + 1] = m_cBLANK_CARD;
  2064. m_nCardsTable[j] = 0;
  2065. }
  2066. }//end for~~
  2068. for(l=0;l<m_nCardsCounter;l++)
  2069. {
  2070. if( m_cCards[l].m_nValue == k )
  2071. {
  2072. m_cDiscarding[8] = m_cCards[l];
  2073. m_cDiscarding[9] = m_cCards[l + 1];
  2075. m_cCards[l + 0] = m_cBLANK_CARD;
  2076. m_cCards[l + 1] = m_cBLANK_CARD;
  2078. m_nCardsTable[k] = 0;
  2079. }
  2080. }
  2081. return 1;
  2083. }//end if~
  2084. } //end for~
  2085. return 0;
  2086. }//end if~
  2087. }
  2088. return 0;
  2089. }
  2090. }
  2091. return 0;
  2092. }
  2094. //寻找双顺;
  2095. int CPlayingCards::Search222(CCardsType& Cards_Type)
  2096. {
  2097. if( AI_Patch1() )
  2098. {
  2099. return 1;
  2100. }
  2102. int i,j;
  2103. //如果大于J,Q,K,则不要;
  2104. if( Cards_Type.m_nTypeValue > 11 )
  2105. {
  2106. return 0;
  2107. }
  2109. for(i=Cards_Type.m_nTypeValue+1;i<=12;i++)
  2110. {
  2111. if( m_nCardsTable[i] == 2 )
  2112. {
  2113. if( m_nCardsTable[i + 1] == 2 && m_nCardsTable[i + 2] == 2 )
  2114. {
  2115. for(j=0;j<m_nCardsCounter;j++)
  2116. {
  2117. if( m_cCards[j].m_nValue == i )
  2118. {
  2119. m_cDiscardingType.m_nTypeNum   = 222;
  2120. m_cDiscardingType.m_nTypeValue = i;
  2122. m_nDiscardingCounter = 6;
  2124. for(int k=0;k<6;k++)
  2125. {
  2126. m_cDiscarding[k] = m_cCards[j + k];
  2127. m_cCards[j + k] = m_cBLANK_CARD;
  2128. }
  2129. m_nCardsTable[i] = 0;
  2130. m_nCardsTable[i + 1] = 0;
  2131. m_nCardsTable[i + 2] = 0;
  2132. return 1;
  2133. }
  2134. }//end for~~
  2135. }
  2136. }//end if;
  2137. }
  2138. return 0;
  2139. }
  2140. //寻找双顺;
  2141. int CPlayingCards::Search2222(CCardsType& Cards_Type)
  2142. {
  2143. if( AI_Patch1() )
  2144. {
  2145. return 1;
  2146. }
  2148. int i,j;
  2149. //如果大于J,Q,K,则不要;
  2150. if( Cards_Type.m_nTypeValue > 10 )
  2151. {
  2152. return 0;
  2153. }
  2155. for(i=Cards_Type.m_nTypeValue+1;i<=11;i++)
  2156. {
  2157. if( m_nCardsTable[i] == 2 )
  2158. {
  2159. if( m_nCardsTable[i + 1] == 2 && 
  2160. m_nCardsTable[i + 2] == 2 && 
  2161. m_nCardsTable[i + 3] == 2 )
  2162. {
  2163. for(j=0;j<m_nCardsCounter;j++)
  2164. {
  2165. if( m_cCards[j].m_nValue == i )
  2166. {
  2167. m_cDiscardingType.m_nTypeNum   = 2222;
  2168. m_cDiscardingType.m_nTypeValue = i;
  2170. m_nDiscardingCounter = 8;
  2172. for(int k=0;k<8;k++)
  2173. {
  2174. m_cDiscarding[k] = m_cCards[j + k];
  2175. m_cCards[j + k] = m_cBLANK_CARD;
  2176. }
  2177. m_nCardsTable[i] = 0;
  2178. m_nCardsTable[i + 1] = 0;
  2179. m_nCardsTable[i + 2] = 0;
  2180. m_nCardsTable[i + 3] = 0;
  2181. return 1;
  2182. }
  2183. }//end for~~
  2184. }
  2185. }//end if;
  2186. }
  2187. return 0;
  2188. }
  2189. //寻找5单顺出;
  2190. int CPlayingCards::Search5(CCardsType& Cards_Type)
  2191. {
  2192. if( AI_Patch1() )
  2193. {
  2194. return 1;
  2195. }
  2197. int i,j,k,l;
  2198. //连续单牌的个数;
  2199. int counter_1;
  2200. int counter_2;
  2201. int counter_3;
  2203. //如果是10,j,q,k,A,则考虑对手中牌的个数,如果太少就考虑寻找炸弹;
  2205. if( Cards_Type.m_nTypeValue >= 10 ) 
  2206. {
  2207. return 0;
  2208. }
  2209. //第一遍扫描,看是否有全单的单顺;
  2211. for(i=Cards_Type.m_nTypeValue+1;i<=10;i++)
  2212. {
  2213.     counter_1 = 0;
  2214. for(j=i;j<i+5;j++)
  2215. {
  2216. if( m_nCardsTable[j] != 1 )
  2217. {
  2218. break;
  2219. }
  2220. else
  2221. {
  2222. counter_1++;
  2223. }
  2224. }
  2225. //看连续牌数是否等于5;
  2226. if( counter_1 == 5 )
  2227. {
  2228. //其他相关判断;
  2229. //出牌处理;
  2230. m_cDiscardingType.m_nTypeNum   = 5;
  2231. m_cDiscardingType.m_nTypeValue = i;
  2233. m_nDiscardingCounter = 5;
  2235. for(k=0;k<m_nCardsCounter;k++)
  2236. {
  2237. if( m_cCards[k].m_nValue == i )
  2238. {
  2239. for(l=0;l<5;l++)
  2240. {
  2241. m_cDiscarding[l] = m_cCards[k + l];
  2243. m_cCards[k + l] = m_cBLANK_CARD;
  2245. m_nCardsTable[i + l] = 0;
  2246. }
  2247. }
  2248. }
  2249. return 1; //搞定,返回;
  2250. }
  2252. //第二遍扫描;
  2253.     counter_1 = 0;
  2254. counter_2 = 0;
  2255. counter_3 = 0;
  2257. for(j=i;j<i+5;j++)
  2258. {
  2259. if( m_nCardsTable[j] == 1 )
  2260. {
  2261. counter_1++;
  2262. }
  2263. else if( m_nCardsTable[j] == 2 )
  2264. {
  2265. counter_2++;
  2266. }
  2267. else if( m_nCardsTable[j] == 3 )
  2268. {
  2269. counter_3++;
  2270. }
  2271. else
  2272. {
  2273. break;  //如果没有牌或者是四张(炸弹),则不考虑;
  2274. }
  2275. }
  2276. //看牌是否等于5;
  2277. if( counter_1 == 4 && counter_2 + counter_3 == 1 )
  2278. {
  2279. //其他相关判断;
  2280. //出牌处理;
  2281. m_cDiscardingType.m_nTypeNum   = 5;
  2282. m_cDiscardingType.m_nTypeValue = i;
  2284. m_nDiscardingCounter = 5;
  2286. for(k=0;k<m_nCardsCounter;k++)
  2287. {
  2288. if( m_cCards[k].m_nValue == i )
  2289. {
  2290. for(l=0;l<5;l++)
  2291. {
  2292. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2293. {
  2294. k++;
  2295. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2296. {
  2297. k++;
  2298. }
  2299. }
  2301. m_cDiscarding[l] = m_cCards[k + l];
  2302. m_cCards[k + l] = m_cBLANK_CARD;
  2304. m_nCardsTable[i + l]--;
  2305. }
  2306. }
  2307. }
  2308. return 1; //搞定,返回;
  2309. }
  2310. }//end for~;
  2311. return 0;
  2312. }
  2313. //寻找6单顺出;
  2314. int CPlayingCards::Search6(CCardsType& Cards_Type)
  2315. {
  2316. if( AI_Patch1() )
  2317. {
  2318. return 1;
  2319. }
  2321. int i,j,k,l;
  2322. //连续单牌的个数;
  2323. int counter_1;
  2324. int counter_2;
  2325. int counter_3;
  2327. //如果是10,j,q,k,A,则考虑对手中牌的个数,如果太少就考虑寻找炸弹;
  2329. if( Cards_Type.m_nTypeValue >= 9 ) 
  2330. {
  2331. return 0;
  2332. }
  2334. for(i=Cards_Type.m_nTypeValue+1;i<=9;i++)
  2335. {
  2336. //第一遍扫描,看是否有全单的单顺;
  2337.     counter_1 = 0;
  2338. for(j=i;j<i+6;j++)
  2339. {
  2340. if( m_nCardsTable[j] != 1 )
  2341. {
  2342. break;
  2343. }
  2344. else
  2345. {
  2346. counter_1++;
  2347. }
  2348. }
  2349. //看连续牌数是否等于6;
  2350. if( counter_1 == 6 )
  2351. {
  2352. //其他相关判断;
  2353. //出牌处理;
  2354. m_cDiscardingType.m_nTypeNum   = 6;
  2355. m_cDiscardingType.m_nTypeValue = i;
  2357. m_nDiscardingCounter = 6;
  2359. for(k=0;k<m_nCardsCounter;k++)
  2360. {
  2361. if( m_cCards[k].m_nValue == i )
  2362. {
  2363. for(l=0;l<6;l++)
  2364. {
  2365. m_cDiscarding[l] = m_cCards[k + l];
  2367. m_cCards[k + l] = m_cBLANK_CARD;
  2369. m_nCardsTable[i + l] = 0;
  2370. }
  2371. }
  2372. }
  2373. return 1; //搞定,返回;
  2374. }
  2376. //第二遍扫描;
  2377.     counter_1 = 0;
  2378. counter_2 = 0;
  2379. counter_3 = 0;
  2381. for(j=i;j<i+6;j++)
  2382. {
  2383. if( m_nCardsTable[j] == 1 )
  2384. {
  2385. counter_1++;
  2386. }
  2387. else if( m_nCardsTable[j] == 2 )
  2388. {
  2389. counter_2++;
  2390. }
  2391. else if( m_nCardsTable[j] == 3 )
  2392. {
  2393. counter_3++;
  2394. }
  2395. else
  2396. {
  2397. break;  //如果没有牌或者是四张(炸弹),则不考虑;
  2398. }
  2399. }
  2400. //看牌是否等于5;
  2401. if( counter_1 == 4 && counter_2 + counter_3 == 2 ||
  2402. counter_1 == 5 && counter_2 + counter_3 == 1 )
  2403. {
  2404. //其他相关判断;
  2405. //出牌处理;
  2406. m_cDiscardingType.m_nTypeNum   = 6;
  2407. m_cDiscardingType.m_nTypeValue = i;
  2409. m_nDiscardingCounter = 6;
  2411. for(k=0;k<m_nCardsCounter;k++)
  2412. {
  2413. if( m_cCards[k].m_nValue == i )
  2414. {
  2415. for(l=0;l<6;l++)
  2416. {
  2417. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2418. {
  2419. k++;
  2420. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2421. {
  2422. k++;
  2423. }
  2424. }
  2426. m_cDiscarding[l] = m_cCards[k + l];
  2427. m_cCards[k + l]  = m_cBLANK_CARD;
  2429. m_nCardsTable[i + l]--;
  2430. }
  2431. }
  2432. }
  2433. return 1; //搞定,返回;
  2434. }
  2435. }//end for~;
  2436. return 0;
  2437. }
  2438. //寻找7单顺出;
  2439. int CPlayingCards::Search7(CCardsType& Cards_Type)
  2440. {
  2441. if( AI_Patch1() )
  2442. {
  2443. return 1;
  2444. }
  2445. int i,j,k,l;
  2446. //连续单牌的个数;
  2447. int counter_1;
  2448. int counter_2;
  2449. int counter_3;
  2451. //如果是10,j,q,k,A,则考虑对手中牌的个数,如果太少就考虑寻找炸弹;
  2453. if( Cards_Type.m_nTypeValue >= 8 ) 
  2454. {
  2455. return 0;
  2456. }
  2458. for(i=Cards_Type.m_nTypeValue+1;i<=8;i++)
  2459. {
  2460. //第一遍扫描,看是否有全单的单顺;
  2461.     counter_1 = 0;
  2462. for(j=i;j<i+7;j++)
  2463. {
  2464. if( m_nCardsTable[j] != 1 )
  2465. {
  2466. break;
  2467. }
  2468. else
  2469. {
  2470. counter_1++;
  2471. }
  2472. }
  2473. //看连续牌数是否等于7;
  2474. if( counter_1 == 7 )
  2475. {
  2476. //其他相关判断;
  2477. //出牌处理;
  2478. m_cDiscardingType.m_nTypeNum   = 7;
  2479. m_cDiscardingType.m_nTypeValue = i;
  2481. m_nDiscardingCounter = 7;
  2483. for(k=0;k<m_nCardsCounter;k++)
  2484. {
  2485. if( m_cCards[k].m_nValue == i )
  2486. {
  2487. for(l=0;l<7;l++)
  2488. {
  2489. m_cDiscarding[l] = m_cCards[k + l];
  2491. m_cCards[k + l] = m_cBLANK_CARD;
  2493. m_nCardsTable[i + l] = 0;
  2494. }
  2495. }
  2496. }
  2497. return 1; //搞定,返回;
  2498. }
  2500. //第二遍扫描;
  2501.     counter_1 = 0;
  2502. counter_2 = 0;
  2503. counter_3 = 0;
  2505. for(j=i;j<i+7;j++)
  2506. {
  2507. if( m_nCardsTable[j] == 1 )
  2508. {
  2509. counter_1++;
  2510. }
  2511. else if( m_nCardsTable[j] == 2 )
  2512. {
  2513. counter_2++;
  2514. }
  2515. else if( m_nCardsTable[j] == 3 )
  2516. {
  2517. counter_3++;
  2518. }
  2519. else
  2520. {
  2521. break;  //如果没有牌或者是四张(炸弹),则不考虑;
  2522. }
  2523. }
  2524. //看连续牌数是否等于7;
  2525. if( counter_1 == 4 && counter_2 + counter_3 == 3 ||
  2526. counter_1 == 5 && counter_2 + counter_3 == 2 ||
  2527. counter_1 == 6 && counter_2 + counter_3 == 1 )
  2528. {
  2529. //其他相关判断;
  2530. //出牌处理;
  2531. m_cDiscardingType.m_nTypeNum   = 7;
  2532. m_cDiscardingType.m_nTypeValue = i;
  2534. m_nDiscardingCounter = 7;
  2536. for(k=0;k<m_nCardsCounter;k++)
  2537. {
  2538. if( m_cCards[k].m_nValue == i )
  2539. {
  2540. for(l=0;l<7;l++)
  2541. {
  2542. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2543. {
  2544. k++;
  2545. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2546. {
  2547. k++;
  2548. }
  2549. }
  2551. m_cDiscarding[l] = m_cCards[k + l];
  2552. m_cCards[k + l] = m_cBLANK_CARD;
  2554. m_nCardsTable[i + l]--;
  2555. }
  2556. }
  2557. }
  2558. return 1; //搞定,返回;
  2559. }
  2560. }//end for~;
  2561. return 0;
  2562. }
  2563. //寻找8单顺出;
  2564. int CPlayingCards::Search8(CCardsType& Cards_Type)
  2565. {
  2566. if( AI_Patch1() )
  2567. {
  2568. return 1;
  2569. }
  2570. int i,j,k,l;
  2571. //连续单牌的个数;
  2572. int counter_1;
  2573. int counter_2;
  2574. int counter_3;
  2576. //如果是10,j,q,k,A,则考虑对手中牌的个数,如果太少就考虑寻找炸弹;
  2578. if( Cards_Type.m_nTypeValue >= 7 ) 
  2579. {
  2580. return 0;
  2581. }
  2583. for(i=Cards_Type.m_nTypeValue+1;i<=7;i++)
  2584. {
  2585. //第一遍扫描,看是否有全单的单顺;
  2586.     counter_1 = 0;
  2587. for(j=i;j<i+8;j++)
  2588. {
  2589. if( m_nCardsTable[j] != 1 )
  2590. {
  2591. break;
  2592. }
  2593. else
  2594. {
  2595. counter_1++;
  2596. }
  2597. }
  2598. //看连续牌数是否等于8;
  2599. if( counter_1 == 8 )
  2600. {
  2601. //其他相关判断;
  2602. //出牌处理;
  2603. m_cDiscardingType.m_nTypeNum   = 8;
  2604. m_cDiscardingType.m_nTypeValue = i;
  2606. m_nDiscardingCounter = 8;
  2608. for(k=0;k<m_nCardsCounter;k++)
  2609. {
  2610. if( m_cCards[k].m_nValue == i )
  2611. {
  2612. for(l=0;l<8;l++)
  2613. {
  2614. m_cDiscarding[l] = m_cCards[k + l];
  2616. m_cCards[k + l] = m_cBLANK_CARD;
  2618. m_nCardsTable[i + l] = 0;
  2619. }
  2620. }
  2621. }
  2622. return 1; //搞定,返回;
  2623. }
  2625. //第二遍扫描;
  2626.     counter_1 = 0;
  2627. counter_2 = 0;
  2628. counter_3 = 0;
  2630. for(j=i;j<i+8;j++)
  2631. {
  2632. if( m_nCardsTable[j] == 1 )
  2633. {
  2634. counter_1++;
  2635. }
  2636. else if( m_nCardsTable[j] == 2 )
  2637. {
  2638. counter_2++;
  2639. }
  2640. else if( m_nCardsTable[j] == 3 )
  2641. {
  2642. counter_3++;
  2643. }
  2644. else
  2645. {
  2646. break;  //如果没有牌或者是四张(炸弹),则不考虑;
  2647. }
  2648. }
  2649. //看连续牌数是否等于8;
  2650. if( counter_1 == 5 && counter_2 + counter_3 == 3 ||
  2651. counter_1 == 6 && counter_2 + counter_3 == 2 ||
  2652. counter_1 == 7 && counter_2 + counter_3 == 1 )
  2653. {
  2654. //其他相关判断;
  2655. //出牌处理;
  2656. m_cDiscardingType.m_nTypeNum   = 8;
  2657. m_cDiscardingType.m_nTypeValue = i;
  2659. m_nDiscardingCounter = 8;
  2661. for(k=0;k<m_nCardsCounter;k++)
  2662. {
  2663. if( m_cCards[k].m_nValue == i )
  2664. {
  2665. for(l=0;l<8;l++)
  2666. {
  2667. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2668. {
  2669. k++;
  2670. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2671. {
  2672. k++;
  2673. }
  2674. }
  2676. m_cDiscarding[l] = m_cCards[k + l];
  2677. m_cCards[k + l] = m_cBLANK_CARD;
  2679. m_nCardsTable[i + l]--;
  2680. }
  2681. }
  2682. }
  2683. return 1; //搞定,返回;
  2684. }
  2685. }//end for~;
  2686. return 0;
  2687. }
  2688. //寻找9单顺出;
  2689. int CPlayingCards::Search9(CCardsType& Cards_Type)
  2690. {
  2691. if( AI_Patch1() )
  2692. {
  2693. return 1;
  2694. }
  2695. int i,j,k,l;
  2696. //连续单牌的个数;
  2697. int counter_1;
  2698. int counter_2;
  2699. int counter_3;
  2701. //如果是10,j,q,k,A,则考虑对手中牌的个数,如果太少就考虑寻找炸弹;
  2703. if( Cards_Type.m_nTypeValue >= 6 ) 
  2704. {
  2705. return 0;
  2706. }
  2708. for(i=Cards_Type.m_nTypeValue+1;i<=6;i++)
  2709. {
  2710. //第一遍扫描,看是否有全单的单顺;
  2711.     counter_1 = 0;
  2712. for(j=i;j<i+9;j++)
  2713. {
  2714. if( m_nCardsTable[j] != 1 )
  2715. {
  2716. break;
  2717. }
  2718. else
  2719. {
  2720. counter_1++;
  2721. }
  2722. }
  2723. //看连续牌数是否等于9;
  2724. if( counter_1 == 9 )
  2725. {
  2726. //其他相关判断;
  2727. //出牌处理;
  2728. m_cDiscardingType.m_nTypeNum   = 9;
  2729. m_cDiscardingType.m_nTypeValue = i;
  2731. m_nDiscardingCounter = 9;
  2733. for(k=0;k<m_nCardsCounter;k++)
  2734. {
  2735. if( m_cCards[k].m_nValue == i )
  2736. {
  2737. for(l=0;l<9;l++)
  2738. {
  2739. m_cDiscarding[l] = m_cCards[k + l];
  2741. m_cCards[k + l] = m_cBLANK_CARD;
  2743. m_nCardsTable[i + l] = 0;
  2744. }
  2745. }
  2746. }
  2747. return 1; //搞定,返回;
  2748. }
  2750. //第二遍扫描;
  2751.     counter_1 = 0;
  2752. counter_2 = 0;
  2753. counter_3 = 0;
  2755. for(j=i;j<i+9;j++)
  2756. {
  2757. if( m_nCardsTable[j] == 1 )
  2758. {
  2759. counter_1++;
  2760. }
  2761. else if( m_nCardsTable[j] == 2 )
  2762. {
  2763. counter_2++;
  2764. }
  2765. else if( m_nCardsTable[j] == 3 )
  2766. {
  2767. counter_3++;
  2768. }
  2769. else
  2770. {
  2771. break;  //如果没有牌或者是四张(炸弹),则不考虑;
  2772. }
  2773. }
  2774. //看连续牌数是否等于8;
  2775. if( counter_1 == 6 && counter_2 + counter_3 == 3 ||
  2776. counter_1 == 7 && counter_2 + counter_3 == 2 ||
  2777. counter_1 == 8 && counter_2 + counter_3 == 1 )
  2778. {
  2779. //其他相关判断;
  2780. //出牌处理;
  2781. m_cDiscardingType.m_nTypeNum   = 9;
  2782. m_cDiscardingType.m_nTypeValue = i;
  2784. m_nDiscardingCounter = 9;
  2786. for(k=0;k<m_nCardsCounter;k++)
  2787. {
  2788. if( m_cCards[k].m_nValue == i )
  2789. {
  2790. for(l=0;l<9;l++)
  2791. {
  2792. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2793. {
  2794. k++;
  2795. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2796. {
  2797. k++;
  2798. }
  2799. }
  2801. m_cDiscarding[l] = m_cCards[k + l];
  2802. m_cCards[k + l] = m_cBLANK_CARD;
  2804. m_nCardsTable[i + l]--;
  2805. }
  2806. }
  2807. }
  2808. return 1; //搞定,返回;
  2809. }
  2810. }//end for~;
  2811. return 0;
  2812. }
  2813. //寻找10单顺出;
  2814. int CPlayingCards::SearchBeyond10(CCardsType& Cards_Type,int Long)
  2815. {
  2816. if( AI_Patch1() )
  2817. {
  2818. return 1;
  2819. }
  2820. int i,j,k,l;
  2821. //连续单牌的个数;
  2822. int counter_1;
  2823. int counter_2;
  2824. int counter_3;
  2826. //如果是10,j,q,k,A,则考虑对手中牌的个数,如果太少就考虑寻找炸弹;
  2827. // CString str;
  2828. // str.Format("Cards_Type.m_nTypeNum = %dnCards_Type.m_nTypeValue = %dn",
  2829. // Cards_Type.m_nTypeNum,Cards_Type.m_nTypeValue);
  2830. // AfxMessageBox(str);
  2832. if( Cards_Type.m_nTypeValue > 14 - Long ) 
  2833. {
  2835. return 0;
  2836. }
  2838. for(i=Cards_Type.m_nTypeValue+1;i<=14-Long+1;i++)
  2839. {
  2840. //第一遍扫描,看是否有全单的单顺;
  2841.     counter_1 = 0;
  2842. for(j=i;j<i+Long;j++)
  2843. {
  2844. if( m_nCardsTable[j] != 1 )
  2845. {
  2846. break;
  2847. }
  2848. else
  2849. {
  2850. counter_1++;
  2851. }
  2852. }
  2853. //看连续牌数是否等于Long;
  2854. if( counter_1 == Long )
  2855. {
  2856. //其他相关判断;
  2857. //出牌处理;
  2858. m_cDiscardingType.m_nTypeNum   = Long;
  2859. m_cDiscardingType.m_nTypeValue = i;
  2861. m_nDiscardingCounter = Long;
  2863. for(k=0;k<m_nCardsCounter;k++)
  2864. {
  2865. if( m_cCards[k].m_nValue == i )
  2866. {
  2867. for(l=0;l<Long;l++)
  2868. {
  2869. m_cDiscarding[l] = m_cCards[k + l];
  2871. m_cCards[k + l] = m_cBLANK_CARD;
  2873. m_nCardsTable[i + l] = 0;
  2874. }
  2875. }
  2876. }
  2877. return 1; //搞定,返回;
  2878. }
  2880. //第二遍扫描;
  2881.     counter_1 = 0;
  2882. counter_2 = 0;
  2883. counter_3 = 0;
  2885. for(j=i;j<i+Long;j++)
  2886. {
  2887. if( m_nCardsTable[j] == 1 )
  2888. {
  2889. counter_1++;
  2890. }
  2891. else if( m_nCardsTable[j] == 2 )
  2892. {
  2893. counter_2++;
  2894. }
  2895. else if( m_nCardsTable[j] == 3 )
  2896. {
  2897. counter_3++;
  2898. }
  2899. else
  2900. {
  2901. break;  //如果没有牌或者是四张(炸弹),则不考虑;
  2902. }
  2903. }
  2904. //看连续牌数是否等于8;
  2905. if( counter_1 == Long-4 && counter_2 + counter_3 == 4 ||
  2906. counter_1 == Long-3 && counter_2 + counter_3 == 3 ||
  2907. counter_1 == Long-2 && counter_2 + counter_3 == 2 ||
  2908. counter_1 == Long-1 && counter_2 + counter_3 == 1 )
  2909. {
  2910. //其他相关判断;
  2911. //出牌处理;
  2912. m_cDiscardingType.m_nTypeNum   = Long;
  2913. m_cDiscardingType.m_nTypeValue = i;
  2915. m_nDiscardingCounter = Long;
  2917. for(k=0;k<m_nCardsCounter;k++)
  2918. {
  2919. if( m_cCards[k].m_nValue == i )
  2920. {
  2921. for(l=0;l<Long;l++)
  2922. {
  2923. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2924. {
  2925. k++;
  2926. if( m_cCards[k + l].m_nValue == m_cCards[k + l + 1].m_nValue )
  2927. {
  2928. k++;
  2929. }
  2930. }
  2932. m_cDiscarding[l] = m_cCards[k + l];
  2933. m_cCards[k + l] = m_cBLANK_CARD;
  2935. m_nCardsTable[i + l]--;
  2936. }
  2937. }
  2938. }
  2939. return 1; //搞定,返回;
  2940. }
  2941. }//end for~;
  2942. return 0;
  2943. }
  2944. //比较大小后决定不要或者出牌; 
  2945. int CPlayingCards::CompareChoose(CCardsType& Cards_Type)
  2946. {
  2947. // CString str;
  2948. // str.Format("Cards_Type.m_nTypeNum = %dnCards_Type.m_nTypeValue = %dn",
  2949. // Cards_Type.m_nTypeNum,Cards_Type.m_nTypeValue);
  2950. // AfxMessageBox(str);
  2951. // Sleep(1000);
  2953. switch( Cards_Type.m_nTypeNum )
  2954. {
  2955. //选择一个单牌;
  2956. case 1:
  2957. if( Search1(Cards_Type) )
  2958. {
  2959. return 1;
  2960. }
  2961. else
  2962. {
  2963. return 0;
  2964. }
  2965. case 2:
  2966. if( Search2(Cards_Type) )
  2967. {
  2968. return 1;
  2969. }
  2970. else
  2971. {
  2972. return 0;
  2973. }
  2974. case 3:
  2975. if( Search3(Cards_Type) )
  2976. {
  2977. return 1;
  2978. }
  2979. else
  2980. {
  2981. return 0;
  2982. }
  2983. case 4:
  2984. if( SearchBomb(Cards_Type) )
  2985. {
  2986. return 1;
  2987. }
  2988. else
  2989. {
  2990. return 0;
  2991. }
  2992. case 31:
  2993. if( Search31(Cards_Type) )
  2994. {
  2995. return 1;
  2996. }
  2997. else
  2998. {
  2999. return 0;
  3000. }
  3001. case 32:
  3002. if( Search32(Cards_Type) )
  3003. {
  3004. return 1;
  3005. }
  3006. else
  3007. {
  3008. return 0;
  3009. }
  3010. case 411:
  3011. if( Search411(Cards_Type) )
  3012. {
  3013. return 1;
  3014. }
  3015. else
  3016. {
  3017. return 0;
  3018. }
  3019. case 422:
  3020. if( Search422(Cards_Type) )
  3021. {
  3022. return 1;
  3023. }
  3024. else
  3025. {
  3026. return 0;
  3027. }
  3028. case 3311:
  3029. if( Search3311(Cards_Type) )
  3030. {
  3031. return 1;
  3032. }
  3033. else
  3034. {
  3035. return 0;
  3036. }
  3037. case 3322:
  3038. if( Search3322(Cards_Type) )
  3039. {
  3040. return 1;
  3041. }
  3042. else
  3043. {
  3044. return 0;
  3045. }
  3046. case 5:
  3047. if( Search5(Cards_Type) )
  3048. {
  3049. return 1;
  3050. }
  3051. else
  3052. {
  3053. return 0;
  3054. }
  3055. case 6:
  3056. if( Search6(Cards_Type) )
  3057. {
  3058. return 1;
  3059. }
  3060. else
  3061. {
  3062. return 0;
  3063. }
  3064. case 7:
  3065. if( Search7(Cards_Type) )
  3066. {
  3067. return 1;
  3068. }
  3069. else
  3070. {
  3071. return 0;
  3072. }
  3073. case 8:
  3074. if( Search8(Cards_Type) )
  3075. {
  3076. return 1;
  3077. }
  3078. else
  3079. {
  3080. return 0;
  3081. }
  3082. case 9:
  3083. if( Search9(Cards_Type) )
  3084. {
  3085. return 1;
  3086. }
  3087. else
  3088. {
  3089. return 0;
  3090. }
  3091. case 10:
  3092. if( SearchBeyond10(Cards_Type,10) )
  3093. {
  3094. return 1;
  3095. }
  3096. else
  3097. {
  3098. return 0;
  3099. }
  3100. case 11:
  3101. if( SearchBeyond10(Cards_Type,11) )
  3102. {
  3103. return 1;
  3104. }
  3105. else
  3106. {
  3107. return 0;
  3108. }
  3109. case 12:
  3110. if( SearchBeyond10(Cards_Type,12) )
  3111. {
  3113. return 1;
  3114. }
  3115. else
  3116. {
  3117. return 0;
  3118. }
  3119. case 222:
  3120. if( Search222(Cards_Type) )
  3121. {
  3122. return 1;
  3123. }
  3124. else
  3125. {
  3126. return 0;
  3127. }
  3128. case 2222:
  3129. if( Search2222(Cards_Type) )
  3130. {
  3131. return 1;
  3132. }
  3133. else
  3134. {
  3135. return 0;
  3136. }
  3137. }
  3138. return 0;
  3139. }
  3141. //计算牌值;
  3142. int CPlayingCards::AccountCardsValue()
  3143. {
  3144. int Cards_Value = 0;
  3146. switch( m_nCardsTable[16] )
  3147. {
  3148. case 1:
  3149. if( m_cCards[16].m_nColor == 0 ) //大王;
  3150. {
  3151. Cards_Value += 80;
  3152. }
  3153. else
  3154. {
  3155. Cards_Value += 40;
  3156. }
  3157. break;
  3158. case 2:
  3159. Cards_Value += 200;
  3160. break;
  3161. }
  3163. switch( m_nCardsTable[15] )
  3164. {
  3165. case 1:
  3166. Cards_Value += 20;
  3167. break;
  3168. case 2:
  3169. Cards_Value += 40;
  3170. break;
  3171. case 3:
  3172. Cards_Value += 60;
  3173. break;
  3174. case 4:
  3175. Cards_Value += 200;
  3176. break;
  3177. }
  3179. switch( m_nCardsTable[14] )
  3180. {
  3181. case 1:
  3182. Cards_Value += 5;
  3183. break;
  3184. case 2:
  3185. Cards_Value += 10;
  3186. break;
  3187. case 3:
  3188. Cards_Value += 30;
  3189. break;
  3190. case 4:
  3191. Cards_Value += 150;
  3192. break;
  3193. }
  3195. for( int i=3;i<14;i++)
  3196. {
  3197. if( m_nCardsTable[i] == 4 )
  3198. {
  3199. Cards_Value += 100 + i*5;
  3200. }
  3201. }
  3203. return Cards_Value;
  3204. }
  3206. void CPlayingCards::ScanToTable()
  3207. {
  3208. //把两个电脑玩家的牌扫描进表中;
  3209. for(int i=3;i<17;i++)
  3210. {
  3211. m_nCardsTable[i] = 0;
  3212. }
  3213. for(i=0;i<m_nCardsCounter;i++)
  3214. m_nCardsTable[m_cCards[i].m_nValue]++;
  3215. }