zhaobu
/
zhujimajiang_redis
1
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
诸暨麻将添加redis
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
2 Commits
2 Branches
57 MiB
 
 
 
 
 
 
Struktur: 86964399f5
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „86964399f5“
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/机器人服务/GameLogic.cpp

1258 Zeilen
30 KiB
Originalformat Blame Verlauf 

  1. #include "StdAfx.h"

  2. #include "GameLogic.h"

  3. #include "math.h"

  4. 

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

  6. 

  7. //静态变量

  8. bool		CChiHuRight::m_bInit = false;

  9. DWORD		CChiHuRight::m_dwRightMask[MAX_RIGHT_COUNT];

  10. 

  11. //构造函数

  12. CChiHuRight::CChiHuRight()

  13. {

  14. 	ZeroMemory( m_dwRight,sizeof(m_dwRight) );

  15. 

  16. 	if( !m_bInit )

  17. 	{

  18. 		m_bInit = true;

  19. 		for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )

  20. 		{

  21. 			if( 0 == i )

  22. 				m_dwRightMask[i] = 0;

  23. 			else

  24. 				m_dwRightMask[i] = (DWORD(pow(2.0,i-1)))<<28;

  25. 		}

  26. 	}

  27. }

  28. 

  29. //赋值符重载

  30. CChiHuRight & CChiHuRight::operator = ( DWORD dwRight )

  31. {

  32. 	DWORD dwOtherRight = 0;

  33. 	//验证权位

  34. 	if( !IsValidRight( dwRight ) )

  35. 	{

  36. 		//验证取反权位

  37. 		ASSERT( IsValidRight( ~dwRight ) );

  38. 		if( !IsValidRight( ~dwRight ) ) return *this;

  39. 		dwRight = ~dwRight;

  40. 		dwOtherRight = MASK_CHI_HU_RIGHT;

  41. 	}

  42. 

  43. 	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )

  44. 	{

  45. 		if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) )

  46. 			m_dwRight[i] = dwRight&MASK_CHI_HU_RIGHT;

  47. 		else m_dwRight[i] = dwOtherRight;

  48. 	}

  49. 

  50. 	return *this;

  51. }

  52. 

  53. //与等于

  54. CChiHuRight & CChiHuRight::operator &= ( DWORD dwRight )

  55. {

  56. 	bool bNavigate = false;

  57. 	//验证权位

  58. 	if( !IsValidRight( dwRight ) )

  59. 	{

  60. 		//验证取反权位

  61. 		ASSERT( IsValidRight( ~dwRight ) );

  62. 		if( !IsValidRight( ~dwRight ) ) return *this;

  63. 		//调整权位

  64. 		DWORD dwHeadRight = (~dwRight)&0xF0000000;

  65. 		DWORD dwTailRight = dwRight&MASK_CHI_HU_RIGHT;

  66. 		dwRight = dwHeadRight|dwTailRight;

  67. 		bNavigate = true;

  68. 	}

  69. 

  70. 	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )

  71. 	{

  72. 		if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) )

  73. 		{

  74. 			m_dwRight[i] &= (dwRight&MASK_CHI_HU_RIGHT);

  75. 		}

  76. 		else if( !bNavigate )

  77. 			m_dwRight[i] = 0;

  78. 	}

  79. 

  80. 	return *this;

  81. }

  82. 

  83. //或等于

  84. CChiHuRight & CChiHuRight::operator |= ( DWORD dwRight )

  85. {

  86. 	//验证权位

  87. 	if( !IsValidRight( dwRight ) ) return *this;

  88. 

  89. 	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )

  90. 	{

  91. 		if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) )

  92. 			m_dwRight[i] |= (dwRight&MASK_CHI_HU_RIGHT);

  93. 	}

  94. 

  95. 	return *this;

  96. }

  97. 

  98. //与

  99. CChiHuRight CChiHuRight::operator & ( DWORD dwRight )

  100. {

  101. 	CChiHuRight chr = *this;

  102. 	return (chr &= dwRight);

  103. }

  104. 

  105. //与

  106. CChiHuRight CChiHuRight::operator & ( DWORD dwRight ) const

  107. {

  108. 	CChiHuRight chr = *this;

  109. 	return (chr &= dwRight);

  110. }

  111. 

  112. //或

  113. CChiHuRight CChiHuRight::operator | ( DWORD dwRight )

  114. {

  115. 	CChiHuRight chr = *this;

  116. 	return chr |= dwRight;

  117. }

  118. 

  119. //或

  120. CChiHuRight CChiHuRight::operator | ( DWORD dwRight ) const

  121. {

  122. 	CChiHuRight chr = *this;

  123. 	return chr |= dwRight;

  124. }

  125. 

  126. //是否权位为空

  127. bool CChiHuRight::IsEmpty()

  128. {

  129. 	for( BYTE i = 0; i < CountArray(m_dwRight); i++ )

  130. 		if( m_dwRight[i] ) return false;

  131. 	return true;

  132. }

  133. 

  134. //设置权位为空

  135. void CChiHuRight::SetEmpty()

  136. {

  137. 	ZeroMemory( m_dwRight,sizeof(m_dwRight) );

  138. 	return;

  139. }

  140. 

  141. //获取权位数值

  142. BYTE CChiHuRight::GetRightData( DWORD dwRight[], BYTE cbMaxCount )

  143. {

  144. 	ASSERT( cbMaxCount >= CountArray(m_dwRight) );

  145. 	if( cbMaxCount < CountArray(m_dwRight) ) return 0;

  146. 

  147. 	CopyMemory( dwRight,m_dwRight,sizeof(DWORD)*CountArray(m_dwRight) );

  148. 	return CountArray(m_dwRight);

  149. }

  150. 

  151. //设置权位数值

  152. bool CChiHuRight::SetRightData( const DWORD dwRight[], BYTE cbRightCount )

  153. {

  154. 	ASSERT( cbRightCount <= CountArray(m_dwRight) );

  155. 	if( cbRightCount > CountArray(m_dwRight) ) return false;

  156. 

  157. 	ZeroMemory( m_dwRight,sizeof(m_dwRight) );

  158. 	CopyMemory( m_dwRight,dwRight,sizeof(DWORD)*cbRightCount );

  159. 	

  160. 	return true;

  161. }

  162. 

  163. //检查仅位是否正确

  164. bool CChiHuRight::IsValidRight( DWORD dwRight )

  165. {

  166. 	DWORD dwRightHead = dwRight & 0xF0000000;

  167. 	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )

  168. 		if( m_dwRightMask[i] == dwRightHead ) return true;

  169. 	return false;

  170. }

  171. 

  172. //////////////////////////////////////////////////////////////////////////

  173. 

  174. 

  175. 

  176. //////////////////////////////////////////////////////////////////////////

  177. //静态变量

  178. 

  179. //扑克数据

  180. const BYTE CGameLogic::m_cbCardDataArray[MAX_REPERTORY]=

  181. {

  182. 	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子

  183. 	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子

  184. 	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子

  185. 	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子

  186. 	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子

  187. 	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子

  188. 	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子

  189. 	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子

  190. 	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子

  191. 	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子

  192. 	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子

  193. 	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子

  194. };

  195. 

  196. //////////////////////////////////////////////////////////////////////////

  197. 

  198. //构造函数

  199. CGameLogic::CGameLogic()

  200. {

  201. 	m_cbMagicIndex = MAX_INDEX;

  202. }

  203. 

  204. //析构函数

  205. CGameLogic::~CGameLogic()

  206. {

  207. }

  208. 

  209. //混乱扑克

  210. void CGameLogic::RandCardData(BYTE cbCardData[], BYTE cbMaxCount)

  211. {

  212. 	//混乱准备

  213. 	BYTE cbCardDataTemp[CountArray(m_cbCardDataArray)];

  214. 	CopyMemory(cbCardDataTemp,m_cbCardDataArray,sizeof(m_cbCardDataArray));

  215. 

  216. 	//混乱扑克

  217. 	BYTE cbRandCount=0,cbPosition=0;

  218. 	do

  219. 	{

  220. 		cbPosition=rand()%(cbMaxCount-cbRandCount);

  221. 		cbCardData[cbRandCount++]=cbCardDataTemp[cbPosition];

  222. 		cbCardDataTemp[cbPosition]=cbCardDataTemp[cbMaxCount-cbRandCount];

  223. 	} while (cbRandCount<cbMaxCount);

  224. 

  225. 	return;

  226. }

  227. 

  228. //删除扑克

  229. bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard)

  230. {

  231. 	//效验扑克

  232. 	ASSERT(IsValidCard(cbRemoveCard));

  233. 	ASSERT(cbCardIndex[SwitchToCardIndex(cbRemoveCard)]>0);

  234. 

  235. 	//删除扑克

  236. 	BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);

  237. 	if (cbCardIndex[cbRemoveIndex]>0)

  238. 	{

  239. 		cbCardIndex[cbRemoveIndex]--;

  240. 		return true;

  241. 	}

  242. 

  243. 	//失败效验

  244. 	ASSERT(FALSE);

  245. 

  246. 	return false;

  247. }

  248. 

  249. //删除扑克

  250. bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], const BYTE cbRemoveCard[], BYTE cbRemoveCount)

  251. {

  252. 	//删除扑克

  253. 	for (BYTE i=0;i<cbRemoveCount;i++)

  254. 	{

  255. 		//效验扑克

  256. 		ASSERT(IsValidCard(cbRemoveCard[i]));

  257. 		ASSERT(cbCardIndex[SwitchToCardIndex(cbRemoveCard[i])]>0);

  258. 

  259. 		//删除扑克

  260. 		BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard[i]);

  261. 		if (cbCardIndex[cbRemoveIndex]==0)

  262. 		{

  263. 			//错误断言

  264. 			ASSERT(FALSE);

  265. 

  266. 			//还原删除

  267. 			for (BYTE j=0;j<i;j++) 

  268. 			{

  269. 				ASSERT(IsValidCard(cbRemoveCard[j]));

  270. 				cbCardIndex[SwitchToCardIndex(cbRemoveCard[j])]++;

  271. 			}

  272. 

  273. 			return false;

  274. 		}

  275. 		else 

  276. 		{

  277. 			//删除扑克

  278. 			--cbCardIndex[cbRemoveIndex];

  279. 		}

  280. 	}

  281. 

  282. 	return true;

  283. }

  284. 

  285. //删除扑克

  286. bool CGameLogic::RemoveCard(BYTE cbCardData[], BYTE cbCardCount, const BYTE cbRemoveCard[], BYTE cbRemoveCount)

  287. {

  288. 	//检验数据

  289. 	ASSERT(cbCardCount<=14);

  290. 	ASSERT(cbRemoveCount<=cbCardCount);

  291. 

  292. 	//定义变量

  293. 	BYTE cbDeleteCount=0,cbTempCardData[14];

  294. 	if (cbCardCount>CountArray(cbTempCardData))

  295. 		return false;

  296. 	CopyMemory(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));

  297. 

  298. 	//置零扑克

  299. 	for (BYTE i=0;i<cbRemoveCount;i++)

  300. 	{

  301. 		for (BYTE j=0;j<cbCardCount;j++)

  302. 		{

  303. 			if (cbRemoveCard[i]==cbTempCardData[j])

  304. 			{

  305. 				cbDeleteCount++;

  306. 				cbTempCardData[j]=0;

  307. 				break;

  308. 			}

  309. 		}

  310. 	}

  311. 

  312. 	//成功判断

  313. 	if (cbDeleteCount!=cbRemoveCount) 

  314. 	{

  315. 		ASSERT(FALSE);

  316. 		return false;

  317. 	}

  318. 

  319. 	//清理扑克

  320. 	BYTE cbCardPos=0;

  321. 	for (BYTE i=0;i<cbCardCount;i++)

  322. 	{

  323. 		if (cbTempCardData[i]!=0) 

  324. 			cbCardData[cbCardPos++]=cbTempCardData[i];

  325. 	}

  326. 

  327. 	return true;

  328. }

  329. 

  330. //有效判断

  331. bool CGameLogic::IsValidCard(BYTE cbCardData)

  332. {

  333. 	BYTE cbValue=(cbCardData&MASK_VALUE);

  334. 	BYTE cbColor=(cbCardData&MASK_COLOR)>>4;

  335. 	return (((cbValue>=1)&&(cbValue<=9)&&(cbColor<=2))||((cbValue>=1)&&(cbValue<=7)&&(cbColor==3)));

  336. }

  337. 

  338. //扑克数目

  339. BYTE CGameLogic::GetCardCount(const BYTE cbCardIndex[MAX_INDEX])

  340. {

  341. 	//数目统计

  342. 	BYTE cbCardCount=0;

  343. 	for (BYTE i=0;i<MAX_INDEX;i++) 

  344. 		cbCardCount+=cbCardIndex[i];

  345. 

  346. 	return cbCardCount;

  347. }

  348. 

  349. //获取组合

  350. BYTE CGameLogic::GetWeaveCard(BYTE cbWeaveKind, BYTE cbCenterCard, BYTE cbCardBuffer[4])

  351. {

  352. 	//组合扑克

  353. 	switch (cbWeaveKind)

  354. 	{

  355. 	case WIK_LEFT:		//上牌操作

  356. 		{

  357. 			//设置变量

  358. 			cbCardBuffer[0]=cbCenterCard;

  359. 			cbCardBuffer[1]=cbCenterCard+1;

  360. 			cbCardBuffer[2]=cbCenterCard+2;

  361. 

  362. 			return 3;

  363. 		}

  364. 	case WIK_RIGHT:		//上牌操作

  365. 		{

  366. 			//设置变量

  367. 			cbCardBuffer[0]=cbCenterCard;

  368. 			cbCardBuffer[1]=cbCenterCard-1;

  369. 			cbCardBuffer[2]=cbCenterCard-2;

  370. 

  371. 			return 3;

  372. 		}

  373. 	case WIK_CENTER:	//上牌操作

  374. 		{

  375. 			//设置变量

  376. 			cbCardBuffer[0]=cbCenterCard;

  377. 			cbCardBuffer[1]=cbCenterCard-1;

  378. 			cbCardBuffer[2]=cbCenterCard+1;

  379. 

  380. 			return 3;

  381. 		}

  382. 	case WIK_PENG:		//碰牌操作

  383. 		{

  384. 			//设置变量

  385. 			cbCardBuffer[0]=cbCenterCard;

  386. 			cbCardBuffer[1]=cbCenterCard;

  387. 			cbCardBuffer[2]=cbCenterCard;

  388. 

  389. 			return 3;

  390. 		}

  391. 	case WIK_GANG:		//杠牌操作

  392. 		{

  393. 			//设置变量

  394. 			cbCardBuffer[0]=cbCenterCard;

  395. 			cbCardBuffer[1]=cbCenterCard;

  396. 			cbCardBuffer[2]=cbCenterCard;

  397. 			cbCardBuffer[3]=cbCenterCard;

  398. 

  399. 			return 4;

  400. 		}

  401. 	default:

  402. 		{

  403. 			ASSERT(FALSE);

  404. 		}

  405. 	}

  406. 

  407. 	return 0;

  408. }

  409. 

  410. //动作等级

  411. BYTE CGameLogic::GetUserActionRank(BYTE cbUserAction)

  412. {

  413. 	//胡牌等级

  414. 	if (cbUserAction&WIK_CHI_HU) { return 4; }

  415. 

  416. 	//杠牌等级

  417. 	if (cbUserAction&WIK_GANG) { return 3; }

  418. 

  419. 	//碰牌等级

  420. 	if (cbUserAction&WIK_PENG) { return 2; }

  421. 

  422. 	//上牌等级

  423. 	if (cbUserAction&(WIK_RIGHT|WIK_CENTER|WIK_LEFT)) { return 1; }

  424. 

  425. 	return 0;

  426. }

  427. 

  428. //胡牌等级

  429. WORD CGameLogic::GetChiHuActionRank(const CChiHuRight & ChiHuRight)

  430. {

  431. 	WORD wFanShu = 0;

  432. 

  433. 	if( !(ChiHuRight&CHR_QING_LONG_QI_DUI).IsEmpty() )

  434. 		wFanShu = 32;

  435. 	else if( !(ChiHuRight&CHR_DI_HU).IsEmpty() )

  436. 		wFanShu = 32;

  437. 	else if( !(ChiHuRight&CHR_TIAN_HU).IsEmpty() )

  438. 		wFanShu = 32;

  439. 	else if( !(ChiHuRight&CHR_LONG_QI_DUI).IsEmpty() )

  440. 		wFanShu = 16;

  441. 	else if( !(ChiHuRight&CHR_QING_QI_DUI).IsEmpty() )

  442. 		wFanShu = 16;

  443. 	else if( !(ChiHuRight&CHR_QING_YAO_JIU).IsEmpty() )

  444. 		wFanShu = 16;

  445. 	else if( !(ChiHuRight&CHR_QING_DUI).IsEmpty() )

  446. 		wFanShu = 8;

  447. 	else if( !(ChiHuRight&CHR_JIANG_DUI).IsEmpty() )

  448. 		wFanShu = 8;

  449. 	else if( !(ChiHuRight&CHR_QING_YI_SE).IsEmpty() )

  450. 		wFanShu = 4;

  451. 	else if( !(ChiHuRight&CHR_DAI_YAO).IsEmpty() )

  452. 		wFanShu = 4;

  453. 	else if( !(ChiHuRight&CHR_QI_XIAO_DUI).IsEmpty() )

  454. 		wFanShu = 4;

  455. 	else if( !(ChiHuRight&CHR_DA_DUI_ZI).IsEmpty() )

  456. 		wFanShu = 2;

  457. 	else if( !(ChiHuRight&CHR_SHU_FAN).IsEmpty() )

  458. 		wFanShu = 1;

  459. 

  460. 	ASSERT( wFanShu > 0 );

  461. 

  462. 	//杠上花

  463. 	if( !(ChiHuRight&CHR_GANG_KAI).IsEmpty() )

  464. 		wFanShu *= 2;

  465. 	//杠上炮

  466. 	if( !(ChiHuRight&CHR_GANG_SHANG_PAO).IsEmpty() )

  467. 		wFanShu *= 2;

  468. 

  469. 

  470. 	return wFanShu;

  471. }

  472. 

  473. //吃牌判断

  474. /*

  475. BYTE CGameLogic::EstimateEatCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)

  476. {

  477. 	//参数效验

  478. 	ASSERT(IsValidCard(cbCurrentCard));

  479. 

  480. 	//过滤判断

  481. 	if ( cbCurrentCard>=0x31 || IsMagicCard(cbCurrentCard) ) 

  482. 		return WIK_NULL;

  483. 

  484. 	//变量定义

  485. 	BYTE cbExcursion[3]={0,1,2};

  486. 	BYTE cbItemKind[3]={WIK_LEFT,WIK_CENTER,WIK_RIGHT};

  487. 

  488. 	//吃牌判断

  489. 	BYTE cbEatKind=0,cbFirstIndex=0;

  490. 	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);

  491. 	for (BYTE i=0;i<CountArray(cbItemKind);i++)

  492. 	{

  493. 		BYTE cbValueIndex=cbCurrentIndex%9;

  494. 		if ((cbValueIndex>=cbExcursion[i])&&((cbValueIndex-cbExcursion[i])<=6))

  495. 		{

  496. 			//吃牌判断

  497. 			cbFirstIndex=cbCurrentIndex-cbExcursion[i];

  498. 

  499. 			//吃牌不能包含有王霸

  500. 			if( m_cbMagicIndex != MAX_INDEX &&

  501. 				m_cbMagicIndex >= cbFirstIndex && m_cbMagicIndex <= cbFirstIndex+2 ) continue;

  502. 

  503. 			if ((cbCurrentIndex!=cbFirstIndex)&&(cbCardIndex[cbFirstIndex]==0))

  504. 				continue;

  505. 			if ((cbCurrentIndex!=(cbFirstIndex+1))&&(cbCardIndex[cbFirstIndex+1]==0))

  506. 				continue;

  507. 			if ((cbCurrentIndex!=(cbFirstIndex+2))&&(cbCardIndex[cbFirstIndex+2]==0))

  508. 				continue;

  509. 

  510. 			//设置类型

  511. 			cbEatKind|=cbItemKind[i];

  512. 		}

  513. 	}

  514. 

  515. 	return cbEatKind;

  516. }*/

  517. 

  518. //碰牌判断

  519. BYTE CGameLogic::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)

  520. {

  521. 	//参数效验

  522. 	ASSERT(IsValidCard(cbCurrentCard));

  523. 

  524. 	//过滤判断

  525. 	if ( IsMagicCard(cbCurrentCard) ) 

  526. 		return WIK_NULL;

  527. 

  528. 	//碰牌判断

  529. 	return (cbCardIndex[SwitchToCardIndex(cbCurrentCard)]>=2)?WIK_PENG:WIK_NULL;

  530. }

  531. 

  532. //杠牌判断

  533. BYTE CGameLogic::EstimateGangCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)

  534. {

  535. 	//参数效验

  536. 	ASSERT(IsValidCard(cbCurrentCard));

  537. 

  538. 	//过滤判断

  539. 	if ( IsMagicCard(cbCurrentCard) ) 

  540. 		return WIK_NULL;

  541. 

  542. 	//杠牌判断

  543. 	return (cbCardIndex[SwitchToCardIndex(cbCurrentCard)]==3)?WIK_GANG:WIK_NULL;

  544. }

  545. 

  546. //杠牌分析

  547. BYTE CGameLogic::AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult)

  548. {

  549. 	//设置变量

  550. 	BYTE cbActionMask=WIK_NULL;

  551. 	ZeroMemory(&GangCardResult,sizeof(GangCardResult));

  552. 

  553. 	//手上杠牌

  554. 	for (BYTE i=0;i<MAX_INDEX;i++)

  555. 	{

  556. 		if( i == m_cbMagicIndex ) continue;

  557. 		if (cbCardIndex[i]==4)

  558. 		{

  559. 			cbActionMask|=WIK_GANG;

  560. 			GangCardResult.cbCardData[GangCardResult.cbCardCount++]=SwitchToCardData(i);

  561. 		}

  562. 	}

  563. 

  564. 	//组合杠牌

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

  566. 	{

  567. 		if (WeaveItem[i].cbWeaveKind==WIK_PENG)

  568. 		{

  569. 			if (cbCardIndex[SwitchToCardIndex(WeaveItem[i].cbCenterCard)]==1)

  570. 			{

  571. 				cbActionMask|=WIK_GANG;

  572. 				GangCardResult.cbCardData[GangCardResult.cbCardCount++]=WeaveItem[i].cbCenterCard;

  573. 			}

  574. 		}

  575. 	}

  576. 

  577. 	return cbActionMask;

  578. }

  579. 

  580. //吃胡分析

  581. BYTE CGameLogic::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, CChiHuRight &ChiHuRight)

  582. {

  583. 	//变量定义

  584. 	BYTE cbChiHuKind=WIK_NULL;

  585. 	CAnalyseItemArray AnalyseItemArray;

  586. 

  587. 	//设置变量

  588. 	AnalyseItemArray.RemoveAll();

  589. 	ChiHuRight.SetEmpty();

  590. 

  591. 	//构造扑克

  592. 	BYTE cbCardIndexTemp[MAX_INDEX];

  593. 	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

  594. 

  595. 	//cbCurrentCard一定不为0			!!!!!!!!!

  596. 	ASSERT( cbCurrentCard != 0 );

  597. 	if( cbCurrentCard == 0 ) return WIK_NULL;

  598. 

  599. 	/*

  600. 	//	特殊番型

  601. 	*/

  602. 	//七小对牌

  603. 	if( IsQiXiaoDui(cbCardIndex,WeaveItem,cbWeaveCount,cbCurrentCard) ) 

  604. 		ChiHuRight |= CHR_QI_XIAO_DUI;

  605. 

  606. 	if( !ChiHuRight.IsEmpty() )

  607. 		cbChiHuKind = WIK_CHI_HU;

  608. 

  609. 	//插入扑克

  610. 	if (cbCurrentCard!=0)

  611. 		cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

  612. 

  613. 	//必须缺一门

  614. 	if( IsHuaZhu(cbCardIndexTemp,WeaveItem,cbWeaveCount) ) return WIK_NULL;

  615. 

  616. 	//分析扑克

  617. 	AnalyseCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,AnalyseItemArray);

  618. 

  619. 	//胡牌分析

  620. 	if (AnalyseItemArray.GetCount()>0)

  621. 	{

  622. 		//

  623. 		cbChiHuKind = WIK_CHI_HU;

  624. 

  625. 		//牌型分析

  626. 		for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)

  627. 		{

  628. 			//变量定义

  629. 			tagAnalyseItem * pAnalyseItem=&AnalyseItemArray[i];

  630. 

  631. 			/*

  632. 			//	判断番型

  633. 			*/

  634. 			//碰碰和

  635. 			if( IsPengPeng(pAnalyseItem) ) 

  636. 				ChiHuRight |= CHR_DA_DUI_ZI;

  637. 			//带幺

  638. 			if( IsDaiYao(pAnalyseItem) )

  639. 				ChiHuRight |= CHR_DAI_YAO;

  640. 			//将对

  641. 			if( IsJiangDui(pAnalyseItem) )

  642. 				ChiHuRight |= CHR_JIANG_DUI;

  643. 		}

  644. 	}

  645. 		

  646. 	//素番

  647. 	if( cbChiHuKind == WIK_CHI_HU && ChiHuRight.IsEmpty() )

  648. 		ChiHuRight |= CHR_SHU_FAN;

  649. 

  650. 	if( cbChiHuKind == WIK_CHI_HU )

  651. 	{

  652. 		//清一色牌

  653. 		if( IsQingYiSe(cbCardIndex,WeaveItem,cbWeaveCount,cbCurrentCard) )

  654. 			ChiHuRight |= CHR_QING_YI_SE;

  655. 	}

  656. 

  657. 	return cbChiHuKind;

  658. }

  659. 

  660. //听牌分析

  661. BYTE CGameLogic::AnalyseTingCard( const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount )

  662. {

  663. 	//复制数据

  664. 	BYTE cbCardIndexTemp[MAX_INDEX];

  665. 	CopyMemory( cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp) );

  666. 

  667. 	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);

  668. 	CChiHuRight chr;

  669. 

  670. 	if( (cbCardCount-2)%3==0 )

  671. 	{

  672. 		for( BYTE i = 0; i < MAX_INDEX-ZI_PAI_COUNT; i++ )

  673. 		{

  674. 			if( cbCardIndexTemp[i] == 0 ) continue;

  675. 			cbCardIndexTemp[i]--;

  676. 

  677. 			for( BYTE j = 0; j < MAX_INDEX-ZI_PAI_COUNT; j++ )

  678. 			{

  679. 				BYTE cbCurrentCard = SwitchToCardData(j);

  680. 				if( WIK_CHI_HU == AnalyseChiHuCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,cbCurrentCard,chr) )

  681. 					return WIK_LISTEN;

  682. 			}

  683. 

  684. 			cbCardIndexTemp[i]++;

  685. 		}

  686. 	}

  687. 	else

  688. 	{

  689. 		for( BYTE j = 0; j < MAX_INDEX-ZI_PAI_COUNT; j++ )

  690. 		{

  691. 			BYTE cbCurrentCard = SwitchToCardData(j);

  692. 			if( WIK_CHI_HU == AnalyseChiHuCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,cbCurrentCard,chr) )

  693. 				return WIK_LISTEN;

  694. 		}

  695. 	}

  696. 

  697. 	return WIK_NULL;

  698. }

  699. 

  700. //是否听牌

  701. bool CGameLogic::IsTingCard( const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount )

  702. {

  703. 	//复制数据

  704. 	BYTE cbCardIndexTemp[MAX_INDEX];

  705. 	CopyMemory( cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp) );

  706. 

  707. 	CChiHuRight chr;

  708. 	for( BYTE i = 0; i < MAX_INDEX-7; i++ )

  709. 	{

  710. 		BYTE cbCurrentCard = SwitchToCardData( i );

  711. 		if( WIK_CHI_HU == AnalyseChiHuCard( cbCardIndexTemp,WeaveItem,cbWeaveCount,cbCurrentCard,chr ) )

  712. 			return true;

  713. 	}

  714. 	return false;

  715. }

  716. 

  717. //扑克转换

  718. BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex)

  719. {

  720. 	ASSERT(cbCardIndex<34);

  721. 	return ((cbCardIndex/9)<<4)|(cbCardIndex%9+1);

  722. }

  723. 

  724. //扑克转换

  725. BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData)

  726. {

  727. 	ASSERT(IsValidCard(cbCardData));

  728. 	return ((cbCardData&MASK_COLOR)>>4)*9+(cbCardData&MASK_VALUE)-1;

  729. }

  730. 

  731. //扑克转换

  732. BYTE CGameLogic::SwitchToCardData(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT])

  733. {

  734. 	//转换扑克

  735. 	BYTE cbPosition=0;

  736. 	//钻牌

  737. 	if( m_cbMagicIndex != MAX_INDEX )

  738. 	{

  739. 		for( BYTE i = 0; i < cbCardIndex[m_cbMagicIndex]; i++ )

  740. 			cbCardData[cbPosition++] = SwitchToCardData(m_cbMagicIndex);

  741. 	}

  742. 	for (BYTE i=0;i<MAX_INDEX;i++)

  743. 	{

  744. 		if( i == m_cbMagicIndex ) continue;

  745. 		if (cbCardIndex[i]!=0)

  746. 		{

  747. 			for (BYTE j=0;j<cbCardIndex[i];j++)

  748. 			{

  749. 				ASSERT(cbPosition<MAX_COUNT);

  750. 				cbCardData[cbPosition++]=SwitchToCardData(i);

  751. 			}

  752. 		}

  753. 	}

  754. 

  755. 	return cbPosition;

  756. }

  757. 

  758. //扑克转换

  759. BYTE CGameLogic::SwitchToCardIndex(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX])

  760. {

  761. 	//设置变量

  762. 	ZeroMemory(cbCardIndex,sizeof(BYTE)*MAX_INDEX);

  763. 

  764. 	//转换扑克

  765. 	for (BYTE i=0;i<cbCardCount;i++)

  766. 	{

  767. 		ASSERT(IsValidCard(cbCardData[i]));

  768. 		cbCardIndex[SwitchToCardIndex(cbCardData[i])]++;

  769. 	}

  770. 

  771. 	return cbCardCount;

  772. }

  773. 

  774. //分析扑克

  775. bool CGameLogic::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)

  776. {

  777. 	//计算数目

  778. 	BYTE cbCardCount=GetCardCount(cbCardIndex);

  779. 

  780. 	//效验数目

  781. 	ASSERT((cbCardCount>=2)&&(cbCardCount<=MAX_COUNT)&&((cbCardCount-2)%3==0));

  782. 	if ((cbCardCount<2)||(cbCardCount>MAX_COUNT)||((cbCardCount-2)%3!=0))

  783. 		return false;

  784. 

  785. 	//变量定义

  786. 	BYTE cbKindItemCount=0;

  787. 	tagKindItem KindItem[27*2+7+14];

  788. 	ZeroMemory(KindItem,sizeof(KindItem));

  789. 

  790. 	//需求判断

  791. 	BYTE cbLessKindItem=(cbCardCount-2)/3;

  792. 	ASSERT((cbLessKindItem+cbWeaveCount)==4);

  793. 

  794. 	//单吊判断

  795. 	if (cbLessKindItem==0)

  796. 	{

  797. 		//效验参数

  798. 		ASSERT((cbCardCount==2)&&(cbWeaveCount==4));

  799. 

  800. 		//牌眼判断

  801. 		for (BYTE i=0;i<MAX_INDEX;i++)

  802. 		{

  803. 			if (cbCardIndex[i]==2 || 

  804. 				( m_cbMagicIndex != MAX_INDEX && i != m_cbMagicIndex && cbCardIndex[m_cbMagicIndex]+cbCardIndex[i]==2 ) )

  805. 			{

  806. 				//变量定义

  807. 				tagAnalyseItem AnalyseItem;

  808. 				ZeroMemory(&AnalyseItem,sizeof(AnalyseItem));

  809. 

  810. 				//设置结果

  811. 				for (BYTE j=0;j<cbWeaveCount;j++)

  812. 				{

  813. 					AnalyseItem.cbWeaveKind[j]=WeaveItem[j].cbWeaveKind;

  814. 					AnalyseItem.cbCenterCard[j]=WeaveItem[j].cbCenterCard;

  815. 					GetWeaveCard( WeaveItem[j].cbWeaveKind,WeaveItem[j].cbCenterCard,AnalyseItem.cbCardData[j] );

  816. 				}

  817. 				AnalyseItem.cbCardEye=SwitchToCardData(i);

  818. 				if( cbCardIndex[i] < 2 || i == m_cbMagicIndex )

  819. 					AnalyseItem.bMagicEye = true;

  820. 				else AnalyseItem.bMagicEye = false;

  821. 

  822. 				//插入结果

  823. 				AnalyseItemArray.Add(AnalyseItem);

  824. 

  825. 				return true;

  826. 			}

  827. 		}

  828. 

  829. 		return false;

  830. 	}

  831. 

  832. 	//拆分分析

  833. 	BYTE cbMagicCardIndex[MAX_INDEX];

  834. 	CopyMemory(cbMagicCardIndex,cbCardIndex,sizeof(cbMagicCardIndex));

  835. 	BYTE cbMagicCardCount = 0;

  836. 	if( m_cbMagicIndex != MAX_INDEX )

  837. 	{

  838. 		cbMagicCardCount = cbCardIndex[m_cbMagicIndex];

  839. 		if( cbMagicCardIndex[m_cbMagicIndex] ) cbMagicCardIndex[m_cbMagicIndex] = 1;		//减小多余组合

  840. 	}

  841. 	if (cbCardCount>=3)

  842. 	{

  843. 		for (BYTE i=0;i<MAX_INDEX;i++)

  844. 		{

  845. 			//同牌判断

  846. 			if (cbMagicCardIndex[i]+cbMagicCardCount>=3)

  847. 			{

  848. 				ASSERT( cbKindItemCount < CountArray(KindItem) );

  849. 				KindItem[cbKindItemCount].cbCardIndex[0]=i;

  850. 				KindItem[cbKindItemCount].cbCardIndex[1]=i;

  851. 				KindItem[cbKindItemCount].cbCardIndex[2]=i;

  852. 				KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;

  853. 				KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);

  854. 				KindItem[cbKindItemCount].cbValidIndex[0] = cbMagicCardIndex[i]>0?i:m_cbMagicIndex;

  855. 				KindItem[cbKindItemCount].cbValidIndex[1] = cbMagicCardIndex[i]>1?i:m_cbMagicIndex;

  856. 				KindItem[cbKindItemCount].cbValidIndex[2] = cbMagicCardIndex[i]>2?i:m_cbMagicIndex;

  857. 				cbKindItemCount++;

  858. 				if(cbMagicCardIndex[i]+cbMagicCardCount>=6)

  859. 				{

  860. 					ASSERT( cbKindItemCount < CountArray(KindItem) );

  861. 					KindItem[cbKindItemCount].cbCardIndex[0]=i;

  862. 					KindItem[cbKindItemCount].cbCardIndex[1]=i;

  863. 					KindItem[cbKindItemCount].cbCardIndex[2]=i;

  864. 					KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;

  865. 					KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);

  866. 					KindItem[cbKindItemCount].cbValidIndex[0] = cbMagicCardIndex[i]>3?i:m_cbMagicIndex;

  867. 					KindItem[cbKindItemCount].cbValidIndex[1] = m_cbMagicIndex;

  868. 					KindItem[cbKindItemCount].cbValidIndex[2] = m_cbMagicIndex;

  869. 					cbKindItemCount++;

  870. 				}

  871. 			}

  872. 

  873. 			//连牌判断

  874. 			if ((i<(MAX_INDEX-9))&&((i%9)<7))

  875. 			{

  876. 				//只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合

  877. 				if( cbMagicCardCount+cbMagicCardIndex[i]+cbMagicCardIndex[i+1]+cbMagicCardIndex[i+2] >= 3 )

  878. 				{

  879. 					BYTE cbIndex[3] = { i==m_cbMagicIndex?0:cbMagicCardIndex[i],(i+1)==m_cbMagicIndex?0:cbMagicCardIndex[i+1],

  880. 						(i+2)==m_cbMagicIndex?0:cbMagicCardIndex[i+2] };

  881. 					int nMagicCountTemp = cbMagicCardCount;

  882. 					BYTE cbValidIndex[3];

  883. 					while( nMagicCountTemp+cbIndex[0]+cbIndex[1]+cbIndex[2] >= 3 )

  884. 					{

  885. 						for( BYTE j = 0; j < CountArray(cbIndex); j++ )

  886. 						{

  887. 							if( cbIndex[j] > 0 ) 

  888. 							{

  889. 								cbIndex[j]--;

  890. 								cbValidIndex[j] = i+j;

  891. 							}

  892. 							else 

  893. 							{

  894. 								nMagicCountTemp--;

  895. 								cbValidIndex[j] = m_cbMagicIndex;

  896. 							}

  897. 						}

  898. 						if( nMagicCountTemp >= 0 )

  899. 						{

  900. 							ASSERT( cbKindItemCount < CountArray(KindItem) );

  901. 							KindItem[cbKindItemCount].cbCardIndex[0]=i;

  902. 							KindItem[cbKindItemCount].cbCardIndex[1]=i+1;

  903. 							KindItem[cbKindItemCount].cbCardIndex[2]=i+2;

  904. 							KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;

  905. 							KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);

  906. 							CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );

  907. 							cbKindItemCount++;

  908. 						}

  909. 						else break;

  910. 					}

  911. 				}

  912. 			}

  913. 		}

  914. 	}

  915. 

  916. 	//组合分析

  917. 	if (cbKindItemCount>=cbLessKindItem)

  918. 	{

  919. 		//变量定义

  920. 		BYTE cbCardIndexTemp[MAX_INDEX];

  921. 		ZeroMemory(cbCardIndexTemp,sizeof(cbCardIndexTemp));

  922. 

  923. 		//变量定义

  924. 		BYTE cbIndex[4]={0,1,2,3};

  925. 		tagKindItem * pKindItem[4];

  926. 		ZeroMemory(&pKindItem,sizeof(pKindItem));

  927. 

  928. 		//开始组合

  929. 		do

  930. 		{

  931. 			//设置变量

  932. 			CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

  933. 			for (BYTE i=0;i<cbLessKindItem;i++)

  934. 				pKindItem[i]=&KindItem[cbIndex[i]];

  935. 

  936. 			//数量判断

  937. 			bool bEnoughCard=true;

  938. 			for (BYTE i=0;i<cbLessKindItem*3;i++)

  939. 			{

  940. 				//存在判断

  941. 				BYTE cbCardIndex=pKindItem[i/3]->cbValidIndex[i%3]; 

  942. 				if (cbCardIndexTemp[cbCardIndex]==0)

  943. 				{

  944. 					bEnoughCard=false;

  945. 					break;

  946. 				}

  947. 				else 

  948. 					cbCardIndexTemp[cbCardIndex]--;

  949. 			}

  950. 

  951. 			//胡牌判断

  952. 			if (bEnoughCard==true)

  953. 			{

  954. 				//牌眼判断

  955. 				BYTE cbCardEye=0;

  956. 				bool bMagicEye = false;

  957. 				for (BYTE i=0;i<MAX_INDEX;i++)

  958. 				{

  959. 					if (cbCardIndexTemp[i]==2)

  960. 					{

  961. 						cbCardEye=SwitchToCardData(i);

  962. 						if( i == m_cbMagicIndex ) bMagicEye = true;

  963. 						break;

  964. 					}

  965. 					else if( i!=m_cbMagicIndex && 

  966. 						m_cbMagicIndex != MAX_INDEX && cbCardIndexTemp[i]+cbCardIndexTemp[m_cbMagicIndex]==2 )

  967. 					{

  968. 						cbCardEye = SwitchToCardData(i);

  969. 						bMagicEye = true;

  970. 					}

  971. 				}

  972. 

  973. 				//组合类型

  974. 				if (cbCardEye!=0)

  975. 				{

  976. 					//变量定义

  977. 					tagAnalyseItem AnalyseItem;

  978. 					ZeroMemory(&AnalyseItem,sizeof(AnalyseItem));

  979. 

  980. 					//设置组合

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

  982. 					{

  983. 						AnalyseItem.cbWeaveKind[i]=WeaveItem[i].cbWeaveKind;

  984. 						AnalyseItem.cbCenterCard[i]=WeaveItem[i].cbCenterCard;

  985. 						GetWeaveCard( WeaveItem[i].cbWeaveKind,WeaveItem[i].cbCenterCard,

  986. 							AnalyseItem.cbCardData[i] );

  987. 					}

  988. 

  989. 					//设置牌型

  990. 					for (BYTE i=0;i<cbLessKindItem;i++) 

  991. 					{

  992. 						AnalyseItem.cbWeaveKind[i+cbWeaveCount]=pKindItem[i]->cbWeaveKind;

  993. 						AnalyseItem.cbCenterCard[i+cbWeaveCount]=pKindItem[i]->cbCenterCard;

  994. 						AnalyseItem.cbCardData[cbWeaveCount+i][0] = SwitchToCardData(pKindItem[i]->cbValidIndex[0]);

  995. 						AnalyseItem.cbCardData[cbWeaveCount+i][1] = SwitchToCardData(pKindItem[i]->cbValidIndex[1]);

  996. 						AnalyseItem.cbCardData[cbWeaveCount+i][2] = SwitchToCardData(pKindItem[i]->cbValidIndex[2]);

  997. 					}

  998. 

  999. 					//设置牌眼

  1000. 					AnalyseItem.cbCardEye=cbCardEye;

  1001. 					AnalyseItem.bMagicEye = bMagicEye;

  1002. 

  1003. 					//插入结果

  1004. 					AnalyseItemArray.Add(AnalyseItem);

  1005. 				}

  1006. 			}

  1007. 

  1008. 			//设置索引

  1009. 			if (cbIndex[cbLessKindItem-1]==(cbKindItemCount-1))

  1010. 			{

  1011. 				BYTE i=cbLessKindItem-1;

  1012. 				for (;i>0;i--)

  1013. 				{

  1014. 					if ((cbIndex[i-1]+1)!=cbIndex[i])

  1015. 					{

  1016. 						BYTE cbNewIndex=cbIndex[i-1];

  1017. 						for (BYTE j=(i-1);j<cbLessKindItem;j++) 

  1018. 							cbIndex[j]=cbNewIndex+j-i+2;

  1019. 						break;

  1020. 					}

  1021. 				}

  1022. 				if (i==0)

  1023. 					break;

  1024. 			}

  1025. 			else

  1026. 				cbIndex[cbLessKindItem-1]++;

  1027. 		} while (true);

  1028. 

  1029. 	}

  1030. 

  1031. 	return (AnalyseItemArray.GetCount()>0);

  1032. }

  1033. 

  1034. //钻牌

  1035. bool CGameLogic::IsMagicCard( BYTE cbCardData )

  1036. {

  1037. 	if( m_cbMagicIndex != MAX_INDEX )

  1038. 		return SwitchToCardIndex(cbCardData) == m_cbMagicIndex;

  1039. 	return false;

  1040. }

  1041. 

  1042. //排序,根据牌值排序

  1043. bool CGameLogic::SortCardList( BYTE cbCardData[MAX_COUNT], BYTE cbCardCount )

  1044. {

  1045. 	//数目过虑

  1046. 	if (cbCardCount==0||cbCardCount>MAX_COUNT) return false;

  1047. 

  1048. 	//排序操作

  1049. 	bool bSorted=true;

  1050. 	BYTE cbSwitchData=0,cbLast=cbCardCount-1;

  1051. 	do

  1052. 	{

  1053. 		bSorted=true;

  1054. 		for (BYTE i=0;i<cbLast;i++)

  1055. 		{

  1056. 			if (cbCardData[i]>cbCardData[i+1])

  1057. 			{

  1058. 				//设置标志

  1059. 				bSorted=false;

  1060. 

  1061. 				//扑克数据

  1062. 				cbSwitchData=cbCardData[i];

  1063. 				cbCardData[i]=cbCardData[i+1];

  1064. 				cbCardData[i+1]=cbSwitchData;

  1065. 			}	

  1066. 		}

  1067. 		cbLast--;

  1068. 	} while(bSorted==false);

  1069. 

  1070. 	return true;

  1071. }

  1072. 

  1073. /*

  1074. // 胡法分析函数

  1075. */

  1076. 

  1077. //大对子

  1078. bool CGameLogic::IsPengPeng( const tagAnalyseItem *pAnalyseItem )

  1079. {

  1080. 	for( BYTE i = 0; i < CountArray(pAnalyseItem->cbWeaveKind); i++ )

  1081. 	{

  1082. 		if( pAnalyseItem->cbWeaveKind[i]&(WIK_LEFT|WIK_CENTER|WIK_RIGHT) )

  1083. 			return false;

  1084. 	}

  1085. 	return true;

  1086. }

  1087. 

  1088. //清一色牌

  1089. bool CGameLogic::IsQingYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount,const BYTE cbCurrentCard)

  1090. {

  1091. 	//胡牌判断

  1092. 	BYTE cbCardColor=0xFF;

  1093. 

  1094. 	for (BYTE i=0;i<MAX_INDEX;i++)

  1095. 	{

  1096. 		if(i==m_cbMagicIndex) continue;

  1097. 		if (cbCardIndex[i]!=0)

  1098. 		{

  1099. 			//花色判断

  1100. 			if (cbCardColor!=0xFF)

  1101. 				return false;

  1102. 

  1103. 			//设置花色

  1104. 			cbCardColor=(SwitchToCardData(i)&MASK_COLOR);

  1105. 

  1106. 			//设置索引

  1107. 			i=(i/9+1)*9-1;

  1108. 		}

  1109. 	}

  1110. 

  1111. 	//如果手上只有王霸

  1112. 	if( cbCardColor == 0xFF )

  1113. 	{

  1114. 		ASSERT( m_cbMagicIndex != MAX_INDEX && cbCardIndex[m_cbMagicIndex] > 0 );

  1115. 		//检查组合

  1116. 		ASSERT( cbItemCount > 0 );

  1117. 		cbCardColor = WeaveItem[0].cbCenterCard&MASK_COLOR;

  1118. 	}

  1119. 

  1120. 	if((cbCurrentCard&MASK_COLOR)!=cbCardColor && !IsMagicCard(cbCurrentCard) ) return false;

  1121. 

  1122. 	//组合判断

  1123. 	for (BYTE i=0;i<cbItemCount;i++)

  1124. 	{

  1125. 		BYTE cbCenterCard=WeaveItem[i].cbCenterCard;

  1126. 		if ((cbCenterCard&MASK_COLOR)!=cbCardColor)	return false;

  1127. 	}

  1128. 

  1129. 	return true;

  1130. }

  1131. 

  1132. //七小对牌

  1133. bool CGameLogic::IsQiXiaoDui(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount,const BYTE cbCurrentCard)

  1134. {

  1135. 	//组合判断

  1136. 	if (cbWeaveCount!=0) return false;

  1137. 

  1138. 	//单牌数目

  1139. 	BYTE cbReplaceCount = 0;

  1140. 

  1141. 	//临时数据

  1142. 	BYTE cbCardIndexTemp[MAX_INDEX];

  1143. 	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

  1144. 

  1145. 	//插入数据

  1146. 	BYTE cbCurrentIndex = SwitchToCardIndex(cbCurrentCard);

  1147. 	cbCardIndexTemp[cbCurrentIndex]++;

  1148. 

  1149. 	//计算单牌

  1150. 	for (BYTE i=0;i<MAX_INDEX;i++)

  1151. 	{

  1152. 		BYTE cbCardCount=cbCardIndexTemp[i];

  1153. 

  1154. 		//王牌过滤

  1155. 		if( i == m_cbMagicIndex ) continue;

  1156. 

  1157. 		//单牌统计

  1158. 		if( cbCardCount == 1 || cbCardCount == 3 ) 	cbReplaceCount++;

  1159. 	}

  1160. 

  1161. 	//王牌不够

  1162. 	if( m_cbMagicIndex != MAX_INDEX && cbReplaceCount > cbCardIndexTemp[m_cbMagicIndex] ||

  1163. 		m_cbMagicIndex == MAX_INDEX && cbReplaceCount > 0 )

  1164. 		return false;

  1165. 

  1166. 	return true;

  1167. 

  1168. }

  1169. 

  1170. //带幺

  1171. bool CGameLogic::IsDaiYao( const tagAnalyseItem *pAnalyseItem )

  1172. {

  1173. 	//检查牌眼

  1174. 	BYTE cbCardValue = pAnalyseItem->cbCardEye&MASK_VALUE;

  1175. 	if( cbCardValue != 1 && cbCardValue != 9 ) return false;

  1176. 

  1177. 	for( BYTE i = 0; i < CountArray(pAnalyseItem->cbWeaveKind); i++ )

  1178. 	{

  1179. 		if( pAnalyseItem->cbWeaveKind[i]&(WIK_LEFT|WIK_CENTER|WIK_RIGHT) )

  1180. 		{

  1181. 			BYTE j = 0;

  1182. 			for( ; j < 3; j++ )

  1183. 			{

  1184. 				cbCardValue = pAnalyseItem->cbCardData[i][j]&MASK_VALUE;

  1185. 				if( cbCardValue == 1 || cbCardValue == 9 ) break;

  1186. 			}

  1187. 			if( j == 3 ) return false;

  1188. 		}

  1189. 		else

  1190. 		{

  1191. 			cbCardValue = pAnalyseItem->cbCenterCard[i]&MASK_VALUE;

  1192. 			if( cbCardValue != 1 && cbCardValue != 9 ) return false;

  1193. 		}

  1194. 	}

  1195. 	return true;

  1196. }

  1197. 

  1198. //将对

  1199. bool CGameLogic::IsJiangDui( const tagAnalyseItem *pAnalyseItem )

  1200. {

  1201. 	//是否大对子

  1202. 	if( !IsPengPeng(pAnalyseItem) ) return false;

  1203. 

  1204. 	//检查牌眼

  1205. 	BYTE cbCardValue = pAnalyseItem->cbCardEye&MASK_VALUE;

  1206. 	if( cbCardValue != 2 && cbCardValue != 5 && cbCardValue != 8 ) return false;

  1207. 

  1208. 	for( BYTE i = 0; i < CountArray(pAnalyseItem->cbWeaveKind); i++ )

  1209. 	{

  1210. 		if( pAnalyseItem->cbWeaveKind[i]&(WIK_LEFT|WIK_CENTER|WIK_RIGHT) )

  1211. 		{

  1212. 			BYTE j = 0;

  1213. 			for( ; j < 3; j++ )

  1214. 			{

  1215. 				cbCardValue = pAnalyseItem->cbCardData[i][j]&MASK_VALUE;

  1216. 				if( cbCardValue == 2 || cbCardValue == 5 || cbCardValue == 8 ) break;

  1217. 			}

  1218. 			if( j == 3 ) return false;

  1219. 		}

  1220. 		else

  1221. 		{

  1222. 			cbCardValue = pAnalyseItem->cbCenterCard[i]&MASK_VALUE;

  1223. 			if( cbCardValue != 2 && cbCardValue != 5 && cbCardValue != 8 ) return false;

  1224. 		}

  1225. 	}

  1226. 	return true;

  1227. }

  1228. 

  1229. //是否花猪

  1230. bool CGameLogic::IsHuaZhu( const BYTE cbCardIndex[], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE bDingQueHuase)

  1231. {

  1232. 	BYTE cbColor[3] = { 0,0,0 };

  1233. 	for( BYTE i = 0; i < MAX_INDEX; i++ )

  1234. 	{

  1235. 		if( cbCardIndex[i] > 0 )

  1236. 		{

  1237. 			BYTE cbCardColor = SwitchToCardData(i)&MASK_COLOR;

  1238. 			cbColor[cbCardColor>>4]++;

  1239. 

  1240. 			i = (i/9+1)*9-1;

  1241. 		}

  1242. 	}

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

  1244. 	{

  1245. 		BYTE cbCardColor = WeaveItem[i].cbCenterCard&MASK_COLOR;

  1246. 		cbColor[cbCardColor>>4]++;

  1247. 	}

  1248. 	//缺一门就不是花猪

  1249. 	for( BYTE i = 0; i < CountArray(cbColor); i++ )

  1250. 		if( cbColor[i] == 0 ) return false;

  1251. 

  1252. 	if (INVALID_BYTE!= bDingQueHuase && 0 != cbColor[bDingQueHuase])

  1253. 		return false;

  1254. 	return true;

  1255. }

  1256. 

  1257. //////////////////////////////////////////////////////////////////////////