#include "ZJH_GameLogic.h"

bool CZJHGameLogic::IsValidCard(uint8 cbCard)
{
	uint8 cbColor = GetCardColorEx(cbCard);
	uint8 cbValue = GetCardValue(cbCard);
	if ((cbValue >= 1 && cbValue <= 13) && (cbColor >= 0 && cbColor <= 3))
	{
		return true;
	}
	CC_ASSERT(0);
	return false;
}

//逻辑数值;
uint8 CZJHGameLogic::GetCardLogicValue(const uint8 cbCard)
{
	if (!IsValidCard(cbCard)) return 0;

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

void CZJHGameLogic::SortCardList(uint8 cbCardBuffer[], const uint8 cbBufferCount)
{
	CC_ASSERT(cbBufferCount == ZJH_MAX_COUNT);
	if (cbBufferCount != ZJH_MAX_COUNT)
	{
		return;
	}

	uint8 cbLogicValue[ZJH_MAX_COUNT] = { 0 };
	for (uint8 i = 0; i < cbBufferCount; i++)
	{
		cbLogicValue[i] = GetCardLogicValue(cbCardBuffer[i]);
	}

	//排序操作;
	bool bSorted = true;
	uint8 bSwapData = 0, bLast = cbBufferCount - 1;
	do
	{
		bSorted = true;
		for (uint8 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);
}

uint8 CZJHGameLogic::GetCardType(const uint8 cbCardData[], const uint8 cbCardCount)
{
	CC_ASSERT(cbCardCount == ZJH_MAX_COUNT);
	if (ZJH_MAX_COUNT != cbCardCount)
	{
		return ZJH_CT_ERROR;
	}

	uint8 cbTempList[ZJH_MAX_COUNT] = { 0 };
	memcpy(cbTempList, cbCardData, sizeof(uint8)*ZJH_MAX_COUNT);
	SortCardList(cbTempList, cbCardCount);

	if (cbCardCount == ZJH_MAX_COUNT)
	{
		uint8 cbSameCount = 1;
		bool b235Card = false, bLineCard = true, bSameColor = true;
		uint8 cbFirstColor = GetCardColor(cbTempList[0]);
		uint8 cbFirstValue = GetCardLogicValue(cbTempList[0]);

		//牌形分析;
		for (uint8 i = 1; i < cbCardCount; ++i)
		{
			uint8 cbNextColor = GetCardColor(cbTempList[i]);
			uint8 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 (uint8 i = 0; i < cbCardCount; ++i)
		{
			uint8 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 == ZJH_MAX_COUNT)
		{
			return ZJH_CT_BAO_ZI;
		}

		//顺金类型;
		if (bSameColor && bLineCard)
		{
			return ZJH_CT_SHUN_JIN;
		}

		//金花类型;
		if (bSameColor && !bLineCard)
		{
			return ZJH_CT_JIN_HUA;
		}

		//顺子类型;
		if (!bSameColor && bLineCard)
		{
			return ZJH_CT_SHUN_ZI;
		}

		//对子类型;
		if (cbSameCount == ZJH_MAX_COUNT - 1 || GetCardValue(cbTempList[1]) == GetCardValue(cbTempList[2]))
		{
			return ZJH_CT_DOUBLE;
		}

		//特殊235;
		if (b235Card && !bSameColor)
		{
			return ZJH_CT_SPECIAL;
		}

		return ZJH_CT_SINGLE;
	}

	return ZJH_CT_ERROR;
}

bool CZJHGameLogic::CompareCard(const uint8 cbFirstData[], const uint8 cbNextData[], const uint8 cbCardCount)
{
	CC_ASSERT(ZJH_MAX_COUNT == cbCardCount);
	if (ZJH_MAX_COUNT != cbCardCount)
	{
		return false;
	}

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

	//第二组牌;
	uint8 cbNextTemp[ZJH_MAX_COUNT] = { 0 };
	CopyMemory(cbNextTemp, cbNextData, sizeof(cbNextTemp));
	SortCardList(cbNextTemp, cbCardCount);
	uint8 cbNextType = GetCardType(cbNextTemp, cbCardCount);
	uint8 cbNextColor = GetCardColor(cbNextTemp[0]);
	//235 > 豹子
	if ((cbNextType + cbFirstType) == (ZJH_CT_SPECIAL + ZJH_CT_BAO_ZI))
	{
		return (cbFirstType > cbNextType) ? true : false;
	}

	if (cbNextType == ZJH_CT_SPECIAL)
	{
		cbNextType = ZJH_CT_SINGLE;
	}

	if (cbFirstType == ZJH_CT_SPECIAL)
	{
		cbFirstType = ZJH_CT_SINGLE;
	}

	if (cbFirstType != cbNextType)
	{
		return (cbFirstType > cbNextType) ? true : false;
	}

	switch (cbFirstType)
	{
	case ZJH_CT_BAO_ZI:
	case ZJH_CT_SINGLE:
	case ZJH_CT_JIN_HUA:
	{
		for (uint8 i = 0; i < cbCardCount; ++i)
		{
			uint8 cbNextValue = GetCardLogicValue(cbNextTemp[i]);
			uint8 cbFirstValue = GetCardLogicValue(cbFirstTemp[i]);
			if (cbFirstValue != cbNextValue)
			{
				return (cbFirstValue > cbNextValue) ? true : false;
			}
		}
		return false;
	}
	case ZJH_CT_SHUN_ZI:
	case ZJH_CT_SHUN_JIN:
	{
		uint8 cbNextValue = GetCardLogicValue(cbNextTemp[0]);
		uint8 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 ZJH_CT_DOUBLE:
	{
		uint8 cbNextValue = GetCardLogicValue(cbNextTemp[0]);
		uint8 cbFirstValue = GetCardLogicValue(cbFirstTemp[0]);
		uint8 cbNextValue2 = 0, cbNextValue1 = 0, cbFirstValue2 = 0, cbFirstValue1 = 0;
		uint8 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;
}

// 获取牌型图片路径;
std::string CZJHGameLogic::getCardTypeImagePath(uint8 cbCardType)
{
	switch (cbCardType)
	{
	case ZJH_CT_SINGLE:
		return "Games/ZJH/CardType/SanPai.png";
	case ZJH_CT_DOUBLE:
		return "Games/ZJH/CardType/YiDui.png";
	case ZJH_CT_SHUN_ZI:
		return "Games/ZJH/CardType/ShunZi.png";
	case ZJH_CT_JIN_HUA:
		return "Games/ZJH/CardType/TongHua.png";
	case ZJH_CT_SHUN_JIN:
		return "Games/ZJH/CardType/TongHuaShun.png";
	case ZJH_CT_BAO_ZI:
		return "Games/ZJH/CardType/SanTiao.png";
	default:
		break;
	}

	return "";
}

// 获取牌型声音路径;
std::string CZJHGameLogic::getCardTypeSoundPath(uint8 cbGender, uint8 cbCardType)
{
	std::string strPath = "Games/ZJH/Sound/";
	if (0==cbGender)
	{
		strPath += "man/m_";
	}
	else
	{
		strPath += "woman/f_";
	}

	switch (cbCardType)
	{
	case ZJH_CT_SINGLE:
		strPath += "wulong.mp3";
		break;
	case ZJH_CT_DOUBLE:
		strPath += "duizi.mp3";
		break;
	case ZJH_CT_SHUN_ZI:
		strPath += "shunzi.mp3";
		break;
	case ZJH_CT_JIN_HUA:
		strPath += "tonghua.mp3";
		break;
	case ZJH_CT_SHUN_JIN:
		strPath += "tonghuashun.mp3";
		break;
	case ZJH_CT_BAO_ZI:
		strPath += "santiao.mp3";
		break;
	default:
		return "";
		break;
	}

	return strPath;
}