麻将癞子算法

/***********************************************************
* File Name          :       game_logic.h
* Author             :       liuzhu
* Version            :       1.0
* Date               :       2017-12-21 16:15
* Description        :       麻将癞子逻辑
***********************************************************/

#include "game_logic.h"
#include "game_logic_fan.h"

bool CGameLogic::find_laizi_max_hu(const tagHandCard & handCard, CARD card, bool ziMo, tagHuCard & huCard)
{
	if((huCard.laiziCount + handCard.cardCount)%3 != 2) return false;

	int jiangIndex = 0;
	CARD jiangCard = INVALID_CARD;

	//查找普通胡牌
	tagHuCard fixCard;
	int fixCardCount = 0;
	find_fix_card(handCard, fixCard, fixCardCount);
	int _maxHuFan = -1;
	bool bHasHu = false;

	tagHuCard tmpHuCard;
	memcpy(&tmpHuCard,&huCard,sizeof(huCard));

	if(handCard.cardCount < 2)
	{
		tagHuCard maxHuCard;
		memcpy(&maxHuCard,&tmpHuCard,sizeof(tmpHuCard));
		memcpy(&maxHuCard.mixTureCard, &fixCard.mixTureCard, sizeof(fixCard.mixTureCard));

		maxHuCard.huType = get_hu_type(handCard, maxHuCard);
		maxHuCard.fanType = get_fan_type(handCard, maxHuCard.huCard, maxHuCard);
		maxHuCard.maxFan = CLogicFan::GetInstance()->get_hu_fan(maxHuCard.huType, maxHuCard.fanType, ziMo);
		if(handCard.cardCount == 1)
		{
			maxHuCard.jiangCard[0] = handCard.card[0];
			maxHuCard.jiangCard[1] = handCard.card[0];
		}
		else
		{
			maxHuCard.jiangCard[0] = m_playConfig.laiziCard;
			maxHuCard.jiangCard[1] = m_playConfig.laiziCard;
		}

		if (check_hu_condition(handCard, maxHuCard))
		{
			if(_maxHuFan < maxHuCard.maxFan) 
			{
				_maxHuFan = maxHuCard.maxFan;
				memcpy(&huCard,&maxHuCard,sizeof(huCard));
				memcpy(&huCard.activityCard,handCard.card,sizeof(handCard.card));
				huCard.activityCount = handCard.cardCount;
				bHasHu = true;
			}
		}
	}
	else
	{
		while(jiangIndex < handCard.cardCount)
		{
			CARD _jiangCard = handCard.card[jiangIndex];
			if(jiangCard != _jiangCard)  //重复将就不用找了 
			{
				tagHandCard checkHandCard;
				memcpy(&checkHandCard, &handCard, sizeof(handCard));

				tagHuCard checkHuCard;
				memcpy(&checkHuCard,&tmpHuCard,sizeof(tmpHuCard));

				tagHuCard maxHuCard;
				tagHandCard maxHandCard;

				int fitedCount = 0;
				bool isJiang = _find_jiang(checkHuCard, checkHandCard.card, checkHandCard.cardCount, jiangIndex, fitedCount);
				if(isJiang)
				{
					jiangCard = _jiangCard;

					do 
					{
						memcpy(&maxHandCard, &checkHandCard, sizeof(checkHandCard));				
						memcpy(&maxHuCard,&checkHuCard,sizeof(checkHuCard));
						memcpy(&maxHuCard.mixTureCard, &fixCard.mixTureCard, sizeof(fixCard.mixTureCard));

						if(_find_only_kezi(maxHuCard, maxHandCard.card, maxHandCard.cardCount, 0, fitedCount, fixCardCount))
						{
							maxHuCard.huType = get_hu_type(handCard, maxHuCard);
							maxHuCard.fanType = get_fan_type(handCard, maxHuCard.huCard, maxHuCard);
							maxHuCard.maxFan = CLogicFan::GetInstance()->get_hu_fan(maxHuCard.huType, maxHuCard.fanType, ziMo);

							if (check_hu_condition(handCard, maxHuCard))
							{
								if(_maxHuFan <= maxHuCard.maxFan) 
								{
									_maxHuFan = maxHuCard.maxFan;
									memcpy(&huCard,&maxHuCard,sizeof(huCard));
									memcpy(&huCard.activityCard,handCard.card,sizeof(handCard.card));
									huCard.activityCount = handCard.cardCount;
									bHasHu = true;
								}
							}
						}
					} while (false);

					if(!bHasHu)
					{
						memcpy(&maxHandCard, &checkHandCard, sizeof(checkHandCard));
						memcpy(&maxHuCard,&checkHuCard,sizeof(checkHuCard));
						memcpy(&maxHuCard.mixTureCard, &fixCard.mixTureCard, sizeof(fixCard.mixTureCard));

						if(_find_kezi_shunzi(maxHuCard, maxHandCard.card, maxHandCard.cardCount, 0, fitedCount, fixCardCount))
						{
							maxHuCard.huType = get_hu_type(handCard, maxHuCard);
							maxHuCard.fanType = get_fan_type(handCard, maxHuCard.huCard, maxHuCard);
							maxHuCard.maxFan = CLogicFan::GetInstance()->get_hu_fan(maxHuCard.huType, maxHuCard.fanType, ziMo);

							if (check_hu_condition(handCard, maxHuCard))
							{
								if(_maxHuFan < maxHuCard.maxFan) 
								{
									_maxHuFan = maxHuCard.maxFan;
									memcpy(&huCard,&maxHuCard,sizeof(maxHuCard));
									memcpy(&huCard.activityCard,handCard.card,sizeof(handCard.card));
									huCard.activityCount = handCard.cardCount;

									bHasHu = true;
								}
							}
						}
					}

					if(!bHasHu)
					{
						memcpy(&maxHandCard, &checkHandCard, sizeof(checkHandCard));
						re_sort_card(maxHandCard.card,maxHandCard.cardCount);
						memcpy(&maxHuCard,&checkHuCard,sizeof(checkHuCard));
						memcpy(&maxHuCard.mixTureCard, &fixCard.mixTureCard, sizeof(fixCard.mixTureCard));

						if(_find_kezi_shunzi(maxHuCard, maxHandCard.card, maxHandCard.cardCount, 0, fitedCount, fixCardCount ,false))
						{
							maxHuCard.huType = get_hu_type(handCard, maxHuCard);
							maxHuCard.fanType = get_fan_type(handCard, maxHuCard.huCard, maxHuCard);
							maxHuCard.maxFan = CLogicFan::GetInstance()->get_hu_fan(maxHuCard.huType, maxHuCard.fanType, ziMo);

							if (check_hu_condition(handCard, maxHuCard))
							{
								if(_maxHuFan < maxHuCard.maxFan) 
								{
									_maxHuFan = maxHuCard.maxFan;
									memcpy(&huCard,&maxHuCard,sizeof(maxHuCard));
									memcpy(&huCard.activityCard,handCard.card,sizeof(handCard.card));
									huCard.activityCount = handCard.cardCount;

									bHasHu = true;
								}
							}
						}
					}
				}
			}

			jiangIndex++;
		}

		do 
		{
			tagHandCard checkCard;
			memcpy(&checkCard, &handCard, sizeof(tagHandCard));

			tagHuCard maxHuCard;
			memcpy(&maxHuCard,&tmpHuCard,sizeof(tmpHuCard));

			int fitedCount = 0;
			bool isJiang = _find_jiang(maxHuCard, checkCard.card, checkCard.cardCount, jiangIndex, fitedCount,true);
			if(isJiang)
			{
				memcpy(&maxHuCard.mixTureCard, &fixCard.mixTureCard, sizeof(fixCard.mixTureCard));
				if(_find_kezi_shunzi(maxHuCard, checkCard.card, checkCard.cardCount, 0, fitedCount, fixCardCount))
				{
					if (check_hu_condition(handCard, maxHuCard))
					{
						bHasHu = true;
						maxHuCard.huType = get_hu_type(handCard, maxHuCard);
						maxHuCard.fanType = get_fan_type(handCard, maxHuCard.huCard, maxHuCard);
						maxHuCard.maxFan = CLogicFan::GetInstance()->get_hu_fan(maxHuCard.huType, maxHuCard.fanType, ziMo);
						if(_maxHuFan < maxHuCard.maxFan) 
						{
							_maxHuFan = maxHuCard.maxFan;
							memcpy(&huCard,&maxHuCard,sizeof(huCard));
						}
					}
				}
			}

		} while (false);

		do 
		{
			tagHandCard checkCard;
			memcpy(&checkCard, &handCard, sizeof(tagHandCard));

			tagHuCard maxHuCard;
			memcpy(&maxHuCard,&tmpHuCard,sizeof(tmpHuCard));

			int fitedCount = 0;
			bool isJiang = _find_jiang(maxHuCard, checkCard.card, checkCard.cardCount, jiangIndex, fitedCount,false, true);
			if(isJiang)
			{
				memcpy(&maxHuCard.mixTureCard, &fixCard.mixTureCard, sizeof(fixCard.mixTureCard));
				if(_find_kezi_shunzi(maxHuCard, checkCard.card, checkCard.cardCount, 0, fitedCount, fixCardCount))
				{
					if (check_hu_condition(handCard, maxHuCard))
					{
						bHasHu = true;
						maxHuCard.huType = get_hu_type(handCard, maxHuCard);
						maxHuCard.fanType = get_fan_type(handCard, maxHuCard.huCard, maxHuCard);
						maxHuCard.maxFan = CLogicFan::GetInstance()->get_hu_fan(maxHuCard.huType, maxHuCard.fanType, ziMo);
						if(_maxHuFan < maxHuCard.maxFan) 
						{
							_maxHuFan = maxHuCard.maxFan;
							memcpy(&huCard,&maxHuCard,sizeof(huCard));
						}
					}
				}
			}

		} while (false);
	}

	return bHasHu;
}

