#include "StdAfx.h"
#include "GameLogic.h"

//////////////////////////////////////////////////////////////////////////////////
//静态变量

//索引变量
const BYTE cbIndexCount=5;

//16张玩法：去掉大小王，3个2，1个A
const BYTE	CGameLogic::m_cbCardData16[FULL_COUNT] =
{
	0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,	//方块 A - K
	0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,	//梅花 A - K
	0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,	//红桃 A - K
	0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,	//黑桃 A - K
	0x01,0x11,0x21,0x22
};

//15张玩法：去掉大小王，3个2，3个A，1个K
const BYTE	CGameLogic::m_cbCardData15[FULL_COUNT_15] =
{
	0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,	//方块 A - K
	0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,	//梅花 A - K
	0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,	//红桃 A - K
	0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 		//黑桃 A - K
	0x21, 0x22
};

//////////////////////////////////////////////////////////////////////////////////

//构造函数
CGameLogic::CGameLogic()
{
}

//析构函数
CGameLogic::~CGameLogic()
{
}

//获取类型
BYTE CGameLogic::GetCardType(const BYTE cbCardData[], BYTE cbCardCount, bool isLastCard)
{
	//简单牌型
	switch (cbCardCount)
	{
	case 0:	//空牌
	{
		return CT_ERROR;
	}
	case 1: //单牌
	{
		return CT_SINGLE;
	}
	case 2:	//对牌
	{
		//牌型判断
		if (GetCardLogicValue(cbCardData[0]) == GetCardLogicValue(cbCardData[1])) return CT_DOUBLE;

		return CT_ERROR;
	}
	}

	//分析扑克
	tagAnalyseResult AnalyseResult;
	AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);

	//四牌判断
	if (AnalyseResult.cbBlockCount[3] == 1)
	{
		//牌型判断
		if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount == 4)) return CT_BOMB_CARD;

		// 四带一算三带二;
		if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount == 5)) return CT_THREE_TAKE_TWO;

		// 允许四带三;
		if (IsHasGameRule(ePDKRuleEnum_FOUR_TAKE_THREE))
		{
			// 最后一手牌，四炸可以带一或二张;
			if (isLastCard)
			{
				if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount <= 7) && (cbCardCount > 5)) return CT_FOUR_TAKE_THREE;
			}
			else
			{
				if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount == 7)) return CT_FOUR_TAKE_THREE;
			}
		}

		//return CT_ERROR;
	}

	// 3A炸弹;
	if ((3 == cbCardCount) && IsHasGameRule(ePDKRuleEnum_3ABomb) && (1 == AnalyseResult.cbBlockCount[2]))
	{
		BYTE cbCardData = AnalyseResult.cbCardData[2][0];
		BYTE cbCardValue = GetCardValue(cbCardData);
		if (0x01 == cbCardValue)	// 是A;
		{
			return CT_3A_BOMB_CARD;
		}
	}

	//三带二(只有一个3条);
	if (1 == AnalyseResult.cbBlockCount[2])
	{
		//牌形判断
		if (isLastCard)
		{
			// 三带二;
			if (5 >= cbCardCount) return CT_THREE_TAKE_TWO;
		}
		else
		{
			// 三带二;
			if (5 == cbCardCount) return CT_THREE_TAKE_TWO;
		}
	}

	//两张类型(全是对子);
	if ((AnalyseResult.cbBlockCount[1] >= 2) && (AnalyseResult.cbBlockCount[1] * 2 == cbCardCount))
	{
		//变量定义
		BYTE cbCardData = AnalyseResult.cbCardData[1][0];
		BYTE cbFirstLogicValue = GetCardLogicValue(cbCardData);

		// 连牌不能带2;
		if (cbFirstLogicValue >= GetCardLogicValue(0x02)) return CT_ERROR;

		//连牌判断
		for (BYTE i = 1; i < AnalyseResult.cbBlockCount[1]; i++)
		{
			BYTE cbCardData = AnalyseResult.cbCardData[1][i * 2];
			if (cbFirstLogicValue != (GetCardLogicValue(cbCardData) + i)) return CT_ERROR;
		}

		//二连判断
		if ((AnalyseResult.cbBlockCount[1] * 2) == cbCardCount) return CT_DOUBLE_LINE;

		return CT_ERROR;
	}

	//单张判断(全是单牌只可能是顺子);
	if ((AnalyseResult.cbBlockCount[0] >= 5) && (AnalyseResult.cbBlockCount[0] == cbCardCount))
	{
		//变量定义
		BYTE cbCardData = AnalyseResult.cbCardData[0][0];
		BYTE cbFirstLogicValue = GetCardLogicValue(cbCardData);

		// 连牌不能带2;
		if (cbFirstLogicValue >= GetCardLogicValue(0x02)) return CT_ERROR;

		//连牌判断
		for (BYTE i = 1; i < AnalyseResult.cbBlockCount[0]; i++)
		{
			BYTE cbCardData = AnalyseResult.cbCardData[0][i];
			if (cbFirstLogicValue != (GetCardLogicValue(cbCardData) + i)) return CT_ERROR;
		}

		return CT_SINGLE_LINE;
	}

	//三连判断;
	if (AnalyseResult.cbBlockCount[2] + AnalyseResult.cbBlockCount[3] > 1)
	{
		// 不是最后一手牌，三连必须是5的倍数;
		if (!isLastCard && (cbCardCount % 5 != 0)) return CT_ERROR;
		BYTE cbCardType = CT_ERROR;

		BYTE cbLineCardData[MAX_COUNT] = { 0 };
		BYTE cbLineLength = 0;

		// 目前只从3取到4张相同牌(将3到4张相同的牌放到同一个数组，用来检测是不是连牌);
		for (BYTE i = 2; i <= 3; i++)
		{
			for (BYTE j = 0; j < AnalyseResult.cbBlockCount[i]; j++)
			{
				BYTE cbTmpCardDate = AnalyseResult.cbCardData[i][j*(i + 1)];

				// 连牌不带2;
				if (GetCardLogicValue(cbTmpCardDate) >= GetCardLogicValue(0x02)) continue;

				cbLineCardData[cbLineLength] = cbTmpCardDate;
				cbLineLength++;
			}
		}

		// 重新排序;
		SortCardList(cbLineCardData, cbLineLength, ST_ORDER);

		BYTE cbLastValue = GetCardLogicValue(cbLineCardData[0]);
		//错误过虑(3~A)
		if (cbLastValue > GetCardLogicValue(0x01)) return CT_ERROR;

		// 查找三连数量;
		BYTE cbMaxThreeLength = 1;
		BYTE cbThreeLength = 1;
		BYTE cbMaxThreeCardData = cbLineCardData[0];

		for (BYTE i = 1; i < cbLineLength; i++)
		{
			BYTE cbTmpValue = GetCardLogicValue(cbLineCardData[i]);

			// 不连续
			if (cbLastValue != (cbTmpValue + 1))
			{
				if (cbMaxThreeLength < cbThreeLength)
				{
					cbMaxThreeLength = cbThreeLength;
					cbMaxThreeCardData = cbLineCardData[i - cbMaxThreeLength];
				}

				cbThreeLength = 1;
			}
			else
			{
				cbThreeLength++;
			}

			cbLastValue = cbTmpValue;
		}

		// 最后一个
		if (cbMaxThreeLength < cbThreeLength)
		{
			cbMaxThreeLength = cbThreeLength;
			cbMaxThreeCardData = cbLineCardData[cbLineLength - cbMaxThreeLength];
		}

		// 最后一手牌;
		if (isLastCard && (cbMaxThreeLength * 5 >= cbCardCount))
		{
			cbCardType = CT_THREE_LINE;
		}
		else if (!isLastCard)
		{
			// 计算几个三带二
			BYTE cbTmpBlockCount = cbCardCount / 5;
			if (cbMaxThreeLength == cbTmpBlockCount)
			{
				cbCardType = CT_THREE_LINE;
			}
		}

		return cbCardType;
	}

	return CT_ERROR;
}

