zhaobu
/
zhujimajiang_redis
1
0
複製 0
程式碼 問題 0 合併請求 0 版本發佈 0 Wiki 活動
诸暨麻将添加redis
您不能選擇超過 %s 個話題 話題必須以字母或數字為開頭，可包含連接號 ('-') 且最長為 35 個字
2 提交
2 分支
57 MiB
 
 
 
 
 
 
目錄樹: 86964399f5
分支列表 標籤
${ item.name }
建立分支 ${ searchTerm }
從 '86964399f5'
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/游戏服务器/GameLogicCxz.cpp

1194 行
31 KiB
原始文件 Blame 歷史記錄 

  1. #include "StdAfx.h"

  2. #include "GameLogicCxz.h"

  3. #include "math.h"

  4. #include "TableFrameSinkCxz.h"

  5. #include "fstream"

  6. 

  7. 

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

  9. //静态变量

  10. 

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

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

  13. {

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

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

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

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

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

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

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

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

  22. };

  23. 

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

  25. const BYTE CGameLogicCxz::m_cbCardDataArray_SRLF[MAX_REPERTORY_SRLF] =

  26. {

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

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

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

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

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

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

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

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

  35. };

  36. 

  37. //////////////////////////////////////////////////////////////////////////

  38. 

  39. //构造函数

  40. CGameLogicCxz::CGameLogicCxz(TableFrameSinkCxz* pTableFramSink)

  41. {

  42. 	m_cbMagicIndex = MAX_INDEX;

  43. 	m_pTableFramSink = pTableFramSink;

  44. }

  45. 

  46. //析构函数

  47. CGameLogicCxz::~CGameLogicCxz()

  48. {

  49. }

  50. 

  51. //混乱扑克

  52. BYTE CGameLogicCxz::RandCardData(BYTE cbCardData[])

  53. {

  54. 	BYTE cbCardDataTemp[MAX_REPERTORY_SRLF];

  55. 	BYTE cbMaxCount = 0;

  56. 	//混乱准备

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

  58. 	//{

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

  60. 	//	cbMaxCount = MAX_REPERTORY_SRLF;

  61. 	//}

  62. 	//else {

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

  64. 	cbMaxCount = MAX_REPERTORY_SRLF;

  65. 	//}

  66. 	//混乱扑克

  67. 	BYTE cbRandCount = 0, cbPosition = 0;

  68. 	do

  69. 	{

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

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

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

  73. 	} while (cbRandCount < cbMaxCount);

  74. 	cbRandCount = 0, cbPosition = 0;

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

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

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

  78. 	do

  79. 	{

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

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

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

  83. 	} while (cbRandCount < cbMaxCount);

  84. 	return cbMaxCount;

  85. }

  86. 

  87. //删除扑克

  88. bool CGameLogicCxz::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard)

  89. {

  90. 	//效验扑克

  91. 	ASSERT(IsValidCard(cbRemoveCard));

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

  93. 

  94. 	//删除扑克

  95. 	BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);

  96. 	if (cbCardIndex[cbRemoveIndex]>0)

  97. 	{

  98. 		cbCardIndex[cbRemoveIndex]--;

  99. 		return true;

  100. 	}

  101. 

  102. 	//失败效验

  103. 	ASSERT(FALSE);

  104. 

  105. 	return false;

  106. }

  107. 

  108. //删除扑克

  109. bool CGameLogicCxz::RemoveCard(BYTE cbCardIndex[MAX_INDEX], const BYTE cbRemoveCard[], BYTE cbRemoveCount)

  110. {

  111. 	//删除扑克

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

  113. 	{

  114. 		//效验扑克

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

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

  117. 

  118. 		//删除扑克

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

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

  121. 		{

  122. 			//错误断言

  123. 			ASSERT(FALSE);

  124. 

  125. 			//还原删除

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

  127. 			{

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

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

  130. 			}

  131. 

  132. 			return false;

  133. 		}

  134. 		else 

  135. 		{

  136. 			//删除扑克

  137. 			--cbCardIndex[cbRemoveIndex];

  138. 		}

  139. 	}

  140. 

  141. 	return true;

  142. }

  143. 

  144. //删除扑克

  145. bool CGameLogicCxz::RemoveCard(BYTE cbCardData[], BYTE cbCardCount, const BYTE cbRemoveCard[], BYTE cbRemoveCount)

  146. {

  147. 	//检验数据

  148. 	ASSERT(cbCardCount<=14);

  149. 	ASSERT(cbRemoveCount<=cbCardCount);

  150. 

  151. 	//定义变量

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

  153. 	if (cbCardCount>CountArray(cbTempCardData))

  154. 		return false;

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

  156. 

  157. 	//置零扑克

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

  159. 	{

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

  161. 		{

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

  163. 			{

  164. 				cbDeleteCount++;

  165. 				cbTempCardData[j]=0;

  166. 				break;

  167. 			}

  168. 		}

  169. 	}

  170. 

  171. 	//成功判断

  172. 	if (cbDeleteCount!=cbRemoveCount) 

  173. 	{

  174. 		ASSERT(FALSE);

  175. 		return false;

  176. 	}

  177. 

  178. 	//清理扑克

  179. 	BYTE cbCardPos=0;

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

  181. 	{

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

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

  184. 	}

  185. 

  186. 	return true;

  187. }

  188. 

  189. //有效判断

  190. bool CGameLogicCxz::IsValidCard(BYTE cbCardData)

  191. {

  192. 	BYTE cbValue=(cbCardData&MASK_VALUE);

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

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

  195. }

  196. 

  197. 

  198. //扑克数目

  199. BYTE CGameLogicCxz::GetCardCount(const BYTE cbCardIndex[MAX_INDEX])

  200. {

  201. 	//数目统计

  202. 	BYTE cbCardCount=0;

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

  204. 		cbCardCount+=cbCardIndex[i];

  205. 

  206. 	return cbCardCount;

  207. }

  208. 

  209. //获取组合

  210. BYTE CGameLogicCxz::GetWeaveCard(int cbWeaveKind, BYTE cbCenterCard, BYTE cbCardBuffer[4])

  211. {

  212. 	//组合扑克

  213. 	switch (cbWeaveKind)

  214. 	{

  215. 	case WIK_LEFT:		//上牌操作

  216. 		{

  217. 			//设置变量

  218. 			cbCardBuffer[0]=cbCenterCard;

  219. 			cbCardBuffer[1]=cbCenterCard+1;

  220. 			cbCardBuffer[2]=cbCenterCard+2;

  221. 

  222. 			return 3;

  223. 		}

  224. 	case WIK_RIGHT:		//上牌操作

  225. 		{

  226. 			//设置变量

  227. 			cbCardBuffer[0]=cbCenterCard;

  228. 			cbCardBuffer[1]=cbCenterCard-1;

  229. 			cbCardBuffer[2]=cbCenterCard-2;

  230. 

  231. 			return 3;

  232. 		}

  233. 	case WIK_CENTER:	//上牌操作

  234. 		{

  235. 			//设置变量

  236. 			cbCardBuffer[0]=cbCenterCard;

  237. 			cbCardBuffer[1]=cbCenterCard-1;

  238. 			cbCardBuffer[2]=cbCenterCard+1;

  239. 

  240. 			return 3;

  241. 		}

  242. 	case WIK_PENG:		//碰牌操作

  243. 		{

  244. 			//设置变量

  245. 			cbCardBuffer[0]=cbCenterCard;

  246. 			cbCardBuffer[1]=cbCenterCard;

  247. 			cbCardBuffer[2]=cbCenterCard;

  248. 

  249. 			return 3;

  250. 		}

  251. 	case WIK_GANG:		//杠牌操作

  252. 		{

  253. 			//设置变量

  254. 			cbCardBuffer[0]=cbCenterCard;

  255. 			cbCardBuffer[1]=cbCenterCard;

  256. 			cbCardBuffer[2]=cbCenterCard;

  257. 			cbCardBuffer[3]=cbCenterCard;

  258. 

  259. 			return 4;

  260. 		}

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

  262. 	{

  263. 		//设置变量

  264. 		cbCardBuffer[0] = cbCenterCard;

  265. 		cbCardBuffer[1] = cbCenterCard;

  266. 		cbCardBuffer[2] = cbCenterCard;

  267. 		cbCardBuffer[3] = cbCenterCard;

  268. 

  269. 		return 4;

  270. 	}

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

  272. 	{

  273. 		//设置变量

  274. 		cbCardBuffer[0] = cbCenterCard;

  275. 		cbCardBuffer[1] = cbCenterCard;

  276. 		cbCardBuffer[2] = cbCenterCard;

  277. 		cbCardBuffer[3] = cbCenterCard;

  278. 

  279. 		return 4;

  280. 	}

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

  282. 	{

  283. 		//设置变量

  284. 		cbCardBuffer[0] = cbCenterCard;

  285. 		cbCardBuffer[1] = cbCenterCard;

  286. 		cbCardBuffer[2] = cbCenterCard;

  287. 

  288. 		return 3;

  289. 	}

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

  291. 	{

  292. 		//设置变量

  293. 		cbCardBuffer[0] = cbCenterCard;

  294. 		cbCardBuffer[1] = cbCenterCard;

  295. 		cbCardBuffer[2] = cbCenterCard;

  296. 

  297. 		return 3;

  298. 	}

  299. 	case WIK_BU_GANG:

  300. 	{

  301. 		cbCardBuffer[0] = cbCenterCard;

  302. 		cbCardBuffer[1] = cbCenterCard;

  303. 		cbCardBuffer[2] = cbCenterCard;

  304. 		cbCardBuffer[3] = cbCenterCard;

  305. 

  306. 		return 4;

  307. 	}

  308. 	default:

  309. 		{

  310. 			ASSERT(FALSE);

  311. 		}

  312. 	}

  313. 	return 0;

  314. }

  315. 

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

  317. BYTE CGameLogicCxz::GetUserActionRank(BYTE cbUserAction)

  318. {

  319. 	//胡牌等级

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

  321. 

  322. 	//杠牌等级

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

  324. 

  325. 	//碰牌等级

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

  327. 

  328. 	//上牌等级

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

  330. 

  331. 	return 0;

  332. }

  333. 

  334. //胡牌等级

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

  336. //{

  337. //	WORD wFanShu = 0;

  338. //

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

  340. //		wFanShu = 4;

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

  342. //		wFanShu = 2;

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

  344. //		wFanShu = 2;

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

  346. //		wFanShu = 1;

  347. //	ASSERT( wFanShu > 0 );

  348. //	return wFanShu;

  349. //}

  350. 

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

  352. /*

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

  354. {

  355. 	//参数效验

  356. 	ASSERT(IsValidCard(cbCurrentCard));

  357. 

  358. 	//过滤判断

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

  360. 		return WIK_NULL;

  361. 

  362. 	//变量定义

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

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

  365. 

  366. 	//吃牌判断

  367. 	BYTE cbEatKind=0,cbFirstIndex=0;

  368. 	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);

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

  370. 	{

  371. 		BYTE cbValueIndex=cbCurrentIndex%9;

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

  373. 		{

  374. 			//吃牌判断

  375. 			cbFirstIndex=cbCurrentIndex-cbExcursion[i];

  376. 

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

  378. 			if( m_cbMagicIndex != MAX_INDEX &&

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

  380. 

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

  382. 				continue;

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

  384. 				continue;

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

  386. 				continue;

  387. 

  388. 			//设置类型

  389. 			cbEatKind|=cbItemKind[i];

  390. 		}

  391. 	}

  392. 

  393. 	return cbEatKind;

  394. }*/

  395. 

  396. //碰牌判断

  397. int CGameLogicCxz::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard, BYTE LaiZiPiData)

  398. {

  399. 	//参数效验

  400. 	ASSERT(IsValidCard(cbCurrentCard));

  401. 

  402. 	//过滤判断

  403. 	if (IsMagicCard(cbCurrentCard))

  404. 		return WIK_NULL;

  405. 	if (cbCurrentCard == LaiZiPiData)

  406. 	{

  407. 		BYTE index = SwitchToCardIndex(cbCurrentCard);

  408. 		BYTE zhi = cbCardIndex[index];

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

  410. 	}

  411. 	//碰牌判断

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

  413. }

  414. 

  415. //杠牌判断

  416. int CGameLogicCxz::EstimateGangCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)

  417. {

  418. 	//参数效验

  419. 	ASSERT(IsValidCard(cbCurrentCard));

  420. 

  421. 	//过滤判断

  422. 	if ( IsMagicCard(cbCurrentCard) ) 

  423. 		return WIK_NULL;

  424. 	BYTE index = SwitchToCardIndex(cbCurrentCard);

  425. 	BYTE zhi = cbCardIndex[index];

  426. 	//杠牌判断

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

  428. }

  429. 

  430. //杠牌分析

  431. int CGameLogicCxz::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 */)

  432. {

  433. 	//设置变量

  434. 	int cbActionMask = WIK_NULL;

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

  436. 

  437. 	//手上杠牌

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

  439. 	{

  440. 		if (i == m_cbMagicIndex) continue;

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

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

  443. 		{

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

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

  446. 			{

  447. 				cbActionMask |= WIK_GANG;

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

  449. 			}

  450. 		}

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

  452. 		{

  453. 			BYTE cbCardData = SwitchToCardData(i);

  454. 			cbActionMask |= WIK_GANG;

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

  456. 		}

  457. 	}

  458. 	

  459. 

  460. 	//组合杠牌

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

  462. 	{

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

  464. 		{

  465. 			if (cbCardIndex[SwitchToCardIndex(WeaveItem[i].cbCenterCard)] == 1 && WeaveItem[i].cbCenterCard == bProvideCard)

  466. 			{

  467. 				cbActionMask |= WIK_BU_GANG;

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

  469. 			}

  470. 		}

  471. 	}

  472. 

  473. 	return cbActionMask;

  474. }

  475. 

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

  477. {

  478. 	if (bSubMit == CXZOneStepLaiYou || bSubMit == CXZBanLai)

  479. 	{

  480. 		//变量定义

  481. 		int cbChiHuKind = WIK_NULL;

  482. 		CAnalyseItemArray AnalyseItemArray;

  483. 

  484. 		//设置变量

  485. 		AnalyseItemArray.RemoveAll();

  486. 		ChiHuRight.SetEmpty();

  487. 

  488. 		//构造扑克

  489. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  491. 

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

  493. 		ASSERT(cbCurrentCard != 0);

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

  495. 

  496. 		if (!ChiHuRight.IsEmpty())

  497. 			cbChiHuKind = WIK_ZI_MO;

  498. 

  499. 		//插入扑克

  500. 		if (cbCurrentCard == 0)

  501. 		{

  502. 			ASSERT(false);

  503. 			return false;

  504. 		}

  505. 

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

  507. 

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

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

  510. 		{

  511. 			return WIK_NULL;

  512. 		}

  513. 		BYTE isHuPaiCount = 0;

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

  515. 		{

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

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

  518. 			{

  519. 				return WIK_ZI_MO | WIK_YING_ZIMO;

  520. 			}

  521. 			AnalyseItemArray.RemoveAll();

  522. 			cbCardIndexTemp[LaiZiIndex]--;

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

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

  525. 			{

  526. 				if (i == LaiZiIndex)continue;

  527. 				cbCardIndexTemp[i] += 2;

  528. 				if (cbCardIndexTemp[i]>5){

  529. 					isHuPaiCount++;

  530. 					cbCardIndexTemp[i] -= 2; 

  531. 					continue;

  532. 				}

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

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

  535. 				{

  536. 					isHuPaiCount++;

  537. 				}

  538. 				AnalyseItemArray.RemoveAll();

  539. 				cbCardIndexTemp[i] -= 2;

  540. 			}

  541. 			if (isHuPaiCount >= 26)

  542. 			{

  543. 				return WIK_NULL;

  544. 			}

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

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

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

  548. 			{

  549. 				if (i == LaiZiIndex)continue;

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

  551. 				cbCardIndexTemp[i]++;

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

  553. 				//胡牌分析

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

  555. 				{

  556. 					cbChiHuKind = WIK_ZI_MO;

  557. 					return cbChiHuKind;

  558. 				}

  559. 				AnalyseItemArray.RemoveAll();

  560. 				cbCardIndexTemp[i]--;

  561. 			}

  562. 			//if (cbChiHuKind&WIK_ZI_MO)

  563. 			//{

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

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

  566. 			//	{

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

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

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

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

  571. 			//		{

  572. 			//			isHuPaiCount++;

  573. 			//		}

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

  575. 			//	}

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

  577. 			//	{

  578. 			//		isHuPaiCount = 0;

  579. 			//		return WIK_NULL;

  580. 			//	}

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

  582. 			//}			

  583. 			cbCardIndexTemp[LaiZiIndex]++;

  584. 			return cbChiHuKind;

  585. 		}

  586. 		else

  587. 		{

  588. 			if (cbCurrentCard == m_cbLaiZi)

  589. 			{

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

  591. 				{

  592. 					ASSERT(false);

  593. 					return false;

  594. 				}

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

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

  597. 				{

  598. 					return WIK_ZI_MO | WIK_YING_ZIMO;

  599. 				}

  600. 				cbCardIndexTemp[LaiZiIndex]--;

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

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

  603. 				{

  604. 					if (i == LaiZiIndex)continue;

  605. 					cbCardIndexTemp[i]++;

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

  607. 					//胡牌分析

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

  609. 					{

  610. 						cbChiHuKind = WIK_ZI_MO;

  611. 						return cbChiHuKind;

  612. 					}

  613. 					AnalyseItemArray.RemoveAll();

  614. 					cbCardIndexTemp[i]--;

  615. 				}

  616. 				cbCardIndexTemp[LaiZiIndex]++;

  617. 				return cbChiHuKind;

  618. 			}

  619. 			else

  620. 			{

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

  622. 				//胡牌分析

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

  624. 				{

  625. 					cbChiHuKind |= WIK_ZI_MO;

  626. 					cbChiHuKind |= WIK_YING_ZIMO;

  627. 				}

  628. 				return cbChiHuKind;

  629. 			}

  630. 		}

  631. 		return false;

  632. 	}

  633. 	if (bSubMit == CXZWuLaiDaoDi)

  634. 	{

  635. 		//变量定义

  636. 		int cbChiHuKind = WIK_NULL;

  637. 		CAnalyseItemArray AnalyseItemArray;

  638. 

  639. 		//设置变量

  640. 		AnalyseItemArray.RemoveAll();

  641. 		ChiHuRight.SetEmpty();

  642. 

  643. 		//构造扑克

  644. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  646. 

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

  648. 		ASSERT(cbCurrentCard != 0);

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

  650. 

  651. 		if (!ChiHuRight.IsEmpty())

  652. 			cbChiHuKind = WIK_ZI_MO;

  653. 

  654. 		//插入扑克

  655. 		if (cbCurrentCard == 0)

  656. 		{

  657. 			ASSERT(false);

  658. 			return false;

  659. 		}

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

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

  662. 		if (cbCardIndexTemp[LaiZiIndex] > 0)

  663. 		{

  664. 			return WIK_NULL;

  665. 		}

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

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

  668. 		{

  669. 			cbChiHuKind |= WIK_ZI_MO;

  670. 			cbChiHuKind |= WIK_YING_ZIMO;

  671. 		}

  672. 		return cbChiHuKind;

  673. 	}

  674. 	return false;

  675. }

  676. //听牌分析,

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

  678. {

  679. 	//复制数据

  680. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  682. 

  683. 	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);

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

  685. 	{

  686. 		ASSERT(false);

  687. 		return false;

  688. 	}

  689. 	CChiHuRight chr;

  690. 

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

  692. 	{

  693. 		BYTE cbCurrentCard = SwitchToCardData(i);

  694. 		if (cbCurrentCard == m_cbLaiZi&&subMit == CXZWuLaiDaoDi)continue;

  695. 		if (subMit == CXZBanLai)

  696. 		{

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

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

  699. 				m_cbTingPaiData[i] = 1;

  700. 			else

  701. 			{

  702. 				m_cbTingPaiData[i] = 0;

  703. 			}				

  704. 		}

  705. 		else

  706. 		{

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

  708. 				m_cbTingPaiData[i] = 1;

  709. 			else

  710. 			{

  711. 				m_cbTingPaiData[i] = 0;

  712. 			}

  713. 		}

  714. 	}

  715. 	return true;

  716. }

  717. 

  718. //是否听牌

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

  720. {

  721. 	//复制数据

  722. 	BYTE cbCardIndexTemp[MAX_INDEX];

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

  724. 	BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);

  725. 	CChiHuRight chr;

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

  727. 	{

  728. 		BYTE cbCurrentCard = SwitchToCardData(i);

  729. 		if (((i == LaiZiIndex) && (cbCardIndexTemp[i] > 0) && (subMit == CXZOneStepLaiYou || subMit == CXZBanLai)) || (i == LaiZiIndex&& subMit == CXZWuLaiDaoDi))

  730. 			continue;

  731. 		if (subMit == CXZBanLai && LaiZiCount == 0)

  732. 		{

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

  734. 			if (WIK_YING_ZIMO & wikChiHu)

  735. 			{

  736. 				return true;

  737. 			}

  738. 			else

  739. 				continue;

  740. 		}

  741. 			

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

  743. 			return true;

  744. 	}

  745. 	return false;

  746. }

  747. 

  748. //扑克转换

  749. BYTE CGameLogicCxz::SwitchToCardData(BYTE cbCardIndex)

  750. {

  751. 	//ASSERT(cbCardIndex<34);

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

  753. }

  754. 

  755. //扑克转换

  756. BYTE CGameLogicCxz::SwitchToCardIndex(BYTE cbCardData)

  757. {

  758. 	ASSERT(IsValidCard(cbCardData));

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

  760. }

  761. 

  762. //扑克转换

  763. BYTE CGameLogicCxz::SwitchToCardData(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT])

  764. {

  765. 	//转换扑克

  766. 	BYTE cbPosition=0;

  767. 	//钻牌

  768. 	if( m_cbMagicIndex != MAX_INDEX )

  769. 	{

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

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

  772. 	}

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

  774. 	{

  775. 		if( i == m_cbMagicIndex ) continue;

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

  777. 		{

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

  779. 			{

  780. 				ASSERT(cbPosition<MAX_COUNT);

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

  782. 			}

  783. 		}

  784. 	}

  785. 

  786. 	return cbPosition;

  787. }

  788. 

  789. //扑克转换

  790. BYTE CGameLogicCxz::SwitchToCardIndex(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX])

  791. {

  792. 	//设置变量

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

  794. 

  795. 	//转换扑克

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

  797. 	{

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

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

  800. 	}

  801. 

  802. 	return cbCardCount;

  803. }

  804. 

  805. //分析扑克

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

  807. {

  808. 	//计算数目

  809. 	BYTE cbCardCount = GetCardCount(cbCardIndex);

  810. 

  811. 	//效验数目

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

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

  814. 		return false;

  815. 

  816. 	//变量定义

  817. 	BYTE cbKindItemCount = 0;

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

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

  820. 

  821. 	//需求判断

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

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

  824. 

  825. 	//单吊判断

  826. 	if (cbLessKindItem == 0)

  827. 	{

  828. 		//效验参数

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

  830. 

  831. 		//牌眼判断

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

  833. 		{

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

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

  836. 			{

  837. 				//变量定义

  838. 				tagAnalyseItem AnalyseItem;

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

  840. 

  841. 				//设置结果

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

  843. 				{

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

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

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

  847. 				}

  848. 				AnalyseItem.cbCardEye = SwitchToCardData(i);

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

  850. 					AnalyseItem.bMagicEye = true;

  851. 				else AnalyseItem.bMagicEye = false;

  852. 

  853. 				//插入结果

  854. 				AnalyseItemArray.Add(AnalyseItem);

  855. 

  856. 				return true;

  857. 			}

  858. 		}

  859. 		return false;

  860. 	}

  861. 

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

  863. 	BYTE cbMagicCardIndex[MAX_INDEX];

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

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

  866. 	if (m_cbMagicIndex != MAX_INDEX)

  867. 	{

  868. 		cbMagicCardCount = cbCardIndex[m_cbMagicIndex];

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

  870. 	}

  871. 	if (cbCardCount >= 3)

  872. 	{

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

  874. 		{

  875. 			//同牌判断

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

  877. 			{

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

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

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

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

  882. 				KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;

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

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

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

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

  887. 				cbKindItemCount++;

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

  889. 				{

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

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

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

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

  894. 					KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;

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

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

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

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

  899. 					cbKindItemCount++;

  900. 				}

  901. 			}

  902. 

  903. 			//连牌判断

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

  905. 			{

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

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

  908. 				{

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

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

  911. 					int nMagicCountTemp = cbMagicCardCount;

  912. 					BYTE cbValidIndex[3];

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

  914. 					{

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

  916. 						{

  917. 							if (cbIndex[j] > 0)

  918. 							{

  919. 								cbIndex[j]--;

  920. 								cbValidIndex[j] = i + j;

  921. 							}

  922. 							else

  923. 							{

  924. 								nMagicCountTemp--;

  925. 								cbValidIndex[j] = m_cbMagicIndex;

  926. 							}

  927. 						}

  928. 						if (nMagicCountTemp >= 0)

  929. 						{

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

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

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

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

  934. 							KindItem[cbKindItemCount].cbWeaveKind = WIK_LEFT;

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

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

  937. 							cbKindItemCount++;

  938. 						}

  939. 						else break;

  940. 					}

  941. 				}

  942. 			}

  943. 		}

  944. 	}

  945. 

  946. 	//组合分析

  947. 	if (cbKindItemCount >= cbLessKindItem)

  948. 	{

  949. 		//变量定义

  950. 		BYTE cbCardIndexTemp[MAX_INDEX];

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

  952. 

  953. 		//变量定义

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

  955. 		tagKindItem * pKindItem[4];

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

  957. 

  958. 		//开始组合

  959. 		do

  960. 		{

  961. 			//设置变量

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

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

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

  965. 

  966. 			//数量判断

  967. 			bool bEnoughCard = true;

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

  969. 			{

  970. 				//存在判断

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

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

  973. 				{

  974. 					bEnoughCard = false;

  975. 					break;

  976. 				}

  977. 				else

  978. 					cbCardIndexTemp[cbCardIndex]--;

  979. 			}

  980. 

  981. 			//胡牌判断

  982. 			if (bEnoughCard == true)

  983. 			{

  984. 				//牌眼判断

  985. 				BYTE cbCardEye = 0;

  986. 				bool bMagicEye = false;

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

  988. 				{

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

  990. 					{

  991. 						cbCardEye = SwitchToCardData(i);

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

  993. 						break;

  994. 					}

  995. 					else if (i != m_cbMagicIndex &&

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

  997. 					{

  998. 						cbCardEye = SwitchToCardData(i);

  999. 						bMagicEye = true;

  1000. 					}

  1001. 				}

  1002. 

  1003. 				//组合类型

  1004. 				if (cbCardEye != 0)

  1005. 				{

  1006. 					//变量定义

  1007. 					tagAnalyseItem AnalyseItem;

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

  1009. 

  1010. 					//设置组合

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

  1012. 					{

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

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

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

  1016. 							AnalyseItem.cbCardData[i]);

  1017. 					}

  1018. 

  1019. 					//设置牌型

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

  1021. 					{

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

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

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

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

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

  1027. 					}

  1028. 

  1029. 					//设置牌眼

  1030. 					AnalyseItem.cbCardEye = cbCardEye;

  1031. 					AnalyseItem.bMagicEye = bMagicEye;

  1032. 

  1033. 					//插入结果

  1034. 					AnalyseItemArray.Add(AnalyseItem);

  1035. 				}

  1036. 			}

  1037. 

  1038. 			//设置索引

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

  1040. 			{

  1041. 				BYTE i = cbLessKindItem - 1;

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

  1043. 				{

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

  1045. 					{

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

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

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

  1049. 						break;

  1050. 					}

  1051. 				}

  1052. 				if (i == 0)

  1053. 					break;

  1054. 			}

  1055. 			else

  1056. 				cbIndex[cbLessKindItem - 1]++;

  1057. 		} while (true);

  1058. 

  1059. 	}

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

  1061. }

  1062. 

  1063. //钻牌

  1064. bool CGameLogicCxz::IsMagicCard(BYTE cbCardData)

  1065. {

  1066. 	if( m_cbMagicIndex != MAX_INDEX )

  1067. 		return SwitchToCardIndex(cbCardData) == m_cbMagicIndex;

  1068. 	return false;

  1069. }

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

  1071. BYTE CGameLogicCxz::GetLaiZiCount(const BYTE cbCardIndex[MAX_INDEX], BYTE m_cbLaiZi)

  1072. {

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

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

  1075. 	{

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

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

  1078. 		{

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

  1080. 			{

  1081. 				LaiZiCount = 1;

  1082. 			}

  1083. 			else

  1084. 			{

  1085. 				LaiZiCount = 2;

  1086. 			}

  1087. 		}

  1088. 	}

  1089. 	return LaiZiCount;

  1090. }

  1091. 

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

  1093. bool CGameLogicCxz::SortCardList(BYTE cbCardData[MAX_COUNT], BYTE cbCardCount)

  1094. {

  1095. 	//数目过虑

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

  1097. 

  1098. 	//排序操作

  1099. 	bool bSorted=true;

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

  1101. 	do

  1102. 	{

  1103. 		bSorted=true;

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

  1105. 		{

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

  1107. 			{

  1108. 				//设置标志

  1109. 				bSorted=false;

  1110. 

  1111. 				//扑克数据

  1112. 				cbSwitchData=cbCardData[i];

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

  1114. 				cbCardData[i+1]=cbSwitchData;

  1115. 			}	

  1116. 		}

  1117. 		cbLast--;

  1118. 	} while(bSorted==false);

  1119. 

  1120. 	return true;

  1121. }

  1122. 

  1123. byte CGameLogicCxz::GetValue(USHORT uNum, byte PaiZhi)

  1124. {

  1125. 	byte bRet = 0;

  1126. 

  1127. 	switch (uNum)

  1128. 	{

  1129. 	case 0:

  1130. 		return PaiZhi;

  1131. 	case 1:

  1132. 		return PaiZhi + 41;

  1133. 	case 2:

  1134. 		return PaiZhi + 82;

  1135. 	case 3:

  1136. 		return PaiZhi + 123;

  1137. 	case 4:

  1138. 		return PaiZhi + 164;

  1139. 	default:

  1140. 		ASSERT(FALSE);

  1141. 		return 0;

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

  1143. 		break;

  1144. 	}

  1145. 

  1146. 	return bRet + PaiZhi;

  1147. }

  1148. 

  1149. bool CGameLogicCxz::PeiPai(BYTE ParZhi[MAX_REPERTORY_SRLF])

  1150. {

  1151. 	std::ifstream in;

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

  1153. 	in.open(filename);

  1154. 	if (!in.is_open())

  1155. 	{

  1156. 		return false;

  1157. 		//ASSERT(false);

  1158. 	}

  1159. 	static BYTE TempCardData[MAX_REPERTORY_SRLF];

  1160. 	//static BYTE TempCardDatar[MAX_REPERTORY];

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

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

  1163. 	BYTE tempCount = 0;

  1164. 	char ch[1];

  1165. 	while (!in.eof())

  1166. 	{

  1167. 		in.read(ch, 1);

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

  1169. 	}

  1170. 	in.close(); 

  1171. 	//TempCardData[108] = 0;

  1172. 	for (BYTE i = 0; i < MAX_REPERTORY_SRLF; i++)

  1173. 	{

  1174. 		ASSERT(i < MAX_REPERTORY_SRLF);

  1175. 		ParZhi[i] = TempCardData[MAX_REPERTORY_SRLF - i - 1];

  1176. 	}

  1177. 	//TempCardDatar[MAX_REPERTORY] = 0;

  1178. 	return true;

  1179. }

  1180. BYTE CGameLogicCxz::GetEndCard(const BYTE cbCardIndex[MAX_INDEX], BYTE mLaiZiData)

  1181. {

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

  1183. 	{

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

  1185. 		{

  1186. 			return SwitchToCardData(i);

  1187. 		}

  1188. 	}

  1189. 	ASSERT(false);

  1190. 	return mLaiZiData;

  1191. }

  1192. 

  1193. //////////////////////////////////////////////////////////////////////////