bool CGameLogic::_find_jiang(tagHuCard& huCard, CARD handCard[], int handCount, int findPos, int& fitedCount,bool bBaoTou, bool bLaiziBaoTou)
{
	bool bFindJiang = false;
	CARD jiangCard = INVALID_CARD;
	int needLaiziCount = 0;

	if(bLaiziBaoTou)
	{
		jiangCard = m_playConfig.laiziCard;
		needLaiziCount = 2;
		bFindJiang = (huCard.laiziCount >= needLaiziCount);
	}
	else if(bBaoTou)
	{
		jiangCard = huCard.huCard;
		needLaiziCount = (jiangCard==m_playConfig.laiziCard ? 2:1);
		bFindJiang = (huCard.laiziCount >= needLaiziCount);
	}
	else
	{
		jiangCard = handCard[findPos];
		if(findPos + 1 < handCount) 
		{
			bFindJiang = (jiangCard == handCard[findPos+1]);
		}
		if(!bFindJiang)
		{
			needLaiziCount = 1;
			bFindJiang = (huCard.laiziCount > 0);
		}
	}
	if(bFindJiang)
	{
		fitedCount = fitedCount + needLaiziCount;
		for (int i = 0; i < 2 - needLaiziCount;i++)
		{
			remove_card(handCard,handCount,jiangCard);
		}
		for(int i = 0;i< needLaiziCount;i++)
		{
			huCard.laiziFitCard[i] = jiangCard;
		}
		huCard.jiangCard[0] = jiangCard;
		huCard.jiangCard[1] = jiangCard;
	}

	return bFindJiang;
}