//排列扑克
VOID CGameLogic::SortCardList(BYTE cbCardData[], BYTE cbCardCount, BYTE cbSortType)
{
	//数目过虑
	if (cbCardCount==0) return;
	if (cbSortType==ST_CUSTOM) return;

	//转换数值
	BYTE cbSortValue[MAX_COUNT];
	for (BYTE i=0;i<cbCardCount;i++) cbSortValue[i]=GetCardLogicValue(cbCardData[i]);	

	//排序操作
	bool bSorted=true;
	BYTE cbSwitchData=0,cbLast=cbCardCount-1;
	do
	{
		bSorted=true;
		for (BYTE i=0;i<cbLast;i++)
		{
			if ((cbSortValue[i]<cbSortValue[i+1])||
				((cbSortValue[i]==cbSortValue[i+1])&&(cbCardData[i]<cbCardData[i+1])))
			{
				//设置标志
				bSorted=false;

				//扑克数据
				cbSwitchData=cbCardData[i];
				cbCardData[i]=cbCardData[i+1];
				cbCardData[i+1]=cbSwitchData;

				//排序权位
				cbSwitchData=cbSortValue[i];
				cbSortValue[i]=cbSortValue[i+1];
				cbSortValue[i+1]=cbSwitchData;
			}	
		}
		cbLast--;
	} while(bSorted==false);

	//数目排序
	if (cbSortType==ST_COUNT)
	{
		//变量定义
		BYTE cbCardIndex=0;

		//分析扑克
		tagAnalyseResult AnalyseResult;
		AnalysebCardData(&cbCardData[cbCardIndex],cbCardCount-cbCardIndex,AnalyseResult);

		//提取扑克
		for (BYTE i=0;i<CountArray(AnalyseResult.cbBlockCount);i++)
		{
			//拷贝扑克
			BYTE cbIndex=CountArray(AnalyseResult.cbBlockCount)-i-1;
			CopyMemory(&cbCardData[cbCardIndex],AnalyseResult.cbCardData[cbIndex],AnalyseResult.cbBlockCount[cbIndex]*(cbIndex+1)*sizeof(BYTE));

			//设置索引
			cbCardIndex+=AnalyseResult.cbBlockCount[cbIndex]*(cbIndex+1)*sizeof(BYTE);
		}
	}

	return;
}

//混乱扑克
VOID CGameLogic::RandCard16List(BYTE cbCardBuffer[], BYTE cbBufferCount)
{
	//混乱准备
	BYTE cbCardData[CountArray(m_cbCardData16)];
	CopyMemory(cbCardData, m_cbCardData16, sizeof(m_cbCardData16));

	//混乱扑克
	BYTE cbRandCount=0,cbPosition=0;
	do
	{
		cbPosition=rand()%(cbBufferCount-cbRandCount);
		cbCardBuffer[cbRandCount++]=cbCardData[cbPosition];
		cbCardData[cbPosition]=cbCardData[cbBufferCount-cbRandCount];
	} while (cbRandCount<cbBufferCount);

	return;
}

VOID CGameLogic::RandCard15List(BYTE cbCardBuffer[], BYTE cbBufferCount)
{
	//混乱准备
	BYTE cbCardData[CountArray(m_cbCardData15)];
	CopyMemory(cbCardData, m_cbCardData15, sizeof(m_cbCardData15));

	//混乱扑克
	BYTE cbRandCount = 0, cbPosition = 0;
	do
	{
		cbPosition = rand() % (cbBufferCount - cbRandCount);
		cbCardBuffer[cbRandCount++] = cbCardData[cbPosition];
		cbCardData[cbPosition] = cbCardData[cbBufferCount - cbRandCount];
	} while (cbRandCount < cbBufferCount);

	return;
}


//删除扑克
bool CGameLogic::RemoveCardList(const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount)
{
	//检验数据
	ASSERT(cbRemoveCount<=cbCardCount);

	//定义变量
	BYTE cbDeleteCount=0,cbTempCardData[MAX_COUNT];
	if (cbCardCount>CountArray(cbTempCardData)) return false;
	CopyMemory(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));

	//置零扑克
	for (BYTE i=0;i<cbRemoveCount;i++)
	{
		for (BYTE j=0;j<cbCardCount;j++)
		{
			if (cbRemoveCard[i]==cbTempCardData[j])
			{
				cbDeleteCount++;
				cbTempCardData[j]=0;
				break;
			}
		}
	}
	if (cbDeleteCount!=cbRemoveCount) return false;

	ZeroMemory(cbCardData,cbCardCount*sizeof(cbCardData[0]));
	//清理扑克
	BYTE cbCardPos=0;
	for (BYTE i=0;i<cbCardCount;i++)
	{
		if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
	}

	return true;
}

//删除扑克
bool CGameLogic::RemoveCard(const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount)
{
	//检验数据
	ASSERT(cbRemoveCount<=cbCardCount);

	//定义变量
	BYTE cbDeleteCount=0,cbTempCardData[MAX_COUNT];
	if (cbCardCount>CountArray(cbTempCardData)) return false;
	CopyMemory(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));

	//置零扑克
	for (BYTE i=0;i<cbRemoveCount;i++)
	{
		for (BYTE j=0;j<cbCardCount;j++)
		{
			if (cbRemoveCard[i]==cbTempCardData[j])
			{
				cbDeleteCount++;
				cbTempCardData[j]=0;
				break;
			}
		}
	}
	if (cbDeleteCount!=cbRemoveCount) return false;

	//清理扑克
	BYTE cbCardPos=0;
	for (BYTE i=0;i<cbCardCount;i++)
	{
		if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
	}

	return true;
}

//删除扑克
bool CGameLogic::RemoveCardEx(const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount)
{
	//检验数据
	ASSERT(cbRemoveCount <= cbCardCount);

	//定义变量
	BYTE cbDeleteCount = 0;
	BYTE cbTempCardData[FULL_COUNT] = {0};

	if (cbCardCount > CountArray(cbTempCardData)) return false;
	CopyMemory(cbTempCardData, cbCardData, cbCardCount*sizeof(cbCardData[0]));

	//置零扑克
	for (BYTE i = 0; i < cbRemoveCount; i++)
	{
		for (BYTE j = 0; j < cbCardCount; j++)
		{
			if (cbRemoveCard[i] == cbTempCardData[j])
			{
				cbDeleteCount++;
				cbTempCardData[j] = 0;
				break;
			}
		}
	}
	if (cbDeleteCount != cbRemoveCount) return false;

	//清理扑克
	BYTE cbCardPos = 0;
	for (BYTE i = 0; i < cbCardCount; i++)
	{
		if (cbTempCardData[i] != 0)
		{
			cbCardData[cbCardPos++] = cbTempCardData[i];
		}
	}

	return true;
}

