zhaobu
/
zhujimajiang_redis
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
诸暨麻将添加redis
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
2 Branches
57 MiB
 
 
 
 
 
 
Tree: 86964399f5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '86964399f5'
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/游戏服务器/GameLogicOther.cpp

1464 lines
37 KiB
Raw Blame History 

  1. #include "StdAfx.h"

  2. #include "GameLogicOther.h"

  3. #include "math.h"

  4. #include "TableFrameSinkOther.h"

  5. #include "fstream"

  6. #include "GameLogic.h"

  7. 

  8. //////////////////////////////////////////////////////////////////////////

  9. //静态变量

  10. 

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

  12. const BYTE CGameLogicOther::m_cbCardDataArray[MAX_REPERTORY] =

  13. {

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

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

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

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

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

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

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

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

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

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

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

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

  26. };

  27. 

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

  29. const BYTE CGameLogicOther::m_cbCardDataArray_SRLF[MAX_REPERTORY_SRLF] =

  30. {

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

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

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

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

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

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

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

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

  39. };

  40. 

  41. //////////////////////////////////////////////////////////////////////////

  42. 

  43. //构造函数

  44. CGameLogicOther::CGameLogicOther(CTableFrameSinkOther* pTableFramSink)

  45. {

  46. 	m_cbMagicIndex = MAX_INDEX;

  47. 	m_pTableFramSink = pTableFramSink;

  48. }

  49. 

  50. //析构函数

  51. CGameLogicOther::~CGameLogicOther()

  52. {

  53. }

  54. 

  55. //混乱扑克

  56. BYTE CGameLogicOther::RandCardData(BYTE cbCardData[])

  57. {

  58. 	BYTE cbCardDataTemp[MAX_REPERTORY];

  59. 	BYTE cbMaxCount = 0;

  60. 	//混乱准备

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

  62. 	//{

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

  64. 	//	cbMaxCount = MAX_REPERTORY_SRLF;

  65. 	//}

  66. 	//else {

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

  68. 	cbMaxCount = MAX_REPERTORY;

  69. 	//}

  70. 	//混乱扑克

  71. 	BYTE cbRandCount = 0, cbPosition = 0;

  72. 	do

  73. 	{

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

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

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

  77. 	} while (cbRandCount < cbMaxCount);

  78. 

  79. 	return cbMaxCount;

  80. }

  81. 

  82. //删除扑克

  83. bool CGameLogicOther::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard)

  84. {

  85. 	//效验扑克

  86. 	ASSERT(IsValidCard(cbRemoveCard));

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

  88. 

  89. 	//删除扑克

  90. 	BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);

  91. 	if (cbCardIndex[cbRemoveIndex]>0)

  92. 	{

  93. 		cbCardIndex[cbRemoveIndex]--;

  94. 		return true;

  95. 	}

  96. 

  97. 	//失败效验

  98. 	ASSERT(FALSE);

  99. 

  100. 	return false;

  101. }

  102. 

  103. //删除扑克

  104. bool CGameLogicOther::RemoveCard(BYTE cbCardIndex[MAX_INDEX], const BYTE cbRemoveCard[], BYTE cbRemoveCount)

  105. {

  106. 	//删除扑克

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

  108. 	{

  109. 		//效验扑克

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

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

  112. 

  113. 		//删除扑克

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

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

  116. 		{

  117. 			//错误断言

  118. 			ASSERT(FALSE);

  119. 

  120. 			//还原删除

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

  122. 			{

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

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

  125. 			}

  126. 

  127. 			return false;

  128. 		}

  129. 		else 

  130. 		{

  131. 			//删除扑克

  132. 			--cbCardIndex[cbRemoveIndex];

  133. 		}

  134. 	}

  135. 

  136. 	return true;

  137. }

  138. 

  139. //删除扑克

  140. bool CGameLogicOther::RemoveCard(BYTE cbCardData[], BYTE cbCardCount, const BYTE cbRemoveCard[], BYTE cbRemoveCount)

  141. {

  142. 	//检验数据

  143. 	ASSERT(cbCardCount<=14);

  144. 	ASSERT(cbRemoveCount<=cbCardCount);

  145. 

  146. 	//定义变量

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

  148. 	if (cbCardCount>CountArray(cbTempCardData))

  149. 		return false;

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

  151. 

  152. 	//置零扑克

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

  154. 	{

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

  156. 		{

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

  158. 			{

  159. 				cbDeleteCount++;

  160. 				cbTempCardData[j]=0;

  161. 				break;

  162. 			}

  163. 		}

  164. 	}

  165. 

  166. 	//成功判断

  167. 	if (cbDeleteCount!=cbRemoveCount) 

  168. 	{

  169. 		ASSERT(FALSE);

  170. 		return false;

  171. 	}

  172. 

  173. 	//清理扑克

  174. 	BYTE cbCardPos=0;

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

  176. 	{

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

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

  179. 	}

  180. 

  181. 	return true;

  182. }

  183. 

  184. //有效判断

  185. bool CGameLogicOther::IsValidCard(BYTE cbCardData)

  186. {

  187. 	BYTE cbValue=(cbCardData&MASK_VALUE);

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

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

  190. }

  191. 

  192. 

  193. //扑克数目

  194. BYTE CGameLogicOther::GetCardCount(const BYTE cbCardIndex[MAX_INDEX])

  195. {

  196. 	//数目统计

  197. 	BYTE cbCardCount=0;

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

  199. 		cbCardCount+=cbCardIndex[i];

  200. 

  201. 	return cbCardCount;

  202. }

  203. 

  204. //获取组合

  205. BYTE CGameLogicOther::GetWeaveCard(int cbWeaveKind, BYTE cbCenterCard, BYTE cbCardBuffer[4])

  206. {

  207. 	//组合扑克

  208. 	switch (cbWeaveKind)

  209. 	{

  210. 	case WIK_LEFT:		//上牌操作

  211. 		{

  212. 			//设置变量

  213. 			cbCardBuffer[0]=cbCenterCard;

  214. 			cbCardBuffer[1]=cbCenterCard+1;

  215. 			cbCardBuffer[2]=cbCenterCard+2;

  216. 

  217. 			return 3;

  218. 		}

  219. 	case WIK_RIGHT:		//上牌操作

  220. 		{

  221. 			//设置变量

  222. 			cbCardBuffer[0]=cbCenterCard;

  223. 			cbCardBuffer[1]=cbCenterCard-1;

  224. 			cbCardBuffer[2]=cbCenterCard-2;

  225. 

  226. 			return 3;

  227. 		}

  228. 	case WIK_CENTER:	//上牌操作

  229. 		{

  230. 			//设置变量

  231. 			cbCardBuffer[0]=cbCenterCard;

  232. 			cbCardBuffer[1]=cbCenterCard-1;

  233. 			cbCardBuffer[2]=cbCenterCard+1;

  234. 

  235. 			return 3;

  236. 		}

  237. 	case WIK_PENG:		//碰牌操作

  238. 		{

  239. 			//设置变量

  240. 			cbCardBuffer[0]=cbCenterCard;

  241. 			cbCardBuffer[1]=cbCenterCard;

  242. 			cbCardBuffer[2]=cbCenterCard;

  243. 

  244. 			return 3;

  245. 		}

  246. 	case WIK_GANG:		//杠牌操作

  247. 		{

  248. 			//设置变量

  249. 			cbCardBuffer[0]=cbCenterCard;

  250. 			cbCardBuffer[1]=cbCenterCard;

  251. 			cbCardBuffer[2]=cbCenterCard;

  252. 			cbCardBuffer[3]=cbCenterCard;

  253. 

  254. 			return 4;

  255. 		}

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

  257. 	{

  258. 		//设置变量

  259. 		cbCardBuffer[0] = cbCenterCard;

  260. 		cbCardBuffer[1] = cbCenterCard;

  261. 		cbCardBuffer[2] = cbCenterCard;

  262. 		cbCardBuffer[3] = cbCenterCard;

  263. 

  264. 		return 4;

  265. 	}

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

  267. 	{

  268. 		//设置变量

  269. 		cbCardBuffer[0] = cbCenterCard;

  270. 		cbCardBuffer[1] = cbCenterCard;

  271. 		cbCardBuffer[2] = cbCenterCard;

  272. 		cbCardBuffer[3] = cbCenterCard;

  273. 

  274. 		return 4;

  275. 	}

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

  277. 	{

  278. 		//设置变量

  279. 		cbCardBuffer[0] = cbCenterCard;

  280. 		cbCardBuffer[1] = cbCenterCard;

  281. 		cbCardBuffer[2] = cbCenterCard;

  282. 

  283. 		return 3;

  284. 	}

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

  286. 	{

  287. 		//设置变量

  288. 		cbCardBuffer[0] = cbCenterCard;

  289. 		cbCardBuffer[1] = cbCenterCard;

  290. 		cbCardBuffer[2] = cbCenterCard;

  291. 

  292. 		return 3;

  293. 	}

  294. 	case WIK_BU_GANG:

  295. 	{

  296. 		cbCardBuffer[0] = cbCenterCard;

  297. 		cbCardBuffer[1] = cbCenterCard;

  298. 		cbCardBuffer[2] = cbCenterCard;

  299. 		cbCardBuffer[3] = cbCenterCard;

  300. 

  301. 		return 4;

  302. 	}

  303. 	default:

  304. 		{

  305. 			ASSERT(FALSE);

  306. 		}

  307. 	}

  308. 	return 0;

  309. }

  310. 

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

  312. BYTE CGameLogicOther::GetUserActionRank(INT cbUserAction)

  313. {

  314. 	//胡牌等级

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

  316. 

  317. 	if (cbUserAction&WIK_DUO_PAO){ return 3; }

  318. 	//杠牌等级

  319. 	if (cbUserAction&WIK_MING_GANG) { return 2; }

  320. 

  321. 	//碰牌等级

  322. 	if (cbUserAction&WIK_PENG) { return 1; }

  323. 

  324. 	//上牌等级

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

  326. 

  327. 	return 0;

  328. }

  329. 

  330. //胡牌等级

  331. WORD CGameLogicOther::GetChiHuActionRank(const CChiHuRight & ChiHuRight)

  332. {

  333. 	WORD wFanShu = 0;

  334. 

  335. 	if (!(ChiHuRight&CHR_QING_DUI).IsEmpty())

  336. 		wFanShu = 4;

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

  338. 		wFanShu = 2;

  339. 	else if (!(ChiHuRight&CHK_PENGPENG).IsEmpty())

  340. 		wFanShu = 2;

  341. 	else if (!(ChiHuRight&CHK_CHI_HU).IsEmpty())

  342. 		wFanShu = 1;

  343. 	ASSERT( wFanShu > 0 );

  344. 	return wFanShu;

  345. }

  346. 

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

  348. /*

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

  350. {

  351. 	//参数效验

  352. 	ASSERT(IsValidCard(cbCurrentCard));

  353. 

  354. 	//过滤判断

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

  356. 		return WIK_NULL;

  357. 

  358. 	//变量定义

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

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

  361. 

  362. 	//吃牌判断

  363. 	BYTE cbEatKind=0,cbFirstIndex=0;

  364. 	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);

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

  366. 	{

  367. 		BYTE cbValueIndex=cbCurrentIndex%9;

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

  369. 		{

  370. 			//吃牌判断

  371. 			cbFirstIndex=cbCurrentIndex-cbExcursion[i];

  372. 

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

  374. 			if( m_cbMagicIndex != MAX_INDEX &&

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

  376. 

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

  378. 				continue;

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

  380. 				continue;

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

  382. 				continue;

  383. 

  384. 			//设置类型

  385. 			cbEatKind|=cbItemKind[i];

  386. 		}

  387. 	}

  388. 

  389. 	return cbEatKind;

  390. }*/

  391. 

  392. //碰牌判断

  393. int CGameLogicOther::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)

  394. {

  395. 	//参数效验

  396. 	ASSERT(IsValidCard(cbCurrentCard));

  397. 

  398. 	//过滤判断

  399. 	if (IsMagicCard(cbCurrentCard))

  400. 		return WIK_NULL;

  401. 	//碰牌判断

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

  403. }

  404. 

  405. //杠牌判断

  406. int CGameLogicOther::EstimateGangCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)

  407. {

  408. 	//参数效验

  409. 	ASSERT(IsValidCard(cbCurrentCard));

  410. 

  411. 	//过滤判断

  412. 	if ( IsMagicCard(cbCurrentCard) ) 

  413. 		return WIK_NULL;

  414. 	BYTE index = SwitchToCardIndex(cbCurrentCard);

  415. 	BYTE zhi = cbCardIndex[index];

  416. 	//杠牌判断

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

  418. }

  419. 

  420. //杠牌分析

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

  422. {

  423. 	//设置变量

  424. 	int cbActionMask = WIK_NULL;

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

  426. 

  427. 	//手上杠牌

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

  429. 	{

  430. 		if (i == m_cbMagicIndex) continue;

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

  432. 		{

  433. 			BYTE cbCardData = SwitchToCardData(i);

  434. 			cbActionMask |= WIK_GANG;

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

  436. 		}

  437. 	}

  438. 	

  439. 

  440. 	//组合杠牌

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

  442. 	{

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

  444. 		{

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

  446. 			{

  447. 				cbActionMask |= WIK_BU_GANG;

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

  449. 			}

  450. 		}

  451. 	}

  452. 

  453. 	return cbActionMask;

  454. }

  455. 

  456. ////吃胡分析,把吃胡分析改成自摸分析。因为我们已经没有吃牌动作了，所以不存在吃胡模式

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

  458. //{

  459. //	//变量定义

  460. //	int cbChiHuKind=WIK_NULL;

  461. //	CAnalyseItemArray AnalyseItemArray;

  462. //

  463. //	//设置变量

  464. //	AnalyseItemArray.RemoveAll();

  465. //	ChiHuRight.SetEmpty();

  466. //

  467. //	//构造扑克

  468. //	BYTE cbCardIndexTemp[MAX_INDEX];

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

  470. //

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

  472. //	ASSERT( cbCurrentCard != 0 );

  473. //	if( cbCurrentCard == 0 ) return WIK_NULL;

  474. //

  475. //	if( !ChiHuRight.IsEmpty() )

  476. //		cbChiHuKind = WIK_ZI_MO;

  477. //

  478. //	//插入扑克

  479. //	if (cbCurrentCard == 0)

  480. //	{

  481. //		ASSERT(false);

  482. //		return false;

  483. //	}

  484. //

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

  486. //

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

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

  489. //	{

  490. //		return WIK_NULL;

  491. //	}

  492. //	BYTE isHuPaiCount = 0;

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

  494. //	{

  495. //		cbCardIndexTemp[LaiZiIndex]--;

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

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

  498. //		{

  499. //			cbCardIndexTemp[i]++;

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

  501. //			//胡牌分析

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

  503. //			{

  504. //				cbChiHuKind = WIK_ZI_MO;

  505. //				isHuPaiCount++;

  506. //			}

  507. //			cbCardIndexTemp[i]--;

  508. //		}

  509. //		cbCardIndexTemp[LaiZiIndex]++;

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

  511. //		{

  512. //			isHuPaiCount = 0;

  513. //			return WIK_NULL;

  514. //		}

  515. //		return cbChiHuKind;

  516. //	}

  517. //	else

  518. //	{

  519. //		if (cbCurrentCard == m_cbLaiZi)

  520. //		{

  521. //			if (cbCardIndexTemp[LaiZiIndex] != 1)

  522. //			{

  523. //				ASSERT(false);

  524. //				return false;

  525. //			}		

  526. //			cbCardIndexTemp[LaiZiIndex]--;

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

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

  529. //			{

  530. //				cbCardIndexTemp[i]++;

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

  532. //				//胡牌分析

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

  534. //				{

  535. //					cbChiHuKind = WIK_ZI_MO;

  536. //				}

  537. //				cbCardIndexTemp[i]--;

  538. //			}

  539. //			cbCardIndexTemp[LaiZiIndex]++;

  540. //			return cbChiHuKind;

  541. //		}

  542. //		else

  543. //		{

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

  545. //			//胡牌分析

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

  547. //			{

  548. //				cbChiHuKind = WIK_ZI_MO;

  549. //				ChiHuRight |= CHR_YING_ZIMO;

  550. //			}

  551. //			return cbChiHuKind;

  552. //		}

  553. //	}	

  554. //}

  555. 

  556. int CGameLogicOther::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CChiHuRight &ChiHuRight, BYTE bSubMit)

  557. {

  558. 	if (bSubMit == XueLiu)

  559. 	{

  560. 		//变量定义

  561. 		int cbChiHuKind = WIK_NULL;

  562. 		CAnalyseItemArray AnalyseItemArray;

  563. 

  564. 		//设置变量

  565. 		AnalyseItemArray.RemoveAll();

  566. 		ChiHuRight.SetEmpty();

  567. 

  568. 		//构造扑克

  569. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  571. 		if (!ChiHuRight.IsEmpty())

  572. 			cbChiHuKind = WIK_ZI_MO;

  573. 		if (IsHuaZhu(cbCardIndexTemp, WeaveItem, cbWeaveCount))

  574. 		{

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

  576. 			//胡牌分析

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

  578. 			{

  579. 				cbChiHuKind |= WIK_ZI_MO;

  580. 			}

  581. 			return cbChiHuKind;

  582. 		}

  583. 		return WIK_NULL;

  584. 	}

  585. 	return WIK_NULL;

  586. }

  587. 

  588. bool CGameLogicOther::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *m_cbTingPaiData, BYTE subMit)

  589. {

  590. 	//复制数据

  591. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  593. 

  594. 	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);

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

  596. 	{

  597. 		ASSERT(false);

  598. 		return false;

  599. 	}

  600. 	CChiHuRight chr;

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

  602. 	{

  603. 		if (cbCardIndexTemp[i] == 4)continue;

  604. 		cbCardIndexTemp[i]++;

  605. 		if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, chr, subMit))

  606. 			m_cbTingPaiData[i] = 1;

  607. 		else

  608. 		{

  609. 			m_cbTingPaiData[i] = 0;

  610. 		}

  611. 		cbCardIndexTemp[i]--;

  612. 	}

  613. 	int tempcount = 0;

  614. 	for (int i = 0; i < MAX_INDEX; i++)

  615. 	{

  616. 		if (m_cbTingPaiData[i] == 1)tempcount++;

  617. 	}

  618. 	if (tempcount == 0)return false;

  619. 	return true;

  620. }

  621. 

  622. //是否听牌,true表示已经听牌

  623. bool CGameLogicOther::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE subMit)

  624. {

  625. 	//复制数据

  626. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  628. 	CChiHuRight chr;

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

  630. 	{

  631. 		if (cbCardIndexTemp[i] == 4)continue;

  632. 		cbCardIndexTemp[i]++;

  633. 		if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, chr, subMit))

  634. 			return true;

  635. 		cbCardIndexTemp[i]--;

  636. 	}

  637. 	return false;

  638. }

  639. 

  640. //扑克转换

  641. BYTE CGameLogicOther::SwitchToCardData(BYTE cbCardIndex)

  642. {

  643. 	//ASSERT(cbCardIndex<34);

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

  645. }

  646. 

  647. //扑克转换

  648. BYTE CGameLogicOther::SwitchToCardIndex(BYTE cbCardData)

  649. {

  650. 	ASSERT(IsValidCard(cbCardData));

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

  652. }

  653. 

  654. //扑克转换

  655. BYTE CGameLogicOther::SwitchToCardData(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT])

  656. {

  657. 	//转换扑克

  658. 	BYTE cbPosition=0;

  659. 	//钻牌

  660. 	if( m_cbMagicIndex != MAX_INDEX )

  661. 	{

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

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

  664. 	}

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

  666. 	{

  667. 		if( i == m_cbMagicIndex ) continue;

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

  669. 		{

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

  671. 			{

  672. 				ASSERT(cbPosition<MAX_COUNT);

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

  674. 			}

  675. 		}

  676. 	}

  677. 

  678. 	return cbPosition;

  679. }

  680. 

  681. //扑克转换

  682. BYTE CGameLogicOther::SwitchToCardIndex(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX])

  683. {

  684. 	//设置变量

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

  686. 

  687. 	//转换扑克

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

  689. 	{

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

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

  692. 	}

  693. 

  694. 	return cbCardCount;

  695. }

  696. //默认换三张

  697. bool CGameLogicOther::ExchangeCardIndex(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[EXCHANGE])

  698. {

  699. 	BYTE TempCardIndex[MAX_INDEX] = {0};

  700. 	CopyMemory(TempCardIndex, cbCardIndex, sizeof(TempCardIndex));

  701. 	BYTE cbTempCardData[MAX_COUNT] = { 0 };

  702. 	SwitchToCardData(TempCardIndex, cbTempCardData);

  703. 	BYTE WanCount = 0;//万

  704. 	BYTE WanTempCardData[MAX_COUNT];

  705. 	BYTE TiaoCount = 0;//条

  706. 	BYTE TiaoTempCardData[MAX_COUNT];

  707. 	BYTE TongCount = 0;//筒

  708. 	BYTE TongTempCardData[MAX_COUNT];

  709. 	ZeroMemory(WanTempCardData, sizeof(WanTempCardData));

  710. 	ZeroMemory(TiaoTempCardData, sizeof(TiaoTempCardData));

  711. 	ZeroMemory(TongTempCardData, sizeof(TongTempCardData));

  712. 	for (int i = 0; i < MAX_INDEX; i++)//获取手牌花色个数

  713. 	{

  714. 		if (TempCardIndex[i] == 0)continue;

  715. 		if (i < 9)

  716. 			while (TempCardIndex[i]--)

  717. 				WanTempCardData[WanCount++] = SwitchToCardData(i);		

  718. 		else if (i < 18)

  719. 			while (TempCardIndex[i]--)

  720. 				TiaoTempCardData[TiaoCount++] = SwitchToCardData(i);

  721. 		else

  722. 			while (TempCardIndex[i]--)

  723. 				TongTempCardData[TongCount++] = SwitchToCardData(i);

  724. 	}	

  725. 	if (TongCount>TiaoCount&&TongCount > WanCount)//根据花色多少决定默认换三张的牌，筒最多

  726. 	{

  727. 		if (TiaoCount > WanCount&&WanCount >= 3)

  728. 		{

  729. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  730. 			return true;

  731. 		}

  732. 		else if (TiaoCount >= 3)

  733. 		{

  734. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  735. 			return true;

  736. 		}

  737. 		else if (WanCount >= 3)

  738. 		{

  739. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  740. 			return true;

  741. 		}

  742. 		else

  743. 		{

  744. 			CopyMemory(cbCardData, TongTempCardData, EXCHANGE);

  745. 			return true;

  746. 		}

  747. 		ASSERT(false);

  748. 		return false;

  749. 	}

  750. 	else if (TiaoCount > TongCount&&TiaoCount > WanCount)//条最多

  751. 	{

  752. 		if (TongCount > WanCount&&WanCount >= 3)

  753. 		{

  754. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  755. 			return true;

  756. 		}

  757. 		else if(TongCount >= 3)

  758. 		{

  759. 			CopyMemory(cbCardData, TongTempCardData, EXCHANGE);

  760. 			return true;

  761. 		}

  762. 		else if (WanCount >= 3)

  763. 		{

  764. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  765. 			return true;

  766. 		}

  767. 		else

  768. 		{

  769. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  770. 			return true;

  771. 		}	

  772. 		ASSERT(false);

  773. 		return false; 

  774. 	}

  775. 	else if (WanCount > TongCount&&WanCount > TiaoCount)        //万最多

  776. 	{

  777. 		if (TongCount > TiaoCount&&TiaoCount >= 3)

  778. 		{

  779. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  780. 			return true;

  781. 		}

  782. 		else if (TongCount >= 3)

  783. 		{

  784. 			CopyMemory(cbCardData, TongTempCardData, EXCHANGE);

  785. 			return true;

  786. 		}

  787. 		else if (TiaoCount >= 3)

  788. 		{

  789. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  790. 			return true;

  791. 		}

  792. 		else

  793. 		{

  794. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  795. 			return true;

  796. 		}		

  797. 		ASSERT(false);

  798. 		return false;

  799. 	}

  800. 	else

  801. 	{

  802. 		if (TiaoCount == TongCount&&WanCount >= 3)

  803. 		{

  804. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  805. 			return true;

  806. 		}

  807. 		else if(TiaoCount == WanCount&&TongCount >= 3)

  808. 		{

  809. 			CopyMemory(cbCardData, TongTempCardData, EXCHANGE);

  810. 			return true;

  811. 		}

  812. 		else if (WanCount == TongCount && TiaoCount>=3)

  813. 		{

  814. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  815. 			return true;

  816. 		}

  817. 		else if (TiaoCount == TongCount&&WanCount < 3)

  818. 		{

  819. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  820. 			return true;

  821. 		}

  822. 		else if (TiaoCount == WanCount&&TongCount < 3)

  823. 		{

  824. 			CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  825. 			return true;

  826. 		}

  827. 		else

  828. 		{

  829. 			CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  830. 			return true;

  831. 		}

  832. 	}

  833. 	/*if (WanCount <= TiaoCount&&WanCount <= TongCount&&WanCount >= 3)

  834. 	{

  835. 	CopyMemory(cbCardData, WanTempCardData, EXCHANGE);

  836. 	return true;

  837. 	}

  838. 	else if (TiaoCount <= WanCount&& TiaoCount <= TongCount&& TiaoCount >= 3)

  839. 	{

  840. 	CopyMemory(cbCardData, TiaoTempCardData, EXCHANGE);

  841. 	return true;

  842. 	}

  843. 	else

  844. 	{

  845. 	CopyMemory(cbCardData, TongTempCardData, EXCHANGE);

  846. 	return true;

  847. 	}*/

  848. 	ASSERT(false);

  849. 	return false;

  850. }

  851. //分析扑克

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

  853. {

  854. 	//计算数目

  855. 	BYTE cbCardCount = GetCardCount(cbCardIndex);

  856. 

  857. 	//效验数目

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

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

  860. 		return false;

  861. 

  862. 	//变量定义

  863. 	BYTE cbKindItemCount = 0;

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

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

  866. 

  867. 	//需求判断

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

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

  870. 

  871. 	//单吊判断

  872. 	if (cbLessKindItem == 0)

  873. 	{

  874. 		//效验参数

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

  876. 

  877. 		//牌眼判断

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

  879. 		{

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

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

  882. 			{

  883. 				//变量定义

  884. 				tagAnalyseItem AnalyseItem;

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

  886. 

  887. 				//设置结果

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

  889. 				{

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

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

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

  893. 				}

  894. 				AnalyseItem.cbCardEye = SwitchToCardData(i);

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

  896. 					AnalyseItem.bMagicEye = true;

  897. 				else AnalyseItem.bMagicEye = false;

  898. 

  899. 				//插入结果

  900. 				AnalyseItemArray.Add(AnalyseItem);

  901. 

  902. 				return true;

  903. 			}

  904. 		}

  905. 		return false;

  906. 	}

  907. 

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

  909. 	BYTE cbMagicCardIndex[MAX_INDEX];

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

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

  912. 	if (m_cbMagicIndex != MAX_INDEX)

  913. 	{

  914. 		cbMagicCardCount = cbCardIndex[m_cbMagicIndex];

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

  916. 	}

  917. 	if (cbCardCount >= 3)

  918. 	{

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

  920. 		{

  921. 			//同牌判断

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

  923. 			{

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

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

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

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

  928. 				KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;

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

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

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

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

  933. 				cbKindItemCount++;

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

  935. 				{

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

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

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

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

  940. 					KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;

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

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

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

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

  945. 					cbKindItemCount++;

  946. 				}

  947. 			}

  948. 

  949. 			//连牌判断

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

  951. 			{

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

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

  954. 				{

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

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

  957. 					int nMagicCountTemp = cbMagicCardCount;

  958. 					BYTE cbValidIndex[3];

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

  960. 					{

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

  962. 						{

  963. 							if (cbIndex[j] > 0)

  964. 							{

  965. 								cbIndex[j]--;

  966. 								cbValidIndex[j] = i + j;

  967. 							}

  968. 							else

  969. 							{

  970. 								nMagicCountTemp--;

  971. 								cbValidIndex[j] = m_cbMagicIndex;

  972. 							}

  973. 						}

  974. 						if (nMagicCountTemp >= 0)

  975. 						{

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

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

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

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

  980. 							KindItem[cbKindItemCount].cbWeaveKind = WIK_LEFT;

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

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

  983. 							cbKindItemCount++;

  984. 						}

  985. 						else break;

  986. 					}

  987. 				}

  988. 			}

  989. 		}

  990. 	}

  991. 

  992. 	//组合分析

  993. 	if (cbKindItemCount >= cbLessKindItem)

  994. 	{

  995. 		//变量定义

  996. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  998. 

  999. 		//变量定义

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

  1001. 		tagKindItem * pKindItem[4];

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

  1003. 

  1004. 		//开始组合

  1005. 		do

  1006. 		{

  1007. 			//设置变量

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

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

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

  1011. 

  1012. 			//数量判断

  1013. 			bool bEnoughCard = true;

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

  1015. 			{

  1016. 				//存在判断

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

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

  1019. 				{

  1020. 					bEnoughCard = false;

  1021. 					break;

  1022. 				}

  1023. 				else

  1024. 					cbCardIndexTemp[cbCardIndex]--;

  1025. 			}

  1026. 

  1027. 			//胡牌判断

  1028. 			if (bEnoughCard == true)

  1029. 			{

  1030. 				//牌眼判断

  1031. 				BYTE cbCardEye = 0;

  1032. 				bool bMagicEye = false;

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

  1034. 				{

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

  1036. 					{

  1037. 						cbCardEye = SwitchToCardData(i);

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

  1039. 						break;

  1040. 					}

  1041. 					else if (i != m_cbMagicIndex &&

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

  1043. 					{

  1044. 						cbCardEye = SwitchToCardData(i);

  1045. 						bMagicEye = true;

  1046. 					}

  1047. 				}

  1048. 

  1049. 				//组合类型

  1050. 				if (cbCardEye != 0)

  1051. 				{

  1052. 					//变量定义

  1053. 					tagAnalyseItem AnalyseItem;

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

  1055. 

  1056. 					//设置组合

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

  1058. 					{

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

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

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

  1062. 							AnalyseItem.cbCardData[i]);

  1063. 					}

  1064. 

  1065. 					//设置牌型

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

  1067. 					{

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

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

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

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

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

  1073. 					}

  1074. 

  1075. 					//设置牌眼

  1076. 					AnalyseItem.cbCardEye = cbCardEye;

  1077. 					AnalyseItem.bMagicEye = bMagicEye;

  1078. 

  1079. 					//插入结果

  1080. 					AnalyseItemArray.Add(AnalyseItem);

  1081. 				}

  1082. 			}

  1083. 

  1084. 			//设置索引

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

  1086. 			{

  1087. 				BYTE i = cbLessKindItem - 1;

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

  1089. 				{

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

  1091. 					{

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

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

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

  1095. 						break;

  1096. 					}

  1097. 				}

  1098. 				if (i == 0)

  1099. 					break;

  1100. 			}

  1101. 			else

  1102. 				cbIndex[cbLessKindItem - 1]++;

  1103. 		} while (true);

  1104. 

  1105. 	}

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

  1107. }

  1108. 

  1109. //钻牌

  1110. bool CGameLogicOther::IsMagicCard(BYTE cbCardData)

  1111. {

  1112. 	if( m_cbMagicIndex != MAX_INDEX )

  1113. 		return SwitchToCardIndex(cbCardData) == m_cbMagicIndex;

  1114. 	return false;

  1115. }

  1116. 

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

  1118. bool CGameLogicOther::SortCardList(BYTE cbCardData[MAX_COUNT], BYTE cbCardCount)

  1119. {

  1120. 	//数目过虑

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

  1122. 

  1123. 	//排序操作

  1124. 	bool bSorted=true;

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

  1126. 	do

  1127. 	{

  1128. 		bSorted=true;

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

  1130. 		{

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

  1132. 			{

  1133. 				//设置标志

  1134. 				bSorted=false;

  1135. 

  1136. 				//扑克数据

  1137. 				cbSwitchData=cbCardData[i];

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

  1139. 				cbCardData[i+1]=cbSwitchData;

  1140. 			}	

  1141. 		}

  1142. 		cbLast--;

  1143. 	} while(bSorted==false);

  1144. 

  1145. 	return true;

  1146. }

  1147. //编码

  1148. WORD CGameLogicOther::GetValue(BYTE uNum, BYTE uFangShu, BYTE PaiZhi)

  1149. {

  1150. 	WORD mcd = PaiZhi | (uFangShu << 6) | (uNum << 11);

  1151. 	return mcd;

  1152. }

  1153. //解码

  1154. BYTE CGameLogicOther::DeCodeCard(const WORD cbCardData)

  1155. {

  1156. 	//BYTE num = (cbCardData & 0x3800) >> 11;

  1157. 	//BYTE fanshu = (cbCardData & 0x07C0) >> 6;

  1158. 	BYTE TempCardData = cbCardData & 0x003F;

  1159. 	return TempCardData;

  1160. }

  1161. //解码番薯

  1162. BYTE CGameLogicOther::DeCodeFanshu(const WORD cbCardData)

  1163. {

  1164. 	//BYTE num = (cbCardData & 0x3800) >> 11;

  1165. 	BYTE fanshu = (cbCardData & 0x07C0) >> 6;

  1166. 	//BYTE TempCardData = cbCardData & 0x003F;

  1167. 	return fanshu;

  1168. }

  1169. 

  1170. bool CGameLogicOther::PeiPai(BYTE ParZhi[MAX_REPERTORY])

  1171. {

  1172. 	std::ifstream in;

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

  1174. 	in.open(filename);

  1175. 	if (!in.is_open())

  1176. 	{

  1177. 		return false;

  1178. 		//ASSERT(false);

  1179. 	}

  1180. 	static BYTE TempCardData[MAX_REPERTORY];

  1181. 

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

  1183. 

  1184. 	BYTE tempCount = 0;

  1185. 	char ch[1];

  1186. 	while (!in.eof())

  1187. 	{

  1188. 		in.read(ch, 1);

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

  1190. 	}

  1191. 	in.close(); 

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

  1193. 	{

  1194. 		ASSERT(i < MAX_REPERTORY);

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

  1196. 	}

  1197. 

  1198. 	return true;

  1199. }

  1200. BYTE CGameLogicOther::GetEndCard(BYTE cbCardIndex[MAX_INDEX])

  1201. {

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

  1203. 	{

  1204. 		if (cbCardIndex[i] > 0 )

  1205. 		{

  1206. 			return SwitchToCardData(i);

  1207. 		}

  1208. 	}

  1209. 	ASSERT(false);

  1210. 	return 1;

  1211. }

  1212. /*

  1213. // 胡法分析函数

  1214. */

  1215. 

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

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

  1218. //{

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

  1220. //	{

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

  1222. //		{

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

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

  1225. //		}

  1226. //	}

  1227. //

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

  1229. //	{

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

  1231. //

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

  1233. //		{

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

  1235. //		}

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

  1237. //		{

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

  1239. //		}

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

  1241. //		{

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

  1243. //		}

  1244. //		else

  1245. //		{

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

  1247. //		}

  1248. //	}

  1249. //

  1250. //	return true;

  1251. //}

  1252. //大对子

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

  1254. //{

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

  1256. //	{

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

  1258. //			return false;

  1259. //	}

  1260. //	return true;

  1261. //}

  1262. //清一色牌

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

  1264. {

  1265. 	//胡牌判断

  1266. 	BYTE cbCardColor=0xFF;

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

  1268. 	{

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

  1270. 		{

  1271. 			//花色判断

  1272. 			if (cbCardColor!=0xFF)

  1273. 				return false;

  1274. 			//设置花色

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

  1276. 			//设置索引

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

  1278. 		}

  1279. 	}

  1280. 	//组合判断

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

  1282. 	{

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

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

  1285. 	}

  1286. 

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

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

  1289. 	//{

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

  1291. 	//	//检查组合

  1292. 	//	ASSERT( cbItemCount > 0 );

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

  1294. 	//}

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

  1296. 

  1297. 	return true;

  1298. }

  1299. //七小对牌

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

  1301. //{

  1302. //	//组合判断

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

  1304. //

  1305. //	//单牌数目

  1306. //	BYTE cbReplaceCount = 0;

  1307. //

  1308. //	//临时数据

  1309. //	BYTE cbCardIndexTemp[MAX_INDEX];

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

  1311. //

  1312. //	//插入数据

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

  1314. //	cbCardIndexTemp[cbCurrentIndex]++;

  1315. //

  1316. //	//计算单牌

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

  1318. //	{

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

  1320. //

  1321. //		//王牌过滤

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

  1323. //

  1324. //		//单牌统计

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

  1326. //	}

  1327. //

  1328. //	//王牌不够

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

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

  1331. //		return false;

  1332. //

  1333. //	return true;

  1334. //

  1335. //}

  1336. //带幺

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

  1338. //{

  1339. //	//检查牌眼

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

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

  1342. //

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

  1344. //	{

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

  1346. //		{

  1347. //			BYTE j = 0;

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

  1349. //			{

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

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

  1352. //			}

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

  1354. //		}

  1355. //		else

  1356. //		{

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

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

  1359. //		}

  1360. //	}

  1361. //	return true;

  1362. //}

  1363. 

  1364. //将对

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

  1366. //{

  1367. //	//是否大对子

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

  1369. //

  1370. //	//检查牌眼

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

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

  1373. //

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

  1375. //	{

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

  1377. //		{

  1378. //			BYTE j = 0;

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

  1380. //			{

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

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

  1383. //			}

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

  1385. //		}

  1386. //		else

  1387. //		{

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

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

  1390. //		}

  1391. //	}

  1392. //	return true;

  1393. //}

  1394. 

  1395. //是否花猪,xueliu判断花猪牌型,false为花柱

  1396. bool CGameLogicOther::IsHuaZhu(const BYTE cbCardIndex[], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)

  1397. {

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

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

  1400. 	{

  1401. 		if( cbCardIndex[i] > 0 )

  1402. 		{

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

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

  1405. 

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

  1407. 		}

  1408. 	}

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

  1410. 	{

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

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

  1413. 	}

  1414. 

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

  1416. 	//	return true;

  1417. 

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

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

  1420. 		if( cbColor[i] == 0 ) return true;

  1421. 

  1422. 	return false;

  1423. }

  1424. //是否碰碰胡

  1425. bool CGameLogicOther::IsPengPeng(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount)

  1426. {

  1427. 	BYTE cbCardCount = GetCardCount(cbCardIndex);

  1428. 	BYTE DanCount = 0;

  1429. 	BYTE DuiZiCount = 0;

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

  1431. 	{

  1432. 		if (cbCardIndex[i] == 3)

  1433. 		{

  1434. 			DuiZiCount++;

  1435. 		}

  1436. 		if (cbCardIndex[i] == 2)

  1437. 		{

  1438. 			DanCount++;

  1439. 		}

  1440. 	}

  1441. 	switch (cbCardCount)

  1442. 	{

  1443. 	case 2:

  1444. 		if (DanCount == 1)

  1445. 			return true;

  1446. 	case 5:

  1447. 		if (DuiZiCount == 1 && DanCount == 1)

  1448. 			return true;

  1449. 	case 8:

  1450. 		if (DuiZiCount == 2 && DanCount == 1)

  1451. 			return true;

  1452. 	case 11:

  1453. 		if (DuiZiCount == 3 && DanCount == 1)

  1454. 			return true;

  1455. 	case 14:

  1456. 		if (DuiZiCount == 4 && DanCount == 1)

  1457. 			return true;

  1458. 	default:

  1459. 		return false;

  1460. 	}

  1461. 	return false;

  1462. }

  1463. //////////////////////////////////////////////////////////////////////////