bool CGameLogic::_find_shunzi(CARD handCard[], int handCount, int findPos, int shunziPos[], bool findDirect)
{
	int shunziCount = 0;
	shunziPos[shunziCount++] = findPos;

	CARD preCard = handCard[findPos];
	enCardType cardType = get_card_type(preCard);
	if (cardType == CARD_TYPE_FENG) return false; //只有风不能组顺

	if(findDirect)
	{
		//正着找顺子
		for (int i = findPos; i <= handCount-1; i++)
		{
			if(INVALID_CARD == handCard[i]) continue;

			if(preCard == handCard[i]) continue;
			if(preCard + 1 < handCard[i]) return false;

			preCard = handCard[i];
			shunziPos[shunziCount++] = i;
			if(shunziCount == 3) return true;
		}
	}
	else
	{
		//反着找顺子
		for (int i = findPos; i <= handCount-1; i++)
		{
			if(INVALID_CARD == handCard[i]) continue;

			if(preCard == handCard[i]) continue;
			if(preCard - 1 > handCard[i]) return false;

			preCard = handCard[i];
			shunziPos[shunziCount++] = i;
			if(shunziCount == 3) return true;
		}
	}

	return false;
}

bool CGameLogic::_find_kezi(CARD handCard[], int handCount, int findPos, int keziPos[])
{
	if(findPos + 2 > handCount - 1) return false;
	if(handCard[findPos] != handCard[findPos + 2]) return false;

	keziPos[0] = findPos;
	keziPos[1] = findPos + 1;
	keziPos[2] = findPos + 2;

	return true;
}