//排列扑克
VOID CGameLogic::SortOutCardList(BYTE cbCardData[], BYTE cbCardCount, bool isLastCard)
{
	//获取牌型
	BYTE cbCardType = GetCardType(cbCardData, cbCardCount, isLastCard);

	// AAA+BB 结构;
	if (cbCardType == CT_THREE_TAKE_TWO)
	{
		//分析牌
		tagAnalyseResult AnalyseResult = {};
		AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);

		// 三张数量;
		BYTE cbTmpCardCount = 3;
		//CopyMemory(cbCardData, AnalyseResult.cbCardData[2], sizeof(BYTE)*cbTmpCardCount);

		if (AnalyseResult.cbBlockCount[2] == 1)
		{
			for (BYTE i = 0; i < cbTmpCardCount; i++)
			{
				cbCardData[i] = AnalyseResult.cbCardData[2][i];
				AnalyseResult.cbCardData[2][i] = 0x0;
			}
		}
		else if (AnalyseResult.cbBlockCount[3] == 1)
		{
			BYTE i = 0;
			for (i = 0; i < cbTmpCardCount; i++)
			{
				cbCardData[i] = AnalyseResult.cbCardData[3][i];
				AnalyseResult.cbCardData[3][i] = 0x0;
			}

			// 第三张牌;
			cbCardData[i] = AnalyseResult.cbCardData[3][i];
			AnalyseResult.cbCardData[3][i] = 0x0;
			cbTmpCardCount++;
		}


		for( int i = CountArray(AnalyseResult.cbBlockCount)-1; i >= 0; i-- )
		{
			if( i >= 2 ) continue;

			if( AnalyseResult.cbBlockCount[i] > 0 )
			{
				CopyMemory(&cbCardData[cbTmpCardCount], AnalyseResult.cbCardData[i], sizeof(BYTE)*(i + 1)*AnalyseResult.cbBlockCount[i]);

				cbTmpCardCount += (i + 1)*AnalyseResult.cbBlockCount[i];
			}
		}
	}
	else if (cbCardType == CT_FOUR_TAKE_THREE)
	{
		//分析牌
		tagAnalyseResult AnalyseResult = {};
		AnalysebCardData( cbCardData,cbCardCount,AnalyseResult );

		BYTE cbTmpCardCount = 4;
		CopyMemory(cbCardData, AnalyseResult.cbCardData[3], sizeof(BYTE)*cbTmpCardCount);
		
		for( int i = CountArray(AnalyseResult.cbBlockCount)-1; i >= 0; i-- )
		{
			if( i == 3 ) continue;

			if( AnalyseResult.cbBlockCount[i] > 0 )
			{
				CopyMemory(&cbCardData[cbCardCount], AnalyseResult.cbCardData[i], sizeof(BYTE)*(i + 1)*AnalyseResult.cbBlockCount[i]);

				cbTmpCardCount += (i + 1)*AnalyseResult.cbBlockCount[i];
			}
		}
	}
	else if (cbCardType == CT_THREE_LINE)
	{
		//分析牌
		tagAnalyseResult AnalyseResult = {};
		AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);

		//三连判断;
		if (AnalyseResult.cbBlockCount[2] + AnalyseResult.cbBlockCount[3] > 1)
		{
			BYTE cbLineCardData[MAX_COUNT] = { 0 };
			BYTE cbLineLength = 0;

			// 目前只从3取到4张相同牌(将3到4张相同的牌放到同一个数组，用来检测是不是连牌);
			for (BYTE i = 2; i <= 3; i++)
			{
				if (AnalyseResult.cbBlockCount[i] > 0)
				{
					for (BYTE j = 0; j < AnalyseResult.cbBlockCount[i]; j++)
					{
						BYTE cbTmpCardDate = AnalyseResult.cbCardData[i][j*(i + 1)];

						// 连牌不带2;
						if (GetCardLogicValue(cbTmpCardDate) >= GetCardLogicValue(0x02)) continue;

						cbLineCardData[cbLineLength] = cbTmpCardDate;
						cbLineLength++;
					}
				}
			}

			// 重新排序;
			SortCardList(cbLineCardData, cbLineLength, ST_ORDER);

			//分析扑克
			tagDistributing Distributing = {};
			AnalysebDistributing(cbCardData, cbCardCount, Distributing);

			BYTE cbLastValue = GetCardLogicValue(cbLineCardData[0]);

			// 查找三连数量;
			BYTE cbMaxThreeLength = 1;
			BYTE cbThreeLength = 1;
			BYTE cbMaxThreeCardData = cbLineCardData[0];

			for (BYTE i = 1; i < cbLineLength; i++)
			{
				BYTE cbTmpValue = GetCardLogicValue(cbLineCardData[i]);

				// 不连续
				if (cbLastValue != (cbTmpValue + 1))
				{
					if (cbMaxThreeLength < cbThreeLength)
					{
						cbMaxThreeLength = cbThreeLength;
						cbMaxThreeCardData = cbLineCardData[i - cbMaxThreeLength];
					}

					cbThreeLength = 1;
				}
				else
				{
					cbThreeLength++;
				}

				cbLastValue = cbTmpValue;
			}

			// 最后一个
			if (cbMaxThreeLength < cbThreeLength)
			{
				cbMaxThreeLength = cbThreeLength;
				cbMaxThreeCardData = cbLineCardData[cbLineLength - cbMaxThreeLength];
			}

			// 计算几个三带二
			BYTE cbTmpBlockCount = cbCardCount / 5;
			if (cbMaxThreeLength == cbTmpBlockCount)
			{
				//cbCardData[0] = cbMaxThreeCardData;

				// 根据最大值和块长度重新分配;
				BYTE cbTmpCard[MAX_COUNT] = { 0 };
				BYTE cbMaxIndex = GetCardLogicValue(cbMaxThreeCardData);

				BYTE cbCount = 0;
				for (BYTE cbIndex = cbMaxIndex; cbIndex > (cbMaxIndex - cbTmpBlockCount); cbIndex--)
				{
					BYTE cbTmpCount = 0;
					for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
						{
							cbTmpCard[cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);

							Distributing.cbDistributing[cbIndex][3 - cbColorIndex]--;

							if (++cbTmpCount == 3) break;
						}

						if (cbTmpCount == 3) break;
					}
				}

				// 带牌;
				for (BYTE i = 0; i <= GetCardLogicValue(0x02); i++)
				{
					for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][3 - cbColorIndex]; cbColorCount++)
						{
							cbTmpCard[cbCount++] = MakeCardData(i, 3 - cbColorIndex);

							Distributing.cbDistributing[i][3 - cbColorIndex]--;
						}
					}
				}

				if (cbCardCount == cbCount)
				{
					CopyMemory(cbCardData, cbTmpCard, cbCount);
				}
			}
		}
	}

	return;
}

//排列扑克
BYTE CGameLogic::SortOutCardList(BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardType, BYTE cbBlockCount)
{
	BYTE cbMaxCardData = 0x0;

	// AAA+BB 结构;
	if (cbCardType == CT_THREE_TAKE_TWO)
	{
		//分析牌
		tagAnalyseResult AnalyseResult = {};
		AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);

		if (AnalyseResult.cbBlockCount[2] == 1)
		{
			cbMaxCardData = AnalyseResult.cbCardData[2][0];
		}
		else if (AnalyseResult.cbBlockCount[3] == 1)
		{
			cbMaxCardData = AnalyseResult.cbCardData[3][0];
		}
	}
	else if (cbCardType == CT_FOUR_TAKE_THREE)
	{
		//分析牌
		tagAnalyseResult AnalyseResult = {};
		AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);
		
		if (AnalyseResult.cbBlockCount[3] == 1)
		{
			cbMaxCardData = AnalyseResult.cbCardData[3][0];
		}
	}
	else if (cbCardType == CT_THREE_LINE)
	{
		//分析牌
		tagAnalyseResult AnalyseResult = {};
		AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);

		//三连判断;
		if (AnalyseResult.cbBlockCount[2] + AnalyseResult.cbBlockCount[3] > 1)
		{
			BYTE cbLineCardData[MAX_COUNT] = { 0 };
			BYTE cbLineLength = 0;

			// 目前只从3取到4张相同牌(将3到4张相同的牌放到同一个数组，用来检测是不是连牌);
			for (BYTE i = 2; i <= 3; i++)
			{
				if (AnalyseResult.cbBlockCount[i] > 0)
				{
					for (BYTE j = 0; j < AnalyseResult.cbBlockCount[i]; j++)
					{
						BYTE cbTmpCardDate = AnalyseResult.cbCardData[i][j*(i + 1)];

						// 连牌不带2;
						if (GetCardLogicValue(cbTmpCardDate) >= GetCardLogicValue(0x02)) continue;

						cbLineCardData[cbLineLength] = cbTmpCardDate;
						cbLineLength++;
					}
				}
			}

			// 重新排序;
			SortCardList(cbLineCardData, cbLineLength, ST_ORDER);

			BYTE cbLastValue = GetCardLogicValue(cbLineCardData[0]);

			// 查找三连数量;
			BYTE cbMaxThreeLength = 1;
			BYTE cbThreeLength = 1;
			BYTE cbMaxThreeCardData = cbLineCardData[0];

			for (BYTE i = 1; i < cbLineLength; i++)
			{
				BYTE cbTmpValue = GetCardLogicValue(cbLineCardData[i]);

				// 不连续
				if (cbLastValue != (cbTmpValue + 1))
				{
					if (cbMaxThreeLength < cbThreeLength)
					{
						cbMaxThreeLength = cbThreeLength;
						cbMaxThreeCardData = cbLineCardData[i - cbMaxThreeLength];
					}

					cbThreeLength = 1;
				}
				else
				{
					cbThreeLength++;
				}

				cbLastValue = cbTmpValue;
			}

			// 最后一个
			if (cbMaxThreeLength < cbThreeLength)
			{
				cbMaxThreeLength = cbThreeLength;
				cbMaxThreeCardData = cbLineCardData[cbLineLength - cbMaxThreeLength];
			}

			// 三连长度比较;
			if (cbMaxThreeLength >= cbBlockCount)
			{
				cbMaxCardData = cbMaxThreeCardData;
			}
		}
	}

	return cbMaxCardData;
}

