#include "DZ_GameLogic.h"

#define IS_BOME_TYPE(x,y) (((x)>>(y))>0)

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

//扑克数据
const uint8 DZ_CGameLogic::m_cbCardData[DZ_FULL_COUNT] =
{
	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,	//方块 A - K
	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,	//梅花 A - K
	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,	//红桃 A - K
	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,	//黑桃 A - K
	0x4E, 0x4F,
	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,	//方块 A - K
	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,	//梅花 A - K
	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,	//红桃 A - K
	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,	//黑桃 A - K
	0x4E, 0x4F,
};

//扑克数据
const uint8	DZ_CGameLogic::m_cbNoJokerCardData[DZ_NO_JOKER_COUNT] =
{
	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,	//方块 A - K
	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,	//梅花 A - K
	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,	//红桃 A - K
	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,	//黑桃 A - K
	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,	//方块 A - K
	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,	//梅花 A - K
	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,	//红桃 A - K
	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,	//黑桃 A - K
};

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

//构造函数
DZ_CGameLogic::DZ_CGameLogic()
{

}

//析构函数
DZ_CGameLogic::~DZ_CGameLogic()
{

}

int DZ_CGameLogic::GetCardType(const uint8 cbCardData[], uint8 cbCardCount, bool isLastCard)
{
	//简单牌型
	switch (cbCardCount)
	{
	case 0:	//空牌
		{
			return DZ_CT_ERROR;
		}
	case 1: //单牌
		{
			return TransListToInt(0,DZ_CT_SINGLE);
		}
	case 2:	//对牌火箭
		{
			//牌型判断
			//if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return TransListToInt(0,DZ_CT_MISSILE_CARD);
			if (GetCardLogicValue(cbCardData[0])==GetCardLogicValue(cbCardData[1])) return TransListToInt(0,DZ_CT_DOUBLE);

			//赖子判断
			if(GetCardLogicValue(cbCardData[0])!=GetCardLogicValue(cbCardData[1]))
			{
				if (IsLaiZiCard(cbCardData[0]) && !IsLaiZiCard(cbCardData[1]))
				{
					return TransListToInt(0, DZ_CT_DOUBLE);
				}
				else if (!IsLaiZiCard(cbCardData[0]) && IsLaiZiCard(cbCardData[1]))
				{
					return TransListToInt(0, DZ_CT_DOUBLE);
				}

				//if (IsLaiZiCard(cbCardData[0]) || IsLaiZiCard(cbCardData[1]))
				//{
				//	if(((cbCardData[0]!=0x4F) || (cbCardData[0]!=0x4E)) && (cbCardData[1]!=0x4F) && (cbCardData[1]!=0x4E))
				//	{
				//		return TransListToInt(0,DZ_CT_DOUBLE);
				//	}
				//}
			}

			return DZ_CT_ERROR;
		}
	case 4:	//王炸;
	{
		if ((cbCardData[0] == 0x4F) && (cbCardData[1] == 0x4F) && (cbCardData[2] == 0x4E) && (cbCardData[3] == 0x4E))
		{
			return TransListToInt(0, DZ_CT_BOMB_8);
		}
	}
	}

	int dCardType = DZ_CT_ERROR;

	// 炸弹分析;
	if (cbCardCount >= 4 && cbCardCount <= 12)
	{
		bool isSameCard = true;

		// 大小排序王在最前面;
		uint8 cbValue = GetCardValue(cbCardData[cbCardCount - 1]);
		for (uint8 i = 0; i < cbCardCount; i++)
		{
			ASSERT(IsValidCard(cbCardData[i]));
			if (cbValue != GetCardValue(cbCardData[i]) && !IsLaiZiCard(cbCardData[i]))
			{
				isSameCard = false;
				break;
			}
		}

		// 同牌判断
		if (isSameCard)
		{
			// 4张炸弹做三带一特殊处理;
			if (isLastCard && (cbCardCount == 4))
			{
				dCardType = TransListToInt(dCardType, DZ_CT_THREE_TAKE_TWO);
			}

			uint8 cbCardType = DZ_CT_BOMB_4 + cbCardCount - 4;
			cbCardType = (cbCardType > DZ_CT_BOMB_10) ? DZ_CT_BOMB_10 : cbCardType;
			dCardType = TransListToInt(dCardType, cbCardType);

			return dCardType;// TransListToInt(0, cbCardType);
		}
	}

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = {0};
	uint8 cbMagicCardCount = 0;		// 大小王数量;
	uint8 cbNormalCardCount = 0;		// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCardCount++;
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbCardData[i];
		}
	}

	// 没有癞子;
	if (cbMagicCardCount == 0)
	{
		uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
		CopyMemory(bCardDataTemp, cbCardData, sizeof(uint8)*cbCardCount);

		//分析扑克
		tagDZAnalyseResult AnalyseResult;
		zeromemory(&AnalyseResult, sizeof(AnalyseResult));
		AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);

		uint8 cbMaxCardData = 0;
		uint8 cbBlockCount = 0;
		int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);

		// 不存在该类型时候，增加该类型;
		if ((dCardType&(1 << iCardType)) == 0)
		{
			dCardType = TransListToInt(dCardType, iCardType);
		}
	}
	else
	{
		if (cbMagicCardCount >= 1)
		{
			tagDZAnalyseResult AnalyseResult;
			zeromemory(&AnalyseResult, sizeof(AnalyseResult));

			uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
			CopyMemory(&bCardDataTemp[cbMagicCardCount], cbNormalCard, sizeof(uint8)*cbNormalCardCount);

			for (uint8 i = 0; i < 13; i++)
			{
				bCardDataTemp[0] = m_cbCardData[i];

				//两张赖子
				if (cbMagicCardCount >= 2)
				{
					for (uint8 z = 0; z < 13; z++)
					{
						bCardDataTemp[1] = m_cbCardData[z];

						//三张赖子
						if (cbMagicCardCount >= 3)
						{
							for (uint8 f = 0; f < 13; f++)
							{
								bCardDataTemp[2] = m_cbCardData[f];

								//四张赖子
								if (cbMagicCardCount == 4)
								{
									for (uint8 l = 0; l < 13; l++)
									{
										bCardDataTemp[3] = m_cbCardData[l];

										zeromemory(&AnalyseResult, sizeof(AnalyseResult));

										AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);

										//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
										uint8 cbMaxCardData = 0;
										uint8 cbBlockCount = 0;
										int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);
										
										if (iCardType == 0) continue;

										if ((dCardType&(1 << iCardType)) == 0)
										{
											dCardType = TransListToInt(dCardType, iCardType);
										}
									}
								}
								else
								{
									zeromemory(&AnalyseResult, sizeof(AnalyseResult));

									AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);

									//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
									uint8 cbMaxCardData = 0;
									uint8 cbBlockCount = 0;
									int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);

									if (iCardType == 0) continue;

									if ((dCardType&(1 << iCardType)) == 0)
									{
										dCardType = TransListToInt(dCardType, iCardType);
									}
								}
							}
						}
						else
						{
							zeromemory(&AnalyseResult, sizeof(AnalyseResult));

							AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);

							//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
							uint8 cbMaxCardData = 0;
							uint8 cbBlockCount = 0;
							int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);

							if (iCardType == 0) continue;

							if ((dCardType&(1 << iCardType)) == 0)
							{
								dCardType = TransListToInt(dCardType, iCardType);
							}
						}
					}
				}
				else
				{
					zeromemory(&AnalyseResult, sizeof(AnalyseResult));

					AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);

					//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
					uint8 cbMaxCardData = 0;
					uint8 cbBlockCount = 0;
					int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);

					if (iCardType == 0) continue;

					if ((dCardType&(1 << iCardType)) == 0)
					{
						dCardType = TransListToInt(dCardType, iCardType);
					}
				}
			}
		}
	}
	
	return dCardType;
}