bool CGameLogic::_find_duizi(CARD handCard[], int handCount, int findPos, int duiziPos[])
{
	if(findPos + 1 > handCount - 1) return false;
	if(handCard[findPos] != handCard[findPos + 1]) return false;

	duiziPos[0] = findPos;
	duiziPos[1] = findPos + 1;

	return true;
}

bool CGameLogic::_find_quezi(CARD handCard[], int handCount, int findPos, int queziPos[], bool findDirect)
{
	int queziCount = 0;
	queziPos[queziCount++] = findPos;
	CARD preCard = handCard[findPos];
	enCardType cardType = get_card_type(preCard);
	if (cardType == CARD_TYPE_FENG) return false; //只有风不能组顺

	if(findDirect)
	{
		//正着找顺子
		for (int i = findPos; i <= handCount-1; i++)
		{
			if(INVALID_CARD == handCard[i]) continue;

			if(preCard == handCard[i]) continue;
			if(preCard + 2 < handCard[i]) return false;

			preCard = handCard[i];
			queziPos[queziCount++] = i;
			if(queziCount == 2) return true;
		}
	}
	else
	{
		//反着找顺子
		for (int i = findPos; i <= handCount-1; i++)
		{
			if(INVALID_CARD == handCard[i]) continue;

			if(preCard == handCard[i]) continue;
			if(preCard - 2 > handCard[i]) return false;

			preCard = handCard[i];
			queziPos[queziCount++] = i;
			if(queziCount == 2) return true;
		}
	}

	return false;
}