//有效判断
bool CGameLogic::IsValidCard(BYTE cbCardData)
{
	//获取属性
	BYTE cbCardColor = GetCardColor(cbCardData);
	BYTE cbCardValue = GetCardValue(cbCardData);

	//有效判断
	//if ((cbCardData == 0x4E) || (cbCardData == 0x4F)) return true;
	if ((cbCardColor <= 0x30) && (cbCardValue >= 0x01) && (cbCardValue <= 0x0D)) return true;

	return false;
}

//逻辑数值
BYTE CGameLogic::GetCardLogicValue(BYTE cbCardData)
{
	if (!IsValidCard(cbCardData)) return 0;

	//扑克属性
	BYTE cbCardColor=GetCardColor(cbCardData);
	BYTE cbCardValue=GetCardValue(cbCardData);

	if (cbCardValue <= 0 || cbCardValue > 0x0D) return 0;

	ASSERT(cbCardValue>0 && cbCardValue <= 0x0D);

	//转换数值
	//if (cbCardColor==0x40) return cbCardValue+2;
	return (cbCardValue <= 2) ? (cbCardValue + 13) : cbCardValue;
}

//获取最大牌;
BYTE CGameLogic::GetMaxLogicValue(const BYTE cbHandCardData[], BYTE cbHandCardCount)
{
	if (cbHandCardCount <= 0) return 0;

	BYTE cbCardData[MAX_COUNT] = {0};
	CopyMemory(cbCardData, cbHandCardData, cbHandCardCount);

	// 重新排序;
	SortCardList(cbCardData, cbHandCardCount, ST_ORDER);

	return GetCardLogicValue(cbCardData[0]);
}

//对比扑克
bool CGameLogic::CompareCard(const BYTE cbFirstCard[], const BYTE cbNextCard[], BYTE cbFirstCount, BYTE cbNextCount, bool isLastCard)
{
	//获取类型
	BYTE cbNextType=GetCardType(cbNextCard,cbNextCount, isLastCard);
	BYTE cbFirstType=GetCardType(cbFirstCard,cbFirstCount, false);

	//类型判断
	if (cbNextType==CT_ERROR) return false;
	if (cbNextType==CT_3A_BOMB_CARD) return true;

	//炸弹判断
	if ((cbFirstType!=CT_BOMB_CARD)&&(cbNextType==CT_BOMB_CARD)) return true;
	if ((cbFirstType==CT_BOMB_CARD)&&(cbNextType!=CT_BOMB_CARD)) return false;

	//规则判断
	if (cbFirstType!=cbNextType) return false;

	//开始对比
	switch (cbNextType)
	{
	case CT_SINGLE:
	case CT_DOUBLE:
	case CT_SINGLE_LINE:
	case CT_DOUBLE_LINE:
	case CT_BOMB_CARD:
		{
			// 牌数必须相同;
			if (cbFirstCount != cbNextCount) return false;
			
			//获取数值
			BYTE cbNextLogicValue=GetCardLogicValue(cbNextCard[0]);
			BYTE cbFirstLogicValue=GetCardLogicValue(cbFirstCard[0]);

			//对比扑克
			return cbNextLogicValue>cbFirstLogicValue;
		}
	case CT_THREE_TAKE_TWO:
		{
			// 三带二牌数判断;
			if (cbFirstCount < 3 || cbFirstCount > 5) return false;
			if (cbNextCount < 3 || cbNextCount > 5) return false;

			// 不是最后一手牌必须是5张;
			if (cbFirstCount != 5) return false;
			if (!isLastCard && cbNextCount != 5) return false;

			//分析扑克
			tagAnalyseResult NextResult;
			tagAnalyseResult FirstResult;
			AnalysebCardData(cbNextCard,cbNextCount,NextResult);
			AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);

			//获取数值
			BYTE cbFirstLogicValue = 0x0;
			BYTE cbNextLogicValue = 0x0;

			// 四带一算三带二;
			if (1 == FirstResult.cbBlockCount[2])
			{
				cbFirstLogicValue = GetCardLogicValue(FirstResult.cbCardData[2][0]);
			}
			else if (1 == FirstResult.cbBlockCount[3])
			{
				cbFirstLogicValue = GetCardLogicValue(FirstResult.cbCardData[3][0]);
			}

			if (1 == NextResult.cbBlockCount[2])
			{
				cbNextLogicValue = GetCardLogicValue(NextResult.cbCardData[2][0]);
			}
			else if (1 == NextResult.cbBlockCount[3])
			{
				cbNextLogicValue = GetCardLogicValue(NextResult.cbCardData[3][0]);
			}

			//对比扑克
			return cbNextLogicValue>cbFirstLogicValue;
		}
	case CT_FOUR_TAKE_THREE:
		{
			// 四带三牌数判断;
			if (cbFirstCount < 5 || cbFirstCount > 7) return false;
			if (cbNextCount < 5 || cbNextCount > 7) return false;

			// 不是最后一手牌必须是7张;
			if (cbFirstCount != 7) return false;
			if (!isLastCard && cbNextCount != 7) return false;

			//分析扑克
			tagAnalyseResult NextResult;
			tagAnalyseResult FirstResult;
			AnalysebCardData(cbNextCard,cbNextCount,NextResult);
			AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);

			//获取数值
			BYTE cbNextLogicValue=GetCardLogicValue(NextResult.cbCardData[3][0]);
			BYTE cbFirstLogicValue=GetCardLogicValue(FirstResult.cbCardData[3][0]);

			//对比扑克
			return cbNextLogicValue>cbFirstLogicValue;
		}
	case CT_THREE_LINE:
		{
			// 飞机至少牌数是3*2;
			if (cbFirstCount < 6 || cbNextCount < 6) return false;

			// 不是最后一手牌必须是5的倍数;
			if ((cbFirstCount % 5) != 0) return false;
			if (!isLastCard && (cbNextCount % 5) != 0) return false;

			// 不是最后一手牌，两个牌数必须相同;
			if (!isLastCard && (cbNextCount != cbFirstCount)) return false;

			// 是最后一手，必须不大于于上家出牌数;
			if (isLastCard && (cbNextCount > cbFirstCount)) return false;

			// 获取三连长度;
			BYTE cbFirstBlockCount = cbFirstCount / 5;

			BYTE cbFirstTurnCard[MAX_COUNT] = {0};
			BYTE cbNextTurnCard[MAX_COUNT] = {0};
			CopyMemory(cbFirstTurnCard, cbFirstCard, sizeof(BYTE)*cbFirstCount);
			CopyMemory(cbNextTurnCard, cbNextCard, sizeof(BYTE)*cbNextCount);

			BYTE cbFirstCardData = SortOutCardList(cbFirstTurnCard, cbFirstCount, CT_THREE_LINE, cbFirstBlockCount);
			BYTE cbNextCardData = SortOutCardList(cbNextTurnCard, cbNextCount, CT_THREE_LINE, cbFirstBlockCount);

			//获取数值
			BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardData);
			BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardData);

			//对比扑克
			return cbNextLogicValue > cbFirstLogicValue;
		}
	}
	
	return false;
}

