1850 lines
49 KiB
C++
1850 lines
49 KiB
C++
#include "StdAfx.h"
|
|
#include "io.h"
|
|
#include <fstream>
|
|
#include "GameLogic.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//静态变量
|
|
//扑克数据
|
|
const BYTE CGameLogic::m_cbCardData[FULL_COUNT]=
|
|
{
|
|
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D, //方块 A - K
|
|
0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D, //梅花 A - K
|
|
0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D, //红桃 A - K
|
|
0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D, //黑桃 A - K
|
|
0x4E,0x4F,
|
|
};
|
|
//好牌数据
|
|
const BYTE CGameLogic::m_cbGoodcardData[GOOD_CARD_COUNT]=
|
|
{
|
|
0x01,0x02,0x11,0x12,0x21,0x22,0x31,0x32,0x4E,0x4F,
|
|
0x07,0x08,0x09,0x17,0x18,0x19,0x27,0x28,0x29,0x37,0x38,0x39,
|
|
0x0A,0x0B,0x0C,0x0D,0x1A,0x1B,0x1C,0x1D,0x2A,0x2B,0x2C,0x2D,0x3A,0x3B,0x3C,0x3D
|
|
};
|
|
//牌库数据
|
|
std::vector<LandCardList> CGameLogic::m_vecLandCard;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//构造函数
|
|
CGameLogic::CGameLogic()
|
|
{
|
|
}
|
|
|
|
//析构函数
|
|
CGameLogic::~CGameLogic()
|
|
{
|
|
}
|
|
|
|
//加载牌库数据
|
|
void CGameLogic::LoadLandCard()
|
|
{
|
|
m_vecLandCard.clear();
|
|
int ListCount = 0;
|
|
BYTE cardbuffer[51] = {0};
|
|
if (m_vecLandCard.empty())
|
|
{
|
|
std::ostringstream ostr;
|
|
ostr.str("");
|
|
ostr << "randcard/1" << ".card";
|
|
|
|
std::ifstream ifs(ostr.str().c_str());
|
|
if (!ifs.is_open())
|
|
{
|
|
//AfxMessageBox(TEXT("Small_Path 文件未找到"),MB_OK);
|
|
return;
|
|
}
|
|
if (ifs.bad())
|
|
{
|
|
//AfxMessageBox(TEXT("Small_Path is bad! "),MB_OK);
|
|
return;
|
|
}
|
|
LandCardList LcardList;
|
|
BYTE Allcard[FULL_COUNT] = {0};
|
|
int nX1[17] = {0};
|
|
CString strBuf;
|
|
char szBuff[128] = {0};
|
|
while( !ifs.eof() )
|
|
{
|
|
ZeroMemory(szBuff,sizeof(szBuff));
|
|
ifs.getline(szBuff,sizeof(szBuff));
|
|
if (strcmp(szBuff, "(end)")==0)
|
|
{
|
|
int count1 = (int)LcardList.vecLandListCard.size();
|
|
memset(cardbuffer,0,sizeof(cardbuffer));
|
|
for (int j=0;j<count1; j++)
|
|
{
|
|
cardbuffer[j] = LcardList.vecLandListCard[j];
|
|
}
|
|
CopyMemory( Allcard, m_cbCardData, sizeof( m_cbCardData ) );
|
|
if(!RemoveAllCard(cardbuffer,51,Allcard,54))
|
|
{
|
|
strBuf.Format("第%d组牌不合格",ListCount);
|
|
OutputDebugString(strBuf);
|
|
}
|
|
else
|
|
{
|
|
m_vecLandCard.push_back(LcardList);
|
|
}
|
|
ListCount++;
|
|
LcardList.vecLandListCard.clear();
|
|
memset(cardbuffer,0,sizeof(cardbuffer));
|
|
}
|
|
else
|
|
{
|
|
ZeroMemory(nX1,sizeof(nX1));
|
|
std::sscanf(szBuff, "%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X,%X;",
|
|
&nX1[0],&nX1[1],&nX1[2],&nX1[3],&nX1[4],&nX1[5],&nX1[6],&nX1[7],&nX1[8],&nX1[9],&nX1[10],&nX1[11],&nX1[12]
|
|
,&nX1[13],&nX1[14],&nX1[15],&nX1[16]);
|
|
for(int i=0; i<17; i++)
|
|
{
|
|
LcardList.vecLandListCard.push_back((BYTE)nX1[i]);
|
|
}
|
|
}
|
|
}
|
|
strBuf.Format("合格组数;%d",m_vecLandCard.size());
|
|
OutputDebugString(strBuf);
|
|
}
|
|
}
|
|
|
|
//删除所有扑克
|
|
bool CGameLogic::RemoveAllCard( const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount )
|
|
{
|
|
//检验数据
|
|
ASSERT(cbRemoveCount<=cbCardCount);
|
|
if (cbRemoveCount > cbCardCount) return false;
|
|
|
|
//定义变量
|
|
BYTE cbDeleteCount=0, cbDeleteCard[FULL_COUNT]={0};
|
|
if (cbCardCount>CountArray(cbDeleteCard)) return false;
|
|
CopyMemory(cbDeleteCard, cbCardData, cbCardCount*sizeof(cbCardData[0]));
|
|
CString strErrorTip;
|
|
//置零扑克
|
|
for (BYTE i=0; i<cbRemoveCount; i++)
|
|
{
|
|
bool bIsTheCard = false;
|
|
for (BYTE j=0; j<cbCardCount; j++)
|
|
{
|
|
if (cbRemoveCard[i] == cbDeleteCard[j])
|
|
{
|
|
bIsTheCard = true;
|
|
cbDeleteCount++;
|
|
cbDeleteCard[j] = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (!bIsTheCard)
|
|
{
|
|
strErrorTip.Format("%d:%x无法删除", i, cbRemoveCard[i]);
|
|
OutputDebugString(strErrorTip);
|
|
}
|
|
}
|
|
VERIFY_RETURN_FALSE(cbDeleteCount==cbRemoveCount);
|
|
|
|
//清理扑克
|
|
ZeroMemory(cbCardData, cbCardCount);
|
|
for (BYTE i=0,cbCardPos=0; i<cbCardCount; i++)
|
|
{
|
|
if (cbDeleteCard[i] != 0)
|
|
{
|
|
cbCardData[cbCardPos++] = cbDeleteCard[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//获取底牌类型
|
|
BYTE CGameLogic::GetBackCardType( const BYTE cbBackCardData[], bool bLongTaskCheck/*=false*/ )
|
|
{
|
|
//不是长线任务检查
|
|
if (!bLongTaskCheck)
|
|
{
|
|
return BCT_NORMAL;
|
|
}
|
|
|
|
//数据拷贝
|
|
BYTE cbCardData[BACK_COUNT] = {0};
|
|
CopyMemory(cbCardData, cbBackCardData, sizeof(BYTE)*BACK_COUNT);
|
|
SortCardList(cbCardData, BACK_COUNT, ST_ORDER);
|
|
|
|
//提取牌数据
|
|
BYTE cbCardValue[BACK_COUNT]={0}, cbCardColor[BACK_COUNT]={0};
|
|
for (int i=0; i<BACK_COUNT; ++i)
|
|
{
|
|
cbCardValue[i] = GetCardLogicValue(cbCardData[i]);
|
|
cbCardColor[i] = GetCardColor(cbCardData[i]);
|
|
}
|
|
|
|
//双王
|
|
if (cbCardData[0]==0x4F && cbCardData[1]==0x4E)
|
|
{
|
|
return BCT_DOUBLE_JOKER;
|
|
}
|
|
//三个二
|
|
if (cbCardValue[0]==15 && cbCardValue[1]==15 && cbCardValue[2]==15)
|
|
{
|
|
return BCT_THREE_2;
|
|
}
|
|
//单王双2
|
|
if (cbCardColor[0]==0x40 && cbCardValue[1]==15 && cbCardValue[2]==15)
|
|
{
|
|
return BCT_SINGLE_JOKER_DOUBLE_2;
|
|
}
|
|
//同花顺、顺子
|
|
if (cbCardValue[0]==cbCardValue[1]+1 && cbCardValue[1]==cbCardValue[2]+1 && cbCardValue[0]<=14)
|
|
{
|
|
if (cbCardColor[0]==cbCardColor[1] && cbCardColor[1]==cbCardColor[2])
|
|
{
|
|
return BCT_TONGHUASHUN;
|
|
}
|
|
else
|
|
{
|
|
return BCT_SHUNZI;
|
|
}
|
|
}
|
|
//单王
|
|
if (cbCardColor[0] == 0x40)
|
|
{
|
|
return BCT_SINGLE_JOKER;
|
|
}
|
|
//双二
|
|
if (cbCardValue[0]==15 && cbCardValue[1]==15)
|
|
{
|
|
return BCT_DOUBLE_2;
|
|
}
|
|
//全小
|
|
if (cbCardValue[0] < 10)
|
|
{
|
|
return BCT_ALL_LITTLE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//获取底牌倍数
|
|
BYTE CGameLogic::GetBackCardMulitple( const BYTE cbBackCardType )
|
|
{
|
|
// if (cbBackCardType <= BCT_TONGHUASHUN)
|
|
// {
|
|
// return 3;
|
|
// }
|
|
// else if (cbBackCardType <= BCT_ALL_LITTLE)
|
|
// {
|
|
// return 2;
|
|
// }
|
|
return 1;
|
|
}
|
|
|
|
//获取类型
|
|
BYTE CGameLogic::GetCardType( const BYTE cbCardData[], const BYTE cbCardCount )
|
|
{
|
|
ASSERT(cbCardCount!=0);
|
|
if (cbCardCount == 0)
|
|
{
|
|
return CT_ERROR;
|
|
}
|
|
|
|
//简单牌型
|
|
switch (cbCardCount)
|
|
{
|
|
case 1: //单牌
|
|
{
|
|
return CT_SINGLE;
|
|
}
|
|
case 2: //对牌火箭
|
|
{
|
|
//牌型判断
|
|
if (cbCardData[0]==0x4F && cbCardData[1]==0x4E)
|
|
{
|
|
return CT_MISSILE_CARD;
|
|
}
|
|
if (GetCardLogicValue(cbCardData[0]) == GetCardLogicValue(cbCardData[1]))
|
|
{
|
|
return CT_DOUBLE;
|
|
}
|
|
return CT_ERROR;
|
|
}
|
|
}
|
|
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult;
|
|
if (!AnalysebCardData(cbCardData, cbCardCount, AnalyseResult))
|
|
{
|
|
return CT_ERROR;
|
|
}
|
|
|
|
//四牌判断
|
|
if (AnalyseResult.cbFourCount > 0)
|
|
{
|
|
//牌型判断
|
|
if (AnalyseResult.cbFourCount==1 && cbCardCount==4)
|
|
{
|
|
return CT_BOMB_CARD;
|
|
}
|
|
if (AnalyseResult.cbFourCount==1 && AnalyseResult.cbSingleCount==2 && cbCardCount==6)
|
|
{
|
|
return CT_FOUR_TAKE_ONE;
|
|
}
|
|
if (AnalyseResult.cbFourCount==1 && AnalyseResult.cbDoubleCount==1 && cbCardCount==6)
|
|
{
|
|
return CT_FOUR_TAKE_ONE;
|
|
}
|
|
if (AnalyseResult.cbFourCount==1 && AnalyseResult.cbDoubleCount==2 && cbCardCount==8)
|
|
{
|
|
return CT_FOUR_TAKE_TWO;
|
|
}
|
|
|
|
//分析含有炸弹飞机
|
|
if (AnalyseResult.cbThreeCount > 0)
|
|
{
|
|
if ((AnalyseResult.cbFourCount+AnalyseResult.cbThreeCount)*4 == cbCardCount)
|
|
{
|
|
BYTE cbAnalyCardData[MAX_COUNT]={0}, cbAnalyCardCount=0;
|
|
//拷贝四张牌
|
|
for (int i=0; i<AnalyseResult.cbFourCount; ++i)
|
|
{
|
|
CopyMemory(&cbAnalyCardData[cbAnalyCardCount], &AnalyseResult.cbFourCardData[i*4], 3);
|
|
cbAnalyCardCount += 3;
|
|
}
|
|
//拷贝三张牌
|
|
for (int i=0; i<AnalyseResult.cbThreeCount; ++i)
|
|
{
|
|
CopyMemory(&cbAnalyCardData[cbAnalyCardCount], &AnalyseResult.cbThreeCardData[i*3], 3);
|
|
cbAnalyCardCount += 3;
|
|
}
|
|
SortCardList(cbAnalyCardData, cbAnalyCardCount, ST_ORDER);
|
|
if (GetCardType(cbAnalyCardData, cbAnalyCardCount) == CT_THREE_LINE)
|
|
{
|
|
return CT_THREE_TAKE_ONE;
|
|
}
|
|
}
|
|
}
|
|
return CT_ERROR;
|
|
}
|
|
|
|
//三牌判断
|
|
if (AnalyseResult.cbThreeCount > 0)
|
|
{
|
|
//三条类型
|
|
if (AnalyseResult.cbThreeCount==1 && cbCardCount==3)
|
|
{
|
|
return CT_THREE;
|
|
}
|
|
//连牌判断
|
|
if (AnalyseResult.cbThreeCount > 1)
|
|
{
|
|
//变量定义
|
|
BYTE cbFirstCard = AnalyseResult.cbThreeCardData[0];
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCard);
|
|
BYTE cbStartIndex = 1;
|
|
if (cbFirstLogicValue == 15)
|
|
{
|
|
cbFirstLogicValue = GetCardLogicValue(AnalyseResult.cbThreeCardData[cbStartIndex*3]);
|
|
cbStartIndex = 2;
|
|
}
|
|
|
|
//连牌判断
|
|
BYTE cbThreeLength=1, cbMaxThreeLenght=1;
|
|
for (; cbStartIndex<AnalyseResult.cbThreeCount; cbStartIndex++)
|
|
{
|
|
cbThreeLength++;
|
|
BYTE cbNextCard = AnalyseResult.cbThreeCardData[cbStartIndex*3];
|
|
if (cbFirstLogicValue != (GetCardLogicValue(cbNextCard)+cbMaxThreeLenght))
|
|
{
|
|
cbFirstLogicValue = GetCardLogicValue(cbNextCard);
|
|
cbThreeLength = 1;
|
|
}
|
|
if (cbThreeLength > cbMaxThreeLenght)
|
|
{
|
|
cbMaxThreeLenght = cbThreeLength;
|
|
}
|
|
}
|
|
//特殊判断
|
|
if (cbMaxThreeLenght != AnalyseResult.cbThreeCount)
|
|
{
|
|
if (cbMaxThreeLenght==AnalyseResult.cbThreeCount-1 && cbMaxThreeLenght*4==cbCardCount)
|
|
{
|
|
return CT_THREE_TAKE_ONE;
|
|
}
|
|
return CT_ERROR;
|
|
}
|
|
}
|
|
|
|
//牌形判断
|
|
if (AnalyseResult.cbThreeCount*3 == cbCardCount)
|
|
{
|
|
return CT_THREE_LINE;
|
|
}
|
|
if (AnalyseResult.cbThreeCount*4 == cbCardCount)
|
|
{
|
|
return CT_THREE_TAKE_ONE;
|
|
}
|
|
if (AnalyseResult.cbThreeCount*5==cbCardCount && AnalyseResult.cbDoubleCount==AnalyseResult.cbThreeCount)
|
|
{
|
|
return CT_THREE_TAKE_TWO;
|
|
}
|
|
return CT_ERROR;
|
|
}
|
|
|
|
//两张类型
|
|
if (AnalyseResult.cbDoubleCount >= 3)
|
|
{
|
|
//变量定义
|
|
BYTE cbFirstCard = AnalyseResult.cbDoubleCardData[0];
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCard);
|
|
//错误过虑
|
|
if (cbFirstLogicValue >= 15)
|
|
{
|
|
return CT_ERROR;
|
|
}
|
|
//连牌判断
|
|
for (BYTE i=1; i<AnalyseResult.cbDoubleCount; i++)
|
|
{
|
|
BYTE cbnextCard = AnalyseResult.cbDoubleCardData[i*2];
|
|
if (cbFirstLogicValue != GetCardLogicValue(cbnextCard)+i)
|
|
{
|
|
return CT_ERROR;
|
|
}
|
|
}
|
|
//二连判断
|
|
if (AnalyseResult.cbDoubleCount*2 == cbCardCount)
|
|
{
|
|
return CT_DOUBLE_LINE;
|
|
}
|
|
return CT_ERROR;
|
|
}
|
|
|
|
//单张判断
|
|
if (AnalyseResult.cbSingleCount>=5 && AnalyseResult.cbSingleCount==cbCardCount)
|
|
{
|
|
//变量定义
|
|
BYTE cbFirstCard = AnalyseResult.cbSingleCardData[0];
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCard);
|
|
//错误过虑
|
|
if (cbFirstLogicValue >= 15)
|
|
{
|
|
return CT_ERROR;
|
|
}
|
|
//连牌判断
|
|
for (BYTE i=1; i<AnalyseResult.cbSingleCount; i++)
|
|
{
|
|
BYTE cbNextCard = AnalyseResult.cbSingleCardData[i];
|
|
if (cbFirstLogicValue != GetCardLogicValue(cbNextCard)+i)
|
|
{
|
|
return CT_ERROR;
|
|
}
|
|
}
|
|
return CT_SINGLE_LINE;
|
|
}
|
|
return CT_ERROR;
|
|
}
|
|
|
|
//混乱扑克
|
|
void CGameLogic::RandCardList( BYTE cbCardBuffer[], BYTE cbBufferCount )
|
|
{
|
|
//混乱准备
|
|
BYTE cbCardData[CountArray(m_cbCardData)] = {0};
|
|
CopyMemory(cbCardData, m_cbCardData, sizeof(m_cbCardData));
|
|
|
|
//混乱扑克
|
|
BYTE cbRandCount=0, cbPosition=0;
|
|
do
|
|
{
|
|
cbPosition = rand()%(cbBufferCount-cbRandCount);
|
|
cbCardBuffer[cbRandCount++] = cbCardData[cbPosition];
|
|
cbCardData[cbPosition] = cbCardData[cbBufferCount-cbRandCount];
|
|
}while (cbRandCount<cbBufferCount);
|
|
}
|
|
|
|
//排列扑克
|
|
void CGameLogic::SortCardList( BYTE cbCardData[], BYTE cbCardCount, BYTE cbSortType )
|
|
{
|
|
//数目过虑
|
|
if (cbCardCount<2) return;
|
|
|
|
//转换数值
|
|
BYTE cbSortValue[MAX_COUNT] = {0};
|
|
for (BYTE i=0; i<cbCardCount; i++)
|
|
{
|
|
cbSortValue[i] = GetCardLogicValue(cbCardData[i]);
|
|
}
|
|
|
|
//排序操作
|
|
bool bSorted = true;
|
|
BYTE cbThreeCount=0, cbLast=cbCardCount-1;
|
|
do
|
|
{
|
|
bSorted = true;
|
|
for (BYTE i=0; i<cbLast; i++)
|
|
{
|
|
if (cbSortValue[i]<cbSortValue[i+1] || (cbSortValue[i]==cbSortValue[i+1]&&cbCardData[i]<cbCardData[i+1]))
|
|
{
|
|
//交换位置
|
|
cbThreeCount = cbCardData[i];
|
|
cbCardData[i] = cbCardData[i+1];
|
|
cbCardData[i+1] = cbThreeCount;
|
|
cbThreeCount = cbSortValue[i];
|
|
cbSortValue[i] = cbSortValue[i+1];
|
|
cbSortValue[i+1] = cbThreeCount;
|
|
bSorted = false;
|
|
}
|
|
}
|
|
cbLast--;
|
|
} while(bSorted==false);
|
|
|
|
//数目排序
|
|
if (cbSortType == ST_COUNT)
|
|
{
|
|
//分析扑克
|
|
BYTE cbIndex = 0;
|
|
tagAnalyseResult AnalyseResult;
|
|
if (AnalysebCardData(cbCardData, cbCardCount, AnalyseResult))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//拷贝四牌
|
|
CopyMemory(&cbCardData[cbIndex], AnalyseResult.cbFourCardData, sizeof(BYTE)*AnalyseResult.cbFourCount*4);
|
|
cbIndex += AnalyseResult.cbFourCount*4;
|
|
|
|
//拷贝三牌
|
|
CopyMemory(&cbCardData[cbIndex], AnalyseResult.cbThreeCardData, sizeof(BYTE)*AnalyseResult.cbThreeCount*3);
|
|
cbIndex += AnalyseResult.cbThreeCount*3;
|
|
|
|
//拷贝对牌
|
|
CopyMemory(&cbCardData[cbIndex], AnalyseResult.cbDoubleCardData, sizeof(BYTE)*AnalyseResult.cbDoubleCount*2);
|
|
cbIndex+=AnalyseResult.cbDoubleCount*2;
|
|
|
|
//拷贝单牌
|
|
CopyMemory(&cbCardData[cbIndex], AnalyseResult.cbSingleCardData, sizeof(BYTE)*AnalyseResult.cbSingleCount);
|
|
cbIndex += AnalyseResult.cbSingleCount;
|
|
}
|
|
}
|
|
|
|
//删除扑克
|
|
bool CGameLogic::RemoveCard( const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount )
|
|
{
|
|
if (cbRemoveCount==0)
|
|
{
|
|
return true;
|
|
}
|
|
//检验数据
|
|
ASSERT(cbRemoveCount<=cbCardCount);
|
|
if (cbRemoveCount>cbCardCount)
|
|
{
|
|
ASSERT(0);
|
|
return false;
|
|
}
|
|
//定义变量
|
|
BYTE cbDeleteCount=0, cbDeleteCard[MAX_COUNT]={0};
|
|
if (cbCardCount>CountArray(cbDeleteCard)) return false;
|
|
CopyMemory(cbDeleteCard, cbCardData, cbCardCount*sizeof(BYTE));
|
|
|
|
//置零扑克
|
|
for (BYTE i=0; i<cbRemoveCount; i++)
|
|
{
|
|
for (BYTE j=0; j<cbCardCount; j++)
|
|
{
|
|
if (cbRemoveCard[i] == cbDeleteCard[j])
|
|
{
|
|
cbDeleteCount++;
|
|
cbDeleteCard[j] = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ASSERT(cbDeleteCount==cbRemoveCount);
|
|
if (cbDeleteCount!=cbRemoveCount) return false;
|
|
|
|
ZeroMemory(cbCardData, sizeof(BYTE)*cbCardCount);
|
|
//清理扑克
|
|
for (BYTE i=0,cbCardPos=0; i<cbCardCount; i++)
|
|
{
|
|
if (cbDeleteCard[i] != 0)
|
|
{
|
|
cbCardData[cbCardPos++] = cbDeleteCard[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//得到好牌
|
|
void CGameLogic::GetGoodCardData( BYTE cbGoodCardData[NORMAL_COUNT] )
|
|
{
|
|
//混乱准备
|
|
BYTE cbCardData[CountArray(m_cbGoodcardData)] = {0};
|
|
BYTE cbCardBuffer[CountArray(m_cbGoodcardData)] = {0};
|
|
CopyMemory(cbCardData, m_cbGoodcardData, sizeof(m_cbGoodcardData));
|
|
|
|
//混乱扑克
|
|
BYTE cbRandCount=0, cbPosition=0;
|
|
BYTE cbBufferCount = CountArray(m_cbGoodcardData);
|
|
do
|
|
{
|
|
cbPosition = rand()%(cbBufferCount-cbRandCount);
|
|
cbCardBuffer[cbRandCount++] = cbCardData[cbPosition];
|
|
cbCardData[cbPosition] = cbCardData[cbBufferCount-cbRandCount];
|
|
}while (cbRandCount<cbBufferCount);
|
|
|
|
//复制好牌
|
|
CopyMemory(cbGoodCardData, cbCardBuffer, NORMAL_COUNT);
|
|
}
|
|
|
|
//删除好牌
|
|
bool CGameLogic::RemoveGoodCardData( BYTE cbGoodcardData[NORMAL_COUNT], BYTE cbGoodCardCount, BYTE cbCardData[FULL_COUNT], BYTE cbCardCount )
|
|
{
|
|
//检验数据
|
|
ASSERT(cbGoodCardCount<=cbCardCount);
|
|
if (cbGoodCardCount>cbCardCount) return false;
|
|
|
|
//定义变量
|
|
BYTE cbDeleteCount=0,cbDeletaCard[FULL_COUNT]={0};
|
|
if (cbCardCount>CountArray(cbDeletaCard)) return false;
|
|
CopyMemory(cbDeletaCard, cbCardData, cbCardCount*sizeof(cbCardData[0]));
|
|
|
|
//置零扑克
|
|
for (BYTE i=0; i<cbGoodCardCount; i++)
|
|
{
|
|
for (BYTE j=0; j<cbCardCount; j++)
|
|
{
|
|
if (cbGoodcardData[i] == cbDeletaCard[j])
|
|
{
|
|
cbDeleteCount++;
|
|
cbDeletaCard[j] = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ASSERT(cbDeleteCount==cbGoodCardCount);
|
|
if (cbDeleteCount!=cbGoodCardCount) return false;
|
|
|
|
//清理扑克
|
|
for (BYTE i=0,cbCardPos=0;i<cbCardCount;i++)
|
|
{
|
|
if (cbDeletaCard[i] != 0)
|
|
{
|
|
cbCardData[cbCardPos++] = cbDeletaCard[i];
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//混乱缓冲区
|
|
void CGameLogic::RandArrayBuffer( BYTE cbBufferData[], BYTE cbBufferCount )
|
|
{
|
|
BYTE cbPosition=0, cbTemp=0;
|
|
for (BYTE i=cbBufferCount; i>1; i--)
|
|
{
|
|
cbPosition=BYTE(rand()%i);
|
|
cbTemp=cbBufferData[i-1];
|
|
cbBufferData[i-1]=cbBufferData[cbPosition];
|
|
cbBufferData[cbPosition]=cbTemp;
|
|
}
|
|
return;
|
|
}
|
|
|
|
//牌型缓冲区
|
|
void CGameLogic::SortArrayBuffer( BYTE cbBufferData[], BYTE cbBufferCount )
|
|
{
|
|
bool bSorted = true;
|
|
BYTE cbTemp=0, cbLast=cbBufferCount-1;
|
|
do
|
|
{
|
|
bSorted = true;
|
|
for (BYTE i=0; i<cbLast; i++)
|
|
{
|
|
if (cbBufferData[i]>cbBufferData[i+1])
|
|
{
|
|
cbTemp = cbBufferData[i];
|
|
cbBufferData[i] = cbBufferData[i+1];
|
|
cbBufferData[i+1] = cbTemp;
|
|
bSorted = false;
|
|
}
|
|
}
|
|
cbLast--;
|
|
} while(bSorted==false);
|
|
}
|
|
|
|
//有效判断
|
|
bool CGameLogic::IsValidCard( BYTE cbCardData )
|
|
{
|
|
//获取属性
|
|
BYTE cbCardColor = GetCardColor(cbCardData);
|
|
BYTE cbCardValue = GetCardValue(cbCardData);
|
|
|
|
//有效判断
|
|
if (cbCardData==0x4E || cbCardData==0x4F)
|
|
{
|
|
return true;
|
|
}
|
|
if (cbCardColor<=0x30 && cbCardValue>=0x01 && cbCardValue<=0x0D)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//有效判断
|
|
bool CGameLogic::IsValidCount( BYTE cbCardCount )
|
|
{
|
|
if (cbCardCount>0 && cbCardCount<=MAX_COUNT)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//有效判断
|
|
bool CGameLogic::IsValidUser( WORD wChairID )
|
|
{
|
|
if (wChairID>=0 && wChairID<GAME_PLAYER)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//逻辑数值
|
|
BYTE CGameLogic::GetCardLogicValue( BYTE cbCardData )
|
|
{
|
|
ASSERT(cbCardData!=0);
|
|
if (cbCardData == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
//扑克属性
|
|
BYTE cbCardColor = GetCardColor(cbCardData);
|
|
BYTE cbCardValue = GetCardValue(cbCardData);
|
|
ASSERT(cbCardValue!=0);
|
|
|
|
//转换数值
|
|
if (cbCardColor == 0x40)
|
|
{
|
|
return cbCardValue+2;
|
|
}
|
|
return (cbCardValue<=2) ? (cbCardValue+13) : cbCardValue;
|
|
}
|
|
|
|
//对比扑克
|
|
bool CGameLogic::CompareCard( const BYTE cbFirstCard[], const BYTE cbNextCard[], BYTE cbFirstCount, BYTE cbNextCount, BYTE cbRecordType )
|
|
{
|
|
//获取类型
|
|
BYTE cbNextType = GetCardType(cbNextCard, cbNextCount);
|
|
BYTE cbFirstType = GetCardType(cbFirstCard, cbFirstCount);
|
|
|
|
//特殊判断
|
|
if (cbFirstCount==12 && cbNextCount==12 && cbRecordType==CT_THREE_TAKE_ONE)
|
|
{
|
|
if (cbNextType == CT_THREE_LINE)
|
|
{
|
|
cbNextType = CT_THREE_TAKE_ONE;
|
|
}
|
|
if (cbFirstType == CT_THREE_LINE)
|
|
{
|
|
cbFirstType = CT_THREE_TAKE_ONE;
|
|
}
|
|
}
|
|
|
|
//类型判断
|
|
if (cbNextType == CT_ERROR) return false;
|
|
if (cbNextType == CT_MISSILE_CARD) return true;
|
|
if (cbFirstType == CT_MISSILE_CARD) return false;
|
|
|
|
//炸弹判断
|
|
if (cbFirstType!=CT_BOMB_CARD && cbNextType==CT_BOMB_CARD) return true;
|
|
if (cbFirstType==CT_BOMB_CARD && cbNextType!=CT_BOMB_CARD) return false;
|
|
|
|
//规则判断
|
|
if (cbFirstType!=cbNextType || cbFirstCount!=cbNextCount) return false;
|
|
|
|
//开始对比
|
|
switch (cbNextType)
|
|
{
|
|
case CT_SINGLE:
|
|
case CT_DOUBLE:
|
|
case CT_THREE:
|
|
case CT_SINGLE_LINE:
|
|
case CT_DOUBLE_LINE:
|
|
case CT_THREE_LINE:
|
|
case CT_BOMB_CARD:
|
|
{
|
|
//获取数值
|
|
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCard[0]);
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCard[0]);
|
|
//对比扑克
|
|
return (cbNextLogicValue>cbFirstLogicValue) ? true : false;
|
|
}
|
|
case CT_THREE_TAKE_ONE:
|
|
case CT_THREE_TAKE_TWO:
|
|
{
|
|
//分析扑克
|
|
tagAnalyseResult NextResult, FirstResult;
|
|
VERIFY(AnalysebCardData(cbNextCard, cbNextCount, NextResult));
|
|
VERIFY(AnalysebCardData(cbFirstCard, cbFirstCount, FirstResult));
|
|
//获取数值
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(FirstResult.cbThreeCardData[0]);
|
|
BYTE cbNextLogicValue = GetCardLogicValue(NextResult.cbThreeCardData[0]);
|
|
|
|
if (NextResult.cbThreeCount>1 && GetCardLogicValue(NextResult.cbThreeCardData[0])!=GetCardLogicValue(NextResult.cbThreeCardData[3])+1)
|
|
{
|
|
cbNextLogicValue = GetCardLogicValue(NextResult.cbThreeCardData[3]);
|
|
}
|
|
if (FirstResult.cbThreeCount>1 && GetCardLogicValue(FirstResult.cbThreeCardData[0])!=GetCardLogicValue(FirstResult.cbThreeCardData[3])+1)
|
|
{
|
|
cbFirstLogicValue = GetCardLogicValue(FirstResult.cbThreeCardData[3]);
|
|
}
|
|
//对比扑克
|
|
return (cbNextLogicValue>cbFirstLogicValue) ? true : false;
|
|
}
|
|
case CT_FOUR_TAKE_ONE:
|
|
case CT_FOUR_TAKE_TWO:
|
|
{
|
|
//分析扑克
|
|
tagAnalyseResult NextResult, FirstResult;
|
|
VERIFY(AnalysebCardData(cbNextCard, cbNextCount, NextResult));
|
|
VERIFY(AnalysebCardData(cbFirstCard, cbFirstCount, FirstResult));
|
|
//获取数值
|
|
BYTE cbNextLogicValue = GetCardLogicValue(NextResult.cbFourCardData[0]);
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(FirstResult.cbFourCardData[0]);
|
|
//对比扑克
|
|
return (cbNextLogicValue>cbFirstLogicValue) ? true : false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//出牌搜索
|
|
bool CGameLogic::SearchOutCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, const BYTE cbTurnCardData[], const BYTE cbTurnCardCount, tagOutCardResult &OutCardResult )
|
|
{
|
|
//设置结果
|
|
ZeroMemory(&OutCardResult, sizeof(OutCardResult));
|
|
//构造扑克
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
BYTE cbTempCardCount = cbHandCardCount;
|
|
CopyMemory(cbTempCardData, cbHandCardData, sizeof(BYTE)*cbHandCardCount);
|
|
//排列扑克
|
|
SortCardList(cbTempCardData, cbTempCardCount, ST_ORDER);
|
|
|
|
//获取类型
|
|
BYTE cbTurnOutType = CT_ERROR;
|
|
if (cbTurnCardCount > 0)
|
|
{
|
|
cbTurnOutType = GetCardType(cbTurnCardData, cbTurnCardCount);
|
|
}
|
|
|
|
//出牌分析
|
|
switch (cbTurnOutType)
|
|
{
|
|
case CT_ERROR: //错误类型
|
|
{
|
|
//获取数值
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTempCardData[cbTempCardCount-1]);
|
|
|
|
//多牌判断
|
|
BYTE cbSameCount = 1;
|
|
for (BYTE i=1; i<cbTempCardCount; i++)
|
|
{
|
|
if (GetCardLogicValue(cbTempCardData[cbTempCardCount-i-1]) == cbLogicValue)
|
|
{
|
|
cbSameCount++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//完成处理
|
|
if (cbSameCount > 1)
|
|
{
|
|
OutCardResult.cbCardCount = cbSameCount;
|
|
for (BYTE j=0; j<cbSameCount; j++)
|
|
{
|
|
OutCardResult.cbCardData[j] = cbTempCardData[cbTempCardCount-1-j];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//单牌处理
|
|
OutCardResult.cbCardCount = 1;
|
|
OutCardResult.cbCardData[0] = cbTempCardData[cbTempCardCount-1];
|
|
return true;
|
|
}break;
|
|
case CT_SINGLE: //单牌类型
|
|
case CT_DOUBLE: //对牌类型
|
|
case CT_THREE: //三条类型
|
|
{
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult;
|
|
VERIFY(AnalysebCardData(cbTempCardData,cbTempCardCount,AnalyseResult));
|
|
|
|
//获取数值
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTurnCardData[0]);
|
|
//寻找单牌
|
|
if (cbTurnCardCount <= 1)
|
|
{
|
|
for (BYTE i=0; i<AnalyseResult.cbSingleCount; i++)
|
|
{
|
|
BYTE cbIndex = AnalyseResult.cbSingleCount-i-1;
|
|
if (GetCardLogicValue(AnalyseResult.cbSingleCardData[cbIndex]) > cbLogicValue)
|
|
{
|
|
//设置结果
|
|
OutCardResult.cbCardCount = cbTurnCardCount;
|
|
CopyMemory(OutCardResult.cbCardData, &AnalyseResult.cbSingleCardData[cbIndex], sizeof(BYTE)*cbTurnCardCount);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
//寻找对牌
|
|
if (cbTurnCardCount <= 2)
|
|
{
|
|
for (BYTE i=0; i<AnalyseResult.cbDoubleCount; i++)
|
|
{
|
|
BYTE cbIndex = (AnalyseResult.cbDoubleCount-i-1)*2;
|
|
if (GetCardLogicValue(AnalyseResult.cbDoubleCardData[cbIndex]) > cbLogicValue)
|
|
{
|
|
//设置结果
|
|
OutCardResult.cbCardCount = cbTurnCardCount;
|
|
CopyMemory(OutCardResult.cbCardData, &AnalyseResult.cbDoubleCardData[cbIndex], sizeof(BYTE)*cbTurnCardCount);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//寻找三牌
|
|
if (cbTurnCardCount <= 3)
|
|
{
|
|
for (BYTE i=0; i<AnalyseResult.cbThreeCount; i++)
|
|
{
|
|
BYTE cbIndex = (AnalyseResult.cbThreeCount-i-1)*3;
|
|
if (GetCardLogicValue(AnalyseResult.cbThreeCardData[cbIndex]) > cbLogicValue)
|
|
{
|
|
//设置结果
|
|
OutCardResult.cbCardCount = cbTurnCardCount;
|
|
CopyMemory(OutCardResult.cbCardData, &AnalyseResult.cbThreeCardData[cbIndex], sizeof(BYTE)*cbTurnCardCount);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}break;
|
|
case CT_SINGLE_LINE: //单连类型
|
|
{
|
|
//长度判断
|
|
if (cbTempCardCount < cbTurnCardCount) break;
|
|
|
|
//获取数值
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTurnCardData[0]);
|
|
//搜索连牌
|
|
for (BYTE i=(cbTurnCardCount-1); i<cbTempCardCount; i++)
|
|
{
|
|
//获取数值
|
|
BYTE cbHandLogicValue = GetCardLogicValue(cbTempCardData[cbTempCardCount-i-1]);
|
|
//构造判断
|
|
if (cbHandLogicValue >= 15) break;
|
|
if (cbHandLogicValue <= cbLogicValue) continue;
|
|
|
|
//搜索连牌
|
|
BYTE cbLineCount = 0;
|
|
for (BYTE j=(cbTempCardCount-i-1); j<cbTempCardCount;j ++)
|
|
{
|
|
if ((GetCardLogicValue(cbTempCardData[j])+cbLineCount) == cbHandLogicValue)
|
|
{
|
|
//增加连数
|
|
OutCardResult.cbCardData[cbLineCount++] = cbTempCardData[j];
|
|
//完成判断
|
|
if (cbLineCount == cbTurnCardCount)
|
|
{
|
|
OutCardResult.cbCardCount = cbTurnCardCount;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}break;
|
|
case CT_DOUBLE_LINE: //对连类型
|
|
{
|
|
//长度判断
|
|
if (cbTempCardCount < cbTurnCardCount) break;
|
|
|
|
//获取数值
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTurnCardData[0]);
|
|
//搜索连牌
|
|
for (BYTE i=(cbTurnCardCount-1); i<cbTempCardCount; i++)
|
|
{
|
|
//获取数值
|
|
BYTE cbHandLogicValue = GetCardLogicValue(cbTempCardData[cbTempCardCount-i-1]);
|
|
//构造判断
|
|
if (cbHandLogicValue <= cbLogicValue) continue;
|
|
if (cbTurnCardCount>1 && cbHandLogicValue>=15) break;
|
|
|
|
//搜索连牌
|
|
BYTE cbLineCount = 0;
|
|
for (BYTE j=(cbTempCardCount-i-1); j<(cbTempCardCount-1); j++)
|
|
{
|
|
if (GetCardLogicValue(cbTempCardData[j])+cbLineCount==cbHandLogicValue && GetCardLogicValue(cbTempCardData[j+1])+cbLineCount==cbHandLogicValue)
|
|
{
|
|
//增加连数
|
|
OutCardResult.cbCardData[cbLineCount*2] = cbTempCardData[j];
|
|
OutCardResult.cbCardData[(cbLineCount++)*2+1] = cbTempCardData[j+1];
|
|
//完成判断
|
|
if (cbLineCount*2 == cbTurnCardCount)
|
|
{
|
|
OutCardResult.cbCardCount = cbTurnCardCount;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}break;
|
|
case CT_THREE_LINE: //三连类型
|
|
case CT_THREE_TAKE_ONE: //三带一单
|
|
case CT_THREE_TAKE_TWO: //三带一对
|
|
{
|
|
//长度判断
|
|
if (cbTempCardCount < cbTurnCardCount) break;
|
|
|
|
//获取数值
|
|
BYTE cbLogicValue = 0;
|
|
for (BYTE i=0; i<cbTurnCardCount-2; i++)
|
|
{
|
|
cbLogicValue = GetCardLogicValue(cbTurnCardData[i]);
|
|
if (GetCardLogicValue(cbTurnCardData[i+1]) != cbLogicValue) continue;
|
|
if (GetCardLogicValue(cbTurnCardData[i+2]) != cbLogicValue) continue;
|
|
break;
|
|
}
|
|
|
|
//属性数值
|
|
BYTE cbTurnLineCount = 0;
|
|
if (cbTurnOutType == CT_THREE_TAKE_ONE) cbTurnLineCount = cbTurnCardCount/4;
|
|
else if (cbTurnOutType == CT_THREE_TAKE_TWO) cbTurnLineCount = cbTurnCardCount/5;
|
|
else cbTurnLineCount = cbTurnCardCount/3;
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResultBuffer;
|
|
VERIFY(AnalysebCardData(cbTempCardData, cbTempCardCount, AnalyseResultBuffer));
|
|
|
|
//搜索连牌
|
|
for (BYTE i=cbTurnLineCount*3-1; i<cbTempCardCount; i++)
|
|
{
|
|
//获取数值
|
|
BYTE cbHandLogicValue = GetCardLogicValue(cbTempCardData[cbTempCardCount-i-1]);
|
|
|
|
//构造判断
|
|
if (cbHandLogicValue <= cbLogicValue) continue;
|
|
if (cbTurnLineCount>1 && cbHandLogicValue>=15) break;
|
|
bool bfour = false;
|
|
for (int b=0; b<AnalyseResultBuffer.cbFourCount; b++)
|
|
{
|
|
if (GetCardLogicValue(AnalyseResultBuffer.cbFourCardData[b*4]) == cbHandLogicValue)
|
|
{
|
|
bfour = true;
|
|
break;
|
|
}
|
|
}
|
|
if (bfour)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//搜索连牌
|
|
BYTE cbLineCount = 0;
|
|
for (BYTE j=(cbTempCardCount-i-1); j<(cbTempCardCount-2); j++)
|
|
{
|
|
//设置变量
|
|
OutCardResult.cbCardCount = 0;
|
|
//三牌判断
|
|
if (GetCardLogicValue(cbTempCardData[j])+cbLineCount != cbHandLogicValue) continue;
|
|
if (GetCardLogicValue(cbTempCardData[j+1])+cbLineCount != cbHandLogicValue) continue;
|
|
if (GetCardLogicValue(cbTempCardData[j+2])+cbLineCount != cbHandLogicValue) continue;
|
|
|
|
//增加连数
|
|
OutCardResult.cbCardData[cbLineCount*3] = cbTempCardData[j];
|
|
OutCardResult.cbCardData[cbLineCount*3+1] = cbTempCardData[j+1];
|
|
OutCardResult.cbCardData[(cbLineCount++)*3+2] = cbTempCardData[j+2];
|
|
|
|
//完成判断
|
|
if (cbLineCount == cbTurnLineCount)
|
|
{
|
|
//连牌设置
|
|
OutCardResult.cbCardCount = cbLineCount*3;
|
|
|
|
//构造扑克
|
|
BYTE cbLeftCardData[MAX_COUNT] = {0};
|
|
BYTE cbLeftCount = cbTempCardCount-OutCardResult.cbCardCount;
|
|
CopyMemory(cbLeftCardData, cbTempCardData, sizeof(BYTE)*cbTempCardCount);
|
|
RemoveCard(OutCardResult.cbCardData, OutCardResult.cbCardCount, cbLeftCardData, cbTempCardCount);
|
|
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResultLeft;
|
|
VERIFY(AnalysebCardData(cbLeftCardData,cbLeftCount,AnalyseResultLeft));
|
|
|
|
//单牌处理
|
|
if (cbTurnOutType == CT_THREE_TAKE_ONE)
|
|
{
|
|
//提取单牌
|
|
for (BYTE k=0; k<AnalyseResultLeft.cbSingleCount; k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex = AnalyseResultLeft.cbSingleCount-k-1;
|
|
if (cbHandLogicValue == GetCardLogicValue(AnalyseResultLeft.cbSingleCardData[cbIndex]))
|
|
{
|
|
continue;
|
|
}
|
|
BYTE cbSignedCard = AnalyseResultLeft.cbSingleCardData[cbIndex];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbSignedCard;
|
|
}
|
|
|
|
//提取对牌
|
|
for (BYTE k=0; k<AnalyseResultLeft.cbDoubleCount*2; k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex = (AnalyseResultLeft.cbDoubleCount*2-k-1);
|
|
BYTE cbSignedCard = AnalyseResultLeft.cbDoubleCardData[cbIndex];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbSignedCard;
|
|
}
|
|
|
|
//提取三牌
|
|
for (BYTE k=0; k<AnalyseResultLeft.cbThreeCount*3; k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex = (AnalyseResultLeft.cbThreeCount*3-k-1);
|
|
BYTE cbSignedCard = AnalyseResultLeft.cbThreeCardData[cbIndex];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbSignedCard;
|
|
}
|
|
|
|
//提取四牌
|
|
for (BYTE k=0;k<AnalyseResultLeft.cbFourCount*4;k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex=(AnalyseResultLeft.cbFourCount*4-k-1);
|
|
BYTE cbSignedCard=AnalyseResultLeft.cbFourCardData[cbIndex];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++]=cbSignedCard;
|
|
}
|
|
}
|
|
|
|
//对牌处理
|
|
if (cbTurnOutType == CT_THREE_TAKE_TWO)
|
|
{
|
|
//提取对牌
|
|
for (BYTE k=0; k<AnalyseResultLeft.cbDoubleCount; k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex = (AnalyseResultLeft.cbDoubleCount-k-1)*2;
|
|
BYTE cbCardData1 = AnalyseResultLeft.cbDoubleCardData[cbIndex];
|
|
BYTE cbCardData2 = AnalyseResultLeft.cbDoubleCardData[cbIndex+1];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbCardData1;
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbCardData2;
|
|
}
|
|
|
|
//提取三牌
|
|
for (BYTE k=0; k<AnalyseResultLeft.cbThreeCount; k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex = (AnalyseResultLeft.cbThreeCount-k-1)*3;
|
|
BYTE cbCardData1 = AnalyseResultLeft.cbThreeCardData[cbIndex];
|
|
BYTE cbCardData2 = AnalyseResultLeft.cbThreeCardData[cbIndex+1];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbCardData1;
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbCardData2;
|
|
}
|
|
|
|
//提取四牌
|
|
for (BYTE k=0; k<AnalyseResultLeft.cbFourCount; k++)
|
|
{
|
|
//中止判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount) break;
|
|
|
|
//设置扑克
|
|
BYTE cbIndex = (AnalyseResultLeft.cbFourCount-k-1)*4;
|
|
BYTE cbCardData1 = AnalyseResultLeft.cbFourCardData[cbIndex];
|
|
BYTE cbCardData2 = AnalyseResultLeft.cbFourCardData[cbIndex+1];
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbCardData1;
|
|
OutCardResult.cbCardData[OutCardResult.cbCardCount++] = cbCardData2;
|
|
}
|
|
}
|
|
|
|
//完成判断
|
|
if (OutCardResult.cbCardCount == cbTurnCardCount)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}break;
|
|
}
|
|
|
|
//搜索炸弹
|
|
if (cbTempCardCount>=4 && cbTurnOutType!=CT_MISSILE_CARD)
|
|
{
|
|
//变量定义
|
|
BYTE cbLogicValue = 0;
|
|
if (cbTurnOutType == CT_BOMB_CARD)
|
|
{
|
|
cbLogicValue = GetCardLogicValue(cbTurnCardData[0]);
|
|
}
|
|
|
|
//搜索炸弹
|
|
for (BYTE i=3; i<cbTempCardCount; i++)
|
|
{
|
|
//获取数值
|
|
BYTE cbHandLogicValue = GetCardLogicValue(cbTempCardData[cbTempCardCount-i-1]);
|
|
|
|
//构造判断
|
|
if (cbHandLogicValue <= cbLogicValue) continue;
|
|
|
|
//炸弹判断
|
|
BYTE j = 1;
|
|
BYTE cbTempLogicValue = GetCardLogicValue(cbTempCardData[cbTempCardCount-i-1]);
|
|
for (; j<4; j++)
|
|
{
|
|
if (GetCardLogicValue(cbTempCardData[cbTempCardCount+j-i-1]) != cbTempLogicValue)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (j != 4)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//设置结果
|
|
OutCardResult.cbCardCount = 4;
|
|
OutCardResult.cbCardData[0] = cbTempCardData[cbTempCardCount-i-1];
|
|
OutCardResult.cbCardData[1] = cbTempCardData[cbTempCardCount-i];
|
|
OutCardResult.cbCardData[2] = cbTempCardData[cbTempCardCount-i+1];
|
|
OutCardResult.cbCardData[3] = cbTempCardData[cbTempCardCount-i+2];
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//搜索火箭
|
|
if (cbTempCardCount>=2 && cbTempCardData[0]==0x4F && cbTempCardData[1]==0x4E)
|
|
{
|
|
if (cbTurnOutType == CT_MISSILE_CARD) return true;
|
|
//设置结果
|
|
OutCardResult.cbCardCount = 2;
|
|
OutCardResult.cbCardData[0] = cbTempCardData[0];
|
|
OutCardResult.cbCardData[1] = cbTempCardData[1];
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//提示出牌
|
|
bool CGameLogic::SearchOutCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, const BYTE cbTurnCardData[], const BYTE cbTurnCardCount, tagPromptCardResult &OutCardResult )
|
|
{
|
|
//设置结果
|
|
ZeroMemory(&OutCardResult, sizeof(OutCardResult));
|
|
|
|
//拷贝出牌
|
|
BYTE cbOutCardData[MAX_COUNT] = {0};
|
|
BYTE cbOutCardCount = cbTurnCardCount;
|
|
CopyMemory(cbOutCardData, cbTurnCardData, cbTurnCardCount);
|
|
|
|
bool bContinue = true;
|
|
tagOutCardResult TempOutCardResult;
|
|
while (bContinue)
|
|
{
|
|
ZeroMemory(&TempOutCardResult, sizeof(TempOutCardResult));
|
|
SearchOutCard(cbHandCardData, cbHandCardCount, cbOutCardData, cbOutCardCount, TempOutCardResult);
|
|
if (TempOutCardResult.cbCardCount > 0)
|
|
{
|
|
BYTE cbPos = OutCardResult.cbResultCount;
|
|
OutCardResult.cbCardCount[cbPos] = TempOutCardResult.cbCardCount;
|
|
CopyMemory(OutCardResult.cbCardData[cbPos], TempOutCardResult.cbCardData, sizeof(BYTE)*TempOutCardResult.cbCardCount);
|
|
OutCardResult.cbResultCount++;
|
|
|
|
cbOutCardCount = TempOutCardResult.cbCardCount;
|
|
CopyMemory(cbOutCardData, TempOutCardResult.cbCardData, sizeof(BYTE)*TempOutCardResult.cbCardCount);
|
|
}
|
|
else
|
|
{
|
|
bContinue = false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//分析扑克
|
|
bool CGameLogic::AnalysebCardData( const BYTE cbCardData[], const BYTE cbCardCount, tagAnalyseResult &AnalyseResult )
|
|
{
|
|
//设置结果
|
|
ZeroMemory(&AnalyseResult, sizeof(AnalyseResult));
|
|
if (cbCardCount == 0) return false;
|
|
|
|
//扑克分析
|
|
for (BYTE i=0; i<cbCardCount; i++)
|
|
{
|
|
//变量定义
|
|
BYTE cbSameCount = 1;
|
|
BYTE cbFirstLogicValue = GetCardLogicValue(cbCardData[i]);
|
|
if (cbFirstLogicValue == 0) return false;
|
|
|
|
//搜索同牌
|
|
for (BYTE j=i+1; j<cbCardCount; j++)
|
|
{
|
|
BYTE cbNextLogicValue = GetCardLogicValue(cbCardData[j]);
|
|
if (cbNextLogicValue == 0) return false;
|
|
//获取扑克
|
|
if (cbNextLogicValue != cbFirstLogicValue) break;
|
|
//设置变量
|
|
cbSameCount++;
|
|
}
|
|
|
|
//设置结果
|
|
switch (cbSameCount)
|
|
{
|
|
case 1: //单张
|
|
{
|
|
BYTE cbIndex = AnalyseResult.cbSingleCount++;
|
|
AnalyseResult.cbSingleCardData[cbIndex*cbSameCount] = cbCardData[i];
|
|
}break;
|
|
case 2: //两张
|
|
{
|
|
BYTE cbIndex = AnalyseResult.cbDoubleCount++;
|
|
AnalyseResult.cbDoubleCardData[cbIndex*cbSameCount] = cbCardData[i];
|
|
AnalyseResult.cbDoubleCardData[cbIndex*cbSameCount+1] = cbCardData[i+1];
|
|
}break;
|
|
case 3: //三张
|
|
{
|
|
BYTE cbIndex = AnalyseResult.cbThreeCount++;
|
|
AnalyseResult.cbThreeCardData[cbIndex*cbSameCount] = cbCardData[i];
|
|
AnalyseResult.cbThreeCardData[cbIndex*cbSameCount+1] = cbCardData[i+1];
|
|
AnalyseResult.cbThreeCardData[cbIndex*cbSameCount+2] = cbCardData[i+2];
|
|
}break;
|
|
case 4: //四张
|
|
{
|
|
BYTE cbIndex = AnalyseResult.cbFourCount++;
|
|
AnalyseResult.cbFourCardData[cbIndex*cbSameCount] = cbCardData[i];
|
|
AnalyseResult.cbFourCardData[cbIndex*cbSameCount+1] = cbCardData[i+1];
|
|
AnalyseResult.cbFourCardData[cbIndex*cbSameCount+2] = cbCardData[i+2];
|
|
AnalyseResult.cbFourCardData[cbIndex*cbSameCount+3] = cbCardData[i+3];
|
|
}break;
|
|
default:
|
|
{
|
|
ASSERT(FALSE);
|
|
}break;
|
|
}
|
|
|
|
//设置索引
|
|
i += cbSameCount-1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//分析炸弹
|
|
void CGameLogic::GetAllBombCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, BYTE cbBomCardData[], BYTE &cbBomCardCount )
|
|
{
|
|
cbBomCardCount = 0;
|
|
//数据校验
|
|
if (cbHandCardCount < 2) return;
|
|
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//大小排序
|
|
SortCardList(cbTempCardData, cbHandCardCount, ST_ORDER);
|
|
|
|
//双王炸弹
|
|
if (0x4F==cbTempCardData[0] && 0x4E==cbTempCardData[1])
|
|
{
|
|
cbBomCardData[cbBomCardCount++] = cbTempCardData[0];
|
|
cbBomCardData[cbBomCardCount++] = cbTempCardData[1];
|
|
}
|
|
|
|
//扑克分析
|
|
for (BYTE i=0; i<cbHandCardCount; i++)
|
|
{
|
|
//变量定义
|
|
BYTE cbSameCount = 1;
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTempCardData[i]);
|
|
|
|
//搜索同牌
|
|
for (BYTE j=i+1; j<cbHandCardCount; j++)
|
|
{
|
|
//获取扑克
|
|
if (GetCardLogicValue(cbTempCardData[j])!=cbLogicValue) break;
|
|
|
|
//设置变量
|
|
cbSameCount++;
|
|
}
|
|
//判断、加入
|
|
if (4 == cbSameCount)
|
|
{
|
|
cbBomCardData[cbBomCardCount++] = cbTempCardData[i];
|
|
cbBomCardData[cbBomCardCount++] = cbTempCardData[i+1];
|
|
cbBomCardData[cbBomCardCount++] = cbTempCardData[i+2];
|
|
cbBomCardData[cbBomCardCount++] = cbTempCardData[i+3];
|
|
}
|
|
//设置索引
|
|
i += cbSameCount-1;
|
|
}
|
|
}
|
|
|
|
//分析三条
|
|
void CGameLogic::GetAllThreeCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, BYTE cbThreeCardData[], BYTE &cbThreeCardCount )
|
|
{
|
|
cbThreeCardCount = 0;
|
|
if (cbHandCardCount < 3) return;
|
|
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//大小排序
|
|
SortCardList(cbTempCardData, cbHandCardCount, ST_ORDER);
|
|
|
|
//扑克分析
|
|
for (BYTE i=0;i<cbHandCardCount;i++)
|
|
{
|
|
//变量定义
|
|
BYTE cbSameCount = 1;
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTempCardData[i]);
|
|
|
|
//搜索同牌
|
|
for (BYTE j=i+1; j<cbHandCardCount; j++)
|
|
{
|
|
//获取扑克
|
|
if (GetCardLogicValue(cbTempCardData[j]) != cbLogicValue) break;
|
|
//设置变量
|
|
cbSameCount++;
|
|
}
|
|
//判断、加入
|
|
if (cbSameCount >= 3)
|
|
{
|
|
cbThreeCardData[cbThreeCardCount++] = cbTempCardData[i];
|
|
cbThreeCardData[cbThreeCardCount++] = cbTempCardData[i+1];
|
|
cbThreeCardData[cbThreeCardCount++] = cbTempCardData[i+2];
|
|
}
|
|
//设置索引
|
|
i += cbSameCount-1;
|
|
}
|
|
}
|
|
|
|
//分析对子
|
|
void CGameLogic::GetAllDoubleCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, BYTE cbDoubleCardData[], BYTE &cbDoubleCardCount )
|
|
{
|
|
cbDoubleCardCount = 0;
|
|
if (cbHandCardCount < 2) return;
|
|
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//大小排序
|
|
SortCardList(cbTempCardData, cbHandCardCount, ST_ORDER);
|
|
|
|
//扑克分析
|
|
for (BYTE i=0; i<cbHandCardCount; i++)
|
|
{
|
|
//变量定义
|
|
BYTE cbSameCount = 1;
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTempCardData[i]);
|
|
|
|
//搜索同牌
|
|
for (BYTE j=i+1; j<cbHandCardCount; j++)
|
|
{
|
|
//获取扑克
|
|
if (GetCardLogicValue(cbTempCardData[j]) != cbLogicValue) break;
|
|
//设置变量
|
|
cbSameCount++;
|
|
}
|
|
//判断、加入
|
|
if (cbSameCount >= 2)
|
|
{
|
|
cbDoubleCardData[cbDoubleCardCount++] = cbTempCardData[i];
|
|
cbDoubleCardData[cbDoubleCardCount++] = cbTempCardData[i+1];
|
|
}
|
|
//设置索引
|
|
i += cbSameCount-1;
|
|
}
|
|
}
|
|
|
|
//分析单牌
|
|
void CGameLogic::GetAllSingleCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, BYTE cbSingleCardData[], BYTE &cbSingleCardCount, bool bOnlySingle )
|
|
{
|
|
cbSingleCardCount = 0;
|
|
if (cbHandCardCount == 0) return;
|
|
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//大小排序
|
|
SortCardList(cbTempCardData, cbHandCardCount, ST_ORDER);
|
|
|
|
//扑克分析
|
|
for (BYTE i=0; i<cbHandCardCount; i++)
|
|
{
|
|
//变量定义
|
|
BYTE cbSameCount = 1;
|
|
BYTE cbLogicValue = GetCardLogicValue(cbTempCardData[i]);
|
|
|
|
//搜索同牌
|
|
for (BYTE j=i+1; j<cbHandCardCount; j++)
|
|
{
|
|
//获取扑克
|
|
if (GetCardLogicValue(cbTempCardData[j]) != cbLogicValue) break;
|
|
//设置变量
|
|
cbSameCount++;
|
|
}
|
|
//判断、加入
|
|
if (bOnlySingle)
|
|
{
|
|
if (cbSameCount == 1)
|
|
{
|
|
cbSingleCardData[cbSingleCardCount++] = cbTempCardData[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (cbSameCount >= 1)
|
|
{
|
|
cbSingleCardData[cbSingleCardCount++] = cbTempCardData[i];
|
|
}
|
|
}
|
|
//设置索引
|
|
i += cbSameCount-1;
|
|
}
|
|
}
|
|
|
|
//分析顺子
|
|
void CGameLogic::GetAllLineCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, BYTE cbLineCardData[], BYTE &cbLineCardCount )
|
|
{
|
|
cbLineCardCount = 0;
|
|
//数据校验
|
|
if (cbHandCardCount < 5) return;
|
|
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//大小排序
|
|
SortCardList(cbTempCardData, cbHandCardCount, ST_ORDER);
|
|
|
|
BYTE cbFirstCard = 0;
|
|
//去除2和王
|
|
for (BYTE i=0; i<cbHandCardCount; ++i)
|
|
{
|
|
if (GetCardLogicValue(cbTempCardData[i]) < 15)
|
|
{
|
|
cbFirstCard = i;
|
|
break;
|
|
}
|
|
}
|
|
//数据校验
|
|
if (cbHandCardCount-cbFirstCard<5) return;
|
|
|
|
BYTE cbSingleLineCount=0, cbSingleLineCard[12]={0};
|
|
BYTE cbLeftCardCount = cbHandCardCount-cbFirstCard;
|
|
bool bFindSingleLine = true;
|
|
//连牌判断
|
|
while (cbLeftCardCount>=5 && bFindSingleLine)
|
|
{
|
|
cbSingleLineCount = 1;
|
|
bFindSingleLine = false;
|
|
BYTE cbLastCard = cbTempCardData[cbFirstCard];
|
|
cbSingleLineCard[cbSingleLineCount-1] = cbTempCardData[cbFirstCard];
|
|
for (BYTE i=cbFirstCard+1; i<cbLeftCardCount; i++)
|
|
{
|
|
BYTE cbCardData = cbTempCardData[i];
|
|
//连续判断
|
|
if (GetCardLogicValue(cbLastCard)-GetCardLogicValue(cbCardData)!=1 && GetCardValue(cbLastCard)!=GetCardValue(cbCardData))
|
|
{
|
|
cbLastCard = cbTempCardData[i];
|
|
if (cbSingleLineCount < 5)
|
|
{
|
|
cbSingleLineCount = 1;
|
|
cbSingleLineCard[cbSingleLineCount-1] = cbTempCardData[i];
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
//同牌判断
|
|
else if (GetCardValue(cbLastCard) != GetCardValue(cbCardData))
|
|
{
|
|
cbLastCard = cbCardData;
|
|
cbSingleLineCard[cbSingleLineCount] = cbCardData;
|
|
++cbSingleLineCount;
|
|
}
|
|
}
|
|
|
|
//保存数据
|
|
if (cbSingleLineCount >= 5)
|
|
{
|
|
RemoveCard(cbSingleLineCard, cbSingleLineCount, cbTempCardData, cbLeftCardCount);
|
|
memcpy(cbLineCardData+cbLineCardCount, cbSingleLineCard, sizeof(BYTE)*cbSingleLineCount);
|
|
cbLineCardCount += cbSingleLineCount;
|
|
cbLeftCardCount -= cbSingleLineCount;
|
|
bFindSingleLine = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//分析顺子
|
|
void CGameLogic::GetAllLineCard( const BYTE cbHandCardData[], const BYTE cbHandCardCount, tagPromptCardInfo &PromptCardInfo )
|
|
{
|
|
//数据校验
|
|
if (cbHandCardCount < 5) return;
|
|
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//大小排序
|
|
SortCardList(cbTempCardData, cbHandCardCount, ST_ORDER);
|
|
|
|
BYTE cbFirstCard = 0;
|
|
//去除2和王
|
|
for (BYTE i=0; i<cbHandCardCount; ++i)
|
|
{
|
|
if (GetCardLogicValue(cbTempCardData[i]) < 15)
|
|
{
|
|
cbFirstCard = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
BYTE cbLinkResult = 0;
|
|
BYTE cbSingleLineCard[12] = {0};
|
|
BYTE cbSingleLineCount = 0;
|
|
BYTE cbLeftCardCount = cbHandCardCount - cbFirstCard;
|
|
bool bFindSingleLine = true;
|
|
//连牌判断
|
|
while (cbLeftCardCount>=5 && bFindSingleLine)
|
|
{
|
|
cbSingleLineCount = 1;
|
|
bFindSingleLine = false;
|
|
BYTE cbLastCard = cbTempCardData[cbFirstCard];
|
|
cbSingleLineCard[cbSingleLineCount-1] = cbTempCardData[cbFirstCard];
|
|
for (BYTE i=cbFirstCard+1; i<cbLeftCardCount; i++)
|
|
{
|
|
BYTE cbCardData=cbTempCardData[i];
|
|
|
|
//连续判断
|
|
if (GetCardLogicValue(cbLastCard)-GetCardLogicValue(cbCardData)!=1 && GetCardValue(cbLastCard)!=GetCardValue(cbCardData))
|
|
{
|
|
cbLastCard = cbTempCardData[i];
|
|
if (cbSingleLineCount < 5)
|
|
{
|
|
cbSingleLineCount = 1;
|
|
cbSingleLineCard[cbSingleLineCount-1] = cbTempCardData[i];
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
//同牌判断
|
|
else if (GetCardValue(cbLastCard) != GetCardValue(cbCardData))
|
|
{
|
|
cbLastCard = cbCardData;
|
|
cbSingleLineCard[cbSingleLineCount] = cbCardData;
|
|
++cbSingleLineCount;
|
|
}
|
|
}
|
|
|
|
//保存数据
|
|
if (cbSingleLineCount >= 5)
|
|
{
|
|
RemoveCard(cbSingleLineCard, cbSingleLineCount, cbTempCardData, cbLeftCardCount);
|
|
CopyMemory(PromptCardInfo.stSingleLineResult.cbCardData[cbLinkResult], cbSingleLineCard, sizeof(BYTE)*cbSingleLineCount);
|
|
PromptCardInfo.stSingleLineResult.cbCardCount[cbLinkResult] = cbSingleLineCount;
|
|
++PromptCardInfo.stSingleLineResult.cbResultCount;
|
|
++cbLinkResult;
|
|
cbLeftCardCount -= cbSingleLineCount;
|
|
bFindSingleLine = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//提取信息
|
|
void CGameLogic::PromptHandCardEachType( const BYTE cbHandCardData[], const BYTE cbHandCardCount, tagPromptCardInfo &PromptCardInfo )
|
|
{
|
|
ZeroMemory(&PromptCardInfo, sizeof(tagPromptCardInfo));
|
|
ASSERT(cbHandCardCount>=0 && cbHandCardCount<=MAX_COUNT);
|
|
if (cbHandCardCount==0 || cbHandCardCount>MAX_COUNT) return;
|
|
|
|
//拷贝数据
|
|
BYTE cbTempCardData[MAX_COUNT] = {0};
|
|
BYTE cbTempCardCount = cbHandCardCount;
|
|
CopyMemory(cbTempCardData, cbHandCardData, cbHandCardCount);
|
|
//排序扑克
|
|
SortCardList(cbTempCardData, cbTempCardCount, ST_ORDER);
|
|
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult;
|
|
VERIFY(AnalysebCardData(cbTempCardData,cbTempCardCount,AnalyseResult));
|
|
|
|
//火箭
|
|
if (AnalyseResult.cbSingleCount>=2 && AnalyseResult.cbSingleCardData[0]==0x4F && AnalyseResult.cbSingleCardData[1]==0x4E)
|
|
{
|
|
PromptCardInfo.stRocketResult.cbResultCount = 1;
|
|
PromptCardInfo.stRocketResult.cbCardCount[0] = 2;
|
|
PromptCardInfo.stRocketResult.cbCardData[0][0] = 0x4F;
|
|
PromptCardInfo.stRocketResult.cbCardData[0][1] = 0x4E;
|
|
}
|
|
|
|
//炸弹
|
|
if (AnalyseResult.cbFourCount > 0)
|
|
{
|
|
PromptCardInfo.stBombResult.cbResultCount = AnalyseResult.cbFourCount;
|
|
for (int i=AnalyseResult.cbFourCount,k=0; i>0; --i,++k)
|
|
{
|
|
PromptCardInfo.stBombResult.cbCardCount[k] = 4;
|
|
CopyMemory(PromptCardInfo.stBombResult.cbCardData[k], &AnalyseResult.cbFourCardData[(i-1)*4], sizeof(BYTE)*4);
|
|
}
|
|
}
|
|
|
|
//四带二
|
|
if (AnalyseResult.cbFourCount>0 && cbHandCardCount>=6)
|
|
{
|
|
int iResultCount = 0;
|
|
for (int i=AnalyseResult.cbFourCount,k=0; i>0; --i,++k)
|
|
{
|
|
//四带二单
|
|
if (AnalyseResult.cbSingleCount >= 2)
|
|
{
|
|
PromptCardInfo.stFourTwoResult.cbCardCount[iResultCount] = 6;
|
|
CopyMemory(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], &AnalyseResult.cbFourCardData[(i-1)*4], sizeof(BYTE)*4);
|
|
CopyMemory(&PromptCardInfo.stFourTwoResult.cbCardData[iResultCount][4], &AnalyseResult.cbSingleCardData[AnalyseResult.cbSingleCount-2], sizeof(BYTE)*2);
|
|
SortCardList(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], 6, ST_ORDER);
|
|
++iResultCount;
|
|
}
|
|
else
|
|
{
|
|
BYTE cbElemCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbElemCardData, cbHandCardData, cbHandCardCount);
|
|
RemoveCard(&AnalyseResult.cbFourCardData[(i-1)*4], 4, cbElemCardData, cbHandCardCount);
|
|
PromptCardInfo.stFourTwoResult.cbCardCount[iResultCount] = 6;
|
|
CopyMemory(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], &AnalyseResult.cbFourCardData[(i-1)*4], sizeof(BYTE)*4);
|
|
CopyMemory(&PromptCardInfo.stFourTwoResult.cbCardData[iResultCount][4], &cbElemCardData[cbHandCardCount-6], sizeof(BYTE)*2);
|
|
SortCardList(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], 6, ST_ORDER);
|
|
++iResultCount;
|
|
}
|
|
//四带二双
|
|
if (cbHandCardCount >= 8)
|
|
{
|
|
if (AnalyseResult.cbDoubleCount >= 2)
|
|
{
|
|
PromptCardInfo.stFourTwoResult.cbCardCount[iResultCount] = 8;
|
|
CopyMemory(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], &AnalyseResult.cbFourCardData[(i-1)*4], sizeof(BYTE)*4);
|
|
CopyMemory(&PromptCardInfo.stFourTwoResult.cbCardData[iResultCount][4], &AnalyseResult.cbDoubleCardData[AnalyseResult.cbDoubleCount*2-4], sizeof(BYTE)*4);
|
|
SortCardList(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], 8, ST_ORDER);
|
|
++iResultCount;
|
|
}
|
|
else
|
|
{
|
|
BYTE cbElemCardData[MAX_COUNT] = {0};
|
|
CopyMemory(cbElemCardData, cbHandCardData, cbHandCardCount);
|
|
RemoveCard(&AnalyseResult.cbFourCardData[(i-1)*4], 4, cbElemCardData, cbHandCardCount);
|
|
//提取对牌
|
|
BYTE cbDoubleCard[MAX_COUNT]={0}, cbDoubleCount=0;
|
|
GetAllDoubleCard(cbElemCardData, cbHandCardCount-4, cbDoubleCard, cbDoubleCount);
|
|
if (cbDoubleCount >= 4)
|
|
{
|
|
PromptCardInfo.stFourTwoResult.cbCardCount[iResultCount] = 8;
|
|
CopyMemory(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], &AnalyseResult.cbFourCardData[(i-1)*4], sizeof(BYTE)*4);
|
|
CopyMemory(&PromptCardInfo.stFourTwoResult.cbCardData[iResultCount][4], &cbDoubleCard[cbDoubleCount-4], sizeof(BYTE)*4);
|
|
SortCardList(PromptCardInfo.stFourTwoResult.cbCardData[iResultCount], 8, ST_ORDER);
|
|
++iResultCount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
PromptCardInfo.stFourTwoResult.cbResultCount = iResultCount;
|
|
}
|
|
|
|
//飞机
|
|
BYTE cbThreeCardData[MAX_COUNT]={0}, cbThreeCardCount=0;
|
|
GetAllThreeCard(cbHandCardData, cbHandCardCount, cbThreeCardData, cbThreeCardCount);
|
|
if (cbThreeCardCount >= 6)
|
|
{
|
|
for (int i=0; i<cbThreeCardCount/3-1; ++i)
|
|
{
|
|
if (GetCardLogicValue(cbThreeCardData[i*3])<=14 && GetCardLogicValue(cbThreeCardData[i*3])==GetCardLogicValue(cbThreeCardData[(i+1)*3])+1)
|
|
{
|
|
PromptCardInfo.cbPlaneResult.cbResultCount = 1;
|
|
CopyMemory(PromptCardInfo.cbPlaneResult.cbCardData[0], &cbThreeCardData[i*3], sizeof(BYTE)*6);
|
|
PromptCardInfo.cbPlaneResult.cbCardCount[0] = 6;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//姐妹对
|
|
BYTE cbElemCardData[MAX_COUNT]={0}, cbElemCardCount=cbHandCardCount;
|
|
CopyMemory(cbElemCardData, cbHandCardData, cbHandCardCount);
|
|
BYTE cbDoubleCard[MAX_COUNT]={0}, cbDoubleCount=0;
|
|
BYTE cbDoubleLineCount = 0;
|
|
while(true)
|
|
{
|
|
ZeroMemory(cbDoubleCard, cbDoubleCount);
|
|
GetAllDoubleCard(cbElemCardData, cbElemCardCount, cbDoubleCard, cbDoubleCount);
|
|
if (cbDoubleCount >= 6)
|
|
{
|
|
BYTE cbSameCount=1, cbPos=0;
|
|
for (int i=0,n=cbDoubleCount/2; i<n; ++i)
|
|
{
|
|
for (int k=i; k<n-1; ++k)
|
|
{
|
|
if (GetCardLogicValue(cbDoubleCard[k*2])<=14 && GetCardLogicValue(cbDoubleCard[k*2])==GetCardLogicValue(cbDoubleCard[(k+1)*2])+1)
|
|
{
|
|
++cbSameCount;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (cbSameCount > 2)
|
|
{
|
|
cbPos = i*2;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
cbSameCount = 1;
|
|
}
|
|
}
|
|
|
|
if (cbSameCount > 2)
|
|
{
|
|
++PromptCardInfo.stDoubleLineResult.cbResultCount;
|
|
PromptCardInfo.stDoubleLineResult.cbCardCount[cbDoubleLineCount] = cbSameCount*2;
|
|
CopyMemory(PromptCardInfo.stDoubleLineResult.cbCardData[cbDoubleLineCount], &cbDoubleCard[cbPos], sizeof(BYTE)*cbSameCount*2);
|
|
RemoveCard(PromptCardInfo.stDoubleLineResult.cbCardData[cbDoubleLineCount], cbSameCount*2, cbElemCardData, cbElemCardCount);
|
|
cbElemCardCount -= cbSameCount*2;
|
|
++cbDoubleLineCount;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//顺子
|
|
GetAllLineCard(cbHandCardData, cbHandCardCount, PromptCardInfo);
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|