//获取类型结果
int DZ_CGameLogic::GetType(tagDZAnalyseResult& AnalyseResult, const uint8 cbCardData[], uint8 cbCardCount, uint8& cbMaxCardData, uint8 &cbBlockCount, bool isLastCard)
{
	// 重置牌值;
	cbMaxCardData = 0x0;
	cbBlockCount = 0;

	//简单牌型
	switch (cbCardCount)
	{
	case 0:	//空牌
	{
		return DZ_CT_ERROR;
	}
	case 1: //单牌
	{
		cbMaxCardData = cbCardData[0];
		return DZ_CT_SINGLE;
	}
	case 2:	//对牌火箭
	{
		//牌型判断
		//if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return TransListToInt(0,DZ_CT_MISSILE_CARD);
		if (GetCardLogicValue(cbCardData[0]) == GetCardLogicValue(cbCardData[1]))
		{
			cbMaxCardData = cbCardData[0];
			return DZ_CT_DOUBLE;
		}

		//赖子判断
		if (GetCardLogicValue(cbCardData[0]) != GetCardLogicValue(cbCardData[1]))
		{
			if (IsLaiZiCard(cbCardData[0]) || IsLaiZiCard(cbCardData[1]))
			{
				if ((cbCardData[0] != 0x4F) && (cbCardData[0] != 0x4E) && (cbCardData[0] != 0x4F) && (cbCardData[1] != 0x4E))
				{
					cbMaxCardData = cbCardData[cbCardCount - 1];

					return DZ_CT_DOUBLE;
				}
			}
		}

		return DZ_CT_ERROR;
	}
	case 4:	//王炸;
	{
		if ((cbCardData[0] == 0x4F) && (cbCardData[1] == 0x4F) && (cbCardData[2] == 0x4E) && (cbCardData[3] == 0x4E))
		{
			cbMaxCardData = cbCardData[0];
			return DZ_CT_BOMB_8;
		}
	}
	}

	//单张判断
	if ((AnalyseResult.cbBlockCount[BLOCK_ONE] >= 5) && (AnalyseResult.cbBlockCount[BLOCK_ONE] == cbCardCount))
	{
		//变量定义
		uint8 cbFirstLogicValue = GetCardLogicValue(AnalyseResult.cbCardData[BLOCK_ONE][0]);

		//错误过虑
		if (cbFirstLogicValue > 14) return DZ_CT_ERROR;

		//连牌判断
		for (uint8 i = 1; i < AnalyseResult.cbBlockCount[BLOCK_ONE]; i++)
		{
			uint8 cbTmpCardData = AnalyseResult.cbCardData[BLOCK_ONE][i];
			if (cbFirstLogicValue != (GetCardLogicValue(cbTmpCardData) + i))
				return DZ_CT_ERROR;
		}

		cbMaxCardData = cbCardData[0];

		return DZ_CT_SINGLE_LINE;
	}

	//两张类型
	if ((AnalyseResult.cbBlockCount[BLOCK_TWO] >= 2) && (AnalyseResult.cbBlockCount[BLOCK_TWO]*2 == cbCardCount))
	{
		//变量定义
		uint8 cbFirstLogicValue = GetCardLogicValue(AnalyseResult.cbCardData[BLOCK_TWO][0]);

		//错误过虑
		if (cbFirstLogicValue > 14) return DZ_CT_ERROR;

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

		//二连判断
		if ((AnalyseResult.cbBlockCount[BLOCK_TWO] * 2) == cbCardCount)
		{
			cbMaxCardData = cbCardData[0];
			return DZ_CT_DOUBLE_LINE;
		}

		return DZ_CT_ERROR;
	}

	// 其他牌型都判断完了，如果还有5张以上牌直接返回DZ_CT_ERROR;
	for (int i = BLOCK_FIVE; i <= BLOCK_TWELVE; i++)
	{
		if (AnalyseResult.cbBlockCount[i] > 0)
		{
			return DZ_CT_ERROR;
		}
	}

	//三带二
	if (AnalyseResult.cbBlockCount[BLOCK_THREE] == 1 && cbCardCount == 5)
	{
		cbMaxCardData = AnalyseResult.cbCardData[BLOCK_THREE][0];
		return DZ_CT_THREE_TAKE_TWO;
	}

	//三带二
	if (isLastCard && AnalyseResult.cbBlockCount[BLOCK_THREE] == 1 && cbCardCount <= 5)
	{
		cbMaxCardData = AnalyseResult.cbCardData[BLOCK_THREE][0];
		return DZ_CT_THREE_TAKE_TWO;
	}

	//三带二
	if ((AnalyseResult.cbBlockCount[BLOCK_FOUR] == 1) && (cbCardCount == 5))
	{
		cbMaxCardData = AnalyseResult.cbCardData[BLOCK_FOUR][0];
		return DZ_CT_THREE_TAKE_TWO;
	}

	//三带二
	if (isLastCard && AnalyseResult.cbBlockCount[BLOCK_FOUR] == 1 && cbCardCount <= 5)
	{
		cbMaxCardData = AnalyseResult.cbCardData[BLOCK_FOUR][0];
		return DZ_CT_THREE_TAKE_TWO;
	}

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

		uint8 cbLineCardData[DZ_MAX_COUNT] = { 0 };
		uint8 cbLineLength = 0;

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

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

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

		uint8 cbLastValue = GetCardLogicValue(cbLineCardData[0]);
		//错误过虑(3~A)
		if (cbLastValue > 14) return DZ_CT_ERROR;

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

		for (uint8 i = 1; i < cbLineLength; i++)
		{
			uint8 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))
		{
			cbBlockCount = cbMaxThreeLength;
			cbMaxCardData = cbMaxThreeCardData;
			cbCardType = DZ_CT_THREE_LINE;
		}
		else if (!isLastCard)
		{
			// 计算几个三带二
			uint8 cbTmpBlockCount = cbCardCount / 5;
			if ((cbTmpBlockCount * 5 == cbCardCount) && (cbMaxThreeLength >= cbTmpBlockCount))
			{
				cbBlockCount = cbTmpBlockCount;
				cbMaxCardData = cbMaxThreeCardData;
				cbCardType = DZ_CT_THREE_LINE;
			}
		}

		return cbCardType;
	}

	return DZ_CT_ERROR;
}

