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

BYTE CGameLogic::m_cbCardListData[FULL_COUNT] =
{
	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,	
	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,	
	0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D	
};

bool CGameLogic::IsValidCard(BYTE cbCard)
{
	BYTE cbCardValue = GetCardValue(cbCard);
	BYTE cbCardColor = GetCardColor(cbCard)>>4;
	if ((cbCardValue>=1&&cbCardValue<=13) && (cbCardColor>=0&&cbCardColor<=3))
	{
		return true;
	}
	ASSERT(0);
	return false;
}

void CGameLogic::RandCardList(BYTE cbCardBuffer[], BYTE cbBufferCount)
{
	BYTE cbCardData[CountArray(m_cbCardListData)];
	CopyMemory(cbCardData, m_cbCardListData, sizeof(m_cbCardListData));

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

void CGameLogic::SortCardList(BYTE cbCardBuffer[], const BYTE cbBufferCount)
{
	VERIFY_RETURN_VOID(cbBufferCount==MAX_COUNT);

	BYTE cbLogicValue[MAX_COUNT] = { 0 };
	for (BYTE i=0; i<cbBufferCount; i++)
	{
		cbLogicValue[i] = GetCardLogicValue(cbCardBuffer[i]);
	}
	//排序操作
	bool bSorted = true;
	BYTE bSwapData=0, bLast=cbBufferCount-1;
	do
	{
		bSorted = true;
		for (BYTE i=0; i<bLast; ++i)
		{
			if ((cbLogicValue[i]<cbLogicValue[i+1]) || (cbLogicValue[i]==cbLogicValue[i+1]&&cbCardBuffer[i]<cbCardBuffer[i+1]))
			{
				bSwapData = cbCardBuffer[i];
				cbCardBuffer[i] = cbCardBuffer[i+1];
				cbCardBuffer[i+1] = bSwapData;
				bSwapData = cbLogicValue[i];
				cbLogicValue[i] = cbLogicValue[i+1];
				cbLogicValue[i+1] = bSwapData;
				bSorted = false;
			}
		}
		bLast--;
	} while (!bSorted);
}

//获取喜钱;
int CGameLogic::GetXiScore(BYTE cbCardType, BYTE cbCardData)
{
	if (CT_BAO_ZI==cbCardType)
	{
		BYTE cbCardValue = GetCardValue(cbCardData);
		if (0x01==cbCardValue)
		{
			return 10;
		}
		else
		{
			return 5;
		}
	}
	else if (CT_SHUN_JIN == cbCardType)
	{
		return 3;
	}

	return 0;
}

BYTE CGameLogic::GetCardLogicValue(BYTE cbCard)
{
	if (!IsValidCard(cbCard)) return 0;

	BYTE cbValue = GetCardValue(cbCard);
	return (cbValue == 1) ? (cbValue + 13) : cbValue;
}

BYTE CGameLogic::GetCardType(BYTE cbCardData[], BYTE cbCardCount)
{
	ASSERT(cbCardCount == MAX_COUNT);
	if (MAX_COUNT != cbCardCount) return CT_ERROR;

	BYTE cbTempList[MAX_COUNT] = { 0 };
	CopyMemory(cbTempList, cbCardData, sizeof(BYTE)*MAX_COUNT);
	SortCardList(cbTempList, cbCardCount);

	if (cbCardCount == MAX_COUNT)
	{
		BYTE cbSameCount = 1;
		bool b235Card=false, bLineCard=true, bSameColor=true;
		BYTE cbFirstColor = GetCardColor(cbTempList[0]);
		BYTE cbFirstValue = GetCardLogicValue(cbTempList[0]);
		//牌形分析
		for (BYTE i=1; i<cbCardCount; ++i)
		{
			BYTE cbNextColor = GetCardColor(cbTempList[i]);
			BYTE cbNextValue = GetCardLogicValue(cbTempList[i]);
			if (cbNextColor != cbFirstColor)
			{
				bSameColor = false;
			}
			if (cbFirstValue != (cbNextValue + i))
			{
				bLineCard = false;
			}
			if (cbFirstValue == cbNextValue)
			{
				cbSameCount++;
			}
		}
		//特殊
		bool bFindCard123[3] = { false, false, false };
		bool bFindCard235[3] = { false, false, false };
		for (BYTE i=0; i<cbCardCount; ++i)
		{
			BYTE cbCardValue = GetCardValue(cbTempList[i]);
			if (1 == cbCardValue)
			{
				bFindCard123[0] = true;
			}
			else if (2 == cbCardValue)
			{
				bFindCard123[1] = true;
				bFindCard235[0] = true;
			}
			else if (3 == cbCardValue)
			{
				bFindCard123[2] = true;
				bFindCard235[1] = true;
			}
			else if (5 == cbCardValue)
			{
				bFindCard235[2] = true;
			}
		}
		//特殊235
		if (bFindCard235[0] && bFindCard235[1] && bFindCard235[2])
		{
			b235Card = true;
		}
		//特殊A32
		if (!bLineCard && bFindCard123[0] && bFindCard123[1] && bFindCard123[2])
		{
			bLineCard = true;
		}
		//豹子类型
		if (cbSameCount == MAX_COUNT) return CT_BAO_ZI;
		//顺金类型
		if (bSameColor && bLineCard)  return CT_SHUN_JIN;
		//金花类型
		if (bSameColor && !bLineCard) return CT_JIN_HUA;
		//顺子类型
		if (!bSameColor && bLineCard) return CT_SHUN_ZI;
		//对子类型
		if (cbSameCount==MAX_COUNT-1 || GetCardValue(cbTempList[1])==GetCardValue(cbTempList[2])) return CT_DOUBLE;
		//特殊235
		//if (b235Card && !bSameColor) return CT_SPECIAL;

		return CT_SINGLE;
	}

	return CT_ERROR;
}

bool CGameLogic::CompareCard(BYTE cbFirstData[], BYTE cbNextData[], BYTE cbCardCount)
{
	ASSERT(MAX_COUNT == cbCardCount);
	if (MAX_COUNT != cbCardCount) return false;

	//第一组牌
	BYTE cbFirstTemp[MAX_COUNT] = { 0 };
	CopyMemory(cbFirstTemp, cbFirstData, sizeof(cbFirstTemp));
	SortCardList(cbFirstTemp, cbCardCount);
	BYTE cbFirstType = GetCardType(cbFirstTemp, cbCardCount);
	BYTE cbFirstColor = GetCardColor(cbFirstTemp[0]);

	//第二组牌
	BYTE cbNextTemp[MAX_COUNT] = { 0 };
	CopyMemory(cbNextTemp, cbNextData, sizeof(cbNextTemp));
	SortCardList(cbNextTemp, cbCardCount);
	BYTE cbNextType = GetCardType(cbNextTemp, cbCardCount);
	BYTE cbNextColor = GetCardColor(cbNextTemp[0]);

	//235 > 豹子
	if ((cbNextType+cbFirstType) == (CT_SPECIAL+CT_BAO_ZI))
	{
		return (cbFirstType>cbNextType) ? true : false;
	}
	if (cbNextType == CT_SPECIAL) cbNextType = CT_SINGLE;
	if (cbFirstType == CT_SPECIAL) cbFirstType = CT_SINGLE;
	if (cbFirstType != cbNextType)
	{
		return (cbFirstType>cbNextType) ? true : false;
	}

	switch (cbFirstType)
	{
	case CT_BAO_ZI:
	case CT_SINGLE:
	case CT_JIN_HUA:
		{
			for (BYTE i=0; i<cbCardCount; ++i)
			{
				BYTE cbNextValue = GetCardLogicValue(cbNextTemp[i]);
				BYTE cbFirstValue = GetCardLogicValue(cbFirstTemp[i]);
				if (cbFirstValue != cbNextValue)
				{
					return (cbFirstValue>cbNextValue) ? true : false;
				}
			}

			return false;
		}
	case CT_SHUN_ZI:
	case CT_SHUN_JIN:
		{
			BYTE cbNextValue = GetCardLogicValue(cbNextTemp[0]);
			BYTE cbFirstValue = GetCardLogicValue(cbFirstTemp[0]);
			if (cbNextValue==14 && GetCardLogicValue(cbNextTemp[cbCardCount-1])==2)
			{
				cbNextValue = 3;
				cbNextColor = GetCardColor(cbNextTemp[1]);
			}
			if (cbFirstValue==14 && GetCardLogicValue(cbFirstTemp[cbCardCount-1])==2)
			{
				cbFirstValue = 3;
				cbFirstColor = GetCardColor(cbFirstTemp[1]);
			}
			if (cbFirstValue != cbNextValue)
			{
				return (cbFirstValue>cbNextValue) ? true : false;
			}
			return false;
		}
	case CT_DOUBLE:
		{
			BYTE cbNextValue = GetCardLogicValue(cbNextTemp[0]);
			BYTE cbFirstValue = GetCardLogicValue(cbFirstTemp[0]);
			BYTE cbNextValue2=0, cbNextValue1=0, cbFirstValue2=0, cbFirstValue1=0;
			BYTE cbNextColor2=0x00, cbFirstColor1=0x00;
			if (cbNextValue == GetCardLogicValue(cbNextTemp[1]))
			{
				cbNextValue2 = cbNextValue;
				cbNextValue1 = GetCardLogicValue(cbNextTemp[2]);
				cbNextColor2 = max(GetCardColor(cbNextTemp[0]), GetCardColor(cbNextTemp[1]));
			}
			else
			{
				cbNextValue2 = GetCardLogicValue(cbNextTemp[2]);
				cbNextValue1 = cbNextValue;
				cbNextColor2 = max(GetCardColor(cbNextTemp[1]), GetCardColor(cbNextTemp[2]));
			}
			if (cbFirstValue == GetCardLogicValue(cbFirstTemp[1]))
			{
				cbFirstValue2 = cbFirstValue;
				cbFirstValue1 = GetCardLogicValue(cbFirstTemp[2]);
				cbFirstColor1 = max(GetCardColor(cbFirstTemp[0]), GetCardColor(cbFirstTemp[1]));
			}
			else
			{
				cbFirstValue2 = GetCardLogicValue(cbFirstTemp[2]);
				cbFirstValue1 = cbFirstValue;
				cbFirstColor1 = max(GetCardColor(cbFirstTemp[1]), GetCardColor(cbFirstTemp[2]));
			}

			if (cbNextValue2 != cbFirstValue2)
			{
				return (cbFirstValue2>cbNextValue2) ? true : false;
			}
			if (cbNextValue1 != cbFirstValue1)
			{
				return (cbFirstValue1>cbNextValue1) ? true : false;
			}
			return false;
		}
	}
	return false;
}

//系统自动开牌;
bool CGameLogic::AutoCompareCard(BYTE cbFirstData[], BYTE cbNextData[], BYTE cbCardCount)
{
	ASSERT(MAX_COUNT == cbCardCount);
	if (MAX_COUNT != cbCardCount) return false;

	//第一组牌
	BYTE cbFirstTemp[MAX_COUNT] = { 0 };
	CopyMemory(cbFirstTemp, cbFirstData, sizeof(cbFirstTemp));
	SortCardList(cbFirstTemp, cbCardCount);
	BYTE cbFirstType = GetCardType(cbFirstTemp, cbCardCount);
	BYTE cbFirstColor = GetCardColor(cbFirstTemp[0]);

	//第二组牌
	BYTE cbNextTemp[MAX_COUNT] = { 0 };
	CopyMemory(cbNextTemp, cbNextData, sizeof(cbNextTemp));
	SortCardList(cbNextTemp, cbCardCount);
	BYTE cbNextType = GetCardType(cbNextTemp, cbCardCount);
	BYTE cbNextColor = GetCardColor(cbNextTemp[0]);

	//235 > 豹子
	if ((cbNextType + cbFirstType) == (CT_SPECIAL + CT_BAO_ZI))
	{
		return (cbFirstType > cbNextType) ? true : false;
	}
	if (cbNextType == CT_SPECIAL) cbNextType = CT_SINGLE;
	if (cbFirstType == CT_SPECIAL) cbFirstType = CT_SINGLE;
	if (cbFirstType != cbNextType)
	{
		return (cbFirstType > cbNextType) ? true : false;
	}

	switch (cbFirstType)
	{
	case CT_BAO_ZI:
	case CT_SINGLE:
	case CT_JIN_HUA:
	{
		for (BYTE i = 0; i < cbCardCount; ++i)
		{
			BYTE cbNextValue = GetCardLogicValue(cbNextTemp[i]);
			BYTE cbFirstValue = GetCardLogicValue(cbFirstTemp[i]);
			if (cbFirstValue != cbNextValue)
			{
				return (cbFirstValue > cbNextValue) ? true : false;
			}
		}

		// 牌值相同比花色;
		return (cbFirstColor > cbNextColor) ? true : false;
	}
	case CT_SHUN_ZI:
	case CT_SHUN_JIN:
	{
		BYTE cbNextValue = GetCardLogicValue(cbNextTemp[0]);
		BYTE cbFirstValue = GetCardLogicValue(cbFirstTemp[0]);
		if (cbNextValue == 14 && GetCardLogicValue(cbNextTemp[cbCardCount - 1]) == 2)
		{
			cbNextValue = 3;
			cbNextColor = GetCardColor(cbNextTemp[1]);
		}
		if (cbFirstValue == 14 && GetCardLogicValue(cbFirstTemp[cbCardCount - 1]) == 2)
		{
			cbFirstValue = 3;
			cbFirstColor = GetCardColor(cbFirstTemp[1]);
		}
		if (cbFirstValue != cbNextValue)
		{
			return (cbFirstValue > cbNextValue) ? true : false;
		}

		// 牌值相同比花色;
		return (cbFirstColor > cbNextColor) ? true : false;
	}
	case CT_DOUBLE:
	{
		BYTE cbNextValue = GetCardLogicValue(cbNextTemp[0]);
		BYTE cbFirstValue = GetCardLogicValue(cbFirstTemp[0]);
		BYTE cbNextValue2 = 0, cbNextValue1 = 0, cbFirstValue2 = 0, cbFirstValue1 = 0;
		BYTE cbNextColor2 = 0x00, cbFirstColor1 = 0x00;
		if (cbNextValue == GetCardLogicValue(cbNextTemp[1]))
		{
			cbNextValue2 = cbNextValue;
			cbNextValue1 = GetCardLogicValue(cbNextTemp[2]);
			cbNextColor2 = max(GetCardColor(cbNextTemp[0]), GetCardColor(cbNextTemp[1]));
		}
		else
		{
			cbNextValue2 = GetCardLogicValue(cbNextTemp[2]);
			cbNextValue1 = cbNextValue;
			cbNextColor2 = max(GetCardColor(cbNextTemp[1]), GetCardColor(cbNextTemp[2]));
		}
		if (cbFirstValue == GetCardLogicValue(cbFirstTemp[1]))
		{
			cbFirstValue2 = cbFirstValue;
			cbFirstValue1 = GetCardLogicValue(cbFirstTemp[2]);
			cbFirstColor1 = max(GetCardColor(cbFirstTemp[0]), GetCardColor(cbFirstTemp[1]));
		}
		else
		{
			cbFirstValue2 = GetCardLogicValue(cbFirstTemp[2]);
			cbFirstValue1 = cbFirstValue;
			cbFirstColor1 = max(GetCardColor(cbFirstTemp[1]), GetCardColor(cbFirstTemp[2]));
		}

		// 比对子大小;
		if (cbNextValue2 != cbFirstValue2)
		{
			return (cbFirstValue2 > cbNextValue2) ? true : false;
		}
		// 比单牌大小;
		if (cbNextValue1 != cbFirstValue1)
		{
			return (cbFirstValue1 > cbNextValue1) ? true : false;
		}

		// 比对子中花色;
		return (cbFirstColor1 > cbNextColor2) ? true : false;
	}
	}
	return false;
}