367 lines
8.2 KiB
C++
367 lines
8.2 KiB
C++
#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;
|
|
} |