bool CGameLogic::_find_duizi_quezi(tagHuCard& huCard, CARD handCard[], int handCount, int findPos, int fitedCount, int groupCount,bool findDirect)
{
	if(fitedCount > huCard.laiziCount) return false;
	while(findPos < handCount - 1 && handCard[findPos] == INVALID_CARD) findPos++;

	if(findPos >= handCount - 1) 
	{

		CARD checkCard[MAX_HAND_CARD_COUNT] = {INVALID_CARD};
		int checkCount = 0;

		for (int i = 0; i < handCount; i++)
		{
			if(handCard[i] != INVALID_CARD)
			{
				checkCard[checkCount++] = handCard[i];
			}
		}

		if(checkCount == 0)
		{
			return true;//不需癞子就可以胡
		}
		else if(checkCount == 1)
		{
			//补两张
			huCard.mixTureCard[groupCount].card[0] = checkCard[0];
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;
			groupCount = groupCount  + 1;
			return true;
		}
		else if(checkCount <= huCard.laiziCount * 2) //剩余的牌大于癞子数*2 直接就不可能胡了
		{
			return _find_duizi_quezi(huCard, checkCard, checkCount, 0, fitedCount, groupCount, findDirect); //找对子缺张
		}

		return false;
	}

	int duiziPos[2] = {0};
	int queziPos[2] = {0};
	bool bFindDuizi = _find_duizi(handCard, handCount, findPos, duiziPos);
	bool bFindQuezi = _find_quezi(handCard, handCount, findPos, queziPos, findDirect);

	bool bFindDuiziHu = false;
	if(bFindDuizi) 
	{
		if(fitedCount +1 <= huCard.laiziCount)
		{
			//补一张移除
			for (int i = 0; i < 2; i++)
			{
				huCard.mixTureCard[groupCount].card[i] = handCard[duiziPos[i]];
				handCard[duiziPos[i]] = INVALID_CARD;
			}
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;

			int findPosD = findPos;
			while(findPosD < handCount - 1 && handCard[findPosD] == INVALID_CARD) findPosD++;
			bFindDuiziHu = _find_duizi_quezi(huCard, handCard, handCount, findPosD, fitedCount+1, groupCount+1, findDirect);
			if(bFindDuiziHu) return true;

			//回溯
			for (int i = 0; i < 2; i++)
			{
				handCard[duiziPos[i]] = huCard.mixTureCard[groupCount].card[i];	
				huCard.mixTureCard[groupCount].card[i] = INVALID_CARD;
			}
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
		}
	}

	bool bFindQueziHu = false;
	if(bFindQuezi)
	{
		if(fitedCount +1 <= huCard.laiziCount)
		{
			//补一张移除
			for (int i = 0; i < 2; i++)
			{
				huCard.mixTureCard[groupCount].card[i] = handCard[queziPos[i]];
				handCard[queziPos[i]] = INVALID_CARD;
			}
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_SHUN_ZI;

			int findPosQ = findPos;
			while(findPosQ < handCount - 1 && handCard[findPosQ] == INVALID_CARD) findPosQ++;
			bFindQueziHu = _find_duizi_quezi(huCard, handCard, handCount, findPosQ, fitedCount+1, groupCount+1, findDirect);
			if(bFindQueziHu) return true;

			//回溯
			for (int i = 0; i < 2; i++)
			{
				handCard[queziPos[i]] = huCard.mixTureCard[groupCount].card[i];	
				huCard.mixTureCard[groupCount].card[i] = INVALID_CARD;
			}
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
		}	
	}

	bool bNotFindHu = false;
	if(!bFindDuizi && !bFindQuezi)
	{
		if(fitedCount +2 <= huCard.laiziCount)
		{
			//补两张
			huCard.mixTureCard[groupCount].card[0] = handCard[findPos];
			int removePos = findPos;
			handCard[findPos] = INVALID_CARD;
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;

			while(findPos < handCount - 1 && handCard[findPos] == INVALID_CARD) findPos++;
			bNotFindHu = _find_duizi_quezi(huCard, handCard, handCount, findPos, fitedCount+2, groupCount+1, findDirect);
			if(bNotFindHu) return true;

			//回溯
			handCard[removePos] = huCard.mixTureCard[groupCount].card[0];
			huCard.mixTureCard[groupCount].card[0] = INVALID_CARD;
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
		}
	}

	return false;
}

bool CGameLogic::_find_only_kezi(tagHuCard& huCard, CARD handCard[], int handCount, int findPos, int fitedCount, int groupCount)
{
	int cardCount[MAX_CARD_INDEX] = {0};
	get_index_count(handCard, handCount, cardCount);

	for (int i = 0; i < MAX_CARD_INDEX; ++i)
	{
		if(cardCount[i] == 3)
		{
			huCard.mixTureCard[groupCount].card[0] = g_card_index[i];
			huCard.mixTureCard[groupCount].card[1] = g_card_index[i];
			huCard.mixTureCard[groupCount].card[2] = g_card_index[i];
			huCard.mixTureCard[groupCount++].type = MIXTURE_CARD_KE_ZI;
		}	
		else if(cardCount[i] == 2) 
		{
			if(fitedCount + 1 > huCard.laiziCount) return false;

			fitedCount = fitedCount+1;
			huCard.mixTureCard[groupCount].card[0] = g_card_index[i];
			huCard.mixTureCard[groupCount].card[1] = g_card_index[i];
			huCard.mixTureCard[groupCount++].type = MIXTURE_CARD_KE_ZI;
		}
		else if(cardCount[i] == 1) 
		{
			if(fitedCount + 2 > huCard.laiziCount) return false;

			fitedCount = fitedCount+2;
			huCard.mixTureCard[groupCount].card[0] = g_card_index[i];
			huCard.mixTureCard[groupCount++].type = MIXTURE_CARD_KE_ZI;
		}
		else if(cardCount[i] == 4) 
		{
			if(fitedCount + 2 > huCard.laiziCount) return false;

			huCard.mixTureCard[groupCount].card[0] = g_card_index[i];
			huCard.mixTureCard[groupCount].card[1] = g_card_index[i];
			huCard.mixTureCard[groupCount].card[2] = g_card_index[i];
			huCard.mixTureCard[groupCount++].type = MIXTURE_CARD_KE_ZI;

			fitedCount = fitedCount+2;
			huCard.mixTureCard[groupCount].card[0] = g_card_index[i];
			huCard.mixTureCard[groupCount++].type = MIXTURE_CARD_KE_ZI;
		}
	}

	if(fitedCount + 3 <= huCard.laiziCount)
	{
		fitedCount = fitedCount+1;
		huCard.mixTureCard[groupCount].card[0] = m_playConfig.laiziCard;
		huCard.mixTureCard[groupCount++].type = MIXTURE_CARD_KE_ZI;
	}

	return true;
}

