Files

425 lines
11 KiB
C++
Raw Permalink Normal View History

2026-03-03 13:56:44 +08:00
#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));
//<2F><><EFBFBD><EFBFBD><EFBFBD>˿<EFBFBD>
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]);
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
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);
}
//<2F><>ȡϲǮ;
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]);
//<2F><><EFBFBD>η<EFBFBD><CEB7><EFBFBD>
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++;
}
}
//<2F><><EFBFBD><EFBFBD>
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;
}
}
//<2F><><EFBFBD><EFBFBD>235
if (bFindCard235[0] && bFindCard235[1] && bFindCard235[2])
{
b235Card = true;
}
//<2F><><EFBFBD><EFBFBD>A32
if (!bLineCard && bFindCard123[0] && bFindCard123[1] && bFindCard123[2])
{
bLineCard = true;
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (cbSameCount == MAX_COUNT) return CT_BAO_ZI;
//˳<><CBB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (bSameColor && bLineCard) return CT_SHUN_JIN;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (bSameColor && !bLineCard) return CT_JIN_HUA;
//˳<><CBB3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (!bSameColor && bLineCard) return CT_SHUN_ZI;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (cbSameCount==MAX_COUNT-1 || GetCardValue(cbTempList[1])==GetCardValue(cbTempList[2])) return CT_DOUBLE;
//<2F><><EFBFBD><EFBFBD>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;
//<2F><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>
BYTE cbFirstTemp[MAX_COUNT] = { 0 };
CopyMemory(cbFirstTemp, cbFirstData, sizeof(cbFirstTemp));
SortCardList(cbFirstTemp, cbCardCount);
BYTE cbFirstType = GetCardType(cbFirstTemp, cbCardCount);
BYTE cbFirstColor = GetCardColor(cbFirstTemp[0]);
//<2F>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD>
BYTE cbNextTemp[MAX_COUNT] = { 0 };
CopyMemory(cbNextTemp, cbNextData, sizeof(cbNextTemp));
SortCardList(cbNextTemp, cbCardCount);
BYTE cbNextType = GetCardType(cbNextTemp, cbCardCount);
BYTE cbNextColor = GetCardColor(cbNextTemp[0]);
//235 > <20><><EFBFBD><EFBFBD>
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;
}
//ϵͳ<CFB5>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD>;
bool CGameLogic::AutoCompareCard(BYTE cbFirstData[], BYTE cbNextData[], BYTE cbCardCount)
{
ASSERT(MAX_COUNT == cbCardCount);
if (MAX_COUNT != cbCardCount) return false;
//<2F><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>
BYTE cbFirstTemp[MAX_COUNT] = { 0 };
CopyMemory(cbFirstTemp, cbFirstData, sizeof(cbFirstTemp));
SortCardList(cbFirstTemp, cbCardCount);
BYTE cbFirstType = GetCardType(cbFirstTemp, cbCardCount);
BYTE cbFirstColor = GetCardColor(cbFirstTemp[0]);
//<2F>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD>
BYTE cbNextTemp[MAX_COUNT] = { 0 };
CopyMemory(cbNextTemp, cbNextData, sizeof(cbNextTemp));
SortCardList(cbNextTemp, cbCardCount);
BYTE cbNextType = GetCardType(cbNextTemp, cbCardCount);
BYTE cbNextColor = GetCardColor(cbNextTemp[0]);
//235 > <20><><EFBFBD><EFBFBD>
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;
}
}
// <20><>ֵ<EFBFBD><D6B5>ͬ<EFBFBD>Ȼ<EFBFBD>ɫ;
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;
}
// <20><>ֵ<EFBFBD><D6B5>ͬ<EFBFBD>Ȼ<EFBFBD>ɫ;
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]));
}
// <20>ȶ<EFBFBD><C8B6>Ӵ<EFBFBD>С;
if (cbNextValue2 != cbFirstValue2)
{
return (cbFirstValue2 > cbNextValue2) ? true : false;
}
// <20>ȵ<EFBFBD><C8B5>ƴ<EFBFBD>С;
if (cbNextValue1 != cbFirstValue1)
{
return (cbFirstValue1 > cbNextValue1) ? true : false;
}
// <20>ȶ<EFBFBD><C8B6><EFBFBD><EFBFBD>л<EFBFBD>ɫ;
return (cbFirstColor1 > cbNextColor2) ? true : false;
}
}
return false;
}