//构造扑克
BYTE CGameLogic::MakeCardData(BYTE cbLogicValue, BYTE cbColorIndex)
{
	//return (cbColorIndex<<4)|(cbValueIndex+1);

	BYTE cbCardColor = (cbColorIndex << 4);

	//转换数值
	if (cbLogicValue > 0x0D)
	{
		cbLogicValue -= 0x0D;
	}

	return (cbCardColor | cbLogicValue);
}

//分析扑克
VOID CGameLogic::AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
	//设置结果
	ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));

	//扑克分析
	for (BYTE i=0;i<cbCardCount;i++)
	{
		//变量定义
		BYTE cbSameCount=1,cbCardValueTemp=0;
		BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);

		//搜索同牌
		for (BYTE j=i+1;j<cbCardCount;j++)
		{
			//获取扑克
			if (GetCardLogicValue(cbCardData[j])!=cbLogicValue) break;

			//设置变量
			cbSameCount++;
		}

		if(cbSameCount > 4)
		{
			ASSERT(FALSE);
			//设置结果
			ZeroMemory(&AnalyseResult, sizeof(AnalyseResult));
			return;
		}

		//设置结果
		BYTE cbIndex=AnalyseResult.cbBlockCount[cbSameCount-1]++;
		for (BYTE j=0;j<cbSameCount;j++) AnalyseResult.cbCardData[cbSameCount-1][cbIndex*cbSameCount+j]=cbCardData[i+j];

		//设置索引
		i+=cbSameCount-1;
	}

	return;
}

//分析分布
VOID CGameLogic::AnalysebDistributing(const BYTE cbCardData[], BYTE cbCardCount, tagDistributing & Distributing)
{
	//设置变量
	ZeroMemory(&Distributing,sizeof(Distributing));

	//设置变量
	for (BYTE i=0;i<cbCardCount;i++)
	{
		//if (cbCardData[i]==0) continue;

		////获取属性
		//BYTE cbCardColor=GetCardColor(cbCardData[i]);
		//BYTE cbCardValue=GetCardValue(cbCardData[i]);

		////分布信息
		//Distributing.cbCardCount++;
		//Distributing.cbDistributing[cbCardValue-1][cbIndexCount]++;
		//Distributing.cbDistributing[cbCardValue-1][cbCardColor>>4]++;

		if (cbCardData[i] == 0) continue;

		//获取属性
		BYTE cbCardColor = GetCardColor(cbCardData[i]);
		BYTE cbCardValue = GetCardLogicValue(cbCardData[i]);

		//分布信息
		Distributing.cbCardCount++;
		Distributing.cbDistributing[cbCardValue][cbIndexCount]++;
		Distributing.cbDistributing[cbCardValue][cbCardColor >> 4]++;
	}

	return;
}

//出牌搜索
BYTE CGameLogic::SearchOutCard( const BYTE cbHandCardData[], BYTE cbHandCardCount, const BYTE cbTurnCardData[], BYTE cbTurnCardCount, 
							   tagSearchCardResult *pSearchCardResult )
{
	//设置结果
	ASSERT( pSearchCardResult != NULL );
	if( pSearchCardResult == NULL ) return 0;
	ZeroMemory(pSearchCardResult,sizeof(tagSearchCardResult));

	//变量定义
	BYTE cbResultCount = 0;
	tagSearchCardResult tmpSearchCardResult = {};

	//构造扑克
	BYTE cbCardData[MAX_COUNT];
	BYTE cbCardCount=cbHandCardCount;
	CopyMemory(cbCardData,cbHandCardData,sizeof(BYTE)*cbHandCardCount);

	//排列扑克
	SortCardList(cbCardData,cbCardCount,ST_ORDER);

	//获取类型(必然不是最后一手牌);
	BYTE cbTurnOutType = GetCardType(cbTurnCardData, cbTurnCardCount, false);

	if (CT_ERROR == cbTurnOutType) return 0;

	// 先当做最后一首牌处理;
	if (CompareCard(cbTurnCardData, cbCardData, cbTurnCardCount, cbCardCount, true) == true)
	{
		pSearchCardResult->cbCardCount[cbResultCount] = cbCardCount;
		memcpy(pSearchCardResult->cbResultCard[cbResultCount], cbCardData, sizeof(BYTE)*cbCardCount);
		cbResultCount++;
	}
	else
	{
		//出牌分析
		switch (cbTurnOutType)
		{
		case CT_SINGLE:				//单牌类型
		case CT_DOUBLE:				//对牌类型
		{
			//变量定义
			BYTE cbReferCard = cbTurnCardData[0];
			BYTE cbSameCount = 1;
			if (cbTurnOutType == CT_DOUBLE) cbSameCount = 2;

			//搜索相同牌
			cbResultCount = SearchSameCard(cbCardData, cbCardCount, cbReferCard, cbSameCount, pSearchCardResult);

			break;
		}
		case CT_SINGLE_LINE:		//单连类型
		{
			//变量定义
			BYTE cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
			cbResultCount = SearchSingleLine(cbCardData, cbCardCount, cbReferCard, cbTurnCardCount, pSearchCardResult);
			break;
		}
		case CT_DOUBLE_LINE:		//对连类型
		{
			//变量定义
			BYTE cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
			BYTE cbLineCount = cbTurnCardCount / 2;
			cbResultCount = SearchDoubleLine(cbCardData, cbCardCount, cbReferCard, cbLineCount, pSearchCardResult);
			break;
		}
		case CT_THREE_LINE:			//三连类型
		{
			//效验牌数
			if (cbCardCount < cbTurnCardCount) break;

			// 搜索出牌的情况，上家必然不是最后一手牌;
			BYTE cbBlockCount = cbTurnCardCount / 5;

			//BYTE cbTmpTurnCard[MAX_COUNT] = {};
			//CopyMemory(cbTmpTurnCard, cbTurnCardData, sizeof(BYTE)*cbTurnCardCount);
			//SortOutCardList(cbTmpTurnCard, cbTurnCardCount, false);
			BYTE cbTmpTurnCard = SortOutCardList((BYTE*)cbTurnCardData, cbTurnCardCount, CT_THREE_LINE, cbBlockCount);

			//搜索(要算出最小牌);
			//BYTE cbMinLogicValue = (GetCardLogicValue(cbTmpTurnCard[0]) - cbBlockCount + 1);
			BYTE cbMinLogicValue = (GetCardLogicValue(cbTmpTurnCard) - cbBlockCount + 1);
			cbResultCount = SearchThreeLineTakeTwo(cbCardData, cbCardCount, cbMinLogicValue, cbBlockCount, pSearchCardResult);

			break;
		}
		case CT_THREE_TAKE_TWO:		//三带一对
		{
			//效验牌数
			if (cbCardCount < cbTurnCardCount) break;

			//BYTE cbTmpTurnCard[MAX_COUNT] = {};
			//CopyMemory(cbTmpTurnCard, cbTurnCardData, sizeof(BYTE)*cbTurnCardCount);
			//SortOutCardList(cbTmpTurnCard, cbTurnCardCount, false);

			BYTE cbTmpTurnCard = SortOutCardList((BYTE*)cbTurnCardData, cbTurnCardCount, CT_THREE_TAKE_TWO, 1);

			//搜索三带牌型
			cbResultCount = SearchThreeTakeTwo(cbCardData, cbCardCount, cbTmpTurnCard, pSearchCardResult);

			break;
		}
		case CT_FOUR_TAKE_THREE:		//四带三
		{
			//效验牌数
			if (!IsHasGameRule(ePDKRuleEnum_FOUR_TAKE_THREE)) break;
			if (cbCardCount < cbTurnCardCount) break;

			//BYTE cbTmpTurnCard[MAX_COUNT] = {};
			//CopyMemory(cbTmpTurnCard, cbTurnCardData, sizeof(BYTE)*cbTurnCardCount);
			//SortOutCardList(cbTmpTurnCard, cbTurnCardCount, false);
			BYTE cbTmpTurnCard = SortOutCardList((BYTE*)cbTurnCardData, cbTurnCardCount, CT_FOUR_TAKE_THREE, 1);

			//搜索带牌
			cbResultCount = SearchFourTakeThree(cbCardData, cbCardCount, cbTmpTurnCard, pSearchCardResult);

			break;
		}
		}

		//搜索炸弹
		if ((cbCardCount >= 4) && (cbTurnOutType != CT_3A_BOMB_CARD))
		{
			//变量定义
			BYTE cbReferCard = 0;
			if (cbTurnOutType == CT_BOMB_CARD) cbReferCard = cbTurnCardData[0];

			//搜索炸弹
			BYTE cbTmpResultCount = SearchSameCard(cbCardData, cbCardCount, cbReferCard, 4, &tmpSearchCardResult);
			for (BYTE i = 0; i < cbTmpResultCount; i++)
			{
				pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[i];
				CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], tmpSearchCardResult.cbResultCard[i],
					sizeof(BYTE)*tmpSearchCardResult.cbCardCount[i]);
				cbResultCount++;
			}
		}

		//搜索火箭(0x01,0x11,0x21)
		if (cbTurnOutType != CT_3A_BOMB_CARD && (cbCardCount >= 3) && (IsHasGameRule(ePDKRuleEnum_3ABomb)))
		{
			BYTE cbACard[3] = { 0 };
			BYTE cbACardCount = 0;

			//有三张A;
			for (BYTE i = 0; i < cbCardCount; i++)
			{
				if (GetCardValue(cbCardData[i]) == 0x01)
				{
					cbACard[cbACardCount] = cbCardData[i];
					cbACardCount++;
				}
			}

			// 3A炸弹
			if (3 == cbACardCount)
			{
				//设置结果
				pSearchCardResult->cbCardCount[cbResultCount] = 3;
				pSearchCardResult->cbResultCard[cbResultCount][0] = cbACard[0];
				pSearchCardResult->cbResultCard[cbResultCount][1] = cbACard[1];
				pSearchCardResult->cbResultCard[cbResultCount][2] = cbACard[2];

				cbResultCount++;
			}
		}
	}

	pSearchCardResult->cbSearchCount = cbResultCount;
	return cbResultCount;
}

