zhaobu
/
zhujimajiang_redis
1
0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
诸暨麻将添加redis
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
2 Commits
2 Ramas
57 MiB
 
 
 
 
 
 
Árbol: 86964399f5
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '86964399f5'
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/游戏服务器/GameLogic.cpp

1587 líneas
40 KiB
Original Blame Histórico 

  1. #include "StdAfx.h"

  2. #include "GameLogic.h"

  3. #include "math.h"

  4. #include "TableFrameSink.h"

  5. #include "fstream"

  6. //////////////////////////////////////////////////////////////////////////

  7. 

  8. //静态变量

  9. bool		CChiHuRight::m_bInit = false;

  10. DWORD		CChiHuRight::m_dwRightMask[MAX_RIGHT_COUNT];

  11. 

  12. //构造函数

  13. CChiHuRight::CChiHuRight()

  14. {

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

  16. 

  17. 	if( !m_bInit )

  18. 	{

  19. 		m_bInit = true;

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

  21. 		{

  22. 			if( 0 == i )

  23. 				m_dwRightMask[i] = 0;

  24. 			else

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

  26. 		}

  27. 	}

  28. }

  29. 

  30. //赋值符重载

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

  32. {

  33. 	DWORD dwOtherRight = 0;

  34. 	//验证权位

  35. 	if( !IsValidRight( dwRight ) )

  36. 	{

  37. 		//验证取反权位

  38. 		ASSERT( IsValidRight( ~dwRight ) );

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

  40. 		dwRight = ~dwRight;

  41. 		dwOtherRight = MASK_CHI_HU_RIGHT;

  42. 	}

  43. 

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

  45. 	{

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

  47. 			m_dwRight[i] = dwRight&MASK_CHI_HU_RIGHT;

  48. 		else m_dwRight[i] = dwOtherRight;

  49. 	}

  50. 

  51. 	return *this;

  52. }

  53. 

  54. //与等于

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

  56. {

  57. 	bool bNavigate = false;

  58. 	//验证权位

  59. 	if( !IsValidRight( dwRight ) )

  60. 	{

  61. 		//验证取反权位

  62. 		ASSERT( IsValidRight( ~dwRight ) );

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

  64. 		//调整权位

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

  66. 		DWORD dwTailRight = dwRight&MASK_CHI_HU_RIGHT;

  67. 		dwRight = dwHeadRight|dwTailRight;

  68. 		bNavigate = true;

  69. 	}

  70. 

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

  72. 	{

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

  74. 		{

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

  76. 		}

  77. 		else if( !bNavigate )

  78. 			m_dwRight[i] = 0;

  79. 	}

  80. 

  81. 	return *this;

  82. }

  83. 

  84. //或等于

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

  86. {

  87. 	//验证权位

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

  89. 

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

  91. 	{

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

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

  94. 	}

  95. 

  96. 	return *this;

  97. }

  98. 

  99. //与

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

  101. {

  102. 	CChiHuRight chr = *this;

  103. 	return (chr &= dwRight);

  104. }

  105. 

  106. //与

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

  108. {

  109. 	CChiHuRight chr = *this;

  110. 	return (chr &= dwRight);

  111. }

  112. 

  113. //或

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

  115. {

  116. 	CChiHuRight chr = *this;

  117. 	return chr |= dwRight;

  118. }

  119. 

  120. //或

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

  122. {

  123. 	CChiHuRight chr = *this;

  124. 	return chr |= dwRight;

  125. }

  126. 

  127. //是否权位为空

  128. bool CChiHuRight::IsEmpty()

  129. {

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

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

  132. 	return true;

  133. }

  134. 

  135. //设置权位为空

  136. void CChiHuRight::SetEmpty()

  137. {

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

  139. 	return;

  140. }

  141. 

  142. //获取权位数值

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

  144. {

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

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

  147. 

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

  149. 	return CountArray(m_dwRight);

  150. }

  151. 

  152. //设置权位数值

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

  154. {

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

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

  157. 

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

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

  160. 	

  161. 	return true;

  162. }

  163. 

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

  165. bool CChiHuRight::IsValidRight( DWORD dwRight )

  166. {

  167. 	DWORD dwRightHead = dwRight & 0xF0000000;

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

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

  170. 	return false;

  171. }

  172. 

  173. //////////////////////////////////////////////////////////////////////////

  174. 

  175. 

  176. 

  177. //////////////////////////////////////////////////////////////////////////

  178. //静态变量

  179. 

  180. //扑克数据,一脚癞油的基础数据

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

  182. {

  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. 	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子

  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. 	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子

  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. 	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子

  195. };

  196. 

  197. //三人两房 扑克数据

  198. const BYTE CGameLogic::m_cbCardDataArray_SRLF[MAX_REPERTORY_SRLF] =

  199. {

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

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

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

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

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

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

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

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

  208. };

  209. 

  210. //////////////////////////////////////////////////////////////////////////

  211. 

  212. //构造函数

  213. CGameLogic::CGameLogic(CTableFrameSink* pTableFramSink)

  214. {

  215. 	m_cbMagicIndex = MAX_INDEX;

  216. 	m_pTableFramSink = pTableFramSink;

  217. }

  218. 

  219. //析构函数

  220. CGameLogic::~CGameLogic()

  221. {

  222. }

  223. 

  224. //混乱扑克

  225. BYTE CGameLogic::RandCardData(BYTE cbCardData[])

  226. {

  227. 	BYTE cbCardDataTemp[MAX_REPERTORY];

  228. 	BYTE cbMaxCount = 0;

  229. 	//混乱准备

  230. 	//if (srlf == m_pTableFramSink->m_gameConfig.wSubGameID)

  231. 	//{

  232. 	//	CopyMemory(cbCardDataTemp, m_cbCardDataArray_SRLF, sizeof(m_cbCardDataArray_SRLF));

  233. 	//	cbMaxCount = MAX_REPERTORY_SRLF;

  234. 	//}

  235. 	//else {

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

  237. 	cbMaxCount = MAX_REPERTORY;

  238. 	//}

  239. 	//混乱扑克

  240. 	BYTE cbRandCount = 0, cbPosition = 0;

  241. 	do

  242. 	{

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

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

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

  246. 	} while (cbRandCount < cbMaxCount);

  247. 	cbRandCount = 0, cbPosition = 0;

  248. 	ZeroMemory(cbCardDataTemp, sizeof(cbCardDataTemp));

  249. 	CopyMemory(cbCardDataTemp, cbCardData, sizeof(cbCardDataTemp));

  250. 	ZeroMemory(cbCardData, sizeof(cbCardData));

  251. 	do

  252. 	{

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

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

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

  256. 	} while (cbRandCount < cbMaxCount);

  257. 	return cbMaxCount;

  258. }

  259. 

  260. //删除扑克

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

  262. {

  263. 	//效验扑克

  264. 	ASSERT(IsValidCard(cbRemoveCard));

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

  266. 

  267. 	//删除扑克

  268. 	BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);

  269. 	if (cbCardIndex[cbRemoveIndex]>0)

  270. 	{

  271. 		cbCardIndex[cbRemoveIndex]--;

  272. 		return true;

  273. 	}

  274. 

  275. 	//失败效验

  276. 	ASSERT(FALSE);

  277. 

  278. 	return false;

  279. }

  280. 

  281. //删除扑克

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

  283. {

  284. 	//删除扑克

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

  286. 	{

  287. 		//效验扑克

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

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

  290. 

  291. 		//删除扑克

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

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

  294. 		{

  295. 			//错误断言

  296. 			ASSERT(FALSE);

  297. 

  298. 			//还原删除

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

  300. 			{

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

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

  303. 			}

  304. 

  305. 			return false;

  306. 		}

  307. 		else 

  308. 		{

  309. 			//删除扑克

  310. 			--cbCardIndex[cbRemoveIndex];

  311. 		}

  312. 	}

  313. 

  314. 	return true;

  315. }

  316. 

  317. //删除扑克

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

  319. {

  320. 	//检验数据

  321. 	ASSERT(cbCardCount<=14);

  322. 	ASSERT(cbRemoveCount<=cbCardCount);

  323. 

  324. 	//定义变量

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

  326. 	if (cbCardCount>CountArray(cbTempCardData))

  327. 		return false;

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

  329. 

  330. 	//置零扑克

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

  332. 	{

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

  334. 		{

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

  336. 			{

  337. 				cbDeleteCount++;

  338. 				cbTempCardData[j]=0;

  339. 				break;

  340. 			}

  341. 		}

  342. 	}

  343. 

  344. 	//成功判断

  345. 	if (cbDeleteCount!=cbRemoveCount) 

  346. 	{

  347. 		ASSERT(FALSE);

  348. 		return false;

  349. 	}

  350. 

  351. 	//清理扑克

  352. 	BYTE cbCardPos=0;

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

  354. 	{

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

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

  357. 	}

  358. 

  359. 	return true;

  360. }

  361. 

  362. //有效判断

  363. bool CGameLogic::IsValidCard(BYTE cbCardData)

  364. {

  365. 	BYTE cbValue=(cbCardData&MASK_VALUE);

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

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

  368. }

  369. 

  370. 

  371. //扑克数目

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

  373. {

  374. 	//数目统计

  375. 	BYTE cbCardCount=0;

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

  377. 		cbCardCount+=cbCardIndex[i];

  378. 

  379. 	return cbCardCount;

  380. }

  381. 

  382. //获取组合

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

  384. {

  385. 	//组合扑克

  386. 	switch (cbWeaveKind)

  387. 	{

  388. 	case WIK_LEFT:		//上牌操作

  389. 		{

  390. 			//设置变量

  391. 			cbCardBuffer[0]=cbCenterCard;

  392. 			cbCardBuffer[1]=cbCenterCard+1;

  393. 			cbCardBuffer[2]=cbCenterCard+2;

  394. 

  395. 			return 3;

  396. 		}

  397. 	case WIK_RIGHT:		//上牌操作

  398. 		{

  399. 			//设置变量

  400. 			cbCardBuffer[0]=cbCenterCard;

  401. 			cbCardBuffer[1]=cbCenterCard-1;

  402. 			cbCardBuffer[2]=cbCenterCard-2;

  403. 

  404. 			return 3;

  405. 		}

  406. 	case WIK_CENTER:	//上牌操作

  407. 		{

  408. 			//设置变量

  409. 			cbCardBuffer[0]=cbCenterCard;

  410. 			cbCardBuffer[1]=cbCenterCard-1;

  411. 			cbCardBuffer[2]=cbCenterCard+1;

  412. 

  413. 			return 3;

  414. 		}

  415. 	case WIK_PENG:		//碰牌操作

  416. 		{

  417. 			//设置变量

  418. 			cbCardBuffer[0]=cbCenterCard;

  419. 			cbCardBuffer[1]=cbCenterCard;

  420. 			cbCardBuffer[2]=cbCenterCard;

  421. 

  422. 			return 3;

  423. 		}

  424. 	case WIK_GANG:		//杠牌操作

  425. 		{

  426. 			//设置变量

  427. 			cbCardBuffer[0]=cbCenterCard;

  428. 			cbCardBuffer[1]=cbCenterCard;

  429. 			cbCardBuffer[2]=cbCenterCard;

  430. 			cbCardBuffer[3]=cbCenterCard;

  431. 

  432. 			return 4;

  433. 		}

  434. 	case WIK_MING_GANG:		//明杠牌操作

  435. 	{

  436. 		//设置变量

  437. 		cbCardBuffer[0] = cbCenterCard;

  438. 		cbCardBuffer[1] = cbCenterCard;

  439. 		cbCardBuffer[2] = cbCenterCard;

  440. 		cbCardBuffer[3] = cbCenterCard;

  441. 

  442. 		return 4;

  443. 	}

  444. 	case WIK_AN_GANG:		//暗杠牌操作

  445. 	{

  446. 		//设置变量

  447. 		cbCardBuffer[0] = cbCenterCard;

  448. 		cbCardBuffer[1] = cbCenterCard;

  449. 		cbCardBuffer[2] = cbCenterCard;

  450. 		cbCardBuffer[3] = cbCenterCard;

  451. 

  452. 		return 4;

  453. 	}

  454. 	case WIK_AN_PIGANG:		//暗皮杠牌操作

  455. 	{

  456. 		//设置变量

  457. 		cbCardBuffer[0] = cbCenterCard;

  458. 		cbCardBuffer[1] = cbCenterCard;

  459. 		cbCardBuffer[2] = cbCenterCard;

  460. 

  461. 		return 3;

  462. 	}

  463. 	case WIK_MING_PIGANG:		//明皮杠牌操作

  464. 	{

  465. 		//设置变量

  466. 		cbCardBuffer[0] = cbCenterCard;

  467. 		cbCardBuffer[1] = cbCenterCard;

  468. 		cbCardBuffer[2] = cbCenterCard;

  469. 

  470. 		return 3;

  471. 	}

  472. 	case WIK_BU_GANG:

  473. 	{

  474. 		cbCardBuffer[0] = cbCenterCard;

  475. 		cbCardBuffer[1] = cbCenterCard;

  476. 		cbCardBuffer[2] = cbCenterCard;

  477. 		cbCardBuffer[3] = cbCenterCard;

  478. 

  479. 		return 4;

  480. 	}

  481. 	default:

  482. 		{

  483. 			ASSERT(FALSE);

  484. 		}

  485. 	}

  486. 	return 0;

  487. }

  488. 

  489. //动作等级,只有碰，杠

  490. BYTE CGameLogic::GetUserActionRank(BYTE cbUserAction)

  491. {

  492. 	//胡牌等级

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

  494. 

  495. 	//杠牌等级

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

  497. 

  498. 	//碰牌等级

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

  500. 

  501. 	//上牌等级

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

  503. 

  504. 	return 0;

  505. }

  506. 

  507. //胡牌等级

  508. //WORD CGameLogic::GetChiHuActionRank(const CChiHuRight & ChiHuRight)

  509. //{

  510. //	WORD wFanShu = 0;

  511. //

  512. //	if (!(ChiHuRight&CHR_YING_LAIYOU).IsEmpty())

  513. //		wFanShu = 4;

  514. //	else if( !(ChiHuRight&CHR_RUAN_LAIYOU).IsEmpty() )

  515. //		wFanShu = 2;

  516. //	else if (!(ChiHuRight&CHR_YING_ZIMO).IsEmpty())

  517. //		wFanShu = 2;

  518. //	else if (!(ChiHuRight&CHR_RUAN_ZIMO).IsEmpty())

  519. //		wFanShu = 1;

  520. //	ASSERT( wFanShu > 0 );

  521. //	return wFanShu;

  522. //}

  523. 

  524. //吃牌判断 一脚耐油不需要

  525. /*

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

  527. {

  528. 	//参数效验

  529. 	ASSERT(IsValidCard(cbCurrentCard));

  530. 

  531. 	//过滤判断

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

  533. 		return WIK_NULL;

  534. 

  535. 	//变量定义

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

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

  538. 

  539. 	//吃牌判断

  540. 	BYTE cbEatKind=0,cbFirstIndex=0;

  541. 	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);

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

  543. 	{

  544. 		BYTE cbValueIndex=cbCurrentIndex%9;

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

  546. 		{

  547. 			//吃牌判断

  548. 			cbFirstIndex=cbCurrentIndex-cbExcursion[i];

  549. 

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

  551. 			if( m_cbMagicIndex != MAX_INDEX &&

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

  553. 

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

  555. 				continue;

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

  557. 				continue;

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

  559. 				continue;

  560. 

  561. 			//设置类型

  562. 			cbEatKind|=cbItemKind[i];

  563. 		}

  564. 	}

  565. 

  566. 	return cbEatKind;

  567. }*/

  568. 

  569. //碰牌判断

  570. int CGameLogic::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard, BYTE LaiZiPiData)

  571. {

  572. 	//参数效验

  573. 	ASSERT(IsValidCard(cbCurrentCard));

  574. 

  575. 	//过滤判断

  576. 	if (IsMagicCard(cbCurrentCard))

  577. 		return WIK_NULL;

  578. 	if (cbCurrentCard == LaiZiPiData)

  579. 	{

  580. 		BYTE index = SwitchToCardIndex(cbCurrentCard);

  581. 		BYTE zhi = cbCardIndex[index];

  582. 		return (zhi == 2) ? WIK_MING_PIGANG : WIK_NULL;

  583. 	}

  584. 	//碰牌判断

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

  586. }

  587. 

  588. //杠牌判断

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

  590. {

  591. 	//参数效验

  592. 	ASSERT(IsValidCard(cbCurrentCard));

  593. 

  594. 	//过滤判断

  595. 	if ( IsMagicCard(cbCurrentCard) ) 

  596. 		return WIK_NULL;

  597. 	BYTE index = SwitchToCardIndex(cbCurrentCard);

  598. 	BYTE zhi = cbCardIndex[index];

  599. 	//杠牌判断

  600. 	return (zhi==3)?WIK_MING_GANG:WIK_NULL;

  601. }

  602. 

  603. //杠牌分析

  604. int CGameLogic::AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX], const BYTE m_cbLaiZiData, const BYTE m_cbLaiZiPiData, const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult, BYTE bProvideCard, bool bCanAnGang /* = true */)

  605. {

  606. 	//设置变量

  607. 	int cbActionMask = WIK_NULL;

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

  609. 

  610. 	if (cbCardIndex[SwitchToCardIndex(m_cbLaiZiPiData)] == 3)

  611. 	{

  612. 		cbActionMask |= (WIK_GANG | WIK_AN_PIGANG);

  613. 		GangCardResult.cbCardData[GangCardResult.cbCardCount++] = m_cbLaiZiPiData;//癞子皮杠

  614. 	}

  615. 	//手上杠牌

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

  617. 	{

  618. 		if (i == m_cbMagicIndex) continue;

  619. 		if (i == SwitchToCardIndex(m_cbLaiZiData))continue;

  620. 		//if (cbCardIndex[i] == 3)

  621. 		//{

  622. 		//	BYTE cbCardLaiZiData = SwitchToCardData(i);//用户手上牌有3个一样的牌，把这个牌复制给临时变量

  623. 		//	if (cbCardLaiZiData == m_cbLaiZiPiData)//判断是否是癞子皮

  624. 		//	{

  625. 		//		cbActionMask |= WIK_GANG;

  626. 		//		GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardLaiZiData;//癞子皮杠

  627. 		//	}

  628. 		//}

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

  630. 		{

  631. 			BYTE cbCardData = SwitchToCardData(i);

  632. 			cbActionMask |= (WIK_GANG | WIK_AN_GANG);

  633. 			GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardData;

  634. 		}

  635. 	}

  636. 	

  637. 	//组合杠牌

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

  639. 	{

  640. 		if (WeaveItem[i].cbWeaveKind == WIK_PENG && WeaveItem[i].cbCenterCard == bProvideCard)

  641. 		{

  642. 			cbActionMask |= WIK_BU_GANG;

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

  644. 		}

  645. 	}

  646. 

  647. 	return cbActionMask;

  648. }

  649. 

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

  651. {

  652. 	if (bSubMit == OneStepLaiYou || bSubMit == BanLai)

  653. 	{

  654. 		//变量定义

  655. 		int cbChiHuKind = WIK_NULL;

  656. 		CAnalyseItemArray AnalyseItemArray;

  657. 

  658. 		//设置变量

  659. 		AnalyseItemArray.RemoveAll();

  660. 		ChiHuRight.SetEmpty();

  661. 

  662. 		//构造扑克

  663. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  665. 

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

  667. 		ASSERT(cbCurrentCard != 0);

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

  669. 

  670. 		if (!ChiHuRight.IsEmpty())

  671. 			cbChiHuKind = WIK_ZI_MO;

  672. 

  673. 		//插入扑克

  674. 		if (cbCurrentCard == 0)

  675. 		{

  676. 			ASSERT(false);

  677. 			return false;

  678. 		}

  679. 

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

  681. 

  682. 		BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);//癞子在牌里面的索引

  683. 		if (cbCardIndexTemp[LaiZiIndex] > 1)//手上癞子超过2个或者2个，就不能胡牌，必须打掉一个

  684. 		{

  685. 			return WIK_NULL;

  686. 		}

  687. 		BYTE isHuPaiCount = 0;

  688. 		if (cbCardIndexTemp[LaiZiIndex] == 1 && cbCurrentCard != m_cbLaiZi)

  689. 		{

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

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

  692. 			{

  693. 				return WIK_ZI_MO | WIK_YING_ZIMO;

  694. 			}

  695. 			AnalyseItemArray.RemoveAll();

  696. 			cbCardIndexTemp[LaiZiIndex]--;

  697. 			cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]--;

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

  699. 			{

  700. 				if (i == LaiZiIndex)continue;

  701. 				cbCardIndexTemp[i] += 2;

  702. 				if (cbCardIndexTemp[i]>5)

  703. 				{

  704. 					isHuPaiCount++;

  705. 					cbCardIndexTemp[i] -= 2;

  706. 					continue;

  707. 				}

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

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

  710. 				{

  711. 					isHuPaiCount++;

  712. 				}

  713. 				AnalyseItemArray.RemoveAll();

  714. 				cbCardIndexTemp[i] -= 2;

  715. 			}

  716. 			if (isHuPaiCount >= 26)

  717. 			{

  718. 				return WIK_NULL;

  719. 			}

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

  721. 			//分析扑克，cbCardIndexTemp是用户手上的牌，WeaveItem,

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

  723. 			{

  724. 				if (i == LaiZiIndex)continue;

  725. 				if (cbCardIndexTemp[i]>4)continue;

  726. 				cbCardIndexTemp[i]++;

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

  728. 				//胡牌分析

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

  730. 				{

  731. 					cbChiHuKind = WIK_ZI_MO;

  732. 					return cbChiHuKind;

  733. 				}

  734. 				AnalyseItemArray.RemoveAll();

  735. 				cbCardIndexTemp[i]--;

  736. 			}

  737. 			//if (cbChiHuKind&WIK_ZI_MO)

  738. 			//{

  739. 			//	cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]--;

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

  741. 			//	{

  742. 			//		if (i == LaiZiIndex)continue;

  743. 			//		cbCardIndexTemp[i] += 2;

  744. 			//		AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);

  745. 			//		if (AnalyseItemArray.GetCount()>0)

  746. 			//		{

  747. 			//			isHuPaiCount++;

  748. 			//		}

  749. 			//		cbCardIndexTemp[i] -= 2;

  750. 			//	}

  751. 			//	if (isHuPaiCount >= 26) //当有癞子时，且癞子是个万能和牌时，需要打掉，或者改牌

  752. 			//	{

  753. 			//		isHuPaiCount = 0;

  754. 			//		return WIK_NULL;

  755. 			//	}

  756. 			//	cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

  757. 			//}			

  758. 			cbCardIndexTemp[LaiZiIndex]++;

  759. 			return cbChiHuKind;

  760. 		}

  761. 		else

  762. 		{

  763. 			if (cbCurrentCard == m_cbLaiZi)

  764. 			{

  765. 				if (cbCardIndexTemp[LaiZiIndex] != 1)

  766. 				{

  767. 					ASSERT(false);

  768. 					return false;

  769. 				}

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

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

  772. 				{

  773. 					return WIK_ZI_MO | WIK_YING_ZIMO;

  774. 				}

  775. 				cbCardIndexTemp[LaiZiIndex]--;

  776. 				//分析扑克，cbCardIndexTemp是用户手上的牌，WeaveItem,

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

  778. 				{

  779. 					if (i == LaiZiIndex)continue;

  780. 					cbCardIndexTemp[i]++;

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

  782. 					//胡牌分析

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

  784. 					{

  785. 						cbChiHuKind = WIK_ZI_MO;

  786. 						return cbChiHuKind;

  787. 					}

  788. 					AnalyseItemArray.RemoveAll();

  789. 					cbCardIndexTemp[i]--;

  790. 				}

  791. 				cbCardIndexTemp[LaiZiIndex]++;

  792. 				return cbChiHuKind;

  793. 			}

  794. 			else

  795. 			{

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

  797. 				//胡牌分析

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

  799. 				{

  800. 					cbChiHuKind |= WIK_ZI_MO;

  801. 					cbChiHuKind |= WIK_YING_ZIMO;

  802. 				}

  803. 				return cbChiHuKind;

  804. 			}

  805. 		}

  806. 		return false;

  807. 	}

  808. 	if (bSubMit == WuLaiDaoDi)

  809. 	{

  810. 		//变量定义

  811. 		int cbChiHuKind = WIK_NULL;

  812. 		CAnalyseItemArray AnalyseItemArray;

  813. 

  814. 		//设置变量

  815. 		AnalyseItemArray.RemoveAll();

  816. 		ChiHuRight.SetEmpty();

  817. 

  818. 		//构造扑克

  819. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  821. 

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

  823. 		ASSERT(cbCurrentCard != 0);

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

  825. 

  826. 		if (!ChiHuRight.IsEmpty())

  827. 			cbChiHuKind = WIK_ZI_MO;

  828. 

  829. 		//插入扑克

  830. 		if (cbCurrentCard == 0)

  831. 		{

  832. 			ASSERT(false);

  833. 			return false;

  834. 		}

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

  836. 		BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);//癞子在牌里面的索引

  837. 		if (cbCardIndexTemp[LaiZiIndex] > 0)

  838. 		{

  839. 			return WIK_NULL;

  840. 		}

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

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

  843. 		{

  844. 			cbChiHuKind |= WIK_ZI_MO;

  845. 			cbChiHuKind |= WIK_YING_ZIMO;

  846. 		}

  847. 		return cbChiHuKind;

  848. 	}

  849. 	return false;

  850. }

  851. //听牌分析,

  852. bool CGameLogic::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *m_cbTingPaiData, BYTE m_cbLaiZi, BYTE subMit,BYTE LaiZiCount)

  853. {

  854. 	//复制数据

  855. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  857. 

  858. 	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);

  859. 	if (cbCardCount > 1 && (cbCardCount - 1) % 3 != 0)

  860. 	{

  861. 		ASSERT(false);

  862. 		return false;

  863. 	}

  864. 	CChiHuRight chr;

  865. 

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

  867. 	{

  868. 		BYTE cbCurrentCard = SwitchToCardData(i);

  869. 		if (cbCurrentCard == m_cbLaiZi&&subMit == WuLaiDaoDi)continue;

  870. 		if (subMit == BanLai)

  871. 		{

  872. 			int wikChiHu = AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit);

  873. 			if ((LaiZiCount == 0 && (wikChiHu&WIK_YING_ZIMO) == WIK_YING_ZIMO) || (LaiZiCount > 0 && (wikChiHu&WIK_ZI_MO) == WIK_ZI_MO))

  874. 				m_cbTingPaiData[i] = 1;

  875. 			else

  876. 			{

  877. 				m_cbTingPaiData[i] = 0;

  878. 			}				

  879. 		}

  880. 		else

  881. 		{

  882. 			if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit))

  883. 				m_cbTingPaiData[i] = 1;

  884. 			else

  885. 			{

  886. 				m_cbTingPaiData[i] = 0;

  887. 			}

  888. 		}

  889. 	}

  890. 	return true;

  891. }

  892. 

  893. //是否听牌

  894. bool CGameLogic::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE m_cbLaiZi, BYTE subMit, BYTE LaiZiCount)

  895. {

  896. 	//复制数据

  897. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  899. 	BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);

  900. 	CChiHuRight chr;

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

  902. 	{

  903. 		BYTE cbCurrentCard = SwitchToCardData(i);

  904. 		if (((i == LaiZiIndex) && (cbCardIndexTemp[i] > 0) && (subMit == OneStepLaiYou || subMit == BanLai)) || (i == LaiZiIndex&& subMit == WuLaiDaoDi))

  905. 			continue;

  906. 		if (subMit == BanLai && LaiZiCount == 0)

  907. 		{

  908. 			int wikChiHu = AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit);

  909. 			if (WIK_YING_ZIMO & wikChiHu)

  910. 			{

  911. 				return true;

  912. 			}

  913. 			else

  914. 				continue;

  915. 		}

  916. 			

  917. 		if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit))

  918. 			return true;

  919. 	}

  920. 	return false;

  921. }

  922. 

  923. //扑克转换

  924. BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex)

  925. {

  926. 	//ASSERT(cbCardIndex<34);

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

  928. }

  929. 

  930. //扑克转换

  931. BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData)

  932. {

  933. 	ASSERT(IsValidCard(cbCardData));

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

  935. }

  936. 

  937. //扑克转换

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

  939. {

  940. 	//转换扑克

  941. 	BYTE cbPosition=0;

  942. 	//钻牌

  943. 	if( m_cbMagicIndex != MAX_INDEX )

  944. 	{

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

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

  947. 	}

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

  949. 	{

  950. 		if( i == m_cbMagicIndex ) continue;

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

  952. 		{

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

  954. 			{

  955. 				ASSERT(cbPosition<MAX_COUNT);

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

  957. 			}

  958. 		}

  959. 	}

  960. 

  961. 	return cbPosition;

  962. }

  963. 

  964. //扑克转换

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

  966. {

  967. 	//设置变量

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

  969. 

  970. 	//转换扑克

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

  972. 	{

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

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

  975. 	}

  976. 

  977. 	return cbCardCount;

  978. }

  979. 

  980. //分析扑克

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

  982. {

  983. 	//计算数目

  984. 	BYTE cbCardCount = GetCardCount(cbCardIndex);

  985. 

  986. 	//效验数目

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

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

  989. 		return false;

  990. 

  991. 	//变量定义

  992. 	BYTE cbKindItemCount = 0;

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

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

  995. 

  996. 	//需求判断

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

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

  999. 

  1000. 	//单吊判断

  1001. 	if (cbLessKindItem == 0)

  1002. 	{

  1003. 		//效验参数

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

  1005. 

  1006. 		//牌眼判断

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

  1008. 		{

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

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

  1011. 			{

  1012. 				//变量定义

  1013. 				tagAnalyseItem AnalyseItem;

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

  1015. 

  1016. 				//设置结果

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

  1018. 				{

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

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

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

  1022. 				}

  1023. 				AnalyseItem.cbCardEye = SwitchToCardData(i);

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

  1025. 					AnalyseItem.bMagicEye = true;

  1026. 				else AnalyseItem.bMagicEye = false;

  1027. 

  1028. 				//插入结果

  1029. 				AnalyseItemArray.Add(AnalyseItem);

  1030. 

  1031. 				return true;

  1032. 			}

  1033. 		}

  1034. 		return false;

  1035. 	}

  1036. 

  1037. 	//拆分分析，用户手上的临时牌变量

  1038. 	BYTE cbMagicCardIndex[MAX_INDEX];

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

  1040. 	BYTE cbMagicCardCount = 0;//用来干什么的不知道

  1041. 	if (m_cbMagicIndex != MAX_INDEX)

  1042. 	{

  1043. 		cbMagicCardCount = cbCardIndex[m_cbMagicIndex];

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

  1045. 	}

  1046. 	if (cbCardCount >= 3)

  1047. 	{

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

  1049. 		{

  1050. 			//同牌判断

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

  1052. 			{

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

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

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

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

  1057. 				KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;

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

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

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

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

  1062. 				cbKindItemCount++;

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

  1064. 				{

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

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

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

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

  1069. 					KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;

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

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

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

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

  1074. 					cbKindItemCount++;

  1075. 				}

  1076. 			}

  1077. 

  1078. 			//连牌判断

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

  1080. 			{

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

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

  1083. 				{

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

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

  1086. 					int nMagicCountTemp = cbMagicCardCount;

  1087. 					BYTE cbValidIndex[3];

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

  1089. 					{

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

  1091. 						{

  1092. 							if (cbIndex[j] > 0)

  1093. 							{

  1094. 								cbIndex[j]--;

  1095. 								cbValidIndex[j] = i + j;

  1096. 							}

  1097. 							else

  1098. 							{

  1099. 								nMagicCountTemp--;

  1100. 								cbValidIndex[j] = m_cbMagicIndex;

  1101. 							}

  1102. 						}

  1103. 						if (nMagicCountTemp >= 0)

  1104. 						{

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

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

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

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

  1109. 							KindItem[cbKindItemCount].cbWeaveKind = WIK_LEFT;

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

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

  1112. 							cbKindItemCount++;

  1113. 						}

  1114. 						else break;

  1115. 					}

  1116. 				}

  1117. 			}

  1118. 		}

  1119. 	}

  1120. 

  1121. 	//组合分析

  1122. 	if (cbKindItemCount >= cbLessKindItem)

  1123. 	{

  1124. 		//变量定义

  1125. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  1127. 

  1128. 		//变量定义

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

  1130. 		tagKindItem * pKindItem[4];

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

  1132. 

  1133. 		//开始组合

  1134. 		do

  1135. 		{

  1136. 			//设置变量

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

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

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

  1140. 

  1141. 			//数量判断

  1142. 			bool bEnoughCard = true;

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

  1144. 			{

  1145. 				//存在判断

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

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

  1148. 				{

  1149. 					bEnoughCard = false;

  1150. 					break;

  1151. 				}

  1152. 				else

  1153. 					cbCardIndexTemp[cbCardIndex]--;

  1154. 			}

  1155. 

  1156. 			//胡牌判断

  1157. 			if (bEnoughCard == true)

  1158. 			{

  1159. 				//牌眼判断

  1160. 				BYTE cbCardEye = 0;

  1161. 				bool bMagicEye = false;

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

  1163. 				{

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

  1165. 					{

  1166. 						cbCardEye = SwitchToCardData(i);

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

  1168. 						break;

  1169. 					}

  1170. 					else if (i != m_cbMagicIndex &&

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

  1172. 					{

  1173. 						cbCardEye = SwitchToCardData(i);

  1174. 						bMagicEye = true;

  1175. 					}

  1176. 				}

  1177. 

  1178. 				//组合类型

  1179. 				if (cbCardEye != 0)

  1180. 				{

  1181. 					//变量定义

  1182. 					tagAnalyseItem AnalyseItem;

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

  1184. 

  1185. 					//设置组合

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

  1187. 					{

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

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

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

  1191. 							AnalyseItem.cbCardData[i]);

  1192. 					}

  1193. 

  1194. 					//设置牌型

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

  1196. 					{

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

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

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

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

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

  1202. 					}

  1203. 

  1204. 					//设置牌眼

  1205. 					AnalyseItem.cbCardEye = cbCardEye;

  1206. 					AnalyseItem.bMagicEye = bMagicEye;

  1207. 

  1208. 					//插入结果

  1209. 					AnalyseItemArray.Add(AnalyseItem);

  1210. 				}

  1211. 			}

  1212. 

  1213. 			//设置索引

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

  1215. 			{

  1216. 				BYTE i = cbLessKindItem - 1;

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

  1218. 				{

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

  1220. 					{

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

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

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

  1224. 						break;

  1225. 					}

  1226. 				}

  1227. 				if (i == 0)

  1228. 					break;

  1229. 			}

  1230. 			else

  1231. 				cbIndex[cbLessKindItem - 1]++;

  1232. 		} while (true);

  1233. 

  1234. 	}

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

  1236. }

  1237. 

  1238. //钻牌

  1239. bool CGameLogic::IsMagicCard( BYTE cbCardData )

  1240. {

  1241. 	if( m_cbMagicIndex != MAX_INDEX )

  1242. 		return SwitchToCardIndex(cbCardData) == m_cbMagicIndex;

  1243. 	return false;

  1244. }

  1245. //获取手牌癞子数量

  1246. BYTE CGameLogic::GetLaiZiCount(const BYTE cbCardIndex[MAX_INDEX], BYTE m_cbLaiZi)

  1247. {

  1248. 	BYTE LaiZiCount = 0;//判断玩家手上是否有癞子

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

  1250. 	{

  1251. 		if (cbCardIndex[i] == 0)continue;

  1252. 		if (SwitchToCardData(i) == m_cbLaiZi)//癞子不能有多个，否则需要打出去

  1253. 		{

  1254. 			if (cbCardIndex[i] == 1)

  1255. 			{

  1256. 				LaiZiCount = 1;

  1257. 			}

  1258. 			else

  1259. 			{

  1260. 				LaiZiCount = 2;

  1261. 			}

  1262. 		}

  1263. 	}

  1264. 	return LaiZiCount;

  1265. }

  1266. 

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

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

  1269. {

  1270. 	//数目过虑

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

  1272. 

  1273. 	//排序操作

  1274. 	bool bSorted=true;

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

  1276. 	do

  1277. 	{

  1278. 		bSorted=true;

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

  1280. 		{

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

  1282. 			{

  1283. 				//设置标志

  1284. 				bSorted=false;

  1285. 

  1286. 				//扑克数据

  1287. 				cbSwitchData=cbCardData[i];

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

  1289. 				cbCardData[i+1]=cbSwitchData;

  1290. 			}	

  1291. 		}

  1292. 		cbLast--;

  1293. 	} while(bSorted==false);

  1294. 

  1295. 	return true;

  1296. }

  1297. 

  1298. byte CGameLogic::GetValue(USHORT uNum, byte PaiZhi)

  1299. {

  1300. 	byte bRet = 0;

  1301. 

  1302. 	switch (uNum)

  1303. 	{

  1304. 	case 0:

  1305. 		return PaiZhi;

  1306. 	case 1:

  1307. 		return PaiZhi + 41;

  1308. 	case 2:

  1309. 		return PaiZhi + 82;

  1310. 	case 3:

  1311. 		return PaiZhi + 123;

  1312. 	case 4:

  1313. 		return PaiZhi + 164;

  1314. 	default:

  1315. 		ASSERT(FALSE);

  1316. 		return 0;

  1317. 		throw _T("非法数值");

  1318. 		break;

  1319. 	}

  1320. 

  1321. 	return bRet + PaiZhi;

  1322. }

  1323. 

  1324. bool CGameLogic::PeiPai(BYTE ParZhi[MAX_REPERTORY])

  1325. {

  1326. 	std::ifstream in;

  1327. 	std::string filename = "zuopai.dat";

  1328. 	in.open(filename);

  1329. 	if (!in.is_open())

  1330. 	{

  1331. 		return false;

  1332. 		//ASSERT(false);

  1333. 	}

  1334. 	static BYTE TempCardData[MAX_REPERTORY];

  1335. 	//static BYTE TempCardDatar[MAX_REPERTORY];

  1336. 	ZeroMemory(TempCardData, sizeof(TempCardData));

  1337. 	//ZeroMemory(TempCardDatar, sizeof(TempCardDatar));

  1338. 	BYTE tempCount = 0;

  1339. 	char ch[1];

  1340. 	while (!in.eof())

  1341. 	{

  1342. 		in.read(ch, 1);

  1343. 		TempCardData[tempCount++] = ch[0];

  1344. 	}

  1345. 	in.close(); 

  1346. 	//TempCardData[108] = 0;

  1347. 	for (BYTE i = 0; i < MAX_REPERTORY; i++)

  1348. 	{

  1349. 		ASSERT(i < MAX_REPERTORY);

  1350. 		ParZhi[i] = TempCardData[MAX_REPERTORY - i - 1];

  1351. 	}

  1352. 	//TempCardDatar[MAX_REPERTORY] = 0;

  1353. 	return true;

  1354. }

  1355. BYTE CGameLogic::GetEndCard(const BYTE cbCardIndex[MAX_INDEX],BYTE mLaiZiData)

  1356. {

  1357. 	for (int i = MAX_INDEX - 1; i >= 0; i--)

  1358. 	{

  1359. 		if (cbCardIndex[i] > 0 && SwitchToCardData(i) != mLaiZiData)

  1360. 		{

  1361. 			return SwitchToCardData(i);

  1362. 		}

  1363. 	}

  1364. 	ASSERT(false);

  1365. 	return mLaiZiData;

  1366. }

  1367. /*

  1368. // 胡法分析函数

  1369. */

  1370. 

  1371. //中张（不带1和9）

  1372. //bool CGameLogic::IsZhongZhang(const BYTE cbCardIndex[], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)

  1373. //{

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

  1375. //	{

  1376. //		if (cbCardIndex[i] > 0)

  1377. //		{

  1378. //			BYTE cbCardValue = SwitchToCardData(i) & MASK_VALUE;

  1379. //			if (cbCardValue == 1 || cbCardValue == 9) return false;

  1380. //		}

  1381. //	}

  1382. //

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

  1384. //	{

  1385. //		BYTE cbCardValue = WeaveItem[i].cbCenterCard & MASK_VALUE;

  1386. //

  1387. //		if (WeaveItem[i].cbWeaveKind & WIK_LEFT)

  1388. //		{

  1389. //			if (cbCardValue == 1 || cbCardValue == 7) return false;

  1390. //		}

  1391. //		else if (WeaveItem[i].cbWeaveKind & WIK_CENTER)

  1392. //		{

  1393. //			if (cbCardValue == 2 || cbCardValue == 8) return false;

  1394. //		}

  1395. //		else if (WeaveItem[i].cbWeaveKind & WIK_RIGHT)

  1396. //		{

  1397. //			if (cbCardValue == 3 || cbCardValue == 9) return false;

  1398. //		}

  1399. //		else

  1400. //		{

  1401. //			if (cbCardValue == 1 || cbCardValue == 9) return false;

  1402. //		}

  1403. //	}

  1404. //

  1405. //	return true;

  1406. //}

  1407. //大对子

  1408. //bool CGameLogic::IsPengPeng( const tagAnalyseItem *pAnalyseItem )

  1409. //{

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

  1411. //	{

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

  1413. //			return false;

  1414. //	}

  1415. //	return true;

  1416. //}

  1417. //清一色牌

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

  1419. //{

  1420. //	//胡牌判断

  1421. //	BYTE cbCardColor=0xFF;

  1422. //

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

  1424. //	{

  1425. //		if(i==m_cbMagicIndex) continue;

  1426. //		if (cbCardIndex[i]!=0)

  1427. //		{

  1428. //			//花色判断

  1429. //			if (cbCardColor!=0xFF)

  1430. //				return false;

  1431. //

  1432. //			//设置花色

  1433. //			cbCardColor=(SwitchToCardData(i)&MASK_COLOR);

  1434. //

  1435. //			//设置索引

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

  1437. //		}

  1438. //	}

  1439. //

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

  1441. //	if( cbCardColor == 0xFF )

  1442. //	{

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

  1444. //		//检查组合

  1445. //		ASSERT( cbItemCount > 0 );

  1446. //		cbCardColor = WeaveItem[0].cbCenterCard&MASK_COLOR;

  1447. //	}

  1448. //

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

  1450. //

  1451. //	//组合判断

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

  1453. //	{

  1454. //		BYTE cbCenterCard=WeaveItem[i].cbCenterCard;

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

  1456. //	}

  1457. //

  1458. //	return true;

  1459. //}

  1460. //七小对牌

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

  1462. //{

  1463. //	//组合判断

  1464. //	if (cbWeaveCount!=0) return false;

  1465. //

  1466. //	//单牌数目

  1467. //	BYTE cbReplaceCount = 0;

  1468. //

  1469. //	//临时数据

  1470. //	BYTE cbCardIndexTemp[MAX_INDEX];

  1471. //	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

  1472. //

  1473. //	//插入数据

  1474. //	BYTE cbCurrentIndex = SwitchToCardIndex(cbCurrentCard);

  1475. //	cbCardIndexTemp[cbCurrentIndex]++;

  1476. //

  1477. //	//计算单牌

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

  1479. //	{

  1480. //		BYTE cbCardCount=cbCardIndexTemp[i];

  1481. //

  1482. //		//王牌过滤

  1483. //		if( i == m_cbMagicIndex ) continue;

  1484. //

  1485. //		//单牌统计

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

  1487. //	}

  1488. //

  1489. //	//王牌不够

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

  1491. //		m_cbMagicIndex == MAX_INDEX && cbReplaceCount > 0 )

  1492. //		return false;

  1493. //

  1494. //	return true;

  1495. //

  1496. //}

  1497. //带幺

  1498. //bool CGameLogic::IsDaiYao( const tagAnalyseItem *pAnalyseItem )

  1499. //{

  1500. //	//检查牌眼

  1501. //	BYTE cbCardValue = pAnalyseItem->cbCardEye&MASK_VALUE;

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

  1503. //

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

  1505. //	{

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

  1507. //		{

  1508. //			BYTE j = 0;

  1509. //			for( ; j < 3; j++ )

  1510. //			{

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

  1512. //				if( cbCardValue == 1 || cbCardValue == 9 ) break;

  1513. //			}

  1514. //			if( j == 3 ) return false;

  1515. //		}

  1516. //		else

  1517. //		{

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

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

  1520. //		}

  1521. //	}

  1522. //	return true;

  1523. //}

  1524. 

  1525. //将对

  1526. //bool CGameLogic::IsJiangDui( const tagAnalyseItem *pAnalyseItem )

  1527. //{

  1528. //	//是否大对子

  1529. //	if( !IsPengPeng(pAnalyseItem) ) return false;

  1530. //

  1531. //	//检查牌眼

  1532. //	BYTE cbCardValue = pAnalyseItem->cbCardEye&MASK_VALUE;

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

  1534. //

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

  1536. //	{

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

  1538. //		{

  1539. //			BYTE j = 0;

  1540. //			for( ; j < 3; j++ )

  1541. //			{

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

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

  1544. //			}

  1545. //			if( j == 3 ) return false;

  1546. //		}

  1547. //		else

  1548. //		{

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

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

  1551. //		}

  1552. //	}

  1553. //	return true;

  1554. //}

  1555. 

  1556. //是否花猪,一脚耐油不需要判断花猪牌型

  1557. /*bool CGameLogic::IsHuaZhu( const BYTE cbCardIndex[], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbDingque)

  1558. {

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

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

  1561. 	{

  1562. 		if( cbCardIndex[i] > 0 )

  1563. 		{

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

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

  1566. 

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

  1568. 		}

  1569. 	}

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

  1571. 	{

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

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

  1574. 	}

  1575. 

  1576. 	if (INVALID_BYTE != cbDingque && 0 != cbColor[cbDingque])

  1577. 		return true;

  1578. 

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

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

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

  1582. 

  1583. 	return true;

  1584. }*/

  1585. 

  1586. //////////////////////////////////////////////////////////////////////////