zhaobu
/
zhujimajiang_redis
1
0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
诸暨麻将添加redis
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
2 Incheckningar
2 Grenar
57 MiB
 
 
 
 
 
 
Träd: 86964399f5
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '86964399f5'
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/机器人服务/AndroidAI.cpp

803 rader
17 KiB
Rå Blame Historik 

  1. #include "StdAfx.h"

  2. #include ".\androidai.h"

  3. 

  4. 

  5. /////////////////////////////////////////////////////////////////////////////////////

  6. //CAndroidAIBase

  7. 

  8. CAndroidAIBase::CAndroidAIBase()

  9. {

  10. 	memset(m_byCardData,0xff,sizeof(m_byCardData));

  11. }

  12. 

  13. CAndroidAIBase::~CAndroidAIBase()

  14. {

  15. }

  16. 

  17. //设置牌

  18. void CAndroidAIBase::SetCardData( const BYTE cbCardData[],BYTE byCardCount, tagWeaveItem wi[MAX_WEAVE], BYTE cbWeaveCount )

  19. {

  20. 	//复制牌

  21. 	CopyMemory(m_byCardData,cbCardData,sizeof(BYTE)*byCardCount);

  22. 	m_byCardCount = byCardCount;

  23. 

  24. 	//初始化

  25. 	ZeroMemory(m_bSelect,sizeof(m_bSelect));

  26. 

  27. 	//

  28. 	ZeroMemory(m_byThreeCard,sizeof(m_byThreeCard));

  29. 	m_byThreeCount = 0;

  30. 	ZeroMemory(m_byGoodThreeCard,sizeof(m_byGoodThreeCard));

  31. 	m_byGoodThreeCount = 0;

  32. 

  33. 	//

  34. 	ZeroMemory(m_byTwoCard,sizeof(m_byTwoCard));

  35. 	m_byTwoCount = 0;

  36. 	ZeroMemory(m_byGoodTwoCard,sizeof(m_byGoodTwoCard));

  37. 	m_byGoodTwoCount = 0;

  38. 

  39. 	//

  40. 	ZeroMemory(m_byRemainThree,sizeof(m_byRemainThree));

  41. 	m_byRemainThreeCount = 0;

  42. 	ZeroMemory(m_byRemainTwo,sizeof(m_byRemainTwo));

  43. 	m_byRemainTwoCount = 0;

  44. 

  45. 	//

  46. 	m_nMaxScoreThree = m_nMaxScoreTwo = 0;

  47. 	m_nActionScore = 0;

  48. 	m_nScoreThree = m_nScoreTwo = 0;

  49. 

  50. 	//

  51. 	m_bHaveJiang = false;

  52. 

  53. 	//

  54. 	m_byBadlyCard = 0xff;

  55. 

  56. 	//胡牌限制条件

  57. 	m_cbColorCount = 0;

  58. 	ZeroMemory( m_cbColor,sizeof(m_cbColor) );

  59. 	m_cbMinColorCount = MAX_COUNT;

  60. 

  61. 	//搜索花色

  62. 	for( BYTE i = 0; i < byCardCount; i++ )

  63. 	{

  64. 		m_cbColor[(cbCardData[i]/9)]++;

  65. 	}

  66. 	for( BYTE i = 0; i < cbWeaveCount; i++ )

  67. 	{

  68. 		m_cbColor[(wi[i].cbCenterCard&MASK_COLOR)>>4]++;

  69. 	}

  70. 	

  71. 	for( BYTE i = 0; i < 3; i++ )

  72. 	{

  73. 		if( m_cbColor[i] > 0 )

  74. 			m_cbColorCount++;

  75. 

  76. 		if( m_cbColor[i] < m_cbMinColorCount )

  77. 			m_cbMinColorCount = m_cbColor[i];

  78. 	}

  79. }

  80. 

  81. //获取最差牌

  82. BYTE CAndroidAIBase::GetBadlyCard()

  83. {

  84. 	return m_byBadlyCard;

  85. }

  86. 

  87. //获取最大分

  88. int CAndroidAIBase::GetMaxScore()

  89. {

  90. 	return m_nActionScore+m_nMaxScoreThree+m_nMaxScoreTwo;

  91. }

  92. 

  93. //两只牌是否是边的

  94. bool CAndroidAIBase::IsEdge( BYTE byCard1,BYTE byCard2 )

  95. {

  96. 	if( 0 == byCard1%9 || 8 == byCard2%9 )

  97. 		return true;

  98. 	return false;

  99. }

  100. 

  101. //搜索相同牌

  102. bool CAndroidAIBase::SearchSameCard( BYTE byCardData,BYTE &byIndex1,BYTE &byIndex2 )

  103. {

  104. 	//

  105. 	byIndex1 = FindIndex(byCardData);

  106. 	if( byIndex1 == 0xff ) return false;

  107. 	byIndex2 = FindIndex(byCardData,byIndex1+1);

  108. 	if( byIndex2 == 0xff ) return false;

  109. 	return true;

  110. }

  111. 

  112. //搜索连牌

  113. bool CAndroidAIBase::SearchLinkCard( BYTE byCardData,BYTE &byIndex1,BYTE &byIndex2 )

  114. {

  115. 	//效验

  116. 	if( byCardData >= 27 ) return false;

  117. 	//第二,三只

  118. 	BYTE byCard1 = byCardData+1;

  119. 	BYTE byCard2 = byCardData+2;

  120. 	if( byCard1 >= 27 || byCard2 >= 27 || byCardData/9 != byCard1/9 || byCardData/9 != byCard2/9 )

  121. 		return false;

  122. 	//寻找

  123. 	byIndex1 = FindIndex(byCard1);

  124. 	if( byIndex1 == 0xff ) return false;

  125. 	byIndex2 = FindIndex(byCard2);

  126. 	if( byIndex2 == 0xff ) return false;

  127. 

  128. 	return true;

  129. }

  130. 

  131. //搜索两只同牌

  132. bool CAndroidAIBase::SearchSameCardRemain( BYTE byCardData,BYTE &byIndex,BYTE byStart )

  133. {

  134. 	byIndex = FindIndexRemain(byCardData,byStart);

  135. 	return 0xff==byIndex?false:true;

  136. }

  137. 

  138. //搜索有卡连牌

  139. bool CAndroidAIBase::SearchLinkCardRemain( BYTE byCardData,BYTE byLinkType,BYTE &byIndex,BYTE byStart )

  140. {

  141. 	//验证

  142. 	if( byCardData >= 27 ) return false;

  143. 	//判断类型

  144. 	BYTE byCard1 = 0xff;

  145. 	if( 0 == byLinkType )			//紧连

  146. 		byCard1 = byCardData+1;

  147. 	else if( 1 == byLinkType )		//有卡

  148. 		byCard1 = byCardData+2;

  149. 	//过滤

  150. 	if( byCard1 >= 27 || byCardData/9 != byCard1/9 ) return false;

  151. 	byIndex = FindIndexRemain(byCard1,byStart);

  152. 	return 0xff==byIndex?false:true;

  153. }

  154. 

  155. //搜索牌

  156. BYTE CAndroidAIBase::FindIndex( BYTE byCardData,BYTE byStart )

  157. {

  158. 	for( BYTE i = byStart; i < m_byCardCount; i++ )

  159. 	{

  160. 		if( byCardData == m_byCardData[i] && !m_bSelect[i] )

  161. 			return i;

  162. 	}

  163. 	return 0xff;

  164. }

  165. 

  166. //在移除最佳三只后搜索牌

  167. BYTE CAndroidAIBase::FindIndexRemain( BYTE byCardData,BYTE byStart )

  168. {

  169. 	for( BYTE i = byStart; i < m_byRemainThreeCount; i++ )

  170. 	{

  171. 		if( byCardData == m_byRemainThree[i] && !m_bSelect[i] )

  172. 			return i;

  173. 	}

  174. 	return 0xff;

  175. }

  176. 

  177. //移除牌

  178. bool CAndroidAIBase::RemoveCard( BYTE byCardIndex )

  179. {

  180. 	//效验

  181. 	ASSERT( m_byCardCount > 0 );

  182. 	if( m_byCardCount == 0 ) return false;

  183. 	ASSERT( byCardIndex >= 0 && byCardIndex < MAX_INDEX );

  184. 	if( byCardIndex < 0 || byCardIndex >= MAX_INDEX ) return false;

  185. 

  186. 	//删除

  187. 	BYTE byCount = m_byCardCount;

  188. 	m_byCardCount = 0;

  189. 	bool bFound = false;

  190. 	for( BYTE i = 0; i < byCount; i++ )

  191. 	{

  192. 		if( i == byCardIndex ) 

  193. 		{

  194. 			bFound = true;

  195. 			continue;

  196. 		}

  197. 		m_byCardData[m_byCardCount++] = m_byCardData[i];

  198. 	}

  199. 

  200. 	if( bFound )

  201. 		m_byCardData[byCount-1] = 0xff;

  202. 

  203. 	return bFound;

  204. }

  205. 

  206. //移除牌值

  207. bool CAndroidAIBase::RemoveCardData( BYTE byCardData )

  208. {

  209. 	//效验

  210. 	ASSERT( m_byCardCount > 0 );

  211. 	if( m_byCardCount == 0 ) return false;

  212. 

  213. 	//删除

  214. 	BYTE byCount = m_byCardCount;

  215. 	m_byCardCount = 0;

  216. 	bool bFound = false;

  217. 	for( BYTE i = 0; i < byCount; i++ )

  218. 	{

  219. 		if( !bFound && m_byCardData[i] == byCardData )

  220. 		{

  221. 			bFound = true;

  222. 			continue;

  223. 		}

  224. 		m_byCardData[m_byCardCount++] = m_byCardData[i];

  225. 	}

  226. 

  227. 	if( bFound)

  228. 		m_byCardData[byCount-1] = 0xff;

  229. 	

  230. 	return bFound;

  231. }

  232. 

  233. /////////////////////////////////////////////////////////////////////////////////////

  234. //CAndroidAI

  235. 

  236. CAndroidAI::CAndroidAI(void)

  237. {

  238. 	ZeroMemory(m_byEnjoinOutCard,sizeof(m_byEnjoinOutCard));

  239. 	m_byEnjoinOutCount = 0;

  240. }

  241. 

  242. CAndroidAI::~CAndroidAI(void)

  243. {

  244. }

  245. 

  246. //思考

  247. void CAndroidAI::Think()

  248. {

  249. 	//重置

  250. 	m_nMaxScoreThree = 0;

  251. 	m_nMaxScoreTwo = 0;

  252. 

  253. 	//分析三只

  254. 	AnalyseThree();

  255. 	//如果没三只

  256. 	BYTE i;

  257. 	if( m_nMaxScoreThree == 0 || m_byRemainThreeCount == 0 )

  258. 	{

  259. 		m_byRemainThreeCount = m_byCardCount;

  260. 		for( i = 0; i < m_byRemainThreeCount; i++ )

  261. 			m_byRemainThree[i] = m_byCardData[i];

  262. 	}

  263. 	//分析两只

  264. 	AnalyseTwo();

  265. 	if( m_nMaxScoreTwo == 0 )

  266. 	{

  267. 		m_byRemainTwoCount = m_byRemainThreeCount;

  268. 		for( i = 0; i < m_byRemainTwoCount; i++ )

  269. 			m_byRemainTwo[i] = m_byRemainThree[i];

  270. 	}

  271. 	//如果全部是两只

  272. 	if( m_byRemainTwoCount == 0 )

  273. 	{

  274. 		SearchTwo();

  275. 		return;

  276. 	}

  277. 	//分析一只

  278. 	AnalyseOne();

  279. }

  280. 

  281. //从最佳两只牌组合中搜索最差牌

  282. BYTE CAndroidAI::GetBadlyIn2Card()

  283. {

  284. 	BYTE byBadly = 0xff;

  285. 	int nMin = 33;

  286. 	int nScore;

  287. 	BYTE byCard;

  288. 	for( BYTE i = 0; i < m_byGoodTwoCount*2; i++ )

  289. 	{

  290. 		byCard = m_byGoodTwoCard[i];

  291. 

  292. 		if( IsEnjoinOutCard(byCard) ) continue;

  293. 

  294. 		if( byCard >= 27 )						//如果是字

  295. 		{

  296. 			nScore = 2;

  297. 		}

  298. 		else if( byCard%9 == 0 || byCard%9 == 8 )	//如果是一或者九

  299. 		{

  300. 			nScore = 6;

  301. 		}

  302. 		else 

  303. 		{

  304. 			nScore = 10;

  305. 		}

  306. 		nScore += AddScore(byCard);

  307. 

  308. 		//去除一种花色

  309. 		if( m_cbColorCount == 3 && m_cbColor[(byCard/9)] == m_cbMinColorCount )

  310. 			nScore -= 10;

  311. 

  312. 		if( nScore < nMin )

  313. 		{

  314. 			nMin = nScore;

  315. 			byBadly = byCard;

  316. 		}

  317. 	}

  318. 	return byBadly;

  319. }

  320. 

  321. //从最佳三只牌组合中搜索最差牌

  322. BYTE CAndroidAI::GetBadlyIn3Card()

  323. {

  324. 	BYTE byBadly = 0xff;

  325. 	int nMin = 33;

  326. 	int nScore;

  327. 	BYTE byCard;

  328. 	for( BYTE i = 0; i < m_byGoodThreeCount*3; i++ )

  329. 	{

  330. 		byCard = m_byGoodThreeCard[i];

  331. 

  332. 		if( IsEnjoinOutCard(byCard) ) continue;

  333. 

  334. 		if( byCard >= 27 )						//如果是字

  335. 		{

  336. 			nScore = 2;

  337. 		}

  338. 		else if( byCard%9 == 0 || byCard%9 == 8 )	//如果是一或者九

  339. 		{

  340. 			nScore = 6;

  341. 		}

  342. 		else 

  343. 		{

  344. 			nScore = 10;

  345. 		}

  346. 		nScore += AddScore(byCard);

  347. 

  348. 		//去除一种花色

  349. 		if( m_cbColorCount == 3 && m_cbColor[(byCard/9)] == m_cbMinColorCount )

  350. 			nScore -= 10;

  351. 

  352. 		if( nScore < nMin )

  353. 		{

  354. 			nMin = nScore;

  355. 			byBadly = byCard;

  356. 		}

  357. 	}

  358. 	return byBadly;

  359. }

  360. 

  361. //设置禁止出的牌

  362. void CAndroidAI::SetEnjoinOutCard( const BYTE cbEnjoinOutCard[],BYTE cbEnjoinOutCount )

  363. {

  364. 	m_byEnjoinOutCount = cbEnjoinOutCount;

  365. 	if( m_byEnjoinOutCount > 0 )

  366. 	{

  367. 		CopyMemory(m_byEnjoinOutCard,cbEnjoinOutCard,sizeof(BYTE)*cbEnjoinOutCount);

  368. 	}

  369. }

  370. 

  371. //模拟操作

  372. void CAndroidAI::SetAction( BYTE byActionMask,BYTE byActionCard )

  373. {

  374. 	//验证

  375. 	ASSERT( byActionCard >=0 && byActionCard < 34 );

  376. 	if( byActionCard >= 34 ) return;

  377. 

  378. 	//枚举

  379. 	switch( byActionMask )

  380. 	{

  381. 	case WIK_LEFT:

  382. 		{

  383. 			m_nActionScore = 300;

  384. 			VERIFY( RemoveCardData(byActionCard+1) );

  385. 			VERIFY( RemoveCardData(byActionCard+2) );

  386. 			//禁止出的牌

  387. 			m_byEnjoinOutCount = 0;

  388. 			m_byEnjoinOutCard[m_byEnjoinOutCount++] = byActionCard;

  389. 			if( byActionCard%9 < 7 )

  390. 				m_byEnjoinOutCard[m_byEnjoinOutCount++] = byActionCard+3;

  391. 			break;

  392. 		}

  393. 	case WIK_CENTER:

  394. 		{

  395. 			m_nActionScore = 300;

  396. 			VERIFY( RemoveCardData(byActionCard-1) );

  397. 			VERIFY( RemoveCardData(byActionCard+1) );

  398. 			//禁止出的牌

  399. 			m_byEnjoinOutCount = 0;

  400. 			m_byEnjoinOutCard[m_byEnjoinOutCount++] = byActionCard;

  401. 			break;

  402. 		}

  403. 	case WIK_RIGHT:

  404. 		{

  405. 			m_nActionScore = 300;

  406. 			VERIFY( RemoveCardData(byActionCard-2) );

  407. 			VERIFY( RemoveCardData(byActionCard-1) );

  408. 			//禁止出的牌

  409. 			m_byEnjoinOutCount = 0;

  410. 			m_byEnjoinOutCard[m_byEnjoinOutCount++] = byActionCard;

  411. 			if( byActionCard%9 > 3 )

  412. 				m_byEnjoinOutCard[m_byEnjoinOutCount++] = byActionCard-3;

  413. 			break;

  414. 		}

  415. 	case WIK_PENG:

  416. 		{

  417. 			m_nActionScore = 300;;

  418. 			VERIFY( RemoveCardData(byActionCard) );

  419. 			VERIFY( RemoveCardData(byActionCard) );

  420. 			//禁止出的牌

  421. 			m_byEnjoinOutCount = 0;

  422. 			m_byEnjoinOutCard[m_byEnjoinOutCount++] = byActionCard;

  423. 			break;

  424. 		}

  425. 	case WIK_GANG:

  426. 		{

  427. 			VERIFY( RemoveCardData(byActionCard) );

  428. 			BYTE byIndex = FindIndex(byActionCard);

  429. 			if( byIndex != 0xff )

  430. 			{

  431. 				m_nActionScore = 300;

  432. 				VERIFY( RemoveCardData(byActionCard) );

  433. 				VERIFY( RemoveCardData(byActionCard) );

  434. 				byIndex = FindIndex(byActionCard);

  435. 				if( byIndex != 0xff )

  436. 					VERIFY( RemoveCardData(byActionCard) );

  437. 			}

  438. 			break;

  439. 		}

  440. 	default:

  441. 		ASSERT( FALSE );

  442. 	}

  443. }

  444. 

  445. //重置得分

  446. void CAndroidAI::ResetScore()

  447. {

  448. 	m_nActionScore = m_nMaxScoreThree = m_nMaxScoreTwo = 0;

  449. }

  450. 

  451. //加权

  452. int CAndroidAI::AddScore( BYTE byCardData )

  453. {

  454. 	int nScore = 0;

  455. 	if( byCardData >= 27 )

  456. 	{

  457. 		return 0;

  458. 	}

  459. 	if( byCardData%9 != 0 && FindIndex(byCardData-1) != 0xff )	//如果剩余的牌中有比其少一的牌

  460. 	{

  461. 		if( byCardData%9 != 1 )						//如果当前牌不是二类即加3

  462. 		{

  463. 			nScore += 3;

  464. 		}

  465. 		else

  466. 		{

  467. 			nScore += 1;

  468. 		}

  469. 	}

  470. 	if( byCardData%9 != 8 && FindIndex(byCardData+1) != 0xff )	//如果剩余的牌中有比起多一个的牌

  471. 	{

  472. 		if( byCardData%9 != 7 )

  473. 		{

  474. 			nScore += 3;

  475. 		}

  476. 		else

  477. 		{

  478. 			nScore += 1;

  479. 		}

  480. 	}

  481. 	if( byCardData%9 > 1 && FindIndex(byCardData-2) != 0xff )		//如果剩余的牌中有比其少二的牌（如3—5,1_3等）

  482. 	{

  483. 		nScore += 2;

  484. 	}

  485. 	

  486. 	if( byCardData%9 < 7 && FindIndex(byCardData+2) != 0xff )		//如果剩余的牌中有比其多二的牌

  487. 	{

  488. 		nScore += 2;

  489. 	}

  490. 

  491. 	return nScore;

  492. }

  493. 

  494. //分析三只

  495. void CAndroidAI::AnalyseThree()

  496. {

  497. 	BYTE byIndex1,byIndex2;

  498. 	BYTE i = 0;

  499. 	for( ; i < m_byCardCount; i++ )

  500. 	{

  501. 		if( !m_bSelect[i] )

  502. 		{

  503. 			m_bSelect[i] = true;

  504. 			//搜索三只

  505. 			if( SearchSameCard(m_byCardData[i],byIndex1,byIndex2) )

  506. 			{

  507. 				//临时记录

  508. 				m_byThreeCard[m_byThreeCount*3] = m_byCardData[i];

  509. 				m_byThreeCard[m_byThreeCount*3+1] = m_byCardData[i];

  510. 				m_byThreeCard[m_byThreeCount*3+2] = m_byCardData[i];

  511. 				

  512. 				//递归

  513. 				m_byThreeCount++;

  514. 				m_nScoreThree += 300;

  515. 				m_bSelect[byIndex1] = true;

  516. 				m_bSelect[byIndex2] = true;

  517. 				AnalyseThree();

  518. 				m_bSelect[byIndex1] = false;

  519. 				m_bSelect[byIndex2] = false;

  520. 				m_nScoreThree -= 300;

  521. 				m_byThreeCount--;

  522. 			}

  523. 			//搜索连牌

  524. 			if( SearchLinkCard(m_byCardData[i],byIndex1,byIndex2) )

  525. 			{

  526. 				//临时记录

  527. 				m_byThreeCard[m_byThreeCount*3] = m_byCardData[i];

  528. 				m_byThreeCard[m_byThreeCount*3+1] = m_byCardData[i]+1;

  529. 				m_byThreeCard[m_byThreeCount*3+2] = m_byCardData[i]+2;

  530. 

  531. 				//递归

  532. 				m_byThreeCount++;

  533. 				m_nScoreThree += 300;

  534. 				m_bSelect[byIndex1] = true;

  535. 				m_bSelect[byIndex2] = true;

  536. 				AnalyseThree();

  537. 				m_bSelect[byIndex1] = false;

  538. 				m_bSelect[byIndex2] = false;

  539. 				m_nScoreThree -= 300;

  540. 				m_byThreeCount--;

  541. 			}

  542. 			m_bSelect[i] = false;

  543. 		}

  544. 	}

  545. 	//如果搜索到分数更高的

  546. 	if( m_nScoreThree > m_nMaxScoreThree )

  547. 	{

  548. 		//记录剩下的

  549. 		m_byRemainThreeCount = 0;

  550. 		m_nMaxScoreThree = m_nScoreThree;

  551. 		for( i = 0; i < m_byCardCount; i++ )

  552. 		{

  553. 			if( !m_bSelect[i] )

  554. 				m_byRemainThree[m_byRemainThreeCount++] = m_byCardData[i];

  555. 		}

  556. 		//记录最佳三只组合

  557. 		m_byGoodThreeCount = m_byThreeCount;

  558. 		CopyMemory(m_byGoodThreeCard,m_byThreeCard,sizeof(m_byThreeCard));

  559. 	}

  560. }

  561. 

  562. //分析两只

  563. void CAndroidAI::AnalyseTwo()

  564. {

  565. 	BYTE byIndex;

  566. 	BYTE i = 0;

  567. 	for(; i < m_byRemainThreeCount; i++ )

  568. 	{

  569. 		if( !m_bSelect[i] )

  570. 		{

  571. 			m_bSelect[i] = true;

  572. 			//搜索两只相同

  573. 			if( SearchSameCardRemain(m_byRemainThree[i],byIndex,i+1) )

  574. 			{

  575. 				//临时记录

  576. 				m_byTwoCard[m_byTwoCount*2] = m_byRemainThree[i];

  577. 				m_byTwoCard[m_byTwoCount*2+1] = m_byRemainThree[byIndex];

  578. 

  579. 				//判断将

  580. 				m_byTwoCount++;

  581. 				int nGoodSame = 90;

  582. 				if( !m_bHaveJiang )

  583. 				{

  584. 					m_bHaveJiang = true;

  585. 					nGoodSame = 120;

  586. 				}

  587. 				//递归

  588. 				m_nScoreTwo += nGoodSame;

  589. 				m_bSelect[byIndex] = true;

  590. 				AnalyseTwo();

  591. 				m_bSelect[byIndex] = false;

  592. 				if( 120 == nGoodSame )

  593. 					m_bHaveJiang = false;

  594. 				m_nScoreTwo -= nGoodSame;

  595. 				m_byTwoCount--;

  596. 			}

  597. 			//搜索紧连牌

  598. 			if( SearchLinkCardRemain(m_byRemainThree[i],0,byIndex,i+1) )

  599. 			{

  600. 				//临时记录

  601. 				m_byTwoCard[m_byTwoCount*2] = m_byRemainThree[i];

  602. 				m_byTwoCard[m_byTwoCount*2+1] = m_byRemainThree[byIndex];

  603. 

  604. 				//判断边

  605. 				m_byTwoCount++;

  606. 				int nGoodLink;

  607. 				if( IsEdge(m_byRemainThree[i],m_byRemainThree[byIndex]) )

  608. 					nGoodLink = 80;

  609. 				else nGoodLink = 100;

  610. 				//递归

  611. 				m_nScoreTwo += nGoodLink;

  612. 				m_bSelect[byIndex] = true;

  613. 				AnalyseTwo();

  614. 				m_bSelect[byIndex] = false;

  615. 				m_nScoreTwo -= nGoodLink;

  616. 				m_byTwoCount--;

  617. 			}

  618. 			//搜索有卡的连牌

  619. 			if( SearchLinkCardRemain(m_byRemainThree[i],1,byIndex,i+1) )

  620. 			{				

  621. 				//临时记录

  622. 				m_byTwoCard[m_byTwoCount*2] = m_byRemainThree[i];

  623. 				m_byTwoCard[m_byTwoCount*2+1] = m_byRemainThree[byIndex];

  624. 

  625. 				//判断边

  626. 				m_byTwoCount++;

  627. 				int nGoodLink;

  628. 				if( IsEdge(m_byRemainThree[i],m_byRemainThree[byIndex]) )

  629. 					nGoodLink = 70;

  630. 				else nGoodLink = 90;

  631. 				//递归

  632. 				m_nScoreTwo += nGoodLink;

  633. 				m_bSelect[byIndex] = true;

  634. 				AnalyseTwo();

  635. 				m_bSelect[byIndex] = false;

  636. 				m_nScoreTwo -= nGoodLink;

  637. 				m_byTwoCount--;

  638. 			}

  639. 			m_bSelect[i] = false;

  640. 		}

  641. 	}

  642. 	//如果有分数更高的

  643. 	if( m_nScoreTwo > m_nMaxScoreTwo )

  644. 	{

  645. 		//记录剩下的

  646. 		m_nMaxScoreTwo = m_nScoreTwo;

  647. 		m_byRemainTwoCount = 0;

  648. 		for( i = 0; i < m_byRemainThreeCount; i++ )

  649. 		{

  650. 			if( !m_bSelect[i] )

  651. 				m_byRemainTwo[m_byRemainTwoCount++] = m_byRemainThree[i];

  652. 		}

  653. 		//记录最佳两只组合

  654. 		m_byGoodTwoCount = m_byTwoCount;

  655. 		CopyMemory(m_byGoodTwoCard,m_byTwoCard,sizeof(m_byTwoCard));

  656. 	}

  657. }

  658. 

  659. //分析单只

  660. void CAndroidAI::AnalyseOne()

  661. {

  662. 	BYTE byCard;

  663. 	int nScore;

  664. 	int nMin = 33;

  665. 	for(int i = 0;i < m_byRemainTwoCount;i++ )	//找出最差的一张牌

  666. 	{

  667. 		byCard = m_byRemainTwo[i];

  668. 

  669. 		if( IsEnjoinOutCard(byCard) ) continue;

  670. 

  671. 		if( byCard >= 27 )						//如果是字

  672. 		{

  673. 			nScore = 2;

  674. 		}

  675. 		else if( byCard%9 == 0 || byCard%9 == 8 )	//如果是一或者九

  676. 		{

  677. 			nScore = 6;

  678. 		}

  679. 		else 

  680. 		{

  681. 			nScore = 10;

  682. 		}

  683. 

  684. 		nScore += AddScore(byCard);

  685. 

  686. 		//去除一种花色

  687. 		if( m_cbColorCount == 3 && m_cbColor[(byCard/9)] == m_cbMinColorCount )

  688. 			nScore -= 10;

  689. 

  690. 		if( nScore < nMin )

  691. 		{

  692. 			nMin = nScore;

  693. 			m_byBadlyCard = byCard;

  694. 		}

  695. 	}

  696. }

  697. 

  698. //从两只组合中分析

  699. void CAndroidAI::SearchTwo()

  700. {

  701. 	//定义变量

  702. 	BYTE byCardTwo[MAX_COUNT];

  703. 	BYTE byCardTwoCount = 0;

  704. 	bool bTeamHave = false;

  705. 	//设置变量

  706. 	for( int i = 0;i < m_byRemainThreeCount;i++ )

  707. 		byCardTwo[byCardTwoCount++] = m_byRemainThree[i];

  708. 	//仅有一对

  709. 	if( byCardTwoCount == 2 )												//如果只有两张牌

  710. 	{

  711. 		if( byCardTwo[0] == byCardTwo[1] )								//胡牌

  712. 		{

  713. 			if( !IsEnjoinOutCard(byCardTwo[0]) )

  714. 				m_byBadlyCard = byCardTwo[0];								

  715. 			return;

  716. 		}

  717. 		m_byRemainTwoCount = 2;

  718. 		m_byRemainTwo[0] = byCardTwo[0];

  719. 		m_byRemainTwo[1] = byCardTwo[1];

  720. 		AnalyseOne();

  721. 	}

  722. 	else

  723. 	{

  724. 		bool bSameHave = false;

  725. 		int nMinScore = 33;

  726. 		int nScore[8];

  727. 		memset(nScore,33,sizeof(nScore));

  728. 		for( BYTE j = 0;j < byCardTwoCount/2;j++ )					//循环纪录每张牌的分数

  729. 		{

  730. 			if( byCardTwo[j*2] == byCardTwo[j*2 + 1] )				//对子

  731. 			{

  732. 				if( bSameHave )

  733. 				{

  734. 					nScore[j] = 6;

  735. 				}

  736. 				else 

  737. 				{

  738. 					nScore[j] = 8;

  739. 					bSameHave = true;

  740. 				}

  741. 			}

  742. 			else if( byCardTwo[j*2] == byCardTwo[j*2+1] - 1 )		//紧连门子

  743. 			{

  744. 				if( byCardTwo[j*2]%9 == 0 || byCardTwo[j*2+1]%9 == 8 )

  745. 				{

  746. 					nScore[j] = 4;

  747. 				}

  748. 				else

  749. 				{

  750. 					nScore[j] = 7;

  751. 				}

  752. 			}

  753. 			else													//漏一个门子

  754. 			{

  755. 				if( byCardTwo[j*2]%9 == 0 || byCardTwo[j*2+1]%9 == 8 )

  756. 					nScore[j] = 3;

  757. 				else

  758. 					nScore[j] = 5;

  759. 			}

  760. 			

  761. 		}

  762. 		for( BYTE k = 0;k < byCardTwoCount/2;k++)						//找出分数最小的一张牌就是最差的一张

  763. 		{

  764. 			if( nScore[k] < nMinScore )

  765. 			{

  766. 				if( byCardTwo[k*2] % 9 == 0 && !IsEnjoinOutCard(byCardTwo[k*2]) )

  767. 				{

  768. 					m_byBadlyCard = byCardTwo[k*2];

  769. 				}

  770. 				else if( byCardTwo[k*2+1] % 9 == 8 && !IsEnjoinOutCard(byCardTwo[k*2+1]) )

  771. 				{

  772. 					m_byBadlyCard = byCardTwo[k*2+1];

  773. 				}

  774. 				else 

  775. 				{

  776. 					int nIndex = rand()%2;

  777. 					if( IsEnjoinOutCard(byCardTwo[k*2+nIndex]) )

  778. 					{

  779. 						nIndex = (nIndex+1)%2;

  780. 						if( IsEnjoinOutCard(byCardTwo[k*2+nIndex]) ) continue;

  781. 						else m_byBadlyCard = byCardTwo[k*2+nIndex];

  782. 					}

  783. 					else m_byBadlyCard = byCardTwo[k*2+nIndex];

  784. 				}

  785. 				nMinScore = nScore[k];

  786. 			}

  787. 		}

  788. 	}

  789. }

  790. 

  791. //判断牌是否禁止出

  792. bool CAndroidAI::IsEnjoinOutCard( BYTE byCard )

  793. {

  794. 	for( BYTE i = 0; i < m_byEnjoinOutCount; i++ )

  795. 	{

  796. 		if( byCard == m_byEnjoinOutCard[i] )

  797. 			return true;

  798. 	}

  799. 	return false;

  800. }

  801. 

  802. /////////////////////////////////////////////////////////////////////////////////////