//同牌搜索
BYTE CGameLogic::SearchSameCard( const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbReferCard, BYTE cbSameCardCount,
								tagSearchCardResult *pSearchCardResult )
{
	//设置结果
	if( pSearchCardResult )
		ZeroMemory(pSearchCardResult,sizeof(tagSearchCardResult));
	BYTE cbResultCount = 0;

	//构造扑克
	BYTE cbCardData[MAX_COUNT];
	BYTE cbCardCount=cbHandCardCount;
	CopyMemory(cbCardData,cbHandCardData,sizeof(BYTE)*cbHandCardCount);

	//排列扑克
	SortCardList(cbCardData,cbCardCount,ST_ORDER);

	//分析扑克
	tagAnalyseResult AnalyseResult = {};
	AnalysebCardData( cbCardData,cbCardCount,AnalyseResult );

	BYTE cbReferLogicValue = cbReferCard==0?0:GetCardLogicValue(cbReferCard);
	BYTE cbBlockIndex = cbSameCardCount-1;
	do
	{
		for( BYTE i = 0; i < AnalyseResult.cbBlockCount[cbBlockIndex]; i++ )
		{
			BYTE cbIndex = (AnalyseResult.cbBlockCount[cbBlockIndex]-i-1)*(cbBlockIndex+1);
			if( GetCardLogicValue(AnalyseResult.cbCardData[cbBlockIndex][cbIndex]) > cbReferLogicValue )
			{
				if( pSearchCardResult == NULL ) return 1;

				ASSERT( cbResultCount < CountArray(pSearchCardResult->cbCardCount) );

				//复制扑克
				CopyMemory( pSearchCardResult->cbResultCard[cbResultCount],&AnalyseResult.cbCardData[cbBlockIndex][cbIndex],
					cbSameCardCount*sizeof(BYTE) );
				pSearchCardResult->cbCardCount[cbResultCount] = cbSameCardCount;

				cbResultCount++;
			}
		}

		cbBlockIndex++;
	}while( cbBlockIndex < CountArray(AnalyseResult.cbBlockCount) );

	if( pSearchCardResult )
		pSearchCardResult->cbSearchCount = cbResultCount;
	return cbResultCount;
}

//搜索比出牌;
bool CGameLogic::SearchMustOutCard(const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbMustOutCard)
{
	if (!IsValidCard(cbMustOutCard)) return false;

	for (BYTE i = 0; i < cbHandCardCount; i++)
	{
		if (cbHandCardData[i] == cbMustOutCard)
		{
			return true;
		}
	}

	return false;
}

//////////////////////////////////////////////////////////////////////////////////
//搜索单顺;
BYTE CGameLogic::SearchSingleLine(const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbReferCard, BYTE cbLineCount, tagSearchCardResult *pSearchCardResult)
{
	//设置结果
	if (pSearchCardResult == nullptr) return 0;
	if (!IsValidCard(cbReferCard)) return 0;
	if (cbLineCount < 5) return 0;

	//定义变量	
	BYTE cbResultCount = 0;
	BYTE cbReferIndex = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;
	ZeroMemory(pSearchCardResult, sizeof(tagSearchCardResult));

	//超过A
	if (cbReferIndex + cbLineCount > GetCardLogicValue(0x01)+1)
	{
		return cbResultCount;
	}

	//长度判断
	if (cbHandCardCount < cbLineCount)
	{
		return cbResultCount;
	}

	// 癞子分析;
	BYTE cbNormalCard[MAX_COUNT] = { 0 };
	BYTE cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (BYTE i = 0; i < cbHandCardCount; i++)
	{
		cbNormalCard[cbNormalCardCount++] = cbHandCardData[i];
	}

	//排列扑克
	SortCardList(cbNormalCard, cbNormalCardCount, ST_ORDER);

	//分析扑克
	tagDistributing Distributing = {};
	AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);

	//搜索顺子
	BYTE cbMaxIndex = GetCardLogicValue(0x01) - cbLineCount + 1;

	// 不带癞子;
	for (BYTE i = cbReferIndex; i <= cbMaxIndex; i++)
	{
		if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;

		BYTE cbTmpLinkCount = 0;	// 当前最大连牌数;

		for (BYTE j = i; j <= GetCardLogicValue(0x01); j++)
		{
			//继续判断
			if (Distributing.cbDistributing[j][cbIndexCount] < 1)
			{
				break;
			}
			else
			{
				cbTmpLinkCount++;
			}

			// 找到足够大的连牌;
			if (cbTmpLinkCount >= cbLineCount)
			{
				//复制扑克
				BYTE cbCount = 0;
				for (BYTE cbIndex = i; cbIndex <= j; cbIndex++)
				{
					BYTE cbTmpCount = 0;
					for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
						{
							pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);

							if (++cbTmpCount == 1) break;
						}

						if (cbTmpCount == 1) break;
					}
				}

				//设置变量
				pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
				cbResultCount++;
				break;
			}
		}
	}

	if (pSearchCardResult)
	{
		pSearchCardResult->cbSearchCount = cbResultCount;
	}

	return cbResultCount;
}

