zhaobu
/
zhujimajiang_redis
1
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
诸暨麻将添加redis
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
2 Révisions
2 Branches
57 MiB
 
 
 
 
 
 
Aborescence: 86964399f5
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '86964399f5'
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/游戏客户端/GameLogic.cpp

1254 lignes
30 KiB
Brut Annotations Historique 

  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. 	ASSERT( wFanShu > 0 );

  460. 

  461. 	//杠上花

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

  463. 		wFanShu *= 2;

  464. 	//杠上炮

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

  466. 		wFanShu *= 2;

  467. 

  468. 

  469. 	return wFanShu;

  470. }

  471. 

  472. //吃牌判断

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

  474. {

  475. 	//参数效验

  476. 	ASSERT(IsValidCard(cbCurrentCard));

  477. 

  478. 	//过滤判断

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

  480. 		return WIK_NULL;

  481. 

  482. 	//变量定义

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

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

  485. 

  486. 	//吃牌判断

  487. 	BYTE cbEatKind=0,cbFirstIndex=0;

  488. 	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);

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

  490. 	{

  491. 		BYTE cbValueIndex=cbCurrentIndex%9;

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

  493. 		{

  494. 			//吃牌判断

  495. 			cbFirstIndex=cbCurrentIndex-cbExcursion[i];

  496. 

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

  498. 			if( m_cbMagicIndex != MAX_INDEX &&

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

  500. 

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

  502. 				continue;

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

  504. 				continue;

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

  506. 				continue;

  507. 

  508. 			//设置类型

  509. 			cbEatKind|=cbItemKind[i];

  510. 		}

  511. 	}

  512. 

  513. 	return cbEatKind;

  514. }

  515. 

  516. //碰牌判断

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

  518. {

  519. 	//参数效验

  520. 	ASSERT(IsValidCard(cbCurrentCard));

  521. 

  522. 	//过滤判断

  523. 	if ( IsMagicCard(cbCurrentCard) ) 

  524. 		return WIK_NULL;

  525. 

  526. 	//碰牌判断

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

  528. }

  529. 

  530. //杠牌判断

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

  532. {

  533. 	//参数效验

  534. 	ASSERT(IsValidCard(cbCurrentCard));

  535. 

  536. 	//过滤判断

  537. 	if ( IsMagicCard(cbCurrentCard) ) 

  538. 		return WIK_NULL;

  539. 

  540. 	//杠牌判断

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

  542. }

  543. 

  544. //杠牌分析

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

  546. {

  547. 	//设置变量

  548. 	BYTE cbActionMask=WIK_NULL;

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

  550. 

  551. 	//手上杠牌

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

  553. 	{

  554. 		if( i == m_cbMagicIndex ) continue;

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

  556. 		{

  557. 			cbActionMask|=WIK_GANG;

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

  559. 		}

  560. 	}

  561. 

  562. 	//组合杠牌

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

  564. 	{

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

  566. 		{

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

  568. 			{

  569. 				cbActionMask|=WIK_GANG;

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

  571. 			}

  572. 		}

  573. 	}

  574. 

  575. 	return cbActionMask;

  576. }

  577. 

  578. //吃胡分析

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

  580. {

  581. 	//变量定义

  582. 	BYTE cbChiHuKind=WIK_NULL;

  583. 	CAnalyseItemArray AnalyseItemArray;

  584. 

  585. 	//设置变量

  586. 	AnalyseItemArray.RemoveAll();

  587. 	ChiHuRight.SetEmpty();

  588. 

  589. 	//构造扑克

  590. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  592. 

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

  594. 	ASSERT( cbCurrentCard != 0 );

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

  596. 

  597. 	/*

  598. 	//	特殊番型

  599. 	*/

  600. 	//七小对牌

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

  602. 		ChiHuRight |= CHR_QI_XIAO_DUI;

  603. 

  604. 	if( !ChiHuRight.IsEmpty() )

  605. 		cbChiHuKind = WIK_CHI_HU;

  606. 

  607. 	//插入扑克

  608. 	if (cbCurrentCard!=0)

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

  610. 

  611. 	//必须缺一门

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

  613. 

  614. 	//分析扑克

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

  616. 

  617. 	//胡牌分析

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

  619. 	{

  620. 		//

  621. 		cbChiHuKind = WIK_CHI_HU;

  622. 

  623. 		//牌型分析

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

  625. 		{

  626. 			//变量定义

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

  628. 

  629. 			/*

  630. 			//	判断番型

  631. 			*/

  632. 			//碰碰和

  633. 			if( IsPengPeng(pAnalyseItem) ) 

  634. 				ChiHuRight |= CHR_DA_DUI_ZI;

  635. 			//带幺

  636. 			if( IsDaiYao(pAnalyseItem) )

  637. 				ChiHuRight |= CHR_DAI_YAO;

  638. 			//将对

  639. 			if( IsJiangDui(pAnalyseItem) )

  640. 				ChiHuRight |= CHR_JIANG_DUI;

  641. 		}

  642. 	}

  643. 

  644. 	//素番

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

  646. 		ChiHuRight |= CHR_SHU_FAN;

  647. 

  648. 	if( cbChiHuKind == WIK_CHI_HU )

  649. 	{

  650. 		//清一色牌

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

  652. 			ChiHuRight |= CHR_QING_YI_SE;

  653. 	}

  654. 

  655. 	return cbChiHuKind;

  656. }

  657. 

  658. //听牌分析

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

  660. {

  661. 	//复制数据

  662. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  664. 

  665. 	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);

  666. 	CChiHuRight chr;

  667. 

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

  669. 	{

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

  671. 		{

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

  673. 			cbCardIndexTemp[i]--;

  674. 

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

  676. 			{

  677. 				BYTE cbCurrentCard = SwitchToCardData(j);

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

  679. 					return WIK_LISTEN;

  680. 			}

  681. 

  682. 			cbCardIndexTemp[i]++;

  683. 		}

  684. 	}

  685. 	else

  686. 	{

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

  688. 		{

  689. 			BYTE cbCurrentCard = SwitchToCardData(j);

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

  691. 				return WIK_LISTEN;

  692. 		}

  693. 	}

  694. 

  695. 	return WIK_NULL;

  696. }

  697. 

  698. //是否听牌

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

  700. {

  701. 	//复制数据

  702. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  704. 

  705. 	CChiHuRight chr;

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

  707. 	{

  708. 		BYTE cbCurrentCard = SwitchToCardData( i );

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

  710. 			return true;

  711. 	}

  712. 	return false;

  713. }

  714. 

  715. //扑克转换

  716. BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex)

  717. {

  718. 	ASSERT(cbCardIndex<34);

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

  720. }

  721. 

  722. //扑克转换

  723. BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData)

  724. {

  725. 	ASSERT(IsValidCard(cbCardData));

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

  727. }

  728. 

  729. //扑克转换

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

  731. {

  732. 	//转换扑克

  733. 	BYTE cbPosition=0;

  734. 	//钻牌

  735. 	if( m_cbMagicIndex != MAX_INDEX )

  736. 	{

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

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

  739. 	}

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

  741. 	{

  742. 		if( i == m_cbMagicIndex ) continue;

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

  744. 		{

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

  746. 			{

  747. 				ASSERT(cbPosition<MAX_COUNT);

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

  749. 			}

  750. 		}

  751. 	}

  752. 

  753. 	return cbPosition;

  754. }

  755. 

  756. //扑克转换

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

  758. {

  759. 	//设置变量

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

  761. 

  762. 	//转换扑克

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

  764. 	{

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

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

  767. 	}

  768. 

  769. 	return cbCardCount;

  770. }

  771. 

  772. //分析扑克

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

  774. {

  775. 	//计算数目

  776. 	BYTE cbCardCount=GetCardCount(cbCardIndex);

  777. 

  778. 	//效验数目

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

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

  781. 		return false;

  782. 

  783. 	//变量定义

  784. 	BYTE cbKindItemCount=0;

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

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

  787. 

  788. 	//需求判断

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

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

  791. 

  792. 	//单吊判断

  793. 	if (cbLessKindItem==0)

  794. 	{

  795. 		//效验参数

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

  797. 

  798. 		//牌眼判断

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

  800. 		{

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

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

  803. 			{

  804. 				//变量定义

  805. 				tagAnalyseItem AnalyseItem;

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

  807. 

  808. 				//设置结果

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

  810. 				{

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

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

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

  814. 				}

  815. 				AnalyseItem.cbCardEye=SwitchToCardData(i);

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

  817. 					AnalyseItem.bMagicEye = true;

  818. 				else AnalyseItem.bMagicEye = false;

  819. 

  820. 				//插入结果

  821. 				AnalyseItemArray.Add(AnalyseItem);

  822. 

  823. 				return true;

  824. 			}

  825. 		}

  826. 

  827. 		return false;

  828. 	}

  829. 

  830. 	//拆分分析

  831. 	BYTE cbMagicCardIndex[MAX_INDEX];

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

  833. 	BYTE cbMagicCardCount = 0;

  834. 	if( m_cbMagicIndex != MAX_INDEX )

  835. 	{

  836. 		cbMagicCardCount = cbCardIndex[m_cbMagicIndex];

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

  838. 	}

  839. 	if (cbCardCount>=3)

  840. 	{

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

  842. 		{

  843. 			//同牌判断

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

  845. 			{

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

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

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

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

  850. 				KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;

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

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

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

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

  855. 				cbKindItemCount++;

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

  857. 				{

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

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

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

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

  862. 					KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;

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

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

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

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

  867. 					cbKindItemCount++;

  868. 				}

  869. 			}

  870. 

  871. 			//连牌判断

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

  873. 			{

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

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

  876. 				{

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

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

  879. 					int nMagicCountTemp = cbMagicCardCount;

  880. 					BYTE cbValidIndex[3];

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

  882. 					{

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

  884. 						{

  885. 							if( cbIndex[j] > 0 ) 

  886. 							{

  887. 								cbIndex[j]--;

  888. 								cbValidIndex[j] = i+j;

  889. 							}

  890. 							else 

  891. 							{

  892. 								nMagicCountTemp--;

  893. 								cbValidIndex[j] = m_cbMagicIndex;

  894. 							}

  895. 						}

  896. 						if( nMagicCountTemp >= 0 )

  897. 						{

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

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

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

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

  902. 							KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;

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

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

  905. 							cbKindItemCount++;

  906. 						}

  907. 						else break;

  908. 					}

  909. 				}

  910. 			}

  911. 		}

  912. 	}

  913. 

  914. 	//组合分析

  915. 	if (cbKindItemCount>=cbLessKindItem)

  916. 	{

  917. 		//变量定义

  918. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  920. 

  921. 		//变量定义

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

  923. 		tagKindItem * pKindItem[4];

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

  925. 

  926. 		//开始组合

  927. 		do

  928. 		{

  929. 			//设置变量

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

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

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

  933. 

  934. 			//数量判断

  935. 			bool bEnoughCard=true;

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

  937. 			{

  938. 				//存在判断

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

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

  941. 				{

  942. 					bEnoughCard=false;

  943. 					break;

  944. 				}

  945. 				else 

  946. 					cbCardIndexTemp[cbCardIndex]--;

  947. 			}

  948. 

  949. 			//胡牌判断

  950. 			if (bEnoughCard==true)

  951. 			{

  952. 				//牌眼判断

  953. 				BYTE cbCardEye=0;

  954. 				bool bMagicEye = false;

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

  956. 				{

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

  958. 					{

  959. 						cbCardEye=SwitchToCardData(i);

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

  961. 						break;

  962. 					}

  963. 					else if( i!=m_cbMagicIndex && 

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

  965. 					{

  966. 						cbCardEye = SwitchToCardData(i);

  967. 						bMagicEye = true;

  968. 					}

  969. 				}

  970. 

  971. 				//组合类型

  972. 				if (cbCardEye!=0)

  973. 				{

  974. 					//变量定义

  975. 					tagAnalyseItem AnalyseItem;

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

  977. 

  978. 					//设置组合

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

  980. 					{

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

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

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

  984. 							AnalyseItem.cbCardData[i] );

  985. 					}

  986. 

  987. 					//设置牌型

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

  989. 					{

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

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

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

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

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

  995. 					}

  996. 

  997. 					//设置牌眼

  998. 					AnalyseItem.cbCardEye=cbCardEye;

  999. 					AnalyseItem.bMagicEye = bMagicEye;

  1000. 

  1001. 					//插入结果

  1002. 					AnalyseItemArray.Add(AnalyseItem);

  1003. 				}

  1004. 			}

  1005. 

  1006. 			//设置索引

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

  1008. 			{

  1009. 				BYTE i=cbLessKindItem-1;

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

  1011. 				{

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

  1013. 					{

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

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

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

  1017. 						break;

  1018. 					}

  1019. 				}

  1020. 				if (i==0)

  1021. 					break;

  1022. 			}

  1023. 			else

  1024. 				cbIndex[cbLessKindItem-1]++;

  1025. 		} while (true);

  1026. 

  1027. 	}

  1028. 

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

  1030. }

  1031. 

  1032. //钻牌

  1033. bool CGameLogic::IsMagicCard( BYTE cbCardData )

  1034. {

  1035. 	if( m_cbMagicIndex != MAX_INDEX )

  1036. 		return SwitchToCardIndex(cbCardData) == m_cbMagicIndex;

  1037. 	return false;

  1038. }

  1039. 

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

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

  1042. {

  1043. 	//数目过虑

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

  1045. 

  1046. 	//排序操作

  1047. 	bool bSorted=true;

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

  1049. 	do

  1050. 	{

  1051. 		bSorted=true;

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

  1053. 		{

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

  1055. 			{

  1056. 				//设置标志

  1057. 				bSorted=false;

  1058. 

  1059. 				//扑克数据

  1060. 				cbSwitchData=cbCardData[i];

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

  1062. 				cbCardData[i+1]=cbSwitchData;

  1063. 			}	

  1064. 		}

  1065. 		cbLast--;

  1066. 	} while(bSorted==false);

  1067. 

  1068. 	return true;

  1069. }

  1070. 

  1071. /*

  1072. // 胡法分析函数

  1073. */

  1074. 

  1075. //大对子

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

  1077. {

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

  1079. 	{

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

  1081. 			return false;

  1082. 	}

  1083. 	return true;

  1084. }

  1085. 

  1086. //清一色牌

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

  1088. {

  1089. 	//胡牌判断

  1090. 	BYTE cbCardColor=0xFF;

  1091. 

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

  1093. 	{

  1094. 		if(i==m_cbMagicIndex) continue;

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

  1096. 		{

  1097. 			//花色判断

  1098. 			if (cbCardColor!=0xFF)

  1099. 				return false;

  1100. 

  1101. 			//设置花色

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

  1103. 

  1104. 			//设置索引

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

  1106. 		}

  1107. 	}

  1108. 

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

  1110. 	if( cbCardColor == 0xFF )

  1111. 	{

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

  1113. 		//检查组合

  1114. 		ASSERT( cbItemCount > 0 );

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

  1116. 	}

  1117. 

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

  1119. 

  1120. 	//组合判断

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

  1122. 	{

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

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

  1125. 	}

  1126. 

  1127. 	return true;

  1128. }

  1129. 

  1130. //七小对牌

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

  1132. {

  1133. 	//组合判断

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

  1135. 

  1136. 	//单牌数目

  1137. 	BYTE cbReplaceCount = 0;

  1138. 

  1139. 	//临时数据

  1140. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  1142. 

  1143. 	//插入数据

  1144. 	BYTE cbCurrentIndex = SwitchToCardIndex(cbCurrentCard);

  1145. 	cbCardIndexTemp[cbCurrentIndex]++;

  1146. 

  1147. 	//计算单牌

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

  1149. 	{

  1150. 		BYTE cbCardCount=cbCardIndexTemp[i];

  1151. 

  1152. 		//王牌过滤

  1153. 		if( i == m_cbMagicIndex ) continue;

  1154. 

  1155. 		//单牌统计

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

  1157. 	}

  1158. 

  1159. 	//王牌不够

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

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

  1162. 		return false;

  1163. 

  1164. 	return true;

  1165. 

  1166. }

  1167. 

  1168. //带幺

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

  1170. {

  1171. 	//检查牌眼

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

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

  1174. 

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

  1176. 	{

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

  1178. 		{

  1179. 			BYTE j = 0;

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

  1181. 			{

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

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

  1184. 			}

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

  1186. 		}

  1187. 		else

  1188. 		{

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

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

  1191. 		}

  1192. 	}

  1193. 	return true;

  1194. }

  1195. 

  1196. //将对

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

  1198. {

  1199. 	//是否大对子

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

  1201. 

  1202. 	//检查牌眼

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

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

  1205. 

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

  1207. 	{

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

  1209. 		{

  1210. 			BYTE j = 0;

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

  1212. 			{

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

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

  1215. 			}

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

  1217. 		}

  1218. 		else

  1219. 		{

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

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

  1222. 		}

  1223. 	}

  1224. 	return true;

  1225. }

  1226. 

  1227. //是否花猪

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

  1229. {

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

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

  1232. 	{

  1233. 		if( cbCardIndex[i] > 0 )

  1234. 		{

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

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

  1237. 

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

  1239. 		}

  1240. 	}

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

  1242. 	{

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

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

  1245. 	}

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

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

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

  1249. 

  1250. 	return true;

  1251. }

  1252. 

  1253. //////////////////////////////////////////////////////////////////////////