bool CGameLogic::_find_kezi_shunzi(tagHuCard& huCard, CARD handCard[], int handCount, int findPos, int fitedCount, int groupCount,bool findDirect)
{
	if(fitedCount > huCard.laiziCount) return false;
	while(findPos < handCount - 1 && handCard[findPos] == INVALID_CARD) findPos++;

	if(findPos >= handCount - 1) 
	{
		CARD checkCard[MAX_HAND_CARD_COUNT] = {INVALID_CARD};
		int checkCount = 0;

		for (int i = 0; i < handCount; i++)
		{
			if(handCard[i] != INVALID_CARD)
			{
				checkCard[checkCount++] = handCard[i];
			}
		}

		if(checkCount == 0)
		{
			return true;//不需癞子就可以胡
		}
		else if(checkCount == 1)
		{
			//补两张
			huCard.mixTureCard[groupCount].card[0] = checkCard[0];
			huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;
			groupCount = groupCount  + 1;
			return true;
		}
		else if(checkCount <= huCard.laiziCount * 2) //剩余的牌大于癞子数*2 直接就不可能胡了
		{
			return _find_duizi_quezi(huCard, checkCard, checkCount, 0, fitedCount, groupCount,findDirect); //找对子缺张
		}

		return false;
	}

	int shunziPos[3] = {0};
	int keziPos[3] = {0};
	bool bFindKezi = _find_kezi(handCard, handCount, findPos, keziPos);
	bool bFindShunzi = _find_shunzi(handCard, handCount, findPos, shunziPos, findDirect);

	bool bFindKeziHu = false;
	if(bFindKezi) 
	{
		//移除
		for (int i = 0; i < 3; i++)
		{
			huCard.mixTureCard[groupCount].card[i] = handCard[keziPos[i]];
			handCard[keziPos[i]] = INVALID_CARD;
		}
		huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;


		int findPosK = findPos;
		while(findPosK < handCount - 1 && handCard[findPosK] == INVALID_CARD) findPosK++;
		bFindKeziHu = _find_kezi_shunzi(huCard, handCard, handCount, findPosK, fitedCount, groupCount + 1,findDirect);
		if(bFindKeziHu) return true;

		//回溯
		for (int i = 0; i < 3; i++)
		{
			handCard[keziPos[i]] = huCard.mixTureCard[groupCount].card[i];	
			huCard.mixTureCard[groupCount].card[i] = INVALID_CARD;
		}
		huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
	}

	bool bFindShunziHu = false;
	if(bFindShunzi)
	{
		//移除
		for (int i = 0; i < 3; i++)
		{
			huCard.mixTureCard[groupCount].card[i] = handCard[shunziPos[i]];
			handCard[shunziPos[i]] = INVALID_CARD;
		}
		huCard.mixTureCard[groupCount].type = MIXTURE_CARD_SHUN_ZI;

		int findPosS = findPos;
		while(findPosS < handCount - 1 && handCard[findPosS] == INVALID_CARD) findPosS++;
		bFindShunziHu = _find_kezi_shunzi(huCard, handCard, handCount, findPosS, fitedCount, groupCount+1,findDirect);
		if(bFindShunziHu) return true;

		//回溯
		for (int i = 0; i < 3; i++)
		{
			handCard[shunziPos[i]] = huCard.mixTureCard[groupCount].card[i];	
			huCard.mixTureCard[groupCount].card[i] = INVALID_CARD;	
		}
		huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
	}

	bool bNotFindHu = false;
	if(true)
	{
		bool bFindDuiziHu = false;

		int duiziPos[2] = {0};
		int queziPos[2] = {0};
		bool bFindDuizi = _find_duizi(handCard, handCount, findPos, duiziPos);
		bool bFindQuezi = _find_quezi(handCard, handCount, findPos, queziPos,findDirect);

		if(bFindDuizi)
		{
			//补两张	
			if(fitedCount + 1 <= huCard.laiziCount)
			{
				//移除
				for (int i = 0; i < 2; i++)
				{
					huCard.mixTureCard[groupCount].card[i] = handCard[duiziPos[i]];
					handCard[duiziPos[i]] = INVALID_CARD;
				}
				huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;

				while(findPos < handCount - 1 && handCard[findPos] == INVALID_CARD) findPos++;
				bFindDuiziHu = _find_kezi_shunzi(huCard, handCard, handCount, findPos, fitedCount + 1, groupCount+1, findDirect);
				if(bFindDuiziHu) return true;

				//回溯
				for (int i = 0; i < 2; i++)
				{
					handCard[duiziPos[i]] = huCard.mixTureCard[groupCount].card[i];	
					huCard.mixTureCard[groupCount].card[i] = INVALID_CARD;
				}
				huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
			}
		}

		bool bFindQueziHu = false;
		if(bFindQuezi)
		{
			//补两张	
			if(fitedCount + 1 <= huCard.laiziCount)
			{
				//移除
				for (int i = 0; i < 2; i++)
				{
					huCard.mixTureCard[groupCount].card[i] = handCard[queziPos[i]];
					handCard[queziPos[i]] = INVALID_CARD;
				}
				huCard.mixTureCard[groupCount].type = MIXTURE_CARD_SHUN_ZI;

				while(findPos < handCount - 1 && handCard[findPos] == INVALID_CARD) findPos++;
				bFindQueziHu = _find_kezi_shunzi(huCard, handCard, handCount, findPos, fitedCount + 1, groupCount+1, findDirect);
				if(bFindQueziHu) return true;

				//回溯
				for (int i = 0; i < 2; i++)
				{
					handCard[queziPos[i]] = huCard.mixTureCard[groupCount].card[i];	
					huCard.mixTureCard[groupCount].card[i] = INVALID_CARD;
				}
				huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
			}
		}

		if(!bFindDuizi && !bFindQuezi)
		{
			//补两张	
			if(fitedCount + 2 <= huCard.laiziCount)
			{
				int removePos = findPos;
				huCard.mixTureCard[groupCount].type = MIXTURE_CARD_KE_ZI;
				huCard.mixTureCard[groupCount].card[0] = handCard[findPos];
				handCard[findPos] = INVALID_CARD;

				while(findPos < handCount - 1 && handCard[findPos] == INVALID_CARD) findPos++;
				bNotFindHu = _find_kezi_shunzi(huCard, handCard, handCount, findPos, fitedCount + 2, groupCount+1, findDirect);
				if(bNotFindHu) return true;

				huCard.mixTureCard[groupCount].type = MIXTURE_CARD_INVALID;
				handCard[removePos] = huCard.mixTureCard[groupCount].card[0];
				huCard.mixTureCard[groupCount].card[0] = INVALID_CARD;
			}
		}

		bNotFindHu = bNotFindHu || bFindQueziHu || bFindDuiziHu;
	}

	return bFindKeziHu || bFindShunziHu || bNotFindHu;
}