284 lines
7.1 KiB
C++
284 lines
7.1 KiB
C++
#include "NN_GameLogic.h"
|
|
|
|
bool CNNGameLogic::IsValidCard(uint8 cbCard)
|
|
{
|
|
const uint8 cbColor = GetCardColorEx(cbCard);
|
|
const uint8 cbValue = GetCardValue(cbCard);
|
|
return (cbColor<=3 && cbValue>=0x01 && cbValue<=0x0D) ? true : false;
|
|
}
|
|
|
|
uint8 CNNGameLogic::GetLogicValue(uint8 cbCard)
|
|
{
|
|
CC_ASSERT(IsValidCard(cbCard));
|
|
const uint8 cbValue = GetCardValue(cbCard);
|
|
return (cbValue>10) ? 10 : cbValue;
|
|
}
|
|
|
|
void CNNGameLogic::SortCardList(uint8 cbCardData[], uint8 cbCardCount)
|
|
{
|
|
CC_ASSERT((NN_MAX_COUNT - 2) == cbCardCount || NN_MAX_COUNT == cbCardCount);
|
|
if ((NN_MAX_COUNT - 2) != cbCardCount || NN_MAX_COUNT != cbCardCount) return;
|
|
|
|
uint8 cbCardValue[NN_MAX_COUNT] = { 0 };
|
|
for (uint8 i=0; i<cbCardCount; ++i)
|
|
{
|
|
cbCardValue[i] = GetCardValue(cbCardData[i]);
|
|
}
|
|
|
|
bool bSorted = true;
|
|
uint8 cbTempData = 0;
|
|
uint8 cbLast = cbCardCount - 1;
|
|
do
|
|
{
|
|
bSorted = true;
|
|
for (uint8 i = 0; i < cbLast; ++i)
|
|
{
|
|
if ((cbCardValue[i] < cbCardValue[i + 1]) || (cbCardValue[i] == cbCardValue[i + 1] && cbCardData[i] < cbCardData[i + 1]))
|
|
{
|
|
cbTempData = cbCardData[i];
|
|
cbCardData[i] = cbCardData[i + 1];
|
|
cbCardData[i + 1] = cbTempData;
|
|
cbTempData = cbCardValue[i];
|
|
cbCardValue[i] = cbCardValue[i + 1];
|
|
cbCardValue[i + 1] = cbTempData;
|
|
bSorted = false;
|
|
}
|
|
}
|
|
cbLast--;
|
|
} while (!bSorted);
|
|
}
|
|
|
|
bool CNNGameLogic::RemoveCard(uint8 cbCardData[], uint8 cbCardCount, uint8 cbRemoveCard[], uint8 cbRemoveCount)
|
|
{
|
|
CC_ASSERT(cbRemoveCount <= cbCardCount);
|
|
if (cbRemoveCount > cbCardCount) return false;
|
|
|
|
uint8 cbDeleteCount = 0, cbDeleteCard[NN_FULL_COUNT] = { 0 };
|
|
CC_ASSERT(cbCardCount <= sizeof(cbDeleteCard) / sizeof(cbDeleteCard[0]));
|
|
if (cbCardCount > sizeof(cbDeleteCard) / sizeof(cbDeleteCard[0])) return false;
|
|
memcpy(cbDeleteCard, cbCardData, sizeof(cbCardData[0])*cbCardCount);
|
|
|
|
for (uint8 i = 0; i < cbRemoveCount; ++i)
|
|
{
|
|
for (uint8 j = 0; j < cbCardCount; ++j)
|
|
{
|
|
if (cbRemoveCard[i] == cbDeleteCard[j])
|
|
{
|
|
cbDeleteCount++;
|
|
cbDeleteCard[j] = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
CC_ASSERT(cbDeleteCount == cbRemoveCount);
|
|
if (cbDeleteCount != cbRemoveCount) return false;
|
|
|
|
uint8 cbCardPos = 0;
|
|
for (uint8 i = 0; i < cbCardCount; ++i)
|
|
{
|
|
if (0 != cbDeleteCard[i])
|
|
{
|
|
cbCardData[cbCardPos++] = cbDeleteCard[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
uint8 CNNGameLogic::GetCardType(const uint8 cbCardData[], const uint8 cbCardCount, uint8 cbSortCard[])
|
|
{
|
|
CC_ASSERT((NN_MAX_COUNT - 2) == cbCardCount || NN_MAX_COUNT == cbCardCount);
|
|
|
|
uint8 cbTempData[NN_MAX_COUNT] = { 0 };
|
|
memcpy(cbTempData, cbCardData, sizeof(uint8)*cbCardCount);
|
|
|
|
if (NN_MAX_COUNT == cbCardCount && IsWuHuaNiu(cbTempData, cbCardCount))
|
|
{
|
|
if (nullptr != cbSortCard)
|
|
{
|
|
memcpy(cbSortCard, cbCardData, sizeof(uint8)*cbCardCount);
|
|
}
|
|
return NIU_TYPE_WHN;
|
|
}
|
|
if (NN_MAX_COUNT == cbCardCount && IsWuXiaoNiu(cbTempData, cbCardCount))
|
|
{
|
|
if (nullptr != cbSortCard)
|
|
{
|
|
memcpy(cbSortCard, cbCardData, sizeof(uint8)*cbCardCount);
|
|
}
|
|
return NIU_TYPE_WXN;
|
|
}
|
|
if (NN_MAX_COUNT == cbCardCount && IsZhaDan(cbTempData, cbCardCount))
|
|
{
|
|
if (nullptr != cbSortCard)
|
|
{
|
|
CopyMemory(cbSortCard, cbCardData, sizeof(BYTE)*cbCardCount);
|
|
}
|
|
return NIU_TYPE_SHN;
|
|
}
|
|
|
|
uint8 cbValueSum = 0;
|
|
uint8 cbLogicValue[NN_MAX_COUNT] = { 0 };
|
|
for (uint8 i = 0; i < cbCardCount; ++i)
|
|
{
|
|
cbLogicValue[i] = GetLogicValue(cbTempData[i]);
|
|
cbValueSum += cbLogicValue[i];
|
|
}
|
|
|
|
if ((NN_MAX_COUNT - 2) == cbCardCount)
|
|
{
|
|
for (uint8 i = 0; i < cbCardCount; ++i)
|
|
{
|
|
if (0 == (cbValueSum - cbLogicValue[i]) % 10)
|
|
{
|
|
if (nullptr != cbSortCard)
|
|
{
|
|
memcpy(cbSortCard, cbTempData, sizeof(uint8)*cbCardCount);
|
|
if (false==RemoveCard(cbSortCard, cbCardCount, &cbTempData[i], 1))
|
|
{
|
|
CC_ASSERT(false);
|
|
return NIU_TYPE_0;
|
|
}
|
|
cbSortCard[cbCardCount - 1] = cbTempData[i];
|
|
}
|
|
return cbLogicValue[i];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8 i=0; i<cbCardCount-1; ++i)
|
|
{
|
|
for (uint8 j=i+1; j<cbCardCount; ++j)
|
|
{
|
|
uint8 cbCowValue = cbLogicValue[i] + cbLogicValue[j];
|
|
if (0 == (cbValueSum-cbCowValue)%10)
|
|
{
|
|
if (nullptr != cbSortCard)
|
|
{
|
|
uint8 cbDeleteCard[2] = { cbTempData[i],cbTempData[j] };
|
|
memcpy(cbSortCard, cbTempData, sizeof(uint8)*cbCardCount);
|
|
if (false == RemoveCard(cbSortCard, cbCardCount, cbDeleteCard, 2))
|
|
{
|
|
CC_ASSERT(false);
|
|
return NIU_TYPE_0;
|
|
}
|
|
cbSortCard[cbCardCount-2] = cbTempData[i];
|
|
cbSortCard[cbCardCount-1] = cbTempData[j];
|
|
}
|
|
return (cbCowValue>10) ? cbCowValue-10 : cbCowValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nullptr != cbSortCard)
|
|
{
|
|
memcpy(cbSortCard, cbCardData, sizeof(uint8)*cbCardCount);
|
|
}
|
|
return NIU_TYPE_0;
|
|
}
|
|
|
|
uint8 CNNGameLogic::GetWinNiuFan(const uint8 cbCardType)
|
|
{
|
|
switch (cbCardType)
|
|
{
|
|
case NIU_TYPE_WXN:
|
|
return 6;
|
|
case NIU_TYPE_SHN:
|
|
return 5;
|
|
case NIU_TYPE_WHN:
|
|
return 4;
|
|
case NIU_TYPE_10:
|
|
return 3;
|
|
case NIU_TYPE_9:
|
|
case NIU_TYPE_8:
|
|
return 2;
|
|
}
|
|
|
|
CC_ASSERT(cbCardType>=NIU_TYPE_0 && cbCardType<=NIU_TYPE_7);
|
|
return 1;
|
|
}
|
|
|
|
uint8 CNNGameLogic::GetMaxCard(const uint8 cbCardData[], const uint8 cbCardCount)
|
|
{
|
|
uint8 cbTempData[NN_MAX_COUNT] = { 0 };
|
|
memcpy(cbTempData, cbCardData, sizeof(uint8)*cbCardCount);
|
|
SortCardList(cbTempData, cbCardCount);
|
|
return cbTempData[0];
|
|
}
|
|
|
|
bool CNNGameLogic::CompareCard(const tagOpenCardRlt stFirstData, const tagOpenCardRlt stNextData)
|
|
{
|
|
if (stFirstData.cbCardType != stNextData.cbCardType)
|
|
{
|
|
return (stFirstData.cbCardType > stNextData.cbCardType) ? true : false;
|
|
}
|
|
uint8 cbFirstValue = GetCardValue(stFirstData.cbMaxCard);
|
|
uint8 cbNextValue = GetCardValue(stNextData.cbMaxCard);
|
|
if (cbFirstValue != cbNextValue)
|
|
{
|
|
return (cbFirstValue > cbNextValue) ? true : false;
|
|
}
|
|
uint8 cbFirstColor = GetCardColorEx(stFirstData.cbMaxCard);
|
|
uint8 cbNextColor = GetCardColorEx(stNextData.cbMaxCard);
|
|
return (cbFirstColor > cbNextColor) ? true : false;
|
|
}
|
|
|
|
bool CNNGameLogic::IsWuHuaNiu(const uint8 cbCardData[], const uint8 cbCardCount)
|
|
{
|
|
CC_ASSERT(NN_MAX_COUNT == cbCardCount || (NN_MAX_COUNT - 2) == cbCardCount);
|
|
if (NN_MAX_COUNT != cbCardCount && (NN_MAX_COUNT - 2) != cbCardCount) return false;
|
|
|
|
for (uint8 i=0; i<cbCardCount; ++i)
|
|
{
|
|
uint8 cbCardValue = GetCardValue(cbCardData[i]);
|
|
if (cbCardValue < 11) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CNNGameLogic::IsWuXiaoNiu(const uint8 cbCardData[], const uint8 cbCardCount)
|
|
{
|
|
CC_ASSERT(NN_MAX_COUNT == cbCardCount || (NN_MAX_COUNT - 2) == cbCardCount);
|
|
if (NN_MAX_COUNT != cbCardCount && (NN_MAX_COUNT - 2) != cbCardCount) return false;
|
|
|
|
uint8 cbValueSum = 0;
|
|
for (uint8 i=0; i<cbCardCount; ++i)
|
|
{
|
|
uint8 cbCardValue = GetCardValue(cbCardData[i]);
|
|
if (cbCardValue >= 5)
|
|
{
|
|
return false;
|
|
}
|
|
cbValueSum += cbCardValue;
|
|
}
|
|
|
|
return (cbValueSum<=10) ? true : false;
|
|
}
|
|
|
|
//ĘǡńĘÇŐ¨ľŻ;
|
|
bool CNNGameLogic::IsZhaDan(const BYTE cbCardData[], const BYTE cbCardCount)
|
|
{
|
|
ASSERT(NN_MAX_COUNT == cbCardCount || (NN_MAX_COUNT - 2) == cbCardCount);
|
|
if (NN_MAX_COUNT != cbCardCount && (NN_MAX_COUNT - 2) != cbCardCount) return false;
|
|
|
|
BYTE aryCardCount[14] = { 0 };
|
|
|
|
for (BYTE i = 0; i < cbCardCount; ++i)
|
|
{
|
|
BYTE cbCardValue = GetCardValue(cbCardData[i]);
|
|
aryCardCount[cbCardValue]++;
|
|
}
|
|
|
|
for (BYTE j = 0; j < 14; j++)
|
|
{
|
|
if (4 == aryCardCount[j])
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|