//是否同花顺
bool CGameLogic::IsTongHuaShun(BYTE cbCardData[], BYTE cbCardCount)
{
//数目判断
if (cbCardCount!=5) return false;
//变量定义
BYTE bFirstColor=GetCardColor(cbCardData[0]);
BYTE bFirstValue=GetCardLogicValue(cbCardData[0]);
//特殊处理
if (bFirstValue==15)
{
for (BYTE i=1;i<cbCardCount;i++)
{
BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);
if (GetCardColor(cbCardData[i])!=bFirstColor) return false;
if ((bFirstValue!=(cbLogicValue+i))&&(bFirstValue!=(cbLogicValue+i+8))) return false;
}
return true;
}
//分析处理
for (BYTE i=1;i<cbCardCount;i++)
{
if (GetCardColor(cbCardData[i])!=bFirstColor) return false;
if (bFirstValue!=(GetCardLogicValue(cbCardData[i])+i)) return false;
}
return true;
}
//分析扑克
void CGameLogic::AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
//设置结果
ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));
//扑克分析
for (BYTE i=0;i<cbCardCount;i++)
{
//变量定义
BYTE cbSameCount=1;
BYTE cbSameCardData[4]={cbCardData[i],0,0,0};
BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);
//获取同牌
for (int j=i+1;j<cbCardCount;j++)
{
//逻辑对比
if (GetCardLogicValue(cbCardData[j])!=cbLogicValue) break;
//设置扑克
cbSameCardData[cbSameCount++]=cbCardData[j];
}
//保存结果
switch (cbSameCount)
{
case 1: //单张
{
AnalyseResult.cbSignedLogicVolue[AnalyseResult.cbSignedCount]=cbLogicValue;
CopyMemory(&AnalyseResult.cbSignedCardData[(AnalyseResult.cbSignedCount++)*cbSameCount],cbSameCardData,cbSameCount);
break;
}
case 2: //两张
{
AnalyseResult.cbDoubleLogicVolue[AnalyseResult.cbDoubleCount]=cbLogicValue;
CopyMemory(&AnalyseResult.cbDoubleCardData[(AnalyseResult.cbDoubleCount++)*cbSameCount],cbSameCardData,cbSameCount);
break;
}
case 3: //三张
{
AnalyseResult.cbThreeLogicVolue[AnalyseResult.cbThreeCount]=cbLogicValue;
CopyMemory(&AnalyseResult.cbThreeCardData[(AnalyseResult.cbThreeCount++)*cbSameCount],cbSameCardData,cbSameCount);
break;
}
case 4: //四张
{
AnalyseResult.cbFourLogicVolue[AnalyseResult.cbFourCount]=cbLogicValue;
CopyMemory(&AnalyseResult.cbFourCardData[(AnalyseResult.cbFourCount++)*cbSameCount],cbSameCardData,cbSameCount);
break;
}
}
//设置递增
i+=cbSameCount-1;
}
return;
}
//是否对子
bool CGameLogic::IsDouble(BYTE cbCardData[], BYTE cbCardCount)
{
//数目判断
if (cbCardCount!=2) return false;
//分析处理
BYTE bNextValue=GetCardLogicValue(cbCardData[1]);
BYTE bFirstValue=GetCardLogicValue(cbCardData[0]);
return (bNextValue==bFirstValue);
}
//对比扑克
bool CGameLogic::CompareCard(const BYTE bFirstList[], const BYTE bNextList[], BYTE bFirstCount, BYTE bNextCount)
{
//获取类型
BYTE bNextType=GetCardType(bNextList,bNextCount);
BYTE bFirstType=GetCardType(bFirstList,bFirstCount);
//类型判断
if (bFirstType==CT_INVALID) return false;
if (bFirstType==CT_MISSILE_CARD) return true;
//炸弹判断
if ((bFirstType==CT_BOMB_CARD)&&(bNextType!=CT_BOMB_CARD)) return true;
if ((bFirstType!=CT_BOMB_CARD)&&(bNextType==CT_BOMB_CARD)) return false;
//规则判断
if ((bFirstType!=bNextType)||(bFirstCount!=bNextCount)) return false;
//开始对比
switch (bNextType)
{
case CT_SINGLE:
case CT_DOUBLE:
case CT_THREE:
case CT_ONE_LINE:
case CT_DOUBLE_LINE:
case CT_THREE_LINE:
case CT_BOMB_CARD:
{
BYTE bFirstLogicValue=GetCardLogicValue(bFirstList[0]);
BYTE bNextLogicValue=GetCardLogicValue(bNextList[0]);
return bFirstLogicValue>bNextLogicValue;
}
case CT_THREE_LINE_TAKE_ONE:
case CT_THREE_LINE_TAKE_DOUBLE:
{
tagAnalyseResult NextResult;
tagAnalyseResult FirstResult;
AnalysebCardData(bNextList,bNextCount,NextResult);
AnalysebCardData(bFirstList,bFirstCount,FirstResult);
return FirstResult.bThreeLogicVolue[0]>NextResult.bThreeLogicVolue[0];
}
case CT_FOUR_LINE_TAKE_ONE:
case CT_FOUR_LINE_TAKE_DOUBLE:
{
tagAnalyseResult NextResult;
tagAnalyseResult FirstResult;
AnalysebCardData(bNextList,bNextCount,NextResult);
AnalysebCardData(bFirstList,bFirstCount,FirstResult);
return FirstResult.bFourLogicVolue[0]>NextResult.bFourLogicVolue[0];
}
}
return false;
}
//对比扑克
bool CGameLogic::CompareCard(BYTE cbFirstCardData, BYTE cbNextCardData)
{
//数值判断
BYTE cbNextValue=GetCardLogicValue(cbNextCardData);
BYTE cbFirstValue=GetCardLogicValue(cbFirstCardData);
if (cbFirstValue!=cbNextValue) return (cbFirstValue>cbNextValue);
//花色判断
BYTE cbNextColor=GetCardColor(cbNextCardData);
BYTE cbFirstColor=GetCardColor(cbFirstCardData);
return (cbFirstColor>cbNextColor);
}
//是否三条
bool CGameLogic::IsSanTiao(BYTE cbCardData[], BYTE cbCardCount)
{
//数目判断
if (cbCardCount!=3) return false;
//分析处理
BYTE bFirstValue=GetCardLogicValue(cbCardData[0]);
for (BYTE i=1;i<cbCardCount;i++)
{
if (GetCardLogicValue(cbCardData[i])!=bFirstValue) return false;
}
return true;
}
//是否葫芦
bool CGameLogic::IsHuLu(BYTE cbCardData[], BYTE cbCardCount)
{
//数目判断
if (cbCardCount!=5) return false;
//分析处理
BYTE bMidValue=GetCardLogicValue(cbCardData[2]);
BYTE bLastValue=GetCardLogicValue(cbCardData[4]);
BYTE bFirstValue=GetCardLogicValue(cbCardData[0]);
if (GetCardLogicValue(cbCardData[3])!=bLastValue) return false;
if (GetCardLogicValue(cbCardData[1])!=bFirstValue) return false;
if ((bMidValue!=bFirstValue)&&(bMidValue!=bLastValue)) return false;
return true;
}
//排列扑克
void CGameLogic::SortCardList(BYTE cbCardData[], BYTE cbCardCount, BYTE cbSortType)
{
//数目过虑
if (cbCardCount==0) return;
//转换数值
BYTE cbSortValue[MAX_COUNT];
for (BYTE i=0;i<cbCardCount;i++) cbSortValue[i]=GetCardLogicValue(cbCardData[i]);
//排序操作
bool bSorted=true;
BYTE cbThreeCount,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;
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
//拷贝四牌
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.cbSignedCardData,sizeof(BYTE)*AnalyseResult.cbSignedCount);
cbIndex+=AnalyseResult.cbSignedCount;
}
return;
}
//排列扑克
void CGameLogic::SortCardList(BYTE cbCardData[], BYTE cbCardCount)
{
//转换数值
BYTE cbLogicValue[MAX_COUNT];
for (BYTE i=0;i<cbCardCount;i++) cbLogicValue[i]=GetCardLogicValue(cbCardData[i]);
//排序操作
bool bSorted=true;
BYTE cbTempData,bLast=cbCardCount-1;
do
{
bSorted=true;
for (BYTE i=0;i<bLast;i++)
{
if ((cbLogicValue[i]<cbLogicValue[i+1])||
((cbLogicValue[i]==cbLogicValue[i+1])&&(cbCardData[i]<cbCardData[i+1])))
{
//交换位置
cbTempData=cbCardData[i];
cbCardData[i]=cbCardData[i+1];
cbCardData[i+1]=cbTempData;
cbTempData=cbLogicValue[i];
cbLogicValue[i]=cbLogicValue[i+1];
cbLogicValue[i+1]=cbTempData;
bSorted=false;
}
}
bLast--;
} while(bSorted==false);
return;
}
//排列扑克
void CGameLogic::SortCardList(BYTE bCardData[], BYTE bCardCount)
{
//转换数值
BYTE bLogicVolue[ZHUANG_CARD_NUM /*20*/];
for (BYTE i=0;i<bCardCount;i++) bLogicVolue[i]=GetCardLogicValue(bCardData[i]);
//排序操作
bool bSorted=true;
BYTE bTempData,bLast=bCardCount-1;
do
{
bSorted=true;
for (BYTE i=0;i<bLast;i++)
{
if ((bLogicVolue[i]<bLogicVolue[i+1])||
((bLogicVolue[i]==bLogicVolue[i+1])&&(bCardData[i]<bCardData[i+1])))
{
//交换位置
bTempData=bCardData[i];
bCardData[i]=bCardData[i+1];
bCardData[i+1]=bTempData;
bTempData=bLogicVolue[i];
bLogicVolue[i]=bLogicVolue[i+1];
bLogicVolue[i+1]=bTempData;
bSorted=false;
}
}
bLast--;
} while(bSorted==false);
return;
}
//对比扑克
bool CGameLogic::CompareCardData(BYTE cbFirstCardData, BYTE cbNextCardData)
{
//获取花色
BYTE cbLogicColorNext=GetCardLogicColor(cbNextCardData);
BYTE cbLogicColorFirst=GetCardLogicColor(cbFirstCardData);
//对比大小
if ((cbLogicColorNext==COLOR_NT)||(cbLogicColorNext==cbLogicColorFirst))
{
//获取大小
BYTE cbLogicValueNext=GetCardLogicValue(cbNextCardData);
BYTE cbLogicValueFirst=GetCardLogicValue(cbFirstCardData);
//大小判断
if (cbLogicValueNext>cbLogicValueFirst) return true;
}
return false;
}
//获取整数
bool CGameLogic::IsIntValue(BYTE cbCardData[], BYTE cbCardCount)
{
BYTE sum=0;
for(BYTE i=0; i<cbCardCount; i++)
{
sum+=GetCardLogicValue(cbCardData[i]);
}
ASSERT(sum>0);
return (sum%10==0);
}
//是否铁支
bool CGameLogic::IsTieZhi(BYTE cbCardData[], BYTE cbCardCount)
{
//数目判断
if (cbCardCount!=5) return false;
//变量定义
BYTE bNoFixCount=0;
BYTE bCenterValue=GetCardLogicValue(cbCardData[1]);
//分析处理
for (BYTE i=0;i<cbCardCount;i++)
{
if (GetCardLogicValue(cbCardData[i])!=bCenterValue)
{
bNoFixCount++;
if (bNoFixCount>1) return false;
}
}
return (bNoFixCount==1);
}
//排列扑克
void CGameLogic::SortCardList(BYTE cbCardData[], BYTE cbCardCount, BYTE cbSortType)
{
//数目过虑
if (cbCardCount==0) return;
//转换数值
BYTE cbSortValue[CARD_COUNT];
if (ST_VALUE==cbSortType)
{
for (BYTE i=0;i<cbCardCount;i++) cbSortValue[i]=GetCardValue(cbCardData[i]);
}
else
{
if(cbSortType==ST_NEW)
{
for (BYTE i=0;i<cbCardCount;i++) cbSortValue[i]=GetCardNewValue(cbCardData[i]);
}else
{
for (BYTE i=0;i<cbCardCount;i++) cbSortValue[i]=GetCardLogicValue(cbCardData[i]);
}
}
//排序操作
bool bSorted=true;
BYTE cbThreeCount,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);
return;
}
//对比扑克
bool CGameLogic::CompareCard(const BYTE bFirstList[], const BYTE bNextList[], BYTE bFirstCount, BYTE bNextCount)
{
//获取类型
BYTE bNextType=GetCardType(bNextList,bNextCount);
BYTE bFirstType=GetCardType(bFirstList,bFirstCount);
//类型判断
if (bFirstType==CT_INVALID) return false;
// if (bFirstType==CT_MISSILE_CARD) return true;
//炸弹判断
//Del by doctor 20071202 if ((bFirstType==CT_BOMB_CARD)&&(bNextType!=CT_BOMB_CARD)) return true;
//Del by doctor 20071202 if ((bFirstType!=CT_BOMB_CARD)&&(bNextType==CT_BOMB_CARD)) return false;
//规则判断
if ((bFirstType!=bNextType)||(bFirstCount!=bNextCount)) return false;
//开始对比
switch (bNextType)
{
case CT_SINGLE://单
case CT_DOUBLE://对
case CT_THREE://三
case CT_ONE_LINE:
case CT_DOUBLE_LINE:
case CT_THREE_LINE:
case CT_BOMB_CARD://4牌，炸弹
{
BYTE bFirstLogicValue=GetCardLogicValue(bFirstList[0]);
BYTE bNextLogicValue=GetCardLogicValue(bNextList[0]);
return bFirstLogicValue>bNextLogicValue;
}
}
return false;
}
//获取类型
BYTE CGameLogic::GetCardType( BYTE cbCardData[], BYTE cbCardCount, BYTE cbOutCard[]/*=NULL*/, bool bGet/*=false*/ )
{
ASSERT(cbCardCount==MAX_COUNT);
BYTE bKingCount=0,bJokeCount=0;
for(BYTE i=0; i<cbCardCount; i++)
{
if(GetCardValue(cbCardData[i])>10)
{
bKingCount++;
if(GetCardValue(cbCardData[i])>=0xE)
{
bJokeCount++;
}
}
}
if(bKingCount==MAX_COUNT)
{
if(bJokeCount == 2) return OX_DOUBLE_JOKE;
return OX_GOLD;
}
BYTE bTemp[MAX_COUNT];
BYTE bSum=0;
for (BYTE i=0; i<cbCardCount; i++)
{
bTemp[i]=GetCardLogicValue(cbCardData[i]);
bSum+=bTemp[i];
}
for (BYTE i=0; i<cbCardCount-1; i++)
{
for (BYTE j=i+1; j<cbCardCount; j++)
{
if((bSum-bTemp[i]-bTemp[j])%10==0)
{
if (bGet)
{
cbOutCard[0] = cbCardData[i];
cbOutCard[1] = cbCardData[j];
}
return ((bTemp[i]+bTemp[j])>10)?(bTemp[i]+bTemp[j]-10):(bTemp[i]+bTemp[j]);
}
}
}
return OX_VALUE0;
}
//获取牛牛
bool CGameLogic::GetOxCard(BYTE cbCardData[], BYTE cbCardCount)
{
ASSERT(cbCardCount==MAX_COUNT);
//设置变量
BYTE bTemp[MAX_COUNT],bTempData[MAX_COUNT];
CopyMemory(bTempData,cbCardData,sizeof(bTempData));
BYTE bSum=0;
for (BYTE i=0; i<cbCardCount; i++)
{
bTemp[i]=GetCardLogicValue(cbCardData[i]);
bSum+=bTemp[i];
}
//查找牛牛
for (BYTE i=0; i<cbCardCount-1; i++)
{
for (BYTE j=i+1; j<cbCardCount; j++)
{
if((bSum-bTemp[i]-bTemp[j])%10==0)
{
BYTE bCount=0;
for (BYTE k=0; k<cbCardCount; k++)
{
if(k!=i && k!=j)
{
cbCardData[bCount++] = bTempData[k];
}
}
ASSERT(bCount==3);
cbCardData[bCount++] = bTempData[i];
cbCardData[bCount++] = bTempData[j];
return true;
}
}
}
return false;
}
//分析扑克
void CGameLogic::AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
//设置结果
ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));
//扑克分析
for (BYTE i=0;i<cbCardCount;i++)
{
//变量定义
BYTE cbSameCount=1,cbCardValueTemp=0;
BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);
//搜索同牌
for (BYTE j=i+1;j<cbCardCount;j++)
{
//获取扑克
if (GetCardLogicValue(cbCardData[j])!=cbLogicValue) break;
//设置变量
cbSameCount++;
}
//设置结果
switch (cbSameCount)
{
case 1: //单张
{
BYTE cbIndex=AnalyseResult.cbSignedCount++;
AnalyseResult.cbSignedCardData[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;
}
}
//设置索引
i+=cbSameCount-1;
}
return;
}
//获取类型
BYTE CGameLogic::GetCardType(const BYTE bCardData[], BYTE bCardCount)
{
CString strFile,strTemp;
CTime tmCur = CTime::GetCurrentTime();
CString strTime = tmCur.Format("%m%d");
strFile.Format("log\\%sGetCardType.log",strTime);
strTemp.Format("GetCardType %d", bCardCount);
theApp.WriteLog(strFile, strTemp);
//开始分析
switch (bCardCount)
{
case 1: //单牌
{
return CT_SINGLE;
}
case 2: //对牌和火箭
{
return (GetCardLogicValue(bCardData[0])==GetCardLogicValue(bCardData[1]))?CT_DOUBLE:CT_INVALID;
}
case 3:
case 4: //连牌和炸弹
{
//单张判断
if (IsDanLianCardType( bCardData, bCardCount))
{
strTemp.Format("IsDanLianCardType %d", bCardCount);
theApp.WriteLog(strFile, strTemp);
return CT_ONE_LINE;
}
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
BYTE i;
for ( i=1;i<bCardCount;i++)
{
if (bLogicValue!=GetCardLogicValue(bCardData[i])) break;
}
if (i==bCardCount) return (bCardCount==3)?CT_THREE:CT_BOMB_CARD;
if (bCardCount==3) return CT_INVALID;
break;
}
case 5:
{
//单张判断
if (IsDanLianCardType( bCardData, bCardCount))
{
strTemp.Format("IsDanLianCardType %d", bCardCount);
theApp.WriteLog(strFile, strTemp);
return CT_ONE_LINE;
}
break;
}
}
//其他牌型
if (bCardCount>=4)
{
//分析扑克
tagAnalyseResult AnalyseResult;
AnalysebCardData(bCardData,bCardCount,AnalyseResult);
strTemp.Format("AnalyseResult.bFourCount %d, AnalyseResult.bThreeCount=%d, AnalyseResult.bDoubleCount=%d", AnalyseResult.bFourCount, AnalyseResult.bThreeCount,AnalyseResult.bDoubleCount );
theApp.WriteLog(strFile, strTemp);
//四牌判断
if (AnalyseResult.bFourCount>0 )
{
return CT_INVALID;
}
//三牌判断
if (AnalyseResult.bThreeCount>0 && bCardCount >= 9 )
{
if (IsThreeLianCardType( bCardData, bCardCount))
{
return CT_THREE_LINE;
}
}
/*
if (AnalyseResult.bThreeCount>0)
{
//连牌判断
if (AnalyseResult.bThreeCount>1)
{
if (AnalyseResult.bThreeLogicVolue[0]==15) return CT_INVALID;
for (BYTE i=1;i<AnalyseResult.bThreeCount;i++)
{
if (AnalyseResult.bThreeLogicVolue[i]!=(AnalyseResult.bThreeLogicVolue[0]-i)) return CT_INVALID;
}
}
//牌形判断
if (AnalyseResult.bThreeCount*3==bCardCount) return CT_THREE_LINE;
if (AnalyseResult.bThreeCount==(bCardCount-AnalyseResult.bThreeCount*3)) return CT_THREE_LINE_TAKE_ONE;
if ((AnalyseResult.bDoubleCount==AnalyseResult.bThreeCount)&&(bCardCount==(AnalyseResult.bThreeCount*3+AnalyseResult.bDoubleCount*2))) return CT_THREE_LINE_TAKE_DOUBLE;
return CT_INVALID;
}
*/
//两张类型
if (AnalyseResult.bDoubleCount>=3 && bCardCount >= 6 )
{
if ( IsShuangLianCardType( bCardData, bCardCount))
{
return CT_DOUBLE_LINE;
}
}
/*
if (AnalyseResult.bDoubleCount>=3)
{
//二连判断
if (AnalyseResult.bDoubleLogicVolue[0]!=15)
{
for (BYTE i=1;i<AnalyseResult.bDoubleCount;i++)
{
if (AnalyseResult.bDoubleLogicVolue[i]!=(AnalyseResult.bDoubleLogicVolue[0]-i)) return CT_INVALID;
}
if (AnalyseResult.bDoubleCount*2==bCardCount) return CT_DOUBLE_LINE;
}
return CT_INVALID;
}
*/
//单张判断
if ((AnalyseResult.bSignedCount>= 3 )&&(AnalyseResult.bSignedCount==bCardCount) && bCardCount >= 6)
{
if (IsDanLianCardType( bCardData, bCardCount))
{
return CT_ONE_LINE;
}
}
/*
if ((AnalyseResult.bSignedCount>= 3 )&&(AnalyseResult.bSignedCount==bCardCount))
{
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
if (bLogicValue>=15) return CT_INVALID;
for (BYTE i=1;i<AnalyseResult.bSignedCount;i++)
{
if (GetCardLogicValue(bCardData[i])!=(bLogicValue-i)) return CT_INVALID;
}
return CT_ONE_LINE;
}
*/
return CT_INVALID;
}
return CT_INVALID;
}
//是否为单联
//条件：>= 3
bool CGameLogic::IsDanLianCardType(const BYTE bCardData[], BYTE bCardCount)
{
CString strFile,strTemp;
CTime tmCur = CTime::GetCurrentTime();
CString strTime = tmCur.Format("%m%d");
strFile.Format("log\\%sIsDanLianCardType.log",strTime);
strTemp.Format("IsDanLianCardType %d", bCardCount);
theApp.WriteLog(strFile, strTemp);
bool resultBool = false;
if (bCardCount < 3 )
{
return resultBool;
}
//如果有对牌
if( IsHaveDuiCard( bCardData , bCardCount))
{
strTemp.Format("IsHaveDuiCard ");
theApp.WriteLog(strFile, strTemp);
return resultBool;
}
//其他牌型
if (bCardCount>=3)
{
//分析扑克
tagAnalyseResult AnalyseResult;
AnalysebCardData(bCardData,bCardCount,AnalyseResult);
strTemp.Format("AnalyseResult.bSignedCount=%d, bCardCount=%d ", AnalyseResult.bSignedCount, bCardCount);
theApp.WriteLog(strFile, strTemp);
//单张判断
if ((AnalyseResult.bSignedCount>=3)&&(AnalyseResult.bSignedCount==bCardCount))
{
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
strTemp.Format("bLogicValue =%d ", bLogicValue);
theApp.WriteLog(strFile, strTemp);
if (bLogicValue>=15)
{
return resultBool;
}//End if
for (BYTE i=1;i<AnalyseResult.bSignedCount;i++)
{
if (GetCardLogicValue(bCardData[i])!=(bLogicValue-i))
{
strTemp.Format("GetCardLogicValue(bCardData[i])=%d, (bLogicValue-i)=%d, i=%d", GetCardLogicValue(bCardData[i]), (bLogicValue-i), i);
theApp.WriteLog(strFile, strTemp);
return resultBool;
}
}//End for
resultBool = true;
return resultBool;
}//End if ((AnalyseResult.bSignedCount>=3)&&(AnalyseResult.bSignedCount==bCardCount))
}//End if (bCardCount>=3)
return resultBool;
}
//通比牛牛中获取类型（有大小王的时候获取最大牌型）
BYTE CGameLogic::GetBestCardType( BYTE cbCardData[], BYTE cbCardCount, BYTE cbOutCard[2]/*=NULL*/, bool bGet/*=false*/ )
{
int iJokerCount = IsHaveJoker(cbCardData, cbCardCount);
if (iJokerCount== 2)
{
if (bGet)
{
int j=0;
for (BYTE i=0; i<cbCardCount; i++)
{
if (GetCardValue(cbCardData[i])>=14 )
{
cbOutCard[j] = cbCardData[i];
j++;
break;
}
}
for (BYTE i=0; i<cbCardCount; i++)
{
if (GetCardValue(cbCardData[i])<14 )
{
cbOutCard[j] =cbCardData[i];
j++;
break;
}
}
}
for (int i=0; i<MAX_COUNT; i++)
{
if (GetCardValue(cbCardData[i])>=14 )continue;
if (GetCardValue(cbCardData[i])<11) return 10;
}
return OX_DOUBLE_JOKE;
}
else if (iJokerCount == 1)
{
BYTE bTemp[MAX_COUNT-1];
BYTE cbTecpNoJokerData[MAX_COUNT-1];
BYTE bSum=0;
BYTE iNiu=0;
for (BYTE i=0,j=0; i<cbCardCount; i++)
{
if (GetCardValue(cbCardData[i])>=14 )
{
if (bGet)
{
cbOutCard[0] = cbCardData[i];
}
continue;
}
cbTecpNoJokerData[j] = cbCardData[i];
j++;
}
for (BYTE i=0; i<MAX_COUNT-1; i++)
{
bTemp[i]=GetCardLogicValue(cbTecpNoJokerData[i]);
bSum+=bTemp[i];
}
for (BYTE i=0; i<MAX_COUNT-1; i++)
{
if ((bSum-bTemp[i])%10 == 0)
{
if (bGet)
{
cbOutCard[1] = cbTecpNoJokerData[i];
}
return 10;
}
}
for (BYTE i=0; i<MAX_COUNT-2; i++)
{
for (BYTE j=i+1; j<MAX_COUNT-1; j++)
{
int temp = ((bTemp[i]+bTemp[j])>10)?(bTemp[i]+bTemp[j]-10):(bTemp[i]+bTemp[j]);
if (temp>iNiu)
{
iNiu = temp;
if (bGet)
{
cbOutCard[0] = cbTecpNoJokerData[i];
cbOutCard[1] = cbTecpNoJokerData[j];
}
}
}
}
return iNiu;
}
else
{
return GetCardType(cbCardData, cbCardCount,cbOutCard,bGet);
}
}
//获取类型
BYTE CGameLogic::GetCardType(const BYTE bCardData[], BYTE bCardCount)
{
//开始分析
switch (bCardCount)
{
case 1: //单牌
{
return CT_SINGLE;
}
case 2: //对牌和火箭
{
if ((bCardData[0]==0x42)&&(bCardData[1]==0x41)) return CT_MISSILE_CARD;
return (GetCardLogicValue(bCardData[0])==GetCardLogicValue(bCardData[1]))?CT_DOUBLE:CT_INVALID;
}
case 3:
case 4: //连牌和炸弹
{
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
for (BYTE i=1;i<bCardCount;i++)
{
if (bLogicValue!=GetCardLogicValue(bCardData[i])) break;
}
if (i==bCardCount) return (bCardCount==3)?CT_THREE:CT_BOMB_CARD;
if (bCardCount==3) return CT_INVALID;
break;
}
}
//其他牌型
if (bCardCount>=4)
{
//分析扑克
tagAnalyseResult AnalyseResult;
AnalysebCardData(bCardData,bCardCount,AnalyseResult);
//四牌判断
if (AnalyseResult.bFourCount>0)
{
if ((AnalyseResult.bFourCount==1)&&(bCardCount==5)) return CT_FOUR_LINE_TAKE_ONE;
if ((AnalyseResult.bFourCount==1)&&(AnalyseResult.bDoubleCount==1)&&(bCardCount==6)) return CT_FOUR_LINE_TAKE_ONE;
if ((AnalyseResult.bFourCount==1)&&(AnalyseResult.bDoubleCount==2)&&(bCardCount==8)) return CT_FOUR_LINE_TAKE_DOUBLE;
if ((AnalyseResult.bFourCount==1)&&(bCardCount==6)) return CT_FOUR_LINE_TAKE_DOUBLE;
return CT_INVALID;
}
//三牌判断
if (AnalyseResult.bThreeCount>0)
{
//连牌判断
if (AnalyseResult.bThreeCount>1)
{
if (AnalyseResult.bThreeLogicVolue[0]==15) return CT_INVALID;
for (BYTE i=1;i<AnalyseResult.bThreeCount;i++)
{
if (AnalyseResult.bThreeLogicVolue[i]!=(AnalyseResult.bThreeLogicVolue[0]-i)) return CT_INVALID;
}
}
//牌形判断
if (AnalyseResult.bThreeCount*3==bCardCount) return CT_THREE_LINE;
if (AnalyseResult.bThreeCount==(bCardCount-AnalyseResult.bThreeCount*3)) return CT_THREE_LINE_TAKE_ONE;
if ((AnalyseResult.bDoubleCount==AnalyseResult.bThreeCount)&&(bCardCount==(AnalyseResult.bThreeCount*3+AnalyseResult.bDoubleCount*2))) return CT_THREE_LINE_TAKE_DOUBLE;
return CT_INVALID;
}
//两张类型
if (AnalyseResult.bDoubleCount>=3)
{
//二连判断
if (AnalyseResult.bDoubleLogicVolue[0]!=15)
{
for (BYTE i=1;i<AnalyseResult.bDoubleCount;i++)
{
if (AnalyseResult.bDoubleLogicVolue[i]!=(AnalyseResult.bDoubleLogicVolue[0]-i)) return CT_INVALID;
}
if (AnalyseResult.bDoubleCount*2==bCardCount) return CT_DOUBLE_LINE;
}
return CT_INVALID;
}
//单张判断
if ((AnalyseResult.bSignedCount>=5)&&(AnalyseResult.bSignedCount==bCardCount))
{
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
if (bLogicValue>=15) return CT_INVALID;
for (BYTE i=1;i<AnalyseResult.bSignedCount;i++)
{
if (GetCardLogicValue(bCardData[i])!=(bLogicValue-i)) return CT_INVALID;
}
return CT_ONE_LINE;
}
return CT_INVALID;
}
return CT_INVALID;
}
//获取牌型
BYTE CGameLogic::GetCardType(const BYTE cbCardData[], BYTE cbCardCount,BYTE *bcOutCadData )
{
//合法判断
ASSERT(5==cbCardCount);
if (5!=cbCardCount) return CT_ERROR;
//排序扑克
BYTE cbCardDataSort[CARD_COUNT];
CopyMemory(cbCardDataSort,cbCardData,sizeof(BYTE)*cbCardCount);
SortCardList(cbCardDataSort,cbCardCount,ST_NEW);
if(bcOutCadData != NULL)
{
CopyMemory(bcOutCadData,cbCardDataSort,cbCardCount);
}
int n = 0;
BYTE bcMakeMax[5];
memset(bcMakeMax,0,5);
int iBigValue = 0;
BYTE iSingleA[2];
int iIndex = 0;
bcMakeMax[0]= cbCardDataSort[n];
int iGetTenCount = 0;
for (int iten = 0;iten<cbCardCount;iten++)
{
if(GetCardLogicValue(cbCardDataSort[iten])==10||GetCardLogicValue(cbCardDataSort[iten])==11)
{
iGetTenCount++;
}
}
if( iGetTenCount>=3)
{
if(GetCardColor(cbCardDataSort[0])==0x04&&GetCardColor(cbCardDataSort[1])==0x04)
{
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[0];
bcOutCadData[1] = cbCardDataSort[3];
bcOutCadData[2] = cbCardDataSort[4];
bcOutCadData[3] = cbCardDataSort[1];
bcOutCadData[4] = cbCardDataSort[2];
}
return CT_SPECIAL_NIUNIUDW;
}
if(GetCardColor(cbCardDataSort[0])==0x04)
{
//大小王与最小的组合成牛
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[0];
bcOutCadData[1] = cbCardDataSort[3];
bcOutCadData[2] = cbCardDataSort[4];
bcOutCadData[3] = cbCardDataSort[1];
bcOutCadData[4] = cbCardDataSort[2];
}
if(cbCardDataSort[0]==0x42)
return CT_SPECIAL_NIUNIUDW;
else
return CT_SPECIAL_NIUNIUXW;
}else
{
return RetType(GetCardLogicValue(cbCardDataSort[3])+GetCardLogicValue(cbCardDataSort[4]));
}
}
if(iGetTenCount==2||(iGetTenCount==1&&GetCardColor(cbCardDataSort[0])==0x04))
{
if(GetCardColor(cbCardDataSort[0])==0x04&&GetCardColor(cbCardDataSort[1])==0x04)
{
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[0];
bcOutCadData[1] = cbCardDataSort[3];
bcOutCadData[2] = cbCardDataSort[4];
bcOutCadData[3] = cbCardDataSort[1];
bcOutCadData[4] = cbCardDataSort[2];
}
return CT_SPECIAL_NIUNIUDW;
}else
{
//如果有一张王 其他任意三张组合为10则是牛牛
if(GetCardColor(cbCardDataSort[0])==0x04)
{
for ( n=1;n<cbCardCount;n++)
{
for (int j = 1;j<cbCardCount;j++)
{
if(j != n)
{
for (int w = 1;w<cbCardCount;w++)
{
if(w != n&&w!=j)
{
//如果剩余的四张中任意三张能组合位10的整数倍
if((GetCardLogicValue(cbCardDataSort[n])+GetCardLogicValue(cbCardDataSort[j])+GetCardLogicValue(cbCardDataSort[w]))%10==0)
{
int add = 0;
for (int y = 1;y<cbCardCount;y++)
{
if(y != n&&y!=j&&y!=w)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[n];
bcOutCadData[1] = cbCardDataSort[j];
bcOutCadData[2] = cbCardDataSort[w];
bcOutCadData[3] = cbCardDataSort[0];
bcOutCadData[4] = iSingleA[0];
}
if(cbCardDataSort[0]==0x42)
return CT_SPECIAL_NIUNIUDW;
else
return CT_SPECIAL_NIUNIUXW;
}
}
}
}
}
}
//如果有一张王 其他任意三张组合不为10则 取两张点数最大的组合
BYTE bcTmp[4];
int iBig = 0;
int in = 0;
for ( in = 1;in<cbCardCount;in++)
{
for (int j = 1;j<cbCardCount;j++)
{
if(in != j)
{
BYTE bclogic = (GetCardLogicValue(cbCardDataSort[in])+GetCardLogicValue(cbCardDataSort[j]))%10;
if(bclogic>iBig)
{
iBig = bclogic;
int add = 0;
bcTmp[0]=cbCardDataSort[in];
bcTmp[1]=cbCardDataSort[j];
for (int y = 1;y<cbCardCount;y++)
{
if(y != in&&y!=j)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
bcTmp[2]=iSingleA[0];
bcTmp[3]=iSingleA[1];
}
}
}
}
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[0];
bcOutCadData[1] = bcTmp[2];
bcOutCadData[2] = bcTmp[3];
bcOutCadData[3] = bcTmp[0];
bcOutCadData[4] = bcTmp[1];
}
if(iGetTenCount==1&&GetCardColor(cbCardDataSort[0])==0x04)
{
//下面还能组合 有两张为 10 也可以组合成牛牛
}else
{
//如果没有则比较 完与最小组合最大点数和组合
return RetType(GetCardLogicValue(bcTmp[0])+GetCardLogicValue(bcTmp[1]));
}
}else
{
if((GetCardLogicValue(cbCardDataSort[2])+GetCardLogicValue(cbCardDataSort[3])+GetCardLogicValue(cbCardDataSort[4]))%10==0)
{
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[2];
bcOutCadData[1] = cbCardDataSort[3];
bcOutCadData[2] = cbCardDataSort[4];
bcOutCadData[3] = cbCardDataSort[0];
bcOutCadData[4] = cbCardDataSort[1];
}
return CT_SPECIAL_NIUNIU;
}else
{
for ( n= 2;n<cbCardCount;n++)
{
for (int j = 2;j<cbCardCount;j++)
{
if(j != n)
{
if((GetCardLogicValue(cbCardDataSort[n])+GetCardLogicValue(cbCardDataSort[j]))%10==0)
{
int add = 0;
for (int y = 2;y<cbCardCount;y++)
{
if(y != n&&y!=j)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
if(iBigValue<=iSingleA[0]%10)
{
iBigValue = GetCardLogicValue(iSingleA[0])%10;
if(bcOutCadData != NULL)
{
bcOutCadData[0]= cbCardDataSort[0];
bcOutCadData[1]= cbCardDataSort[n];
bcOutCadData[2]= cbCardDataSort[j];
bcOutCadData[3]= cbCardDataSort[1];
bcOutCadData[4]= iSingleA[0];
}
if(iBigValue==0)
{
return CT_SPECIAL_NIUNIU;
}
}
}
}
}
}
if(iBigValue != 0)
{
return RetType(iBigValue);
}
}
}
}
iGetTenCount = 1;
}
//4个组合
if(iGetTenCount==1)
{
if(GetCardColor(cbCardDataSort[0])==0x04)
{
for ( n= 1;n<cbCardCount;n++)
{
for (int j = 1;j<cbCardCount;j++)
{
if(j != n)
{
//任意两张组合成牛
if((GetCardLogicValue(cbCardDataSort[n])+GetCardLogicValue(cbCardDataSort[j]))%10==0)
{
int add = 0;
for (int y = 1;y<cbCardCount;y++)
{
if(y != n&&y!=j)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[0];
bcOutCadData[1] = iSingleA[0];
bcOutCadData[2] = iSingleA[1];
bcOutCadData[3] = cbCardDataSort[n];
bcOutCadData[4] = cbCardDataSort[j];
}
if(cbCardDataSort[0]==0x42)
return CT_SPECIAL_NIUNIUDW;
else
return CT_SPECIAL_NIUNIUXW;
}
}
}
}
//取4张中组合最大的点数
BYTE bcTmp[4];
int iBig = 0;
int in = 0;
for ( in = 1;in<cbCardCount;in++)
{
for (int j = 1;j<cbCardCount;j++)
{
if(in != j)
{
BYTE bclogic = (GetCardLogicValue(cbCardDataSort[in])+GetCardLogicValue(cbCardDataSort[j]))%10;
if(bclogic>iBig)
{
iBig = bclogic;
int add = 0;
bcTmp[0]=cbCardDataSort[in];
bcTmp[1]=cbCardDataSort[j];
for (int y = 1;y<cbCardCount;y++)
{
if(y != in&&y!=j)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
bcTmp[2]=iSingleA[0];
bcTmp[3]=iSingleA[1];
}
}
}
}
if(bcOutCadData != NULL)
{
bcOutCadData[0] = cbCardDataSort[0];
bcOutCadData[1] = bcTmp[2];
bcOutCadData[2] = bcTmp[3];
bcOutCadData[3] = bcTmp[0];
bcOutCadData[4] = bcTmp[1];
}
return RetType(GetCardLogicValue(bcTmp[0])+GetCardLogicValue(bcTmp[1]));
}
//取4张中任两张组合为10 然后求另外两张的组合看是否是组合中最大
for ( n= 1;n<cbCardCount;n++)
{
for (int j = 1;j<cbCardCount;j++)
{
if(j != n)
{
if((GetCardLogicValue(cbCardDataSort[n])+GetCardLogicValue(cbCardDataSort[j]))%10==0)
{
int add = 0;
for (int y = 1;y<cbCardCount;y++)
{
if(y != n&&y!=j)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
if(iBigValue<=(GetCardLogicValue(iSingleA[0])+GetCardLogicValue(iSingleA[1]))%10)
{
iBigValue = GetCardLogicValue(iSingleA[0])+GetCardLogicValue(iSingleA[1])%10;
bcMakeMax[0]= cbCardDataSort[0];
bcMakeMax[1]= cbCardDataSort[j];
bcMakeMax[2]= cbCardDataSort[n];
bcMakeMax[3]= iSingleA[0];
bcMakeMax[4]= iSingleA[1];
if(bcOutCadData != NULL)
{
CopyMemory(bcOutCadData,bcMakeMax,cbCardCount);
}
if(iBigValue==0)
{
return CT_SPECIAL_NIUNIU;
}
}
}
}
}
}
if(iBigValue!= 0)
{
return RetType(iBigValue);
}else
{
//如果组合不成功
iGetTenCount = 0;
}
}
if(iGetTenCount==0)
{
//5个组合
for ( n= 0;n<cbCardCount;n++)
{
for (int j = 0;j<cbCardCount;j++)
{
if(j != n)
{
for (int w = 0;w<cbCardCount;w++)
{
if(w != n&&w!=j)
{
int valueAdd = GetCardLogicValue(cbCardDataSort[n]);
valueAdd += GetCardLogicValue(cbCardDataSort[j]);
valueAdd += GetCardLogicValue(cbCardDataSort[w]);
if(valueAdd%10==0)
{
int add = 0;
for (int y = 0;y<cbCardCount;y++)
{
if(y != n&&y!=j&&y!=w)
{
iSingleA[add] =cbCardDataSort[y];
add++;
}
}
if(iBigValue<=(GetCardLogicValue(iSingleA[0])+GetCardLogicValue(iSingleA[1]))%10)
{
iBigValue = GetCardLogicValue(iSingleA[0])+GetCardLogicValue(iSingleA[1])%10;
bcMakeMax[0]= cbCardDataSort[n];
bcMakeMax[1]= cbCardDataSort[j];
bcMakeMax[2]= cbCardDataSort[w];
bcMakeMax[3]= iSingleA[0];
bcMakeMax[4]= iSingleA[1];
if(bcOutCadData != NULL)
{
CopyMemory(bcOutCadData,bcMakeMax,cbCardCount);
}
if(iBigValue==0)
{
return CT_SPECIAL_NIUNIU;
}
}
}
}
}
}
}
}
if(iBigValue!=0)
{
return RetType(iBigValue);
}
else
{
return CT_POINT;
}
}
return CT_POINT;
}
//对比扑克
bool CGameLogic::CompareCard(BYTE cbFirstData[], BYTE cbNextData[], BYTE cbCardCount)
{
//获取类型
BYTE cbNextType=GetCardType(cbNextData,cbCardCount);
BYTE cbFirstType=GetCardType(cbFirstData,cbCardCount);
//类型判断
if (cbFirstType!=cbNextType) return (cbFirstType>cbNextType);
//简单类型
switch(cbFirstType)
{
case CT_THREE_JQK: //三公类型
case CT_THREE_KING: //三条类型
{
//对比散牌
BYTE cbNextLogicValue=GetCardLogicValue(cbNextData[0]);
BYTE cbFirstLogicValue=GetCardLogicValue(cbFirstData[0]);
//对比散牌
return cbFirstLogicValue>cbNextLogicValue;
}
case CT_VALUES: //点值类型
{
//获取数值
BYTE cbNextValueList=0;
BYTE cbFirstValueList=0;
for (BYTE i=0;i<MAX_COUNT;i++)
{
BYTE cbNextCardValue=GetCardValue(cbNextData[i]);
BYTE cbFirstCardValue=GetCardValue(cbFirstData[i]);
if (cbNextCardValue<10) cbNextValueList=(cbNextValueList+cbNextCardValue)%10;
if (cbFirstCardValue<10) cbFirstValueList=(cbFirstValueList+cbFirstCardValue)%10;
}
//点值对比
if (cbFirstValueList!=cbNextValueList) return cbFirstValueList>cbNextValueList;
//获取公数
BYTE cbNextCountJQK=0;
BYTE cbFirstCountJQK=0;
for (BYTE i=0;i<MAX_COUNT;i++)
{
if (GetCardValue(cbNextData[i])>10) cbNextCountJQK++;
if (GetCardValue(cbFirstData[i])>10) cbFirstCountJQK++;
}
//公数对比
if (cbFirstCountJQK!=cbNextCountJQK) return cbFirstCountJQK>cbNextCountJQK;
//对比散牌
BYTE cbNextLogicValue=GetCardLogicValue(cbNextData[0]);
BYTE cbFirstLogicValue=GetCardLogicValue(cbFirstData[0]);
//对比散牌
return cbFirstLogicValue>cbNextLogicValue;
}
}
return false;
}
//获取类型
BYTE CGameLogic::GetCardType(const BYTE cbCardData[], BYTE cbCardCount)
{
//简单牌型
switch (cbCardCount)
{
case 0: //空牌
{
return CT_ERROR;
}
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;
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
//四牌判断
if (AnalyseResult.cbFourCount>0)
{
//牌型判断
if ((AnalyseResult.cbFourCount==1)&&(cbCardCount==4)) return CT_BOMB_CARD;
// if ((AnalyseResult.cbFourCount==1)&&(AnalyseResult.cbSignedCount==2)&&(cbCardCount==6)) return CT_FOUR_LINE_TAKE_ONE;
if ((AnalyseResult.cbFourCount==1)&&(AnalyseResult.cbSignedCount==2)&&(cbCardCount==6)) return CT_FOUR_LINE_TAKE_ONE;
if ((AnalyseResult.cbFourCount==1)&&(AnalyseResult.cbDoubleCount==2)&&(cbCardCount==8)) return CT_FOUR_LINE_TAKE_TWO;
return CT_ERROR;
}
//三牌判断
if (AnalyseResult.cbThreeCount>0)
{
//三条类型
if(AnalyseResult.cbThreeCount==1 && cbCardCount==3) return CT_THREE ;
//连牌判断
if (AnalyseResult.cbThreeCount>1)
{
//变量定义
BYTE cbCardData=AnalyseResult.cbThreeCardData[0];
BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
//错误过虑
if (cbFirstLogicValue>=15) return CT_ERROR;
//连牌判断
for (BYTE i=1;i<AnalyseResult.cbThreeCount;i++)
{
BYTE cbCardData=AnalyseResult.cbThreeCardData[i*3];
if (cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) return CT_ERROR;
}
}
//牌形判断
if (AnalyseResult.cbThreeCount*3==cbCardCount) return CT_THREE_LINE;
if (AnalyseResult.cbThreeCount*4==cbCardCount) return CT_THREE_LINE_TAKE_ONE;
if ((AnalyseResult.cbThreeCount*5==cbCardCount)&&(AnalyseResult.cbDoubleCount==AnalyseResult.cbThreeCount)) return CT_THREE_LINE_TAKE_TWO;
return CT_ERROR;
}
//两张类型
if (AnalyseResult.cbDoubleCount>=3)
{
//变量定义
BYTE cbCardData=AnalyseResult.cbDoubleCardData[0];
BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
//错误过虑
if (cbFirstLogicValue>=15) return CT_ERROR;
//连牌判断
for (BYTE i=1;i<AnalyseResult.cbDoubleCount;i++)
{
BYTE cbCardData=AnalyseResult.cbDoubleCardData[i*2];
if (cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) return CT_ERROR;
}
//二连判断
if ((AnalyseResult.cbDoubleCount*2)==cbCardCount) return CT_DOUBLE_LINE;
return CT_ERROR;
}
//单张判断
if ((AnalyseResult.cbSignedCount>=5)&&(AnalyseResult.cbSignedCount==cbCardCount))
{
//变量定义
BYTE cbCardData=AnalyseResult.cbSignedCardData[0];
BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
//错误过虑
if (cbFirstLogicValue>=15) return CT_ERROR;
//连牌判断
for (BYTE i=1;i<AnalyseResult.cbSignedCount;i++)
{
BYTE cbCardData=AnalyseResult.cbSignedCardData[i];
if (cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) return CT_ERROR;
}
return CT_SINGLE_LINE;
}
return CT_ERROR;
}
//获取类型
BYTE CGameLogic::GetCardGenre(BYTE cbCardData[], BYTE cbCardCount)
{
//简单牌形
switch (cbCardCount)
{
case 1: //单牌
{
return CT_SINGLE;
}
case 2: //对牌
{
return (GetCardLogicValue(cbCardData[0])==GetCardLogicValue(cbCardData[1]))?CT_ONE_DOUBLE:CT_SINGLE;
}
}
//五条类型
if (cbCardCount>=4)
{
//变量定义
bool cbSameColor=true,bLineCard=true;
BYTE cbFirstColor=GetCardColor(cbCardData[0]);
BYTE cbFirstValue=GetCardLogicValue(cbCardData[0]);
//牌形分析
for (BYTE i=1;i<cbCardCount;i++)
{
//数据分析
if (GetCardColor(cbCardData[i])!=cbFirstColor) cbSameColor=false;
if (cbFirstValue!=(GetCardLogicValue(cbCardData[i])+i)) bLineCard=false;
//结束判断
if ((cbSameColor==false)&&(bLineCard==false)) break;
}
//特殊
if(!bLineCard)
{
//A J 10 9 8特殊
for (BYTE i=1;i<cbCardCount;i++)
{
if ((cbFirstValue-2)!=(GetCardLogicValue(cbCardData[i])+i)) break;
}
if(i==cbCardCount) bLineCard=true;
}
//顺子类型
if ((cbSameColor==false)&&(bLineCard==true)) return CT_SHUN_ZI;
//同花类型
if ((cbSameColor==true)&&(bLineCard==false)) return CT_TONG_HUA;
//同花顺类型
if ((cbSameColor==true)&&(bLineCard==true)) return CT_TONG_HUA_SHUN;
}
//扑克分析
tagAnalyseResult AnalyseResult;
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
//四条类型
if (AnalyseResult.cbFourCount==1) return CT_TIE_ZHI;
//两对类型
if (AnalyseResult.cbDoubleCount==2) return CT_TWO_DOUBLE;
//对牌类型
if ((AnalyseResult.cbDoubleCount==1)&&(AnalyseResult.cbThreeCount==0)) return CT_ONE_DOUBLE;
//葫芦类型
if (AnalyseResult.cbThreeCount==1) return (AnalyseResult.cbDoubleCount==1)?CT_HU_LU:CT_THREE_TIAO;
return CT_SINGLE;
}
//出牌搜索
bool CGameLogic::SearchOutCard(const BYTE cbHandCardData[], BYTE cbHandCardCount, const BYTE cbTurnCardData[], BYTE cbTurnCardCount, tagOutCardResult & OutCardResult)
{
//设置结果
ZeroMemory(&OutCardResult,sizeof(OutCardResult));
//构造扑克
BYTE cbCardData[MAX_COUNT];
BYTE cbCardCount=cbHandCardCount;
CopyMemory(cbCardData,cbHandCardData,sizeof(BYTE)*cbHandCardCount);
//排列扑克
SortCardList(cbCardData,cbCardCount,ST_ORDER);
//获取类型
BYTE cbTurnOutType=GetCardType(cbTurnCardData,cbTurnCardCount);
//出牌分析
switch (cbTurnOutType)
{
case CT_ERROR: //错误类型
{
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbCardData[cbCardCount-1]);
//多牌判断
BYTE cbSameCount=1;
for (BYTE i=1;i<cbCardCount;i++)
{
if (GetCardLogicValue(cbCardData[cbCardCount-i-1])==cbLogicValue) cbSameCount++;
else break;
}
//完成处理
if (cbSameCount>1)
{
OutCardResult.cbCardCount=cbSameCount;
for (BYTE j=0;j<cbSameCount;j++) OutCardResult.cbResultCard[j]=cbCardData[cbCardCount-1-j];
return true;
}
//单牌处理
OutCardResult.cbCardCount=1;
OutCardResult.cbResultCard[0]=cbCardData[cbCardCount-1];
return true;
}
case CT_SINGLE: //单牌类型
case CT_DOUBLE: //对牌类型
case CT_THREE: //三条类型
{
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//分析扑克
tagAnalyseResult AnalyseResult;
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
//寻找单牌
if (cbTurnCardCount<=1)
{
for (BYTE i=0;i<AnalyseResult.cbSignedCount;i++)
{
BYTE cbIndex=AnalyseResult.cbSignedCount-i-1;
if (GetCardLogicValue(AnalyseResult.cbSignedCardData[cbIndex])>cbLogicValue)
{
//设置结果
OutCardResult.cbCardCount=cbTurnCardCount;
CopyMemory(OutCardResult.cbResultCard,&AnalyseResult.cbSignedCardData[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.cbResultCard,&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.cbResultCard,&AnalyseResult.cbThreeCardData[cbIndex],sizeof(BYTE)*cbTurnCardCount);
return true;
}
}
}
break;
}
case CT_SINGLE_LINE: //单连类型
{
//长度判断
if (cbCardCount<cbTurnCardCount) break;
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//搜索连牌
for (BYTE i=(cbTurnCardCount-1);i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue>=15) break;
if (cbHandLogicValue<=cbLogicValue) continue;
//搜索连牌
BYTE cbLineCount=0;
for (BYTE j=(cbCardCount-i-1);j<cbCardCount;j++)
{
if ((GetCardLogicValue(cbCardData[j])+cbLineCount)==cbHandLogicValue)
{
//增加连数
OutCardResult.cbResultCard[cbLineCount++]=cbCardData[j];
//完成判断
if (cbLineCount==cbTurnCardCount)
{
OutCardResult.cbCardCount=cbTurnCardCount;
return true;
}
}
}
}
break;
}
case CT_DOUBLE_LINE: //对连类型
{
//长度判断
if (cbCardCount<cbTurnCardCount) break;
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//搜索连牌
for (BYTE i=(cbTurnCardCount-1);i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue<=cbLogicValue) continue;
if ((cbTurnCardCount>1)&&(cbHandLogicValue>=15)) break;
//搜索连牌
BYTE cbLineCount=0;
for (BYTE j=(cbCardCount-i-1);j<(cbCardCount-1);j++)
{
if (((GetCardLogicValue(cbCardData[j])+cbLineCount)==cbHandLogicValue)
&&((GetCardLogicValue(cbCardData[j+1])+cbLineCount)==cbHandLogicValue))
{
//增加连数
OutCardResult.cbResultCard[cbLineCount*2]=cbCardData[j];
OutCardResult.cbResultCard[(cbLineCount++)*2+1]=cbCardData[j+1];
//完成判断
if (cbLineCount*2==cbTurnCardCount)
{
OutCardResult.cbCardCount=cbTurnCardCount;
return true;
}
}
}
}
break;
}
case CT_THREE_LINE: //三连类型
case CT_THREE_LINE_TAKE_ONE: //三带一单
case CT_THREE_LINE_TAKE_TWO: //三带一对
{
//长度判断
if (cbCardCount<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_LINE_TAKE_ONE) cbTurnLineCount=cbTurnCardCount/4;
else if (cbTurnOutType==CT_THREE_LINE_TAKE_TWO) cbTurnLineCount=cbTurnCardCount/5;
else cbTurnLineCount=cbTurnCardCount/3;
//搜索连牌
for (BYTE i=cbTurnLineCount*3-1;i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue<=cbLogicValue) continue;
if ((cbTurnLineCount>1)&&(cbHandLogicValue>=15)) break;
//搜索连牌
BYTE cbLineCount=0;
for (BYTE j=(cbCardCount-i-1);j<(cbCardCount-2);j++)
{
//设置变量
OutCardResult.cbCardCount=0;
//三牌判断
if ((GetCardLogicValue(cbCardData[j])+cbLineCount)!=cbHandLogicValue) continue;
if ((GetCardLogicValue(cbCardData[j+1])+cbLineCount)!=cbHandLogicValue) continue;
if ((GetCardLogicValue(cbCardData[j+2])+cbLineCount)!=cbHandLogicValue) continue;
//增加连数
OutCardResult.cbResultCard[cbLineCount*3]=cbCardData[j];
OutCardResult.cbResultCard[cbLineCount*3+1]=cbCardData[j+1];
OutCardResult.cbResultCard[(cbLineCount++)*3+2]=cbCardData[j+2];
//完成判断
if (cbLineCount==cbTurnLineCount)
{
//连牌设置
OutCardResult.cbCardCount=cbLineCount*3;
//构造扑克
BYTE cbLeftCardData[MAX_COUNT];
BYTE cbLeftCount=cbCardCount-OutCardResult.cbCardCount;
CopyMemory(cbLeftCardData,cbCardData,sizeof(BYTE)*cbCardCount);
RemoveCard(OutCardResult.cbResultCard,OutCardResult.cbCardCount,cbLeftCardData,cbCardCount);
//分析扑克
tagAnalyseResult AnalyseResultLeft;
AnalysebCardData(cbLeftCardData,cbLeftCount,AnalyseResultLeft);
//单牌处理
if (cbTurnOutType==CT_THREE_LINE_TAKE_ONE)
{
//提取单牌
for (BYTE k=0;k<AnalyseResultLeft.cbSignedCount;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=AnalyseResultLeft.cbSignedCount-k-1;
BYTE cbSignedCard=AnalyseResultLeft.cbSignedCardData[cbIndex];
OutCardResult.cbResultCard[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.cbResultCard[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.cbResultCard[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.cbResultCard[OutCardResult.cbCardCount++]=cbSignedCard;
}
}
//对牌处理
if (cbTurnOutType==CT_THREE_LINE_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.cbResultCard[OutCardResult.cbCardCount++]=cbCardData1;
OutCardResult.cbResultCard[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.cbResultCard[OutCardResult.cbCardCount++]=cbCardData1;
OutCardResult.cbResultCard[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.cbResultCard[OutCardResult.cbCardCount++]=cbCardData1;
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData2;
}
}
//完成判断
if (OutCardResult.cbCardCount==cbTurnCardCount) return true;
}
}
}
break;
}
}
//搜索炸弹
if ((cbCardCount>=4)&&(cbTurnOutType!=CT_MISSILE_CARD))
{
//变量定义
BYTE cbLogicValue=0;
if (cbTurnOutType==CT_BOMB_CARD) cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//搜索炸弹
for (BYTE i=3;i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue<=cbLogicValue) continue;
//炸弹判断
BYTE cbTempLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
BYTE j=1;
for (;j<4;j++)
{
if (GetCardLogicValue(cbCardData[cbCardCount+j-i-1])!=cbTempLogicValue) break;
}
if (j!=4) continue;
//设置结果
OutCardResult.cbCardCount=4;
OutCardResult.cbResultCard[0]=cbCardData[cbCardCount-i-1];
OutCardResult.cbResultCard[1]=cbCardData[cbCardCount-i];
OutCardResult.cbResultCard[2]=cbCardData[cbCardCount-i+1];
OutCardResult.cbResultCard[3]=cbCardData[cbCardCount-i+2];
return true;
}
}
//搜索火箭
if ((cbCardCount>=2)&&(cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E))
{
//设置结果
OutCardResult.cbCardCount=2;
OutCardResult.cbResultCard[0]=cbCardData[0];
OutCardResult.cbResultCard[1]=cbCardData[1];
return true;
}
return false;
}
//对比扑克
bool CGameLogic::CompareCard(const BYTE cbFirstCard[], const BYTE cbNextCard[], BYTE cbFirstCount, BYTE cbNextCount)
{
//获取类型
BYTE cbNextType=GetCardType(cbNextCard,cbNextCount);
BYTE cbFirstType=GetCardType(cbFirstCard,cbFirstCount);
//类型判断
if (cbNextType==CT_ERROR) return false;
if (cbNextType==CT_MISSILE_CARD) return true;
//炸弹判断
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;
}
case CT_THREE_LINE_TAKE_ONE:
case CT_THREE_LINE_TAKE_TWO:
{
//分析扑克
tagAnalyseResult NextResult;
tagAnalyseResult FirstResult;
AnalysebCardData(cbNextCard,cbNextCount,NextResult);
AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);
//获取数值
BYTE cbNextLogicValue=GetCardLogicValue(NextResult.cbThreeCardData[0]);
BYTE cbFirstLogicValue=GetCardLogicValue(FirstResult.cbThreeCardData[0]);
//对比扑克
return cbNextLogicValue>cbFirstLogicValue;
}
case CT_FOUR_LINE_TAKE_ONE:
case CT_FOUR_LINE_TAKE_TWO:
{
//分析扑克
tagAnalyseResult NextResult;
tagAnalyseResult FirstResult;
AnalysebCardData(cbNextCard,cbNextCount,NextResult);
AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);
//获取数值
BYTE cbNextLogicValue=GetCardLogicValue(NextResult.cbFourCardData[0]);
BYTE cbFirstLogicValue=GetCardLogicValue(FirstResult.cbFourCardData[0]);
//对比扑克
return cbNextLogicValue>cbFirstLogicValue;
}
}
return false;
}
//分析扑克
void CGameLogic::AnalysebCardData(const BYTE bCardData[], BYTE bCardCount, tagAnalyseResult & AnalyseResult)
{
//变量定义
BYTE bSameCount=1,bCardValueTemp=0;
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
//设置结果
memset(&AnalyseResult,0,sizeof(AnalyseResult));
//扑克分析
for (BYTE i=1;i<bCardCount;i++)
{
//获取扑克
bCardValueTemp=GetCardLogicValue(bCardData[i]);
if (bCardValueTemp==bLogicValue) bSameCount++;
//保存结果
if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
{
switch (bSameCount)
{
case 2: //两张
{
CopyMemory(&AnalyseResult.m_bDCardData[AnalyseResult.bDoubleCount*2],&bCardData[i-2+((i==bCardCount-1&&bCardValueTemp==bLogicValue)?1:0)],2);
AnalyseResult.bDoubleLogicVolue[AnalyseResult.bDoubleCount++]=bLogicValue;
break;
}
case 3: //三张
{
CopyMemory(&AnalyseResult.m_bTCardData[AnalyseResult.bThreeCount*3],&bCardData[i-3+((i==bCardCount-1&&bCardValueTemp==bLogicValue)?1:0)],3);
AnalyseResult.bThreeLogicVolue[AnalyseResult.bThreeCount++]=bLogicValue;
break;
}
case 4: //四张
{
CopyMemory(&AnalyseResult.m_bFCardData[AnalyseResult.bFourCount*4],&bCardData[i-4+((i==bCardCount-1&&bCardValueTemp==bLogicValue)?1:0)],4);
AnalyseResult.bFourLogicVolue[AnalyseResult.bFourCount++]=bLogicValue;
break;
}
}
}//End if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
//设置变量
if (bCardValueTemp!=bLogicValue)
{
if(bSameCount==1)
{
if(i!=bCardCount-1)
AnalyseResult.m_bSCardData[AnalyseResult.bSignedCount++]=bCardData[i-1];
else
{
AnalyseResult.m_bSCardData[AnalyseResult.bSignedCount++]=bCardData[i-1];
AnalyseResult.m_bSCardData[AnalyseResult.bSignedCount++]=bCardData[i];
}
}
else
{
if(i==bCardCount-1)
AnalyseResult.m_bSCardData[AnalyseResult.bSignedCount++]=bCardData[i];
}//End if
bSameCount=1;
bLogicValue=bCardValueTemp;
}//End if (bCardValueTemp!=bLogicValue)
}//End for (BYTE i=1;i<bCardCount;i++)
//单牌数目
BYTE bOtherCount=AnalyseResult.bDoubleCount*2+AnalyseResult.bThreeCount*3+AnalyseResult.bFourCount*4;
return;
}
//对比扑克
bool CGameLogic::CompareCard(BYTE cbFirstCardData[], BYTE cbNextCardData[], BYTE cbCardCount)
{
//获取类型
BYTE cbNextGenre=GetCardGenre(cbNextCardData,cbCardCount);
BYTE cbFirstGenre=GetCardGenre(cbFirstCardData,cbCardCount);
//类型判断
if (cbFirstGenre!=cbNextGenre) return (cbFirstGenre>cbNextGenre);
//类型对比
switch(cbFirstGenre)
{
case CT_SINGLE: //单牌
{
//对比数值
for (BYTE i=0;i<cbCardCount;i++)
{
BYTE cbNextValue=GetCardLogicValue(cbNextCardData[i]);
BYTE cbFirstValue=GetCardLogicValue(cbFirstCardData[i]);
if (cbFirstValue!=cbNextValue) return cbFirstValue>cbNextValue;
}
//对比花色
return GetCardColor(cbFirstCardData[0])>GetCardColor(cbNextCardData[0]);
}
case CT_HU_LU: //葫芦
case CT_TIE_ZHI: //铁支
case CT_ONE_DOUBLE: //对子
case CT_TWO_DOUBLE: //两对
case CT_THREE_TIAO: //三条
{
//分析扑克
tagAnalyseResult AnalyseResultNext;
tagAnalyseResult AnalyseResultFirst;
AnalysebCardData(cbNextCardData,cbCardCount,AnalyseResultNext);
AnalysebCardData(cbFirstCardData,cbCardCount,AnalyseResultFirst);
//四条数值
if (AnalyseResultFirst.cbFourCount>0)
{
BYTE cbNextValue=AnalyseResultNext.cbFourLogicVolue[0];
BYTE cbFirstValue=AnalyseResultFirst.cbFourLogicVolue[0];
return cbFirstValue>cbNextValue;
}
//三条数值
if (AnalyseResultFirst.cbThreeCount>0)
{
BYTE cbNextValue=AnalyseResultNext.cbThreeLogicVolue[0];
BYTE cbFirstValue=AnalyseResultFirst.cbThreeLogicVolue[0];
return cbFirstValue>cbNextValue;
}
//对子数值
for (BYTE i=0;i<AnalyseResultFirst.cbDoubleCount;i++)
{
BYTE cbNextValue=AnalyseResultNext.cbDoubleLogicVolue[i];
BYTE cbFirstValue=AnalyseResultFirst.cbDoubleLogicVolue[i];
if (cbFirstValue!=cbNextValue) return cbFirstValue>cbNextValue;
}
//散牌数值
for (BYTE i=0;i<AnalyseResultFirst.cbSignedCount;i++)
{
BYTE cbNextValue=AnalyseResultNext.cbSignedLogicVolue[i];
BYTE cbFirstValue=AnalyseResultFirst.cbSignedLogicVolue[i];
if (cbFirstValue!=cbNextValue) return cbFirstValue>cbNextValue;
}
//对子花色
if (AnalyseResultFirst.cbDoubleCount>0)
{
BYTE cbNextColor=GetCardColor(AnalyseResultNext.cbDoubleCardData[0]);
BYTE cbFirstColor=GetCardColor(AnalyseResultFirst.cbDoubleCardData[0]);
return cbFirstColor>cbNextColor;
}
//散牌花色
if (AnalyseResultFirst.cbSignedCount>0)
{
BYTE cbNextColor=GetCardColor(AnalyseResultNext.cbSignedCardData[0]);
BYTE cbFirstColor=GetCardColor(AnalyseResultFirst.cbSignedCardData[0]);
return cbFirstColor>cbNextColor;
}
break;
}
case CT_SHUN_ZI: //顺子
case CT_TONG_HUA: //同花
case CT_TONG_HUA_SHUN: //同花顺
{
//数值判断
BYTE cbNextValue=GetCardLogicValue(cbNextCardData[0]);
BYTE cbFirstValue=GetCardLogicValue(cbFirstCardData[0]);
//特殊列:A J 10 9 8
if( cbFirstGenre == CT_SHUN_ZI )
{
if( GetCardLogicValue(cbNextCardData[0])-3 == GetCardLogicValue(cbNextCardData[1]) )
cbNextValue = GetCardLogicValue(cbNextCardData[1]);
if( GetCardLogicValue(cbFirstCardData[0])-3 == GetCardLogicValue(cbFirstCardData[1]) )
cbFirstValue = GetCardLogicValue(cbFirstCardData[1]);
}
if (cbFirstValue!=cbNextValue) return (cbFirstValue>cbNextValue);
//花色判断
BYTE cbNextColor=GetCardColor(cbNextCardData[0]);
BYTE cbFirstColor=GetCardColor(cbFirstCardData[0]);
return (cbFirstColor>cbNextColor);
}
}
//错误断言
ASSERT(FALSE);
return false;
}