//排列扑克
void DZ_CGameLogic::SortCardList(uint8 cbCardData[], uint8 cbCardCount, uint8 cbSortType)
{
	//数目过虑
	if (cbCardCount == 0) return;

	if (cbSortType == DZ_ST_ORDER)
	{
		//转换数值
		BYTE cbSortValue[DZ_MAX_COUNT];
		for (BYTE i = 0; i < cbCardCount; i++)
		{
			cbSortValue[i] = GetCardLogicValue(cbCardData[i]);
		}

		//排序操作
		bool bSorted = true;
		uint8 cbSwitchData = 0, cbLast = cbCardCount - 1;
		do
		{
			bSorted = true;
			for (uint8 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);
	}
	//数目排序
	else if (cbSortType == DZ_ST_COUNT)
	{
		//变量定义
		uint8 cbCardIndex = 0;

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

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

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

	return;
}

//混乱扑克
void DZ_CGameLogic::RandCardList(uint8 cbCardBuffer[], uint8 cbBufferCount)
{
	//混乱准备
	uint8 cbCardData[CountArray(m_cbCardData)];
	CopyMemory(cbCardData,m_cbCardData,sizeof(m_cbCardData));

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

	return;
}

//混乱扑克
void DZ_CGameLogic::RandNoJokerCardList(uint8 cbCardBuffer[], uint8 cbBufferCount)
{
	//混乱准备
	uint8 cbCardData[CountArray(m_cbNoJokerCardData)];
	CopyMemory(cbCardData, m_cbNoJokerCardData, sizeof(m_cbNoJokerCardData));

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

	return;
}

//删除扑克
bool DZ_CGameLogic::RemoveCard(const uint8 cbRemoveCard[], uint8 cbRemoveCount, uint8 cbCardData[], uint8 cbCardCount)
{
	//检验数据
	ASSERT(cbRemoveCount<=cbCardCount);
	if(cbRemoveCount>cbCardCount)
		return false ;

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

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

	//清理扑克
	zeromemory(cbCardData, sizeof(uint8)*cbCardCount);

	uint8 cbCardPos=0;
	for (uint8 i=0;i<cbCardCount;i++)
	{
		if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
	}

	return true;
}

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

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

	return false;
}

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

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

//#ifdef _DEBUG
//	if(cbCardValue<=0 || cbCardValue>(DZ_MASK_VALUE&0x4f))
//		return 0 ;
//#endif

	ASSERT(cbCardValue>0 && cbCardValue <= (DZ_MASK_VALUE & 0x4f));

	//转换数值
	if (cbCardColor==0x40) return cbCardValue+2;

	return (cbCardValue<=2)?(cbCardValue+13):cbCardValue;
}

//对比扑克
bool DZ_CGameLogic::CompareCard(const DZ_CMD_C_OutCard* pFirstOutCard, const DZ_CMD_C_OutCard* pNextOutCard)
{
	if (pFirstOutCard == nullptr || pNextOutCard == nullptr) return false;

	//获取类型
	int cbFirstType = pFirstOutCard->cbCardType;
	int cbNextType = pNextOutCard->cbCardType;

	//类型判断
	if (cbNextType == DZ_CT_ERROR) return false;

	uint8 cbFirstCount = pFirstOutCard->cbCardCount;
	uint8 cbNextCount = pNextOutCard->cbCardCount;
	bool isFirstLastCard = pFirstOutCard->isLastCard;
	bool isNextLastCard = pNextOutCard->isLastCard;

	uint8 cbFirstCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbNextCard[DZ_MAX_COUNT] = { 0 };
	CopyMemory(cbFirstCard, pFirstOutCard->cbCardData, sizeof(uint8)*cbFirstCount);
	CopyMemory(cbNextCard, pNextOutCard->cbCardData, sizeof(uint8)*cbNextCount);
	
	//炸弹过虑
	int cbTmpFirstType = (cbFirstType >> DZ_CT_BOMB_4);
	int cbTmpNextType = (cbNextType >> DZ_CT_BOMB_4);

	if (cbTmpFirstType > 0 || cbTmpNextType > 0)
	{
		// 当前牌不是炸弹则打不到上一手炸弹牌;
		if (cbTmpNextType < 0) return false;
		//if (cbTmpFirstType > 0) return true;

		//星级比较
		if (cbTmpFirstType != cbTmpNextType)
		{
			return cbTmpNextType > cbTmpFirstType;
		}
		else
		{
			// 取最后一张，一定不是癞子;如果还是癞子，那就是4王炸;
			uint8 cbConsultNext = GetCardLogicValue(cbNextCard[cbNextCount - 1]);
			uint8 cbConsultFirst = GetCardLogicValue(cbFirstCard[cbFirstCount - 1]);

			return cbConsultNext > cbConsultFirst;
		}
	}

	//不同类型
	if (cbFirstType != cbNextType) return false;

	//获取数值
	uint8 cbNextLogicValue = 0;
	uint8 cbFirstLogicValue = 0;

	//分析扑克
	uint8 NextResult[DZ_CT_COUNT] = {0};
	uint8 FirstResult[DZ_CT_COUNT] = { 0 };

	// 单牌;
	if ((cbNextType&(1 << DZ_CT_SINGLE)) != 0 && cbFirstCount == cbNextCount)
	{
		if (cbFirstCount != 1) return false;
	
		//获取数值
		cbNextLogicValue = GetCardLogicValue(cbNextCard[0]);
		cbFirstLogicValue = GetCardLogicValue(cbFirstCard[0]);

		if (cbNextLogicValue > cbFirstLogicValue) return true;
	}
	else if ((cbNextType&(1 << DZ_CT_DOUBLE)) != 0 && cbFirstCount == cbNextCount)
	{
		if (cbFirstCount != 2) return false;

		//获取数值
		cbNextLogicValue = GetCardLogicValue(cbNextCard[1]);
		cbFirstLogicValue = GetCardLogicValue(cbFirstCard[1]);

		if (cbNextLogicValue > cbFirstLogicValue) return true;
	}
	else if ((cbNextType&(1 << DZ_CT_THREE_TAKE_TWO)) != 0)
	{
		// 三带二牌数判断;
		if (cbFirstCount < 3 || cbFirstCount > 5) return false;
		if (cbNextCount < 3 || cbNextCount > 5) return false;

		// 不是最后一手牌必须是5张;
		if (!isFirstLastCard && cbFirstCount != 5) return false;
		if (!isNextLastCard && cbNextCount != 5) return false;
		
		uint8 cbNextBlockCount = 0, cbFirstBlockCount = 0;
		if (!AnalysebCompare(cbNextCard, cbNextCount, NextResult, cbNextBlockCount, DZ_CT_THREE_TAKE_TWO, isNextLastCard))return false;
		if (!AnalysebCompare(cbFirstCard, cbFirstCount, FirstResult, cbFirstBlockCount, DZ_CT_THREE_TAKE_TWO, isFirstLastCard))return false;

		//获取数值
		cbNextLogicValue = GetCardLogicValue(NextResult[DZ_CT_THREE_TAKE_TWO]);
		cbFirstLogicValue = GetCardLogicValue(FirstResult[DZ_CT_THREE_TAKE_TWO]);
		
		if (cbNextLogicValue > cbFirstLogicValue) return true;
	}
	else if ((cbNextType&(1 << DZ_CT_SINGLE_LINE)) != 0 && cbFirstCount == cbNextCount)
	{
		if (cbFirstCount < 5) return false;

		//获取数值
		cbNextLogicValue = GetCardLogicValue(cbNextCard[cbNextCount - 1]);
		cbFirstLogicValue = GetCardLogicValue(cbFirstCard[cbFirstCount - 1]);

		if (cbNextLogicValue > cbFirstLogicValue) return true;

	}
	else if ((cbNextType&(1 << DZ_CT_DOUBLE_LINE)) != 0 && cbFirstCount == cbNextCount)
	{
		if ((cbFirstCount < 4) || (cbFirstCount%2)!=0) return false;

		//获取数值
		cbNextLogicValue = GetCardLogicValue(cbNextCard[cbNextCount - 1]);
		cbFirstLogicValue = GetCardLogicValue(cbFirstCard[cbFirstCount - 1]);

		if (cbNextLogicValue > cbFirstLogicValue) return true;

	}
	else if ((cbNextType&(1 << DZ_CT_THREE_LINE)) != 0)
	{
		// 三带二牌数判断;
		if (cbFirstCount < 6 || cbNextCount < 6) return false;

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

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

		uint8 cbNextBlockCount = 0, cbFirstBlockCount = 0;
		if (!AnalysebCompare(cbNextCard, cbNextCount, NextResult, cbNextBlockCount, DZ_CT_THREE_LINE, isNextLastCard))return false;
		if (!AnalysebCompare(cbFirstCard, cbFirstCount, FirstResult, cbFirstBlockCount, DZ_CT_THREE_LINE, isFirstLastCard))return false;

		if (cbNextBlockCount != cbFirstBlockCount) return false;

		//获取数值
		cbNextLogicValue = GetCardLogicValue(NextResult[DZ_CT_THREE_LINE]);
		cbFirstLogicValue = GetCardLogicValue(FirstResult[DZ_CT_THREE_LINE]);

		if (cbNextLogicValue > cbFirstLogicValue) return true;
	}

	return false;
}

//赖子数目
uint8 DZ_CGameLogic::GetLaiZiCount(const uint8 cbHandCardData[], uint8 cbHandCardCount)
{
	uint8 bLaiZiCount=0;
	for(uint8 i=0;i<cbHandCardCount;i++)
	{
		if (IsLaiZiCard(cbHandCardData[i]))
			bLaiZiCount++;
	}

	return bLaiZiCount;
}

//是否癞子牌
bool DZ_CGameLogic::IsLaiZiCard(uint8 cbCard)
{
	ASSERT(IsValidCard(cbCard));

	if (0x40 == GetCardColor(cbCard))
	{
		return true;
	}

	return false;
}

//分析扑克
void DZ_CGameLogic::AnalysebCardData(const uint8 cbCardData[], uint8 cbCardCount, tagDZAnalyseResult & AnalyseResult)
{
	//设置变量
	uint8 cbTmpCardData[DZ_MAX_COUNT] = { 0 };
	CopyMemory(cbTmpCardData, cbCardData, sizeof(uint8)*cbCardCount);

	SortCardList(cbTmpCardData, cbCardCount, DZ_ST_ORDER);

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

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

			//设置变量
			cbSameCount++;
		}

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

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

	return;
}

//分析比较
bool DZ_CGameLogic::AnalysebCompare(const uint8 cbCardData[], uint8 cbCardCount, uint8 cbMaxCardData[DZ_CT_COUNT], uint8 &cbBlockCount, int dCardType, bool isLastCard)
{
	// 重置;
	cbBlockCount = 0;
	zeromemory(cbMaxCardData, sizeof(cbMaxCardData));

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;		// 大小王数量;
	uint8 cbNormalCardCount = 0;		// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCardCount++;
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbCardData[i];
		}
	}

	int dCardTypeTemp = DZ_CT_ERROR;
	dCardTypeTemp = (1 << dCardType);

	// 没有癞子;
	if (cbMagicCardCount == 0)
	{
		uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
		CopyMemory(bCardDataTemp, cbCardData, sizeof(uint8)*cbCardCount);

		//分析扑克
		tagDZAnalyseResult AnalyseResultTemp;
		zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

		AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);

		//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
		uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
		int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);

		if ((dCardTypeTemp&(1 << iCardType)) != 0)
		{
			//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
			if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
			{
				cbBlockCount = cbTmpBlockCount;
				cbMaxCardData[iCardType] = cbTmpMaxCardData;
			}
		}
	}
	else
	{
		if (cbMagicCardCount >= 1)
		{
			tagDZAnalyseResult AnalyseResultTemp;
			zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

			uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
			CopyMemory(&bCardDataTemp[cbMagicCardCount], cbNormalCard, sizeof(uint8)*cbNormalCardCount);

			for (uint8 i = 0; i < 13; i++)
			{
				bCardDataTemp[0] = m_cbCardData[i];

				//两张赖子
				if (cbMagicCardCount >= 2)
				{
					for (uint8 z = 0; z < 13; z++)
					{
						bCardDataTemp[1] = m_cbCardData[z];

						//三张赖子
						if (cbMagicCardCount >= 3)
						{
							for (uint8 f = 0; f < 13; f++)
							{
								bCardDataTemp[2] = m_cbCardData[f];

								//四张赖子
								if (cbMagicCardCount == 4)
								{
									for (uint8 l = 0; l < 13; l++)
									{
										bCardDataTemp[3] = m_cbCardData[l];

										zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

										AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);

										//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
										uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
										int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);

										if ((dCardTypeTemp&(1 << iCardType)) != 0)
										{
											//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
											//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
											if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
											{
												cbBlockCount = cbTmpBlockCount;
												cbMaxCardData[iCardType] = cbTmpMaxCardData;
											}
										}
									}
								}
								else
								{
									zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

									AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);

									//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
									uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
									int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);

									if ((dCardTypeTemp&(1 << iCardType)) != 0)
									{
										//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
										//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
										if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
										{
											cbBlockCount = cbTmpBlockCount;
											cbMaxCardData[iCardType] = cbTmpMaxCardData;
										}
									}
								}
							}
						}
						else
						{
							zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

							AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);

							//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
							uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
							int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);

							if ((dCardTypeTemp&(1 << iCardType)) != 0)
							{
								//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
								//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
								if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
								{
									cbBlockCount = cbTmpBlockCount;
									cbMaxCardData[iCardType] = cbTmpMaxCardData;
								}
							}
						}
					}
				}
				else
				{
					zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

					AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);

					//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
					uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
					int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);

					if ((dCardTypeTemp&(1 << iCardType)) != 0)
					{
						//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
						//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
						if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
						{
							cbBlockCount = cbTmpBlockCount;
							cbMaxCardData[iCardType] = cbTmpMaxCardData;
						}
					}
				}
			}
		}
	}

	return true;
}

//随机扑克
uint8 DZ_CGameLogic::GetRandomCard(void)
{
	size_t cbIndex = rand()%(sizeof(m_cbCardData)) ;
	return m_cbCardData[cbIndex] ;
}

//排列扑克
void DZ_CGameLogic::SortOutCardList(uint8 cbCardData[], uint8 cbCardCount, int nCardType, bool isLastCard)
{
	return;
}

//牌组转换(将32张牌的使用情况转化为一个32位整型)
int DZ_CGameLogic::TransListToInt(int iOldType,int iNewType)
{
	//数据校验
	if(iNewType == 0) return 0;

	//变量定义
	int nList = 0;
	ASSERT(iNewType != -1);
	nList |= (1<<iNewType);

	return iOldType|nList;
}

//是否包含牌型
bool DZ_CGameLogic::IsHasCardType(int iCardType, CART_TYPE ct_value)
{
	if (iCardType == DZ_CT_ERROR) return false;

	return ((iCardType&(1 << ct_value)) != 0);
}

//是不是炸弹;
bool DZ_CGameLogic::IsBombType(int iCardType)
{
	return ((iCardType >> DZ_CT_BOMB_4) > 0);
}

//分析分布
void DZ_CGameLogic::AnalysebDistributing(const uint8 cbCardData[], uint8 cbCardCount, tagDZDistributing & Distributing)
{
	//设置变量
	zeromemory(&Distributing, sizeof(tagDZDistributing));

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

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

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

		//Distributing.cbDistributing[cbCardValue - 1][cbIndexCount]++;
		//Distributing.cbDistributing[cbCardValue - 1][cbCardColor >> 4]++;
	}

	return;
}

//出牌搜索
uint8 DZ_CGameLogic::SearchOutCard(const uint8 cbHandCardData[], uint8 cbHandCardCount, const DZ_CMD_C_OutCard* pFirstOutCard, tagDZSearchCardResult *pSearchCardResult)
{
	//设置结果
	assert(pSearchCardResult != nullptr);
	if (pSearchCardResult == nullptr || pFirstOutCard == nullptr) return 0;

	//获取类型
	int cbTurnOutType = pFirstOutCard->cbCardType;
	if (cbTurnOutType == DZ_CT_ERROR) return 0;

	uint8 cbTurnCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbTurnCardCount = pFirstOutCard->cbCardCount;
	CopyMemory(cbTurnCardData, pFirstOutCard->cbCardData, sizeof(uint8)*cbTurnCardCount);

	//变量定义
	uint8 cbResultCount = 0;
	tagDZSearchCardResult tmpSearchCardResult = {};
	zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
	SortCardList(cbCardData, cbCardCount, DZ_ST_ORDER);

	//是否一手出完
	int iLastCardType = GetCardType(cbCardData, cbCardCount, true);
	if (iLastCardType != DZ_CT_ERROR)
	{
		DZ_CMD_C_OutCard tmpOutCard;
		zeromemory(&tmpOutCard, sizeof(DZ_CMD_C_OutCard));
		tmpOutCard.isLastCard = true;
		tmpOutCard.cbCardCount = cbHandCardCount;
		tmpOutCard.cbCardType = iLastCardType;
		CopyMemory(tmpOutCard.cbCardData, cbCardData, sizeof(uint8)*cbCardCount);

		if (CompareCard(pFirstOutCard, &tmpOutCard) == true)
		{
			pSearchCardResult->cbCardCount[cbResultCount] = cbCardCount;
			memcpy(pSearchCardResult->cbResultCard[cbResultCount], cbCardData, sizeof(uint8)*cbCardCount);
			cbResultCount++;
		}
	}
	
	// 提示出牌;
	if (IsHasCardType(cbTurnOutType, DZ_CT_SINGLE))
	{
		//变量定义
		uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
		cbResultCount = SearchSingle(cbCardData, cbCardCount, cbReferCard, pSearchCardResult);
	}
	else if (IsHasCardType(cbTurnOutType, DZ_CT_DOUBLE))
	{
		//变量定义
		uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
		cbResultCount = SearchDouble(cbCardData, cbCardCount, cbReferCard, pSearchCardResult);
	}
	else if (IsHasCardType(cbTurnOutType, DZ_CT_SINGLE_LINE))
	{
		//变量定义
		uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
		cbResultCount = SearchSingleLine(cbCardData, cbCardCount, cbReferCard, cbTurnCardCount, pSearchCardResult);
	}
	else if (IsHasCardType(cbTurnOutType, DZ_CT_DOUBLE_LINE))
	{
		//变量定义
		uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
		uint8 cbLineCount = cbTurnCardCount / 2;
		cbResultCount = SearchDoubleLine(cbCardData, cbCardCount, cbReferCard, cbLineCount, pSearchCardResult);
	}
	else if (IsHasCardType(cbTurnOutType, DZ_CT_THREE_TAKE_TWO))
	{
		//效验牌数
		if (cbCardCount < 5) return cbResultCount;
		
		uint8 cbFirstLogicValue = 0, cbBlockCount = 0;
		uint8 FirstResult[DZ_CT_COUNT] = { 0 };
		if (!AnalysebCompare(cbTurnCardData, cbTurnCardCount, FirstResult, cbBlockCount, DZ_CT_THREE_TAKE_TWO, pFirstOutCard->isLastCard))return 0;

		//获取数值
		cbFirstLogicValue = GetCardLogicValue(FirstResult[DZ_CT_THREE_TAKE_TWO]);

		//带癞子搜索;
		cbResultCount = SearchThreeTakeTwo(cbCardData, cbCardCount, cbFirstLogicValue, pSearchCardResult);
	}
	else if (IsHasCardType(cbTurnOutType, DZ_CT_THREE_LINE))
	{
		//效验牌数
		if (cbCardCount < 6) return cbResultCount;

		uint8 cbFirstLogicValue = 0;
		uint8 cbBlockCount = 0;
		uint8 FirstResult[DZ_CT_COUNT] = { 0 };
		if (!AnalysebCompare(cbTurnCardData, cbTurnCardCount, FirstResult, cbBlockCount, DZ_CT_THREE_LINE, pFirstOutCard->isLastCard))return 0;
		
		//带癞子搜索(要算出最小牌);
		cbFirstLogicValue = (GetCardLogicValue(FirstResult[DZ_CT_THREE_LINE]) - cbBlockCount + 1);
		cbResultCount = SearchThreeLineTakeTwo(cbCardData, cbCardCount, cbFirstLogicValue, cbBlockCount, pSearchCardResult);
	}

	//搜索炸弹
	if (cbCardCount >= 4)
	{
		//变量定义
		uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
		SearchBomb(cbCardData, cbCardCount, cbReferCard, cbTurnCardCount, cbTurnOutType, pSearchCardResult, cbResultCount);
	}

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

	return cbResultCount;
}

//搜索单牌(不考虑癞子);
uint8 DZ_CGameLogic::SearchSingle(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, tagDZSearchCardResult *pSearchCardResult)
{
	//设置结果
	if (pSearchCardResult) zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
	
	//分析结果
	uint8 cbResultCount = 0;

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);

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

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

	//比较牌逻辑值;
	uint8 cbReferLogicValue = (cbReferCard == 0) ? 0 : GetCardLogicValue(cbReferCard);
	uint8 cbBlockIndex = BLOCK_ONE;

	do
	{
		for (uint8 i = 0; i < AnalyseResult.cbBlockCount[cbBlockIndex]; i++)
		{
			// 从小到大取牌;
			uint8 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));

				//复制扑克
				memcpy(pSearchCardResult->cbResultCard[cbResultCount], &AnalyseResult.cbCardData[cbBlockIndex][cbIndex], sizeof(uint8));
				pSearchCardResult->cbCardCount[cbResultCount] = 1;

				cbResultCount++;
			}
		}

		cbBlockIndex++;

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

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

	return cbResultCount;
}

//搜索对子;
uint8 DZ_CGameLogic::SearchDouble(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, tagDZSearchCardResult *pSearchCardResult)
{
	//设置结果
	if (pSearchCardResult) zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));

	//分析结果
	uint8 cbResultCount = 0;

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);

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

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

	//比较牌逻辑值;
	uint8 cbReferLogicValue = (cbReferCard == 0) ? 0 : GetCardLogicValue(cbReferCard);
	uint8 cbBlockIndex = BLOCK_TWO;

	do
	{
		for (uint8 i = 0; i < AnalyseResult.cbBlockCount[cbBlockIndex]; i++)
		{
			// 从小到大取牌;
			uint8 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));

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

				cbResultCount++;
			}
		}

		cbBlockIndex++;

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

	// 一个癞子，加一张单牌的情况;
	uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;			// 大小王数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCard[cbMagicCardCount] = cbCardData[i];

			cbMagicCardCount++;
		}
	}

	// 有一张癞子;
	if (cbMagicCardCount > 0)
	{
		for (uint8 i = 0; i < AnalyseResult.cbBlockCount[BLOCK_ONE]; i++)
		{
			// 从小到大取牌;
			uint8 cbIndex = (AnalyseResult.cbBlockCount[BLOCK_ONE] - i - 1);
			
			if (IsLaiZiCard(AnalyseResult.cbCardData[BLOCK_ONE][cbIndex])) continue;

			if (GetCardLogicValue(AnalyseResult.cbCardData[BLOCK_ONE][cbIndex]) > cbReferLogicValue)
			{
				if (pSearchCardResult == NULL) return 1;

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

				//复制扑克
				pSearchCardResult->cbResultCard[cbResultCount][0] = cbMagicCard[cbMagicCardCount - 1];
				pSearchCardResult->cbResultCard[cbResultCount][1] = AnalyseResult.cbCardData[BLOCK_ONE][cbIndex];
				pSearchCardResult->cbCardCount[cbResultCount] = 2;

				cbResultCount++;
			}
		}
	}

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

	return cbResultCount;
}

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

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

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

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

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;					// 大小王数量;
	uint8 cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCard[cbMagicCardCount++] = cbCardData[i];
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbCardData[i];
		}
	}

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

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

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

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

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

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

			// 找到足够大的连牌;
			if (cbTmpLinkCount >= cbLineCount)
			{
				//复制扑克
				uint8 cbCount = 0;
				for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
				{
					uint8 cbTmpCount = 0;
					for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (uint8 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;
					}
				}

				//// 加入癞子;
				//for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
				//{
				//	pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
				//}

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

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

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

			for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
			{
				//继续判断
				if (Distributing.cbDistributing[j][cbIndexCount] < 1)
				{
					// 是否有癞子;
					if (cbUseMagicCount < cbMagicCardCount)
					{
						cbTmpLinkCount++;
						cbUseMagicCount++;
					}
					else
					{
						break;
					}
				}
				else
				{
					cbTmpLinkCount++;
				}

				// 找到足够大的连牌;
				if (cbTmpLinkCount >= cbLineCount)
				{
					// 带癞子分析，如果不包含癞子，就不需要，防止重复分析;
					if (cbUseMagicCount <= 0) break;

					//复制扑克
					uint8 cbCount = 0;
					for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
					{
						uint8 cbTmpCount = 0;
						for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
						{
							for (uint8 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;
						}
					}

					// 加入癞子;
					for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
					{
						pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
					}

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

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

	return cbResultCount;
}

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

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

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

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

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;					// 大小王数量;
	uint8 cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCard[cbMagicCardCount++] = cbCardData[i];
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbCardData[i];
		}
	}

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

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

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

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

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

		for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
		{
			// 有2张牌;
			if (Distributing.cbDistributing[j][cbIndexCount] >= 2)
			{
				cbTmpLinkCount++;
			}
			else
			{
				break;
			}
			
			// 找到足够大的连牌;
			if (cbTmpLinkCount >= cbLineCount)
			{
				//复制扑克
				uint8 cbCount = 0;
				for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
				{
					uint8 cbTmpCount = 0;
					for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (uint8 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;
					}
				}

				//// 加入癞子;
				//for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
				//{
				//	pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
				//}

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

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

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

			for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
			{
				// 有2张牌;
				if (Distributing.cbDistributing[j][cbIndexCount] >= 2)
				{
					cbTmpLinkCount++;
				}
				// 只有一张;
				else if (Distributing.cbDistributing[j][cbIndexCount] == 1)
				{
					// 是否还有癞子;
					if (cbUseMagicCount < cbMagicCardCount)
					{
						cbTmpLinkCount++;
						cbUseMagicCount++;
					}
					else
					{
						break;
					}
				}
				// 一张都没有;
				else
				{
					// 是否还有2张癞子;
					if (cbUseMagicCount + 2 <= cbMagicCardCount)
					{
						cbTmpLinkCount++;
						cbUseMagicCount += 2;
					}
					else
					{
						break;
					}
				}

				// 找到足够大的连牌;
				if (cbTmpLinkCount >= cbLineCount)
				{
					// 带癞子分析，如果不包含癞子，就不需要，防止重复分析;
					if (cbUseMagicCount <= 0) break;

					//复制扑克
					uint8 cbCount = 0;
					for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
					{
						uint8 cbTmpCount = 0;
						for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
						{
							for (uint8 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;
						}
					}

					// 加入癞子;
					for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
					{
						pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
					}

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

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

	return cbResultCount;
}

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

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

	if (cbReferIndex > GetCardLogicValue(0x02)) return 0;

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;					// 大小王数量;
	uint8 cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCard[cbMagicCardCount++] = cbCardData[i];
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbCardData[i];
		}
	}

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

	//只有癞子和同牌，就是炸弹;
	if (GetCardLogicValue(cbNormalCard[0]) == GetCardLogicValue(cbNormalCard[cbNormalCardCount - 1]))
	{
		return 0;
	}

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

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

	uint8 cbMinIndex = 0x03;
	uint8 cbMaxIndex = GetCardLogicValue(0x02);

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

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

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

					if (cbTmpCount == 3) break;
				}

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

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

					// 提取带牌;
					for (uint8 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 == 4 && cbMagicCardCount > 0)
			{
				cbTakeCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - 1];
			}

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

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

			// 带癞子;
			if (Distributing.cbDistributing[i][cbIndexCount] == 2 && (Distributing.cbDistributing[i][cbIndexCount] + cbMagicCardCount) >= 3)
			{
				// 先找带牌，如果找不到带牌，则牌型不成立;
				uint8 cbTmpCount = 0;
				uint8 cbTakeCard[5] = { 0 };

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

						if (cbTmpCount == 3) break;
					}

					if (cbTmpCount == 3) break;
				}

				// 加癞子;
				uint8 cbUseMagicCardCount = 0;
				if (cbTmpCount < 3)
				{
					for (uint8 cbMagicIndex = 0; cbMagicIndex < cbMagicCardCount; cbMagicIndex++)
					{
						// 从小到大;
						cbTakeCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - cbMagicIndex - 1];
						cbUseMagicCardCount++;

						if (cbTmpCount == 3) break;
					}
				}

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

						uint8 cbLogicValue = GetCardLogicValue(AnalyseResult.cbCardData[j][cbIndex]);

						// 过滤相同牌;
						if (i == cbLogicValue) continue;

						// 如果带一个对子比三个头大，则不合理;
						if (j > 0 && cbTmpCount == 3 && cbLogicValue > i) continue;

						// 提取带牌;
						for (uint8 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(uint8)*cbTmpCount);
					pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
					cbResultCount++;
				}
			}
		}
	}

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

	return cbResultCount;
}

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

	// 要打到上家牌，最小连牌值;
	uint8 cbReferIndex = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;

	//超过A
	//if (cbReferIndex + cbBlockCount > 14) return 0;
	if (cbReferIndex + cbBlockCount > GetCardLogicValue(0x01) + 1) return 0;

	zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;					// 大小王数量;
	uint8 cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbHandCardCount; i++)
	{
		if (IsLaiZiCard(cbHandCardData[i]))
		{
			cbMagicCard[cbMagicCardCount++] = cbHandCardData[i];
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbHandCardData[i];
		}
	}

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

	//定义变量	
	uint8 cbResultCount = 0;

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

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

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

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

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

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

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

						if (cbTmpCount == 3) break;
					}
				}

				// 加入尾巴;
				uint8 cbTakeCard[DZ_MAX_COUNT] = {0};
				uint8 cbTakeCardCount = cbNormalCardCount;
				CopyMemory(cbTakeCard, cbNormalCard, sizeof(uint8)*cbNormalCardCount);
				
				// 将已经取出的牌删除;
				if (RemoveCard(cbTmpCard, cbCount, cbTakeCard, cbNormalCardCount))
				{
					cbTakeCardCount -= cbCount;
				}

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

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

						// 提取带牌;
						for (uint8 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 (!IsHasCardType(iCardType, DZ_CT_THREE_LINE)) break;

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

				break;
			}
		}
	}

	// 带癞子分析;
	if (cbMagicCardCount > 0)
	{
		for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
		{
			if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;

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

			for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
			{
				// 有2张牌;
				if (Distributing.cbDistributing[j][cbIndexCount] >= 3)
				{
					cbTmpLinkCount++;
				}
				// 只有2张;
				else if (Distributing.cbDistributing[j][cbIndexCount] == 2)
				{
					// 是否还有癞子;
					if (cbUseMagicCount < cbMagicCardCount)
					{
						cbTmpLinkCount++;
						cbUseMagicCount++;
					}
					else
					{
						break;
					}
				}
				// 只有一张;
				else if (Distributing.cbDistributing[j][cbIndexCount] == 1)
				{
					// 是否还有癞子;
					if (cbUseMagicCount + 2 <= cbMagicCardCount)
					{
						cbTmpLinkCount++;
						cbUseMagicCount += 2;
					}
					else
					{
						break;
					}
				}
				// 一张都没有;
				else
				{
					// 是否还有2张癞子;
					if (cbUseMagicCount + 3 <= cbMagicCardCount)
					{
						cbTmpLinkCount++;
						cbUseMagicCount += 3;
					}
					else
					{
						break;
					}
				}

				// 找到足够大的连牌;
				if (cbTmpLinkCount >= cbBlockCount)
				{
					// 带癞子分析，如果不包含癞子，就不需要，防止重复分析;
					if (cbUseMagicCount <= 0) break;

					//复制扑克
					uint8 cbCount = 0;
					for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
					{
						uint8 cbTmpCount = 0;
						for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
						{
							for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
							{
								cbTmpCard[cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);

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

							if (cbTmpCount == 3) break;
						}
					}

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

					// 将已经取出的牌删除;
					if (RemoveCard(cbTmpCard, cbCount, cbTakeCard, cbNormalCardCount))
					{
						// 加入癞子;
						for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
						{
							cbTmpCard[cbCount++] = cbMagicCard[cbMagic];
						}

						cbTakeCardCount -= cbCount;
					}

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

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

							// 提取带牌;
							for (uint8 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;
					}

					//// 加入癞子;
					//for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
					//{
					//	pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
					//}

					// 带牌不够，加入癞子;
					if (cbCount < cbBlockCount * 5)
					{
						uint8 cbNeedCardCount = cbBlockCount * 5 - cbCount;

						// 剩余癞子数量够不够;
						if (cbUseMagicCount + cbNeedCardCount <= cbMagicCardCount)
						{
							for (uint8 cbMagic = 0; cbMagic < cbNeedCardCount; cbMagic++)
							{
								//pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbUseMagicCount + cbMagic];
								cbTmpCard[cbCount++] = cbMagicCard[cbUseMagicCount + cbMagic];
							}
						}
					}

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

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

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

					break;
				}
			}
		}
	}

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

	return cbResultCount;
}

//搜索炸弹;
uint8 DZ_CGameLogic::SearchBomb(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbReferCount, int iReferCardType, tagDZSearchCardResult *pSearchCardResult, uint8 &cbResultCount)
{
	if (cbHandCardCount < 4) return cbResultCount;
	if (pSearchCardResult == nullptr) return cbResultCount;
	if (!IsValidCard(cbReferCard)) return cbResultCount;

	// 要打的牌是不是炸弹;
	bool isTurnBomb = ((iReferCardType >> DZ_CT_BOMB_4) > 0) ? true : false;
	uint8 cbTurnLogicValue = GetCardLogicValue(cbReferCard) + 1;		// 最后一张牌;

	//构造扑克
	uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
	uint8 cbCardCount = cbHandCardCount;
	memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);

	// 癞子分析;
	uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
	uint8 cbMagicCardCount = 0;					// 大小王数量;
	uint8 cbNormalCardCount = 0;				// 正常牌数量;

	//变幻准备
	for (uint8 i = 0; i < cbCardCount; i++)
	{
		if (IsLaiZiCard(cbCardData[i]))
		{
			cbMagicCard[cbMagicCardCount++] = cbCardData[i];
		}
		else
		{
			cbNormalCard[cbNormalCardCount++] = cbCardData[i];
		}
	}

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

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

	uint8 cbMinIndex = 0x03;
	uint8 cbMaxIndex = GetCardLogicValue(0x02);

	// 不是炸弹，搜索所有炸弹;
	if (!isTurnBomb)
	{
		// 不带癞子搜索(4~8张);
		for (uint8 cbBombCardCount = 4; cbBombCardCount < 8; cbBombCardCount++)
		{
			for (uint8 i = cbMinIndex; i <= cbMaxIndex; i++)
			{
				if (Distributing.cbDistributing[i][cbIndexCount] == cbBombCardCount)
				{
					uint8 cbTmpCount = 0;
					uint8 cbTmpBombCard[12] = { 0 };

					//复制扑克
					for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
					{
						for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
						{
							cbTmpBombCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
						}
					}
					
					if (cbTmpCount == cbBombCardCount)
					{
						//设置变量
						CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpBombCard, sizeof(uint8)*cbTmpCount);
						pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
						cbResultCount++;
					}
				}
			}
		}

		// 带癞子搜索(4~12张);
		if (cbMagicCardCount > 0)
		{
			for (uint8 cbBombCardCount = 4; cbBombCardCount < 12; cbBombCardCount++)
			{
				for (uint8 i = cbMinIndex; i <= cbMaxIndex; i++)
				{
					// 没有牌不变幻;
					if (Distributing.cbDistributing[i][cbIndexCount] <= 0) continue;

					if ((Distributing.cbDistributing[i][cbIndexCount] + cbMagicCardCount) == cbBombCardCount)
					{
						uint8 cbTmpCount = 0;
						uint8 cbTmpBombCard[12] = { 0 };

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

						// 复制癞子;
						for (uint8 cbMagicIndex = 0; cbMagicIndex < cbMagicCardCount; cbMagicIndex++)
						{
							// 从小到大;
							cbTmpBombCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - cbMagicIndex - 1];

							if (cbTmpCount == cbBombCardCount) break;
						}

						if (cbTmpCount == cbBombCardCount)
						{
							//设置变量
							CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpBombCard, sizeof(uint8)*cbTmpCount);
							pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
							cbResultCount++;
						}
					}
				}
			}
		}
		
	}
	else
	{
		bool isJokerBomb = (cbReferCount == 4 && IsHasCardType(iReferCardType, DZ_CT_BOMB_8));

		// 不带癞子，王炸最大;
		if (!isJokerBomb)
		{
			// 不带癞子搜索(4~8张);
			for (uint8 cbBombCardCount = cbReferCount; cbBombCardCount < 8; cbBombCardCount++)
			{
				uint8 i = cbMinIndex;
				if (cbBombCardCount == cbReferCount)
				{
					i = cbTurnLogicValue;
				}

				for (; i <= cbMaxIndex; i++)
				{
					if (Distributing.cbDistributing[i][cbIndexCount] == cbBombCardCount)
					{
						uint8 cbTmpCount = 0;
						uint8 cbTmpBombCard[12] = { 0 };

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

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

			// 不带癞子搜索(4~12张);
			if (cbMagicCardCount > 0)
			{
				for (uint8 cbBombCardCount = cbReferCount; cbBombCardCount < 12; cbBombCardCount++)
				{
					uint8 i = cbMinIndex;
					if (cbBombCardCount == cbReferCount)
					{
						i = cbTurnLogicValue;
					}

					for (; i <= cbMaxIndex; i++)
					{
						// 没有牌不变幻;
						if (Distributing.cbDistributing[i][cbIndexCount] <= 0) continue;

						if ((Distributing.cbDistributing[i][cbIndexCount] + cbMagicCardCount) == cbBombCardCount)
						{
							uint8 cbTmpCount = 0;
							uint8 cbTmpBombCard[12] = { 0 };

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

							// 复制癞子;
							for (uint8 cbMagicIndex = 0; cbMagicIndex < cbMagicCardCount; cbMagicIndex++)
							{
								// 从小到大;
								cbTmpBombCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - cbMagicIndex - 1];

								if (cbTmpCount == cbBombCardCount) break;
							}

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

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

	return cbResultCount;
}

//构造扑克
uint8 DZ_CGameLogic::MakeCardData(uint8 cbLogicValue, uint8 cbColorIndex)
{
	uint8 cbCardColor = (cbColorIndex << 4);

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

	return (cbCardColor | cbLogicValue);
}