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

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

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

//扑克数据
const BYTE	CGameLogic::m_cbCardData[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 BYTE	CGameLogic::m_cbNoJokerCardData[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
};

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

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

}

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

}

int CGameLogic::GetCardType(const BYTE cbCardData[], BYTE cbCardCount, bool isLastCard)
{
	//简单牌型
	switch (cbCardCount)
	{
	case 0:	//空牌
		{
			return CT_ERROR;
		}
	case 1: //单牌
		{
			return TransListToInt(0,CT_SINGLE);
		}
	case 2:	//对牌火箭
		{
			//牌型判断
			//if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return TransListToInt(0,CT_MISSILE_CARD);
			if (GetCardLogicValue(cbCardData[0])==GetCardLogicValue(cbCardData[1])) return TransListToInt(0,CT_DOUBLE);

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

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

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

	int dCardType = CT_ERROR;

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

		// 大小排序王在最前面;
		BYTE cbValue = GetCardValue(cbCardData[cbCardCount - 1]);
		for (BYTE 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, CT_THREE_TAKE_TWO);
			}

			BYTE cbCardType = CT_BOMB_4 + cbCardCount - 4;
			cbCardType = (cbCardType > CT_BOMB_10) ? CT_BOMB_10 : cbCardType;
			dCardType = TransListToInt(dCardType, cbCardType);

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

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

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

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

		//分析扑克
		tagAnalyseResult AnalyseResult;
		ZeroMemory(&AnalyseResult, sizeof(AnalyseResult));
		AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);

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

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

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

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

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

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

								//四张赖子
								if (cbMagicCardCount == 4)
								{
									for (BYTE 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);
										BYTE cbMaxCardData = 0, 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);
									BYTE cbMaxCardData = 0, 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);
							BYTE cbMaxCardData = 0, 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);
					BYTE cbMaxCardData = 0, 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 CGameLogic::GetType(tagAnalyseResult& AnalyseResult, const BYTE cbCardData[], BYTE cbCardCount, BYTE& cbMaxCardData, BYTE &cbBlockCount, bool isLastCard)
{
	// 重置牌值;
	cbMaxCardData = 0x0;
	cbBlockCount = 0x0;

	//简单牌型
	switch (cbCardCount)
	{
	case 0:	//空牌
	{
		return CT_ERROR;
	}
	case 1: //单牌
	{
		cbMaxCardData = cbCardData[0];
		return CT_SINGLE;
	}
	case 2:	//对牌火箭
	{
		//牌型判断
		//if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return TransListToInt(0,CT_MISSILE_CARD);
		if (GetCardLogicValue(cbCardData[0]) == GetCardLogicValue(cbCardData[1]))
		{
			cbMaxCardData = cbCardData[0];
			return 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 CT_DOUBLE;
				}
			}
		}

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

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

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

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

		cbMaxCardData = cbCardData[0];

		return CT_SINGLE_LINE;
	}

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

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

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

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

		return CT_ERROR;
	}

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

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

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

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

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

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

		BYTE cbCardType = CT_ERROR;

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

		// 目前只从3取到5张相同牌(将3到5张相同的牌放到同一个数组，用来检测是不是连牌);
		for (BYTE i = BLOCK_THREE; i <= BLOCK_FOUR; 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) > 14) continue;

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

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

		BYTE cbLastValue = GetCardLogicValue(cbLineCardData[0]);
		//错误过虑(3~A)
		if (cbLastValue > 14) 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))
		{
			cbBlockCount = cbMaxThreeLength;
			cbMaxCardData = cbMaxThreeCardData;
			cbCardType = CT_THREE_LINE;
		}
		else if (!isLastCard)
		{
			// 计算几个三带二
			BYTE cbTmpBlockCount = cbCardCount / 5;
			//if (cbMaxThreeLength == cbTmpBlockCount)
			if ((cbTmpBlockCount * 5 == cbCardCount) && (cbMaxThreeLength >= cbTmpBlockCount))
			{
				cbBlockCount = cbTmpBlockCount;
				cbMaxCardData = cbMaxThreeCardData;
				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_ORDER)
	{
		//转换数值
		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);
	}
	//数目排序
	else if (cbSortType == ST_COUNT)
	{
		//变量定义
		BYTE cbCardIndex = 0;

		//分析扑克
		tagAnalyseResult AnalyseResult;
		ZeroMemory(&AnalyseResult, sizeof(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::RandCardList(BYTE cbCardBuffer[], BYTE cbBufferCount)
{
	//混乱准备
	BYTE cbCardData[CountArray(m_cbCardData)];
	CopyMemory(cbCardData,m_cbCardData,sizeof(m_cbCardData));

	//混乱扑克
	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::RandNoJokerCardList(BYTE cbCardBuffer[], BYTE cbBufferCount)
{
	//混乱准备
	BYTE cbCardData[CountArray(m_cbNoJokerCardData)];
	CopyMemory(cbCardData, m_cbNoJokerCardData, sizeof(m_cbNoJokerCardData));

	//混乱扑克
	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::RemoveCard(const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount)
{
	//检验数据
	ASSERT(cbRemoveCount<=cbCardCount);
	if(cbRemoveCount>cbCardCount)
		return false ;

	//定义变量
	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::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);

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

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

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

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

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

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

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

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

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

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

			if (cbConsultNext > cbConsultFirst)
			{
				// 重置牌型;
				pNextOutCard->cbCardType = (cbTmpNextType << CT_BOMB_4);
				return true;
			}
			else
			{
				return false;
			}

			//return cbConsultNext > cbConsultFirst;
		}
	}

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

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

	//分析扑克
	BYTE NextResult[CT_COUNT] = {0};
	BYTE FirstResult[CT_COUNT] = { 0 };

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

		if (cbNextLogicValue > cbFirstLogicValue)
		{
			// 重置牌型;
			pNextOutCard->cbCardType = (1 << CT_SINGLE);
			return true;
		}
	}
	else if ((cbNextType&(1 << CT_DOUBLE)) != 0 && cbFirstCount == cbNextCount)
	{
		if (cbFirstCount != 2) return false;

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

		if (cbNextLogicValue > cbFirstLogicValue)
		{
			// 重置牌型;
			pNextOutCard->cbCardType = (1 << CT_DOUBLE);
			return true;
		}
	}
	else if ((cbNextType&(1 << 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;
		
		BYTE cbNextBlockCount = 0, cbFirstBlockCount = 0;
		if (!AnalysebCompare(cbNextCard, cbNextCount, NextResult, cbNextBlockCount, CT_THREE_TAKE_TWO, isNextLastCard))return false;
		if (!AnalysebCompare(cbFirstCard, cbFirstCount, FirstResult, cbFirstBlockCount, CT_THREE_TAKE_TWO, isFirstLastCard))return false;

		//获取数值
		cbNextLogicValue = GetCardLogicValue(NextResult[CT_THREE_TAKE_TWO]);
		cbFirstLogicValue = GetCardLogicValue(FirstResult[CT_THREE_TAKE_TWO]);
		
		//if (cbNextLogicValue > cbFirstLogicValue) return true;
		if (cbNextLogicValue > cbFirstLogicValue)
		{
			// 重置牌型;
			pNextOutCard->cbCardType = (1 << CT_THREE_TAKE_TWO);
			return true;
		}
	}
	else if ((cbNextType&(1 << 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;
		if (cbNextLogicValue > cbFirstLogicValue)
		{
			// 重置牌型;
			pNextOutCard->cbCardType = (1 << CT_SINGLE_LINE);
			return true;
		}

	}
	else if ((cbNextType&(1 << 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;
		if (cbNextLogicValue > cbFirstLogicValue)
		{
			// 重置牌型;
			pNextOutCard->cbCardType = (1 << CT_DOUBLE_LINE);
			return true;
		}

	}
	else if ((cbNextType&(1 << 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;

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

		if (cbNextBlockCount != cbFirstBlockCount) return false;

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

		//if (cbNextLogicValue > cbFirstLogicValue) return true;
		if (cbNextLogicValue > cbFirstLogicValue)
		{
			// 重置牌型;
			pNextOutCard->cbCardType = (1 << CT_THREE_LINE);
			return true;
		}
	}

	return false;
}

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

	return bLaiZiCount;
}

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

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

	return false;
}

//分析扑克
void CGameLogic::AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
	//设置变量
	BYTE cbTmpCardData[MAX_COUNT] = { 0 };
	CopyMemory(cbTmpCardData, cbCardData, sizeof(BYTE)*cbCardCount);

	SortCardList(cbTmpCardData, cbCardCount, ST_ORDER);

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

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

			//设置变量
			cbSameCount++;
		}

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

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

	return;
}

//分析比较
bool CGameLogic::AnalysebCompare(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbMaxCardData[CT_COUNT], BYTE &cbBlockCount, int dCardType, bool isLastCard)
{
	// 重置;
	cbBlockCount = 0;
	ZeroMemory(cbMaxCardData, sizeof(cbMaxCardData));

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

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

	int dCardTypeTemp = CT_ERROR;
	dCardTypeTemp = 1 << dCardType;

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

		//分析扑克
		tagAnalyseResult AnalyseResultTemp;
		ZeroMemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

		AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);

		//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
		BYTE 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)
		{
			tagAnalyseResult AnalyseResultTemp;
			ZeroMemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));

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

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

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

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

								//四张赖子
								if (cbMagicCardCount == 4)
								{
									for (BYTE 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);
										BYTE 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);
									BYTE 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);
							BYTE 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);
					BYTE 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;
}

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

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

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

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

	return iOldType|nList;
}

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

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