//搜索双顺;
BYTE CGameLogic::SearchDoubleLine(const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbReferCard, BYTE cbLineCount, tagSearchCardResult *pSearchCardResult)
{
	//设置结果
	if (pSearchCardResult == nullptr) return 0;
	if (!IsValidCard(cbReferCard)) return 0;
	if (cbLineCount < 2) return 0;

	//定义变量	
	BYTE cbResultCount = 0;
	BYTE cbReferIndex = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;
	ZeroMemory(pSearchCardResult, sizeof(tagSearchCardResult));

	//超过A
	if (cbReferIndex + cbLineCount > GetCardLogicValue(0x01) + 1)
	{
		return cbResultCount;
	}

	//长度判断
	if (cbHandCardCount < cbLineCount * 2)
	{
		return cbResultCount;
	}

	// 癞子分析;
	BYTE cbNormalCard[MAX_COUNT] = { 0 };
	BYTE cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (BYTE i = 0; i < cbHandCardCount; i++)
	{
		cbNormalCard[cbNormalCardCount++] = cbHandCardData[i];
	}

	//排列扑克
	SortCardList(cbNormalCard, cbNormalCardCount, ST_ORDER);

	//分析扑克
	tagDistributing Distributing = {};
	AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);

	//搜索顺子
	BYTE cbMaxIndex = GetCardLogicValue(0x01) - cbLineCount + 1;

	// 不带癞子;
	for (BYTE i = cbReferIndex; i <= cbMaxIndex; i++)
	{
		if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;

		BYTE cbTmpLinkCount = 0;	// 当前最大连牌数;
		BYTE cbUseMagicCount = 0;	// 已经使用癞子数量;

		for (BYTE j = i; j <= GetCardLogicValue(0x01); j++)
		{
			// 有2张牌;
			if (Distributing.cbDistributing[j][cbIndexCount] >= 2)
			{
				cbTmpLinkCount++;
			}
			else
			{
				break;
			}

			// 找到足够大的连牌;
			if (cbTmpLinkCount >= cbLineCount)
			{
				//复制扑克
				BYTE cbCount = 0;
				for (BYTE cbIndex = i; cbIndex <= j; cbIndex++)
				{
					BYTE cbTmpCount = 0;
					for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
						{
							pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);

							if (++cbTmpCount == 2) break;
						}

						if (cbTmpCount == 2) break;
					}
				}

				//设置变量
				pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
				cbResultCount++;
				break;
			}
		}
	}

	if (pSearchCardResult)
	{
		pSearchCardResult->cbSearchCount = cbResultCount;
	}

	return cbResultCount;
}

//搜索三带二;
BYTE CGameLogic::SearchThreeTakeTwo(const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbReferCard, tagSearchCardResult *pSearchCardResult)
{
	if (cbHandCardCount < 5) return 0;
	if (pSearchCardResult == nullptr) return 0;
	if (!IsValidCard(cbReferCard)) return 0;

	//定义变量	
	BYTE cbResultCount = 0;
	BYTE cbReferIndex = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;
	ZeroMemory(pSearchCardResult, sizeof(tagSearchCardResult));

	// 只有一张2;
	if (cbReferIndex > GetCardLogicValue(0x01)) return 0;

	//构造扑克
	BYTE cbNormalCard[MAX_COUNT] = { 0 };
	BYTE cbNormalCardCount = cbHandCardCount;
	memcpy(cbNormalCard, cbHandCardData, sizeof(BYTE)*cbHandCardCount);

	//排列扑克
	SortCardList(cbNormalCard, cbNormalCardCount, ST_ORDER);

	//分析扑克
	tagDistributing Distributing = {};
	AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);

	//分析扑克
	tagAnalyseResult AnalyseResult = {};
	AnalysebCardData(cbNormalCard, cbNormalCardCount, AnalyseResult);

	//BYTE cbMinIndex = GetCardLogicValue(0x03);
	BYTE cbMaxIndex = GetCardLogicValue(0x01); // 最大牌是A;

	// 不带癞子搜索;
	for (BYTE i = cbReferIndex; i < cbMaxIndex; i++)
	{
		// 没有不做变幻;
		if (Distributing.cbDistributing[i][cbIndexCount] == 0) continue;

		// 三带二
		if (Distributing.cbDistributing[i][cbIndexCount] == 3)
		{
			// 先找带牌，如果找不到带牌，则牌型不成立;
			BYTE cbTmpCount = 0;
			BYTE cbTakeCard[5] = { 0 };

			//复制扑克
			for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
			{
				for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
				{
					cbTakeCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);

					if (cbTmpCount == 3) break;
				}

				if (cbTmpCount == 3) break;
			}

			for (BYTE j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
			{
				for (BYTE k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
				{
					// 带牌的起始位置;
					BYTE cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);

					// 过滤相同牌;
					if (i == GetCardLogicValue(AnalyseResult.cbCardData[j][cbIndex]))
					{
						continue;
					}

					// 提取带牌;
					for (BYTE n = 0; n < j + 1; n++)
					{
						cbTakeCard[cbTmpCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
						if (cbTmpCount == 5) break;
					}

					if (cbTmpCount == 5) break;
				}

				if (cbTmpCount == 5) break;
			}

			if (cbTmpCount == 5)
			{
				//设置变量
				CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTakeCard, sizeof(BYTE)*cbTmpCount);
				pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
				cbResultCount++;
			}
		}
	}

	if (pSearchCardResult)
	{
		pSearchCardResult->cbSearchCount = cbResultCount;
	}

	return cbResultCount;
}

//搜索四带三;
BYTE CGameLogic::SearchFourTakeThree(const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbReferCard, tagSearchCardResult *pSearchCardResult)
{
	if (cbHandCardCount < 7) return 0;
	if (pSearchCardResult == nullptr) return 0;
	if (!IsValidCard(cbReferCard)) return 0;

	//定义变量	
	BYTE cbResultCount = 0;
	BYTE cbReferIndex = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;
	ZeroMemory(pSearchCardResult, sizeof(tagSearchCardResult));

	// 只有一张2;
	if (cbReferIndex > GetCardLogicValue(0x01)) return 0;

	//构造扑克
	BYTE cbNormalCard[MAX_COUNT] = { 0 };
	BYTE cbNormalCardCount = cbHandCardCount;
	memcpy(cbNormalCard, cbHandCardData, sizeof(BYTE)*cbHandCardCount);

	//排列扑克
	SortCardList(cbNormalCard, cbNormalCardCount, ST_ORDER);

	//分析扑克
	tagDistributing Distributing = {};
	AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);

	//分析扑克
	tagAnalyseResult AnalyseResult = {};
	AnalysebCardData(cbNormalCard, cbNormalCardCount, AnalyseResult);

	BYTE cbMaxIndex = GetCardLogicValue(0x01);	// 最大牌是A;

	// 不带癞子搜索;
	for (BYTE i = cbReferIndex; i < cbMaxIndex; i++)
	{
		// 没有不做变幻;
		if (Distributing.cbDistributing[i][cbIndexCount] == 0) continue;

		// 三带二
		if (Distributing.cbDistributing[i][cbIndexCount] == 4)
		{
			// 先找带牌，如果找不到带牌，则牌型不成立;
			BYTE cbTmpCount = 0;
			BYTE cbTakeCard[7] = { 0 };

			//复制扑克
			for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
			{
				for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
				{
					cbTakeCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);

					if (cbTmpCount == 4) break;
				}

				if (cbTmpCount == 4) break;
			}

			for (BYTE j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
			{
				for (BYTE k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
				{
					// 带牌的起始位置;
					BYTE cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);

					// 过滤相同牌;
					if (i == GetCardLogicValue(AnalyseResult.cbCardData[j][cbIndex]))
					{
						continue;
					}

					// 提取带牌;
					for (BYTE n = 0; n < j + 1; n++)
					{
						cbTakeCard[cbTmpCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
						if (cbTmpCount == 7) break;
					}

					if (cbTmpCount == 7) break;
				}

				if (cbTmpCount == 7) break;
			}

			if (cbTmpCount == 7)
			{
				//设置变量
				CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTakeCard, sizeof(BYTE)*cbTmpCount);
				pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
				cbResultCount++;
			}
		}
	}

	if (pSearchCardResult)
	{
		pSearchCardResult->cbSearchCount = cbResultCount;
	}

	return cbResultCount;
}

//搜索飞机;
BYTE CGameLogic::SearchThreeLineTakeTwo(const BYTE cbHandCardData[], BYTE cbHandCardCount, BYTE cbReferCard, BYTE cbBlockCount, tagSearchCardResult *pSearchCardResult)
{
	//设置结果
	if (pSearchCardResult == nullptr) return 0;
	if (!IsValidCard(cbReferCard)) return 0;
	if (cbHandCardCount < cbBlockCount * 5) return 0;

	BYTE cbReferIndex = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;
	
	//超过A
	if ((cbReferIndex + cbBlockCount) > GetCardLogicValue(0x01)) return 0;

	ZeroMemory(pSearchCardResult, sizeof(tagSearchCardResult));

	// 癞子分析;
	BYTE cbNormalCard[MAX_COUNT] = { 0 };
	BYTE cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (BYTE i = 0; i < cbHandCardCount; i++)
	{
		cbNormalCard[cbNormalCardCount++] = cbHandCardData[i];
	}

	//排列扑克
	SortCardList(cbNormalCard, cbNormalCardCount, ST_ORDER);

	//定义变量	
	BYTE cbResultCount = 0;

	//分析扑克(分布规则：逻辑值);
	tagDistributing Distributing = {};
	AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);

	//搜索顺子
	BYTE cbMaxIndex = GetCardLogicValue(0x01) - cbBlockCount + 1;

	// 不考虑癞子;
	for (BYTE i = cbReferIndex; i <= cbMaxIndex; i++)
	{
		if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;

		BYTE cbTmpLinkCount = 0;	// 当前最大连牌数;
		BYTE cbUseMagicCount = 0;	// 已经使用癞子数量;
		BYTE cbTmpCard[MAX_COUNT] = { 0 };

		for (BYTE j = i; j <= GetCardLogicValue(0x01); j++)
		{
			// 有2张牌;
			if (Distributing.cbDistributing[j][cbIndexCount] >= 3)
			{
				cbTmpLinkCount++;
			}
			else
			{
				break;
			}

			// 找到足够大的连牌;
			if (cbTmpLinkCount >= cbBlockCount)
			{
				//复制扑克
				BYTE cbCount = 0;
				for (BYTE cbIndex = i; cbIndex <= j; cbIndex++)
				{
					BYTE cbTmpCount = 0;
					for (BYTE cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (BYTE cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
						{
							cbTmpCard[cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);

							if (++cbTmpCount == 3) break;
						}

						if (cbTmpCount == 3) break;
					}
				}

				// 加入尾巴;
				BYTE cbTakeCard[MAX_COUNT] = { 0 };
				BYTE cbTakeCardCount = cbNormalCardCount;
				CopyMemory(cbTakeCard, cbNormalCard, sizeof(BYTE)*cbNormalCardCount);

				// 将已经取出的牌删除;
				if (RemoveCard(cbTmpCard, cbCount, cbTakeCard, cbNormalCardCount))
				{
					cbTakeCardCount -= cbCount;
				}

				// 分析剩余牌;
				tagAnalyseResult AnalyseResult = {};
				AnalysebCardData(cbTakeCard, cbTakeCardCount, AnalyseResult);

				for (BYTE j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
				{
					for (BYTE k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
					{
						// 带牌的起始位置;
						BYTE cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);

						// 提取带牌;
						for (BYTE n = 0; n < j + 1; n++)
						{
							cbTmpCard[cbCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
							if (cbCount == cbBlockCount * 5) break;
						}

						if (cbCount == cbBlockCount * 5) break;
					}

					if (cbCount == cbBlockCount * 5) break;
				}

				// 牌数不对;
				if (cbCount != cbBlockCount * 5) break;

				int iCardType = GetCardType(cbTmpCard, cbCount, false);
				if (iCardType != CT_THREE_LINE) break;

				// 找到牌型;
				if (cbCount == cbBlockCount * 5)
				{
					//设置变量
					CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpCard, sizeof(BYTE)*cbCount);
					pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
					cbResultCount++;
				}

				break;
			}
		}
	}

	if (pSearchCardResult)
	{
		pSearchCardResult->cbSearchCount = cbResultCount;
	}

	return cbResultCount;
}

////得到飞机的块大小;
//BYTE CGameLogic::GetThreeLineBlockCount(const BYTE cbCardData[], BYTE cbCardCount, bool isLastCard)
//{
//	// 非最后一手牌，必须是5的倍数;
//	if (!isLastCard) return cbCardCount / 5;
//	
//	// 5的倍数;
//	if ((cbCardCount % 5) == 0) return cbCardCount / 5;
//
//	//分析牌
//	tagAnalyseResult AnalyseResult = {};
//	AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);
//
//	//三连判断;
//	if (AnalyseResult.cbBlockCount[2] + AnalyseResult.cbBlockCount[3] > 1)
//	{
//		BYTE cbLineCardData[MAX_COUNT] = { 0 };
//		BYTE cbLineLength = 0;
//
//		// 目前只从3取到4张相同牌(将3到4张相同的牌放到同一个数组，用来检测是不是连牌);
//		for (BYTE i = 2; i <= 3; i++)
//		{
//			if (AnalyseResult.cbBlockCount[i] > 0)
//			{
//				for (BYTE j = 0; j < AnalyseResult.cbBlockCount[i]; j++)
//				{
//					BYTE cbTmpCardDate = AnalyseResult.cbCardData[i][j*(i + 1)];
//
//					// 连牌不带2;
//					if (GetCardLogicValue(cbTmpCardDate) >= GetCardLogicValue(0x02)) continue;
//
//					cbLineCardData[cbLineLength] = cbTmpCardDate;
//					cbLineLength++;
//				}
//			}
//		}
//
//		// 重新排序;
//		SortCardList(cbLineCardData, cbLineLength, ST_ORDER);
//
//		//分析扑克
//		tagDistributing Distributing = {};
//		AnalysebDistributing(cbCardData, cbCardCount, Distributing);
//
//		BYTE cbLastValue = GetCardLogicValue(cbLineCardData[0]);
//
//		// 查找三连数量;
//		BYTE cbMaxThreeLength = 1;
//		BYTE cbThreeLength = 1;
//		BYTE cbMaxThreeCardData = cbLineCardData[0];
//
//		for (BYTE i = 1; i < cbLineLength; i++)
//		{
//			BYTE cbTmpValue = GetCardLogicValue(cbLineCardData[i]);
//
//			// 不连续
//			if (cbLastValue != (cbTmpValue + 1))
//			{
//				if (cbMaxThreeLength < cbThreeLength)
//				{
//					cbMaxThreeLength = cbThreeLength;
//					cbMaxThreeCardData = cbLineCardData[i - cbMaxThreeLength];
//				}
//
//				cbThreeLength = 1;
//			}
//			else
//			{
//				cbThreeLength++;
//			}
//
//			cbLastValue = cbTmpValue;
//		}
//
//		// 最后一个
//		if (cbMaxThreeLength < cbThreeLength)
//		{
//			cbMaxThreeLength = cbThreeLength;
//			cbMaxThreeCardData = cbLineCardData[cbLineLength - cbMaxThreeLength];
//		}
//
//		return cbMaxThreeLength;
//	}
//
//	return 0;
//}