12749 lines
415 KiB
C++
12749 lines
415 KiB
C++
#include "StdAfx.h"
|
||
#include "GameLogic.h"
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
//静态变量
|
||
const BYTE CGameLogic::m_bCardListData[CARD_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
|
||
//0x41,0x42,
|
||
};
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
//构造函数
|
||
CGameLogic::CGameLogic()
|
||
{
|
||
ZeroMemory(btCardSpecialData,sizeof(btCardSpecialData));
|
||
m_bClassicRule = true;
|
||
}
|
||
|
||
//析构函数
|
||
CGameLogic::~CGameLogic()
|
||
{
|
||
}
|
||
|
||
//获取类型
|
||
BYTE CGameLogic::GetCardType(BYTE bCardData[], BYTE bCardCount,BYTE btSpecialCard[])
|
||
{
|
||
//数据校验
|
||
ASSERT(bCardCount==3 || bCardCount==5||13==bCardCount) ;
|
||
if(bCardCount!=3 && bCardCount!=5&&bCardCount!=13) return CT_INVALID ;
|
||
|
||
tagAnalyseData AnalyseData ;
|
||
memset(&AnalyseData , 0 , sizeof(tagAnalyseData)) ;
|
||
|
||
//ASSERT(3==bCardCount || 5==bCardCount) ;
|
||
|
||
AnalyseCard(bCardData , bCardCount , AnalyseData) ;
|
||
|
||
//开始分析
|
||
switch (bCardCount)
|
||
{
|
||
case 3: //三条类型
|
||
{
|
||
//单牌类型
|
||
if(3==AnalyseData.bOneCount) return CT_SINGLE;
|
||
|
||
//对带一张
|
||
if(1==AnalyseData.bTwoCount && 1==AnalyseData.bOneCount) return CT_ONE_DOUBLE ;
|
||
|
||
//三张牌型
|
||
if(1==AnalyseData.bThreeCount) return CT_THREE ;
|
||
|
||
//错误类型
|
||
return CT_INVALID ;
|
||
}
|
||
case 5: //五张牌型
|
||
{
|
||
bool bFlushNoA = false , bFlushFirstA = false , bFlushBackA = false ;
|
||
|
||
if (GetCardLogicValue(bCardData[0])>= CARD_XW && GetCardLogicValue(bCardData[1])<CARD_XW)
|
||
{
|
||
//A连在后
|
||
if ((GetCardLogicValue(bCardData[4])==10 || GetCardLogicValue(bCardData[4])==11) && GetCardLogicValue(bCardData[1])==14)
|
||
{
|
||
bFlushBackA = true;
|
||
for (BYTE i=1; i<4; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if (1 != nValue && nValue != 2)
|
||
{
|
||
bFlushBackA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if (14==GetCardLogicValue(bCardData[1]) && 5>=GetCardLogicValue(bCardData[2]))//A连在前
|
||
{
|
||
bFlushFirstA = true;
|
||
for (BYTE i=2; i<4; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if (1 != nValue && nValue != 2)
|
||
{
|
||
bFlushFirstA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if (5>=GetCardLogicValue(bCardData[1])
|
||
&& (GetCardLogicValue(bCardData[0])==CARD_DW || GetCardLogicValue(bCardData[0])==CARD_XW))//A连在前
|
||
{
|
||
bFlushFirstA = true;
|
||
for (BYTE i=1; i<4; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if (1 != nValue && nValue != 2)
|
||
{
|
||
bFlushFirstA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
bFlushNoA = true;
|
||
bool bRes=false;
|
||
for (BYTE i=1; i<4; ++i)
|
||
{
|
||
BYTE A=GetCardLogicValue(bCardData[i]);
|
||
BYTE B=GetCardLogicValue(bCardData[i+1]);
|
||
BYTE nValue=A-B;
|
||
|
||
if (nValue==2)
|
||
{
|
||
if (!bRes) //第一次进入
|
||
{
|
||
bRes=true;
|
||
continue;
|
||
}
|
||
//第二次进入
|
||
bFlushNoA = false;
|
||
break;
|
||
}
|
||
|
||
if (1 != nValue)
|
||
{
|
||
bFlushNoA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(bCardData[0])== CARD_DW && GetCardLogicValue(bCardData[1])==CARD_XW)
|
||
{
|
||
if (GetCardLogicValue(bCardData[0])==CARD_DW&& GetCardLogicValue(bCardData[1])==CARD_XW)
|
||
{
|
||
bFlushBackA = true;
|
||
BYTE bIndex = 0;
|
||
for (BYTE i=2; i<5; ++i)
|
||
{
|
||
if (GetCardLogicValue(bCardData[i])>=10)
|
||
bIndex++;
|
||
}
|
||
if (GetCardLogicValue(bCardData[2]) != 14)
|
||
{
|
||
|
||
for (BYTE i=2; i<4; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if ((1 != nValue && nValue != 2 )/*|| bIndex!=3*/)
|
||
{
|
||
bFlushBackA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else //16 15 14 12 10 16 15 14 11 10 16 15 14 13 10
|
||
{ //16 15 14 12 11 16 15 14 13 11
|
||
//16 15 14 13 12
|
||
if (GetCardLogicValue(bCardData[4]) == 10 && bIndex == 3)
|
||
{
|
||
if (!(GetCardLogicValue(bCardData[3]) == 12||GetCardLogicValue(bCardData[3]) == 11||
|
||
GetCardLogicValue(bCardData[3]) == 13))
|
||
{
|
||
bFlushBackA = false;
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(bCardData[4]) == 11 && bIndex == 3)
|
||
{
|
||
if (!(GetCardLogicValue(bCardData[3]) == 12||GetCardLogicValue(bCardData[3]) == 13))
|
||
{
|
||
bFlushBackA = false;
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(bCardData[4]) == 12 && bIndex == 3)
|
||
{
|
||
if (!(GetCardLogicValue(bCardData[3]) == 13))
|
||
{
|
||
bFlushBackA = false;
|
||
}
|
||
}
|
||
else if ( 5>=GetCardLogicValue(bCardData[3]) && (GetCardLogicValue(bCardData[3]) != GetCardLogicValue(bCardData[4])))
|
||
{
|
||
bFlushFirstA = true;
|
||
for (BYTE i=3; i<4; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if (1 != nValue && nValue != 2 && nValue !=3)
|
||
{
|
||
bFlushFirstA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else //zyy 3/18 2鬼带两张认成A在后顺子 修复
|
||
{
|
||
for (BYTE i=2; i<4; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if ((1 != nValue && nValue != 2 )/*|| bIndex!=3*/)
|
||
{
|
||
bFlushBackA = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
//zyy 3/9
|
||
bFlushNoA = true;
|
||
bool bRes1=false;
|
||
bool bRes2=false;
|
||
for (BYTE i=2; i<4; ++i)
|
||
{
|
||
BYTE A=GetCardLogicValue(bCardData[i]);
|
||
BYTE B=GetCardLogicValue(bCardData[i+1]);
|
||
BYTE nValue=A-B;
|
||
|
||
if (nValue==3)
|
||
{
|
||
if (!bRes1 && !bRes2)
|
||
{
|
||
bRes1 = true;
|
||
bRes2 = true;
|
||
continue;
|
||
}
|
||
|
||
bFlushNoA = false;
|
||
break;
|
||
}
|
||
|
||
if (nValue == 2)
|
||
{
|
||
if (!bRes1)
|
||
{
|
||
bRes1 = true;
|
||
continue;
|
||
}
|
||
else if (!bRes2)
|
||
{
|
||
bRes2 = true;
|
||
continue;
|
||
}
|
||
|
||
bFlushNoA = false;
|
||
break;
|
||
}
|
||
|
||
if (1 != nValue && nValue != 2 && nValue !=3)
|
||
{
|
||
bFlushNoA = false;
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
else if ((GetCardLogicValue(bCardData[4])==10 || GetCardLogicValue(bCardData[4])==11 || GetCardLogicValue(bCardData[4])==12) && GetCardLogicValue(bCardData[2]==14))
|
||
{
|
||
bFlushBackA = true;
|
||
for(BYTE i=2 ; i<4 ; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if (1 != nValue && nValue != 2 && nValue !=3)
|
||
{
|
||
bFlushBackA = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//A连在后
|
||
if (14 == GetCardLogicValue(bCardData[0]) && 10 == GetCardLogicValue(bCardData[4]))
|
||
{
|
||
bFlushBackA = true;
|
||
}
|
||
else
|
||
{
|
||
bFlushNoA = true;
|
||
}
|
||
|
||
for(BYTE i=0 ; i<4 ; ++i)
|
||
{
|
||
BYTE nValue=GetCardLogicValue(bCardData[i])-GetCardLogicValue(bCardData[i+1]);
|
||
if(1!=nValue)
|
||
{
|
||
bFlushBackA = false ;
|
||
bFlushNoA = false ;
|
||
break;
|
||
}
|
||
}
|
||
|
||
//A连在前
|
||
if(false==bFlushBackA && false==bFlushNoA && 14==GetCardLogicValue(bCardData[0]))
|
||
{
|
||
bFlushFirstA = true ;
|
||
for (BYTE i = 1; i < 4; ++i)
|
||
{
|
||
if (1 != GetCardLogicValue(bCardData[i]) - GetCardLogicValue(bCardData[i + 1]))
|
||
{
|
||
bFlushFirstA = false;
|
||
}
|
||
}
|
||
|
||
if (2 != GetCardLogicValue(bCardData[4]))
|
||
{
|
||
bFlushFirstA = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
//同花五牌
|
||
if(false==bFlushBackA && false==bFlushNoA && false==bFlushFirstA)
|
||
{
|
||
if(true==AnalyseData.bStraight) return CT_FIVE_FLUSH ;
|
||
}
|
||
else if(true==bFlushNoA)
|
||
{
|
||
//杂顺类型
|
||
if(false==AnalyseData.bStraight) return CT_FIVE_MIXED_FLUSH_NO_A;
|
||
//同花顺牌
|
||
else return CT_FIVE_STRAIGHT_FLUSH_NO_A ;
|
||
}
|
||
else if(true==bFlushFirstA)
|
||
{
|
||
//杂顺类型
|
||
if(false==AnalyseData.bStraight) return CT_FIVE_MIXED_FLUSH_FIRST_A;
|
||
//同花顺牌
|
||
else return CT_FIVE_STRAIGHT_FLUSH_FIRST_A ;
|
||
}
|
||
else if(true==bFlushBackA)
|
||
{
|
||
//杂顺类型
|
||
if(false==AnalyseData.bStraight) return CT_FIVE_MIXED_FLUSH_BACK_A;
|
||
//同花顺牌
|
||
else return CT_FIVE_STRAIGHT_FLUSH_BACK_A ;
|
||
}
|
||
|
||
//五带0张
|
||
if (1==AnalyseData.bFiveCount) return CT_FIVE_BOMB;
|
||
//四带单张
|
||
if(1==AnalyseData.bFourCount && 1==AnalyseData.bOneCount) return CT_FIVE_FOUR_ONE ;
|
||
//三条一对
|
||
if(1==AnalyseData.bThreeCount && 1==AnalyseData.bTwoCount) return CT_FIVE_THREE_DEOUBLE ;
|
||
//三条带单
|
||
if(1==AnalyseData.bThreeCount && 2==AnalyseData.bOneCount) return CT_THREE ;
|
||
//两对牌型
|
||
if(2==AnalyseData.bTwoCount && 1==AnalyseData.bOneCount) return CT_FIVE_TWO_DOUBLE ;
|
||
//只有一对
|
||
if(1==AnalyseData.bTwoCount && 3==AnalyseData.bOneCount) return CT_ONE_DOUBLE ;
|
||
//单牌类型
|
||
if(5==AnalyseData.bOneCount && false==AnalyseData.bStraight) return CT_SINGLE ;
|
||
//错误类型
|
||
return CT_INVALID;
|
||
}
|
||
case 13://13张特殊牌型
|
||
{
|
||
bool TwelveKing=false;
|
||
//同花十三水
|
||
if(13==AnalyseData.bOneCount&&true==AnalyseData.bStraight)
|
||
return CT_THIRTEEN_FLUSH;
|
||
//十三水
|
||
if(13==AnalyseData.bOneCount)
|
||
return CT_THIRTEEN;
|
||
//十二皇族
|
||
TwelveKing=true;
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
if(GetCardLogicValue(bCardData[i])<11)
|
||
{
|
||
TwelveKing=false;
|
||
break;
|
||
}
|
||
}
|
||
if(TwelveKing)
|
||
{
|
||
return CT_TWELVE_KING;
|
||
}
|
||
|
||
|
||
|
||
//三同花顺
|
||
/*bool bThreeStraightFlush = false;
|
||
bThreeStraightFlush = IsThreeFlushStraight(bCardData,bCardCount);
|
||
if (bThreeStraightFlush)
|
||
{
|
||
return CT_THREE_STRAIGHTFLUSH;
|
||
}*/
|
||
//三同花顺子
|
||
{
|
||
BYTE bCardList[13] = {0};
|
||
memcpy(bCardList,bCardData,sizeof(BYTE)*13);
|
||
SortCardList(bCardList,13);
|
||
BYTE bLeftCount = 13;
|
||
BYTE cbStraightFlush[5] = {0};
|
||
BYTE bTempCount = 5;
|
||
tagAnalyseType tagCardType = GetType(bCardList,bLeftCount);
|
||
if (tagCardType.bStraightFlush)
|
||
{
|
||
|
||
for (BYTE i = 0;i<tagCardType.btStraightFlush;++i)
|
||
{
|
||
CopyMemory(bCardList,bCardData,sizeof(bCardList));
|
||
bLeftCount = 13;
|
||
SortCardList(bCardList,13);
|
||
ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
|
||
cbStraightFlush[0]=bCardList[tagCardType.cbStraightFlush[i*5]];
|
||
cbStraightFlush[1]=bCardList[tagCardType.cbStraightFlush[i*5+1]];
|
||
cbStraightFlush[2]=bCardList[tagCardType.cbStraightFlush[i*5+2]];
|
||
cbStraightFlush[3]=bCardList[tagCardType.cbStraightFlush[i*5+3]];
|
||
cbStraightFlush[4]=bCardList[tagCardType.cbStraightFlush[i*5+4]];
|
||
|
||
//移除第一个同花顺
|
||
RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
|
||
bLeftCount -= bTempCount;
|
||
|
||
//备份剩余牌
|
||
BYTE bLeftCardList[13] = {0};
|
||
CopyMemory(bLeftCardList,bCardList,bLeftCount);
|
||
BYTE bLeftCount1 =bLeftCount;
|
||
|
||
tagAnalyseType tagCardType1 = GetType(bCardList,bLeftCount);
|
||
if (tagCardType1.bStraightFlush)
|
||
{
|
||
for (BYTE j = 0;j<tagCardType1.btStraightFlush;++j)
|
||
{
|
||
//重新赋值
|
||
CopyMemory(bCardList,bLeftCardList,bLeftCount1);
|
||
ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
|
||
bLeftCount =bLeftCount1;
|
||
cbStraightFlush[0]=bCardList[tagCardType1.cbStraightFlush[j*5]];
|
||
cbStraightFlush[1]=bCardList[tagCardType1.cbStraightFlush[j*5+1]];
|
||
cbStraightFlush[2]=bCardList[tagCardType1.cbStraightFlush[j*5+2]];
|
||
cbStraightFlush[3]=bCardList[tagCardType1.cbStraightFlush[j*5+3]];
|
||
cbStraightFlush[4]=bCardList[tagCardType1.cbStraightFlush[j*5+4]];
|
||
//移除第二个同花顺
|
||
RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
|
||
bLeftCount -= bTempCount;
|
||
|
||
|
||
//判断剩余3张是否也符合同花顺
|
||
bool bThreeStraightFlush = false;
|
||
SortCardList(bCardList , bLeftCount, enDescend) ;
|
||
|
||
if (GetCardLogicValue(bCardList[0]) >=CARD_XW && GetCardLogicValue(bCardList[1]) <CARD_XW)
|
||
{
|
||
if((GetCardColor(bCardList[1]) == GetCardColor(bCardList[2]))&&
|
||
(GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==1
|
||
|| GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==2
|
||
|| (GetCardLogicValue(bCardList[1]) == 14 &&GetCardLogicValue(bCardList[2])<=3))
|
||
)
|
||
{
|
||
bThreeStraightFlush = true;
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(bCardList[0]) ==CARD_DW && GetCardLogicValue(bCardList[1]) ==CARD_XW)
|
||
{
|
||
bThreeStraightFlush = true;
|
||
}
|
||
else
|
||
{
|
||
if((GetCardColor(bCardList[0]) == GetCardColor(bCardList[1]) && GetCardColor(bCardList[0]) == GetCardColor(bCardList[2]))&&
|
||
((GetCardLogicValue(bCardList[0])==GetCardLogicValue(bCardList[1])+1 && GetCardLogicValue(bCardList[1])==GetCardLogicValue(bCardList[2])+1)
|
||
|| (GetCardLogicValue(bCardList[0]) == 14 &&GetCardLogicValue(bCardList[1])==3 &&GetCardLogicValue(bCardList[2])==2)))
|
||
{
|
||
bThreeStraightFlush = true;
|
||
}
|
||
}
|
||
if (bThreeStraightFlush)
|
||
{
|
||
return CT_THREE_STRAIGHTFLUSH;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//三炸弹
|
||
if(3==AnalyseData.bFourCount)
|
||
{
|
||
return CT_THREE_BOMB;
|
||
}
|
||
//全大
|
||
bool AllBig=true;
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
if(GetCardLogicValue(bCardData[i])<8&&GetCardLogicValue(bCardData[i]) != CARD_XW&&GetCardLogicValue(bCardData[i]) != CARD_DW)
|
||
{
|
||
AllBig=false;
|
||
break;
|
||
}
|
||
}
|
||
if(AllBig)
|
||
{
|
||
return CT_ALL_BIG;
|
||
}
|
||
//全小
|
||
bool AllSmall=true;
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
if(GetCardLogicValue(bCardData[i])>8&&GetCardLogicValue(bCardData[i]) != CARD_XW&&GetCardLogicValue(bCardData[i]) != CARD_DW)
|
||
{
|
||
AllSmall=false;
|
||
break;
|
||
}
|
||
}
|
||
if(AllSmall)
|
||
{
|
||
return CT_ALL_SMALL;
|
||
}
|
||
//凑一色
|
||
{
|
||
BYTE Flush=1;
|
||
BYTE bStartIndex = 0;
|
||
BYTE SColor=0;
|
||
BYTE bSameColorList[13] = {0};
|
||
memcpy(bSameColorList, bCardData, sizeof(BYTE)*13);
|
||
SortCardList(bSameColorList,13);
|
||
if (GetCardLogicValue(bSameColorList[0])>= CARD_XW && GetCardLogicValue(bSameColorList[1])<CARD_XW)
|
||
{
|
||
bStartIndex=1;
|
||
}else if (GetCardLogicValue(bSameColorList[0])>= CARD_XW && GetCardLogicValue(bSameColorList[1])>=CARD_XW)
|
||
{
|
||
bStartIndex=2;
|
||
}
|
||
|
||
{
|
||
SColor=GetCardColor(bSameColorList[bStartIndex]);
|
||
for(int i=bStartIndex+1;i<13;i++)
|
||
{
|
||
if(SColor==(GetCardColor(bSameColorList[i])) || SColor==((GetCardColor(bSameColorList[i])+2)%4))
|
||
{
|
||
Flush++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(13-bStartIndex==Flush)
|
||
{
|
||
return CT_SAME_COLOR;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//四套冲三
|
||
if(4==AnalyseData.bThreeCount||(3==AnalyseData.bThreeCount&&1==AnalyseData.bFourCount)
|
||
||(2==AnalyseData.bThreeCount&&1==AnalyseData.bFourCount&&(AnalyseData.bTwoCount>=1) &&(GetCardLogicValue(bCardData[0])==CARD_XW||GetCardLogicValue(bCardData[0])==CARD_DW)))
|
||
{
|
||
return CT_FOUR_THREESAME;
|
||
}
|
||
//五对冲三
|
||
if((5==AnalyseData.bTwoCount&&1==AnalyseData.bThreeCount)||(3==AnalyseData.bTwoCount&&1==AnalyseData.bFourCount&&1==AnalyseData.bThreeCount)
|
||
||(1==AnalyseData.bTwoCount&&2==AnalyseData.bFourCount&&1==AnalyseData.bThreeCount))
|
||
{
|
||
return CT_FIVEPAIR_THREE;
|
||
}
|
||
//六对半
|
||
if(6==AnalyseData.bTwoCount||(4==AnalyseData.bTwoCount&&1==AnalyseData.bFourCount)||(2==AnalyseData.bTwoCount&&2==AnalyseData.bFourCount)
|
||
||(3==AnalyseData.bFourCount))
|
||
{
|
||
return CT_SIXPAIR;
|
||
}
|
||
//三同花
|
||
{
|
||
//定义变量
|
||
BYTE bCardList[13] = {0};
|
||
memcpy(bCardList, bCardData, sizeof(BYTE)*13);
|
||
BYTE bLeftCCount = 13;
|
||
BYTE bTempCard[3][5] = {0};
|
||
BYTE bTempCCount[3] = {0};
|
||
bool Flush = true;
|
||
//摆牌开始
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
if (!IsFlush(bCardList, bLeftCCount, bTempCard[i], bTempCCount[i], (i==2?3:5)))
|
||
{
|
||
Flush = false;
|
||
break;
|
||
}
|
||
|
||
RemoveCard(bTempCard[i], bTempCCount[i], bCardList, bLeftCCount);
|
||
bLeftCCount -= bTempCCount[i];
|
||
|
||
if (i<2) CopyMemory(&btSpecialCard[i*5],bTempCard[i], bTempCCount[i]);
|
||
else CopyMemory(&btSpecialCard[10],bTempCard[i], bTempCCount[i]);
|
||
}
|
||
|
||
if (Flush)
|
||
{
|
||
return CT_THREE_FLUSH;
|
||
}
|
||
|
||
}
|
||
|
||
//三顺子
|
||
{
|
||
BYTE bCardList[13] = {0};
|
||
memcpy(bCardList,bCardData,sizeof(BYTE)*13);
|
||
SortCardList(bCardList,13);
|
||
BYTE bLeftCount = 13;
|
||
BYTE cbStraight[5] = {0};
|
||
BYTE bTempCount = 5;
|
||
bool Straight = true;
|
||
tagAnalyseType tagCardType = GetType(bCardList,bLeftCount);
|
||
if (tagCardType.bStraight)
|
||
{
|
||
int xxx = 0;
|
||
for(BYTE i=0;i<20;i++)
|
||
{
|
||
if(tagCardType.cbStraight[i*5]==0&&tagCardType.cbStraight[i*5+1]==0)
|
||
{
|
||
xxx = i;
|
||
break;
|
||
}
|
||
}
|
||
if (xxx>tagCardType.btStraight)
|
||
{
|
||
tagCardType.btStraight = xxx;
|
||
}
|
||
ZeroMemory(btSpecialCard,sizeof(BYTE)*13);
|
||
for (BYTE i = 0;i<tagCardType.btStraight;++i) //zyy 特殊牌少了1次
|
||
{
|
||
CopyMemory(bCardList,bCardData,sizeof(bCardList));
|
||
bLeftCount = 13;
|
||
SortCardList(bCardList,13);
|
||
ZeroMemory(cbStraight,sizeof(cbStraight));
|
||
cbStraight[0]=bCardList[tagCardType.cbStraight[i*5]];
|
||
cbStraight[1]=bCardList[tagCardType.cbStraight[i*5+1]];
|
||
cbStraight[2]=bCardList[tagCardType.cbStraight[i*5+2]];
|
||
cbStraight[3]=bCardList[tagCardType.cbStraight[i*5+3]];
|
||
cbStraight[4]=bCardList[tagCardType.cbStraight[i*5+4]];
|
||
|
||
//移除第一个顺子
|
||
RemoveCard(cbStraight, bTempCount, bCardList, bLeftCount);
|
||
bLeftCount -= bTempCount;
|
||
CopyMemory(btSpecialCard,cbStraight, bTempCount);
|
||
//备份剩余牌
|
||
BYTE bLeftCardList[13] = {0};
|
||
CopyMemory(bLeftCardList,bCardList,bLeftCount);
|
||
BYTE bLeftCount1 =bLeftCount;
|
||
|
||
tagAnalyseType tagCardType1 = GetType(bCardList,bLeftCount);
|
||
if (tagCardType1.bStraight)
|
||
{
|
||
for (BYTE j = 0;j<tagCardType1.btStraight;++j)
|
||
{
|
||
//重新赋值
|
||
CopyMemory(bCardList,bLeftCardList,bLeftCount1);
|
||
ZeroMemory(cbStraight,sizeof(cbStraight));
|
||
bLeftCount =bLeftCount1;
|
||
cbStraight[0]=bCardList[tagCardType1.cbStraight[j*5]];
|
||
cbStraight[1]=bCardList[tagCardType1.cbStraight[j*5+1]];
|
||
cbStraight[2]=bCardList[tagCardType1.cbStraight[j*5+2]];
|
||
cbStraight[3]=bCardList[tagCardType1.cbStraight[j*5+3]];
|
||
cbStraight[4]=bCardList[tagCardType1.cbStraight[j*5+4]];
|
||
//移除第二个顺子
|
||
RemoveCard(cbStraight, bTempCount, bCardList, bLeftCount);
|
||
bLeftCount -= bTempCount;
|
||
CopyMemory(btSpecialCard+5,cbStraight, bTempCount);
|
||
|
||
//判断剩余3张是否也符合顺子
|
||
bool bThreeStraight = false;
|
||
SortCardList(bCardList , bLeftCount, enDescend) ;
|
||
if (GetCardLogicValue(bCardList[0]) >=CARD_XW && GetCardLogicValue(bCardList[1]) <CARD_XW)
|
||
{
|
||
if(GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==1
|
||
|| GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==2
|
||
|| (GetCardLogicValue(bCardList[1]) == 14 &&GetCardLogicValue(bCardList[2])<=3)
|
||
)
|
||
{
|
||
bThreeStraight = true;
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(bCardList[0]) ==CARD_DW && GetCardLogicValue(bCardList[1]) ==CARD_XW)
|
||
{
|
||
bThreeStraight = true;
|
||
}
|
||
else
|
||
{
|
||
if((GetCardLogicValue(bCardList[0])==GetCardLogicValue(bCardList[1])+1 && GetCardLogicValue(bCardList[1])==GetCardLogicValue(bCardList[2])+1)
|
||
|| (GetCardLogicValue(bCardList[0]) == 14 &&GetCardLogicValue(bCardList[1])==3 &&GetCardLogicValue(bCardList[2])==2))
|
||
{
|
||
bThreeStraight = true;
|
||
}
|
||
}
|
||
if (bThreeStraight)
|
||
{
|
||
CopyMemory(btSpecialCard+10,bCardList , bLeftCount);
|
||
return CT_THREE_STRAIGHT;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return CT_INVALID;
|
||
}
|
||
|
||
//排列扑克
|
||
void CGameLogic::SortCardList(BYTE bCardData[], BYTE bCardCount,enSortCardType SortCardType)
|
||
{
|
||
ASSERT(bCardCount>=1 && bCardCount<=13) ;
|
||
if(bCardCount<1 || bCardCount>13) return ;
|
||
|
||
//转换数值
|
||
BYTE bLogicVolue[13];
|
||
for (BYTE i=0;i<bCardCount;i++) bLogicVolue[i]=GetCardLogicValue(bCardData[i]);
|
||
|
||
if(enDescend==SortCardType)
|
||
{
|
||
//排序操作
|
||
bool bSorted=true;
|
||
BYTE bTempData,bLast=bCardCount-1;
|
||
BYTE m_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);
|
||
}
|
||
else if(enAscend==SortCardType)
|
||
{
|
||
//排序操作
|
||
bool bSorted=true;
|
||
BYTE bTempData,bLast=bCardCount-1;
|
||
BYTE m_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);
|
||
}
|
||
else if(enColor==SortCardType)
|
||
{
|
||
//排序操作
|
||
bool bSorted=true;
|
||
BYTE bTempData,bLast=bCardCount-1;
|
||
BYTE m_bCardCount=1;
|
||
BYTE bColor[13];
|
||
for (BYTE i=0;i<bCardCount;i++) bColor[i]=GetCardColor(bCardData[i]);
|
||
do
|
||
{
|
||
bSorted=true;
|
||
for (BYTE i=0;i<bLast;i++)
|
||
{
|
||
if ((bColor[i]<bColor[i+1])||
|
||
((bColor[i]==bColor[i+1])&&(GetCardLogicValue(bCardData[i])<GetCardLogicValue(bCardData[i+1]))))
|
||
{
|
||
//交换位置
|
||
bTempData=bCardData[i];
|
||
bCardData[i]=bCardData[i+1];
|
||
bCardData[i+1]=bTempData;
|
||
bTempData=bColor[i];
|
||
bColor[i]=bColor[i+1];
|
||
bColor[i+1]=bTempData;
|
||
bSorted=false;
|
||
}
|
||
}
|
||
bLast--;
|
||
} while(bSorted==false);
|
||
}
|
||
return;
|
||
}
|
||
|
||
//混乱扑克
|
||
void CGameLogic::RandCardList(BYTE bCardBuffer[], BYTE bBufferCount)
|
||
{
|
||
//混乱准备
|
||
BYTE bCardData[sizeof(m_bCardListData)];
|
||
CopyMemory(bCardData,m_bCardListData,sizeof(m_bCardListData));
|
||
//CopyMemory(bCardBuffer,m_bCardListData,sizeof(m_bCardListData));
|
||
|
||
//混乱扑克
|
||
BYTE bRandCount=0,bPosition=0;
|
||
do
|
||
{
|
||
bPosition=rand()%(bBufferCount-bRandCount);
|
||
bCardBuffer[bRandCount++]=bCardData[bPosition];
|
||
bCardData[bPosition]=bCardData[bBufferCount-bRandCount];
|
||
} while (bRandCount<bBufferCount);
|
||
return;
|
||
}
|
||
|
||
//删除扑克
|
||
bool CGameLogic::RemoveCard(const BYTE bRemoveCard[], BYTE bRemoveCount, BYTE bCardData[], BYTE bCardCount)
|
||
{
|
||
//检验数据
|
||
ASSERT(bRemoveCount<=bCardCount);
|
||
|
||
//定义变量
|
||
BYTE bDeleteCount=0,bTempCardData[13];
|
||
if (bCardCount>CountArray(bTempCardData)) return false;
|
||
CopyMemory(bTempCardData,bCardData,bCardCount*sizeof(bCardData[0]));
|
||
|
||
//置零扑克
|
||
for (BYTE i=0;i<bRemoveCount;i++)
|
||
{
|
||
for (BYTE j=0;j<bCardCount;j++)
|
||
{
|
||
if (bRemoveCard[i]==bTempCardData[j])
|
||
{
|
||
bDeleteCount++;
|
||
bTempCardData[j]=0;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (bDeleteCount!=bRemoveCount) return false;
|
||
|
||
//清理扑克
|
||
BYTE bCardPos=0;
|
||
for (BYTE i=0;i<bCardCount;i++)
|
||
{
|
||
if (bTempCardData[i]!=0) bCardData[bCardPos++]=bTempCardData[i];
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//逻辑数值
|
||
BYTE CGameLogic::GetCardLogicValue(BYTE bCardData)
|
||
{
|
||
//扑克属性
|
||
BYTE bCardValue=GetCardValue(bCardData);
|
||
BYTE bCardColor=GetCardColor(bCardData);
|
||
if(bCardColor==0x04)
|
||
{
|
||
return bCardValue+14;
|
||
}
|
||
//转换数值
|
||
return (bCardValue==1)?(bCardValue+13):bCardValue;
|
||
}
|
||
|
||
/*
|
||
返回值:
|
||
* bNextList>bFirstList:true
|
||
bNextList<bFirstList:false
|
||
*/
|
||
//对比扑克;
|
||
BYTE CGameLogic::CompareCard(BYTE bInFirstList[], BYTE bInNextList[], BYTE bFirstCount, BYTE bNextCount , bool bComperWithOther)
|
||
{
|
||
tagAnalyseData FirstAnalyseData , NextAnalyseData;
|
||
|
||
memset(&FirstAnalyseData , 0 , sizeof(tagAnalyseData)) ;
|
||
memset(&NextAnalyseData , 0 , sizeof(tagAnalyseData)) ;
|
||
|
||
//排列扑克;
|
||
BYTE bFirstList[13] = {0};
|
||
BYTE bNextList[13] = {0};
|
||
CopyMemory(bFirstList , bInFirstList , bFirstCount) ;
|
||
CopyMemory(bNextList , bInNextList , bNextCount) ;
|
||
SortCardList(bFirstList , bFirstCount , enDescend) ;
|
||
SortCardList(bNextList , bNextCount , enDescend) ;
|
||
|
||
//ASSERT(3 == bFirstCount || 5 == bFirstCount || 3 == bNextCount || 5 == bNextCount || 13 == bFirstCount || 13 == bNextCount);
|
||
|
||
AnalyseCard(bFirstList , bFirstCount , FirstAnalyseData);
|
||
|
||
AnalyseCard(bNextList , bNextCount , NextAnalyseData);
|
||
|
||
BYTE cbTempFirstCount = (FirstAnalyseData.bOneCount + FirstAnalyseData.bTwoCount * 2 + FirstAnalyseData.bThreeCount * 3 + FirstAnalyseData.bFourCount * 4 + FirstAnalyseData.bFiveCount * 5);
|
||
//ASSERT(bFirstCount == cbTempFirstCount);
|
||
if (bFirstCount != cbTempFirstCount)
|
||
{
|
||
return 0 ;
|
||
}
|
||
|
||
BYTE cbTempNextCount = (NextAnalyseData.bOneCount + NextAnalyseData.bTwoCount * 2 + NextAnalyseData.bThreeCount * 3 + NextAnalyseData.bFourCount * 4 + NextAnalyseData.bFiveCount * 5);
|
||
//ASSERT(bNextCount = cbTempNextCount);
|
||
if (bNextCount != cbTempNextCount)
|
||
{
|
||
return 0 ;
|
||
}
|
||
|
||
//数据验证;
|
||
//ASSERT((bFirstCount == bNextCount) || (bFirstCount != bNextCount && (3 == bFirstCount && 5 == bNextCount || 5 == bFirstCount && 3 == bNextCount)));
|
||
if(!((bFirstCount==bNextCount) || (bFirstCount!=bNextCount && (3==bFirstCount && 5==bNextCount || 5==bFirstCount && 3==bNextCount)))) return 0 ;
|
||
|
||
//获取类型;
|
||
//ASSERT(3==bNextCount || 5==bNextCount) ;
|
||
//ASSERT(3==bFirstCount || 5==bFirstCount) ;
|
||
|
||
BYTE bNextType = GetCardType(bNextList,bNextCount,btCardSpecialData);
|
||
BYTE bFirstType = GetCardType(bFirstList,bFirstCount,btCardSpecialData);
|
||
|
||
//ASSERT(SSS_CT_INVALID != bNextType && SSS_CT_INVALID != bFirstType);
|
||
if(CT_INVALID==bFirstType || CT_INVALID==bNextType) return 0;
|
||
|
||
//头段比较;
|
||
if(true==bComperWithOther)
|
||
{
|
||
if(3==bFirstCount)
|
||
{
|
||
//开始对比;
|
||
if(bNextType==bFirstType)
|
||
{
|
||
switch(bFirstType)
|
||
{
|
||
case CT_SINGLE: //单牌类型;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
for (BYTE i = 0; i < 3; ++i)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//表示不比水;
|
||
return 2;
|
||
|
||
}
|
||
case CT_ONE_DOUBLE: //对带一张;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
cbNextLogicValue = GetCardLogicValue(bNextList[NextAnalyseData.bOneFirst[0]]);
|
||
cbFirstLogicValue = GetCardLogicValue(bFirstList[FirstAnalyseData.bOneFirst[0]]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
else
|
||
{
|
||
return 2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
case CT_THREE: //三张牌型;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue; //比较数值;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
return bNextType>bFirstType;
|
||
}
|
||
}
|
||
else if(5==bFirstCount)
|
||
{
|
||
//开始对比;
|
||
if(bNextType==bFirstType)
|
||
{
|
||
switch(bFirstType)
|
||
{
|
||
case CT_SINGLE: //单牌类型;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
for (BYTE i = 0; i < 5; ++i)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
case CT_ONE_DOUBLE: //对带一张;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//对比单张;
|
||
for(BYTE i=0; i<3; ++i)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[i]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[i]];
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) != GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue; //比较数值;
|
||
}
|
||
}
|
||
case CT_FIVE_TWO_DOUBLE: //两对牌型;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[1]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[1]];
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) != GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue; //比较数值;
|
||
}
|
||
}
|
||
|
||
case CT_THREE: //三张牌型;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue); //比较数值
|
||
}
|
||
}
|
||
|
||
case CT_FIVE_MIXED_FLUSH_FIRST_A: //A在前顺子;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
return 2; // 12345 怎么比 都是一样大;
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
|
||
||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
|
||
{
|
||
if(GetCardLogicValue(bNextList[2]) == GetCardLogicValue(bFirstList[2]))
|
||
return 2;
|
||
else
|
||
return GetCardLogicValue(bNextList[2]) > GetCardLogicValue(bFirstList[2]) ; //比较数值
|
||
}
|
||
|
||
if(GetCardLogicValue(bNextList[0]) == GetCardLogicValue(bFirstList[0]))
|
||
return 2;
|
||
else
|
||
return GetCardLogicValue(bNextList[0]) > GetCardLogicValue(bFirstList[0]) ; //比较数值
|
||
|
||
}
|
||
case CT_FIVE_MIXED_FLUSH_NO_A: //没A杂顺
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
|
||
||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
|
||
{
|
||
if(GetCardLogicValue(bNextList[4]) == GetCardLogicValue(bFirstList[4]))
|
||
return 2;
|
||
else
|
||
return GetCardLogicValue(bNextList[4]) > GetCardLogicValue(bFirstList[4]) ; //比较数值;
|
||
}
|
||
|
||
if(GetCardLogicValue(bNextList[0])==GetCardLogicValue(bFirstList[0]))
|
||
return 2;
|
||
else
|
||
return GetCardLogicValue(bNextList[0]) > GetCardLogicValue(bFirstList[0]); //比较数值;
|
||
}
|
||
case CT_FIVE_MIXED_FLUSH_BACK_A: //A在后顺子;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
return 2; // 10 J Q K 1 怎么比 都是一样大;
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
|
||
||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
|
||
{
|
||
if(GetCardLogicValue(bNextList[2]) == GetCardLogicValue(bFirstList[2]))
|
||
return 2;
|
||
else
|
||
return GetCardLogicValue(bNextList[2]) > GetCardLogicValue(bFirstList[2]) ; //比较数值;
|
||
}
|
||
|
||
if(GetCardLogicValue(bNextList[0])==GetCardLogicValue(bFirstList[0]))
|
||
return 2;
|
||
else
|
||
return GetCardLogicValue(bNextList[0]) > GetCardLogicValue(bFirstList[0]); //比较数值;
|
||
|
||
}
|
||
|
||
case CT_FIVE_FLUSH: //同花五牌;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
//比较数值;
|
||
for (BYTE i = 0; i<5; ++i)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return 2;
|
||
}
|
||
|
||
case CT_FIVE_THREE_DEOUBLE: //三条一对;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
|
||
case CT_FIVE_FOUR_ONE: //四带一张;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
//zyy 如果顺子有王 就比第三张;
|
||
if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
|
||
||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
|
||
{
|
||
if(GetCardLogicValue(bNextList[3]) == GetCardLogicValue(bFirstList[3]))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(bNextList[3]) > GetCardLogicValue(bFirstList[3]) ; //比较数值;
|
||
}
|
||
}
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue); //比较数值;
|
||
}
|
||
}
|
||
case CT_FIVE_BOMB: //五相 //zyy五同需要比较第二张;
|
||
{
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bFiveFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFiveFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
if(GetCardLogicValue(bNextList[1]) == GetCardLogicValue(bFirstList[1]))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return GetCardLogicValue(bNextList[1]) > GetCardLogicValue(bFirstList[1]);
|
||
}
|
||
}
|
||
case CT_FIVE_STRAIGHT_FLUSH_NO_A: //没A同花顺
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (GetCardLogicValue(bNextList[0]) == CARD_DW||GetCardLogicValue(bNextList[0]) == CARD_XW
|
||
||GetCardLogicValue(bFirstList[0]) == CARD_DW||GetCardLogicValue(bFirstList[0]) == CARD_XW)
|
||
{
|
||
//比较数值;
|
||
//for(BYTE i=2; i<5; ++i)
|
||
//if(GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
|
||
|
||
/// zyy 3/6 2017;
|
||
if ( GetCardLogicValue(bNextList[4]) != GetCardLogicValue(bFirstList[4]))
|
||
{
|
||
return GetCardLogicValue(bNextList[4]) > GetCardLogicValue(bFirstList[4]);
|
||
}
|
||
else
|
||
{
|
||
return 2;
|
||
}
|
||
}
|
||
//比较数值;
|
||
for (BYTE i = 0; i<5; ++i)
|
||
{
|
||
if (GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
|
||
{
|
||
return GetCardLogicValue(bNextList[i]) > GetCardLogicValue(bFirstList[i]);
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return 2;
|
||
|
||
}
|
||
case CT_FIVE_STRAIGHT_FLUSH_FIRST_A://A在前同花顺;
|
||
case CT_FIVE_STRAIGHT_FLUSH_BACK_A: //A在后同花顺;
|
||
{
|
||
//数据验证;
|
||
//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
return 2; // 10 J Q K 1 怎么比 都是一样大;
|
||
}
|
||
default:
|
||
|
||
return false ;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
//同花顺牌;
|
||
//if( bNextType==CT_FIVE_STRAIGHT_FLUSH_FIRST_A || bNextType==CT_FIVE_STRAIGHT_FLUSH)
|
||
//{
|
||
// if(CT_FIVE_STRAIGHT_FLUSH_FIRST_A==bFirstType || CT_FIVE_STRAIGHT_FLUSH==bFirstType)
|
||
// {
|
||
// if(bNextType!=bFirstType)
|
||
// return bNextType > bFirstType ;
|
||
//
|
||
// //比较数值;
|
||
// for(BYTE i=0; i<5; ++i)
|
||
// if(GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
|
||
// return GetCardLogicValue(bNextList[i]) > GetCardLogicValue(bFirstList[i]) ;
|
||
//
|
||
// //比较花色;
|
||
// return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]) ;
|
||
// }
|
||
//}
|
||
return bNextType>bFirstType ;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(bNextType==bFirstType)
|
||
{
|
||
switch(bFirstType)
|
||
{
|
||
case CT_THIRTEEN_FLUSH:
|
||
{
|
||
return 2;
|
||
}
|
||
case CT_TWELVE_KING:
|
||
{
|
||
for (int i = 0; i < 13; i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
return 2;
|
||
}
|
||
case CT_THREE_STRAIGHTFLUSH:
|
||
{
|
||
for (int i = 0; i < 13; i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
case CT_THREE_BOMB:
|
||
{
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if(cbNextCardValue==cbFirstCardValue) return false ;
|
||
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[i]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[i]];
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
|
||
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
case CT_ALL_BIG:
|
||
{
|
||
for (int i = 0; i < 13; i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
return 2;
|
||
}
|
||
case CT_ALL_SMALL:
|
||
{
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
return 2;
|
||
}
|
||
case CT_SAME_COLOR:
|
||
{
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
case CT_FOUR_THREESAME:
|
||
{
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if(cbNextCardValue==cbFirstCardValue) return false ;
|
||
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[i]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[i]];
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
case CT_FIVEPAIR_THREE:
|
||
{
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
for (int i = 0; i < 5; i++)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[i]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[i]];
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
|
||
case CT_SIXPAIR:
|
||
{
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
for (int i = 0; i < 6; i++)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[i]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[i]];
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
|
||
if (GetCardLogicValue(cbNextCardValue) == GetCardLogicValue(cbFirstCardValue))
|
||
{
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
return GetCardLogicValue(cbNextCardValue) > GetCardLogicValue(cbFirstCardValue);
|
||
}
|
||
}
|
||
case CT_THREE_FLUSH:
|
||
{
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
case CT_THREE_STRAIGHT:
|
||
{
|
||
for(int i=0;i<13;i++)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
return 2;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return bNextType>bFirstType;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//开始对比;
|
||
if(bNextType==bFirstType)
|
||
{
|
||
switch(bFirstType)
|
||
{
|
||
case CT_SINGLE: //单牌类型;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
for(BYTE i=0 ; i<3 ; ++i)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);
|
||
}
|
||
case CT_ONE_DOUBLE: //对带一张;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
|
||
ASSERT(cbNextCardValue!=cbFirstCardValue) ;
|
||
if(cbNextCardValue==cbFirstCardValue) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
|
||
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
|
||
//比较花色;
|
||
return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
|
||
return bNextCount < bFirstCount ;
|
||
}
|
||
case CT_FIVE_TWO_DOUBLE: //两对牌型;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[0]];
|
||
|
||
ASSERT(cbNextCardValue!=cbFirstCardValue) ;
|
||
if(cbNextCardValue==cbFirstCardValue) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
cbNextCardValue = bNextList[NextAnalyseData.bTwoFirst[1]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bTwoFirst[1]];
|
||
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//对比单牌;
|
||
cbNextCardValue = bNextList[NextAnalyseData.bOneFirst[0]];
|
||
cbFirstCardValue = bFirstList[FirstAnalyseData.bOneFirst[0]];
|
||
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
|
||
//比较花色;
|
||
return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
//return bNextCount < bFirstCount ;
|
||
}
|
||
|
||
case CT_THREE: //三张牌型;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if(cbNextCardValue==cbFirstCardValue) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
case CT_FIVE_MIXED_FLUSH_FIRST_A: //A在前顺子;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW ||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
|
||
{
|
||
cbNextLogicValue = GetCardLogicValue(bNextList[2]);
|
||
cbFirstLogicValue = GetCardLogicValue(bFirstList[2]);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(bNextList[2]) > GetCardColor(bFirstList[2]);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色 A5432 比较 5的花色;
|
||
return GetCardColor(bNextList[1]) > GetCardColor(bFirstList[1]);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
case CT_FIVE_MIXED_FLUSH_NO_A: //没A杂顺
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
|
||
{
|
||
cbNextLogicValue = GetCardLogicValue(bNextList[2]);
|
||
cbFirstLogicValue = GetCardLogicValue(bFirstList[2]);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(bNextList[2]) > GetCardColor(bFirstList[2]);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]); //比较花色
|
||
}
|
||
else
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue; //比较数值
|
||
}
|
||
}
|
||
case CT_FIVE_MIXED_FLUSH_BACK_A: //A在后顺子;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
|
||
{
|
||
cbNextLogicValue = GetCardLogicValue(bNextList[2]);
|
||
cbFirstLogicValue = GetCardLogicValue(bFirstList[2]);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(bNextList[2]) > GetCardColor(bFirstList[2]);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
if(cbNextLogicValue==cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
case CT_FIVE_FLUSH: //同花五牌;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
BYTE cbNextCardColor = GetCardColor(bNextList[0]);
|
||
BYTE cbFirstCardColor = GetCardColor(bFirstList[0]);
|
||
|
||
//先比花色;
|
||
if (cbNextCardColor!=cbFirstCardColor)
|
||
{
|
||
//比较花色;
|
||
return cbNextCardColor > cbFirstCardColor;
|
||
}
|
||
|
||
//比较数值;
|
||
for(BYTE i=0; i<5; ++i)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return cbNextCardColor > cbFirstCardColor;
|
||
}
|
||
|
||
case CT_FIVE_THREE_DEOUBLE: //三条一对;
|
||
{
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bThreeFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bThreeFirst[0]];
|
||
|
||
//数据验证;
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if(cbNextCardValue==cbFirstCardValue) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
case CT_FIVE_BOMB: //zyy
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
//比较数值;
|
||
for(BYTE i=0; i<5; ++i)
|
||
{
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue && (cbNextLogicValue != 16 || cbNextLogicValue != 15))
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]);
|
||
}
|
||
case CT_FIVE_FOUR_ONE: //四带一张;
|
||
{
|
||
//数据验证;
|
||
BYTE cbNextCardValue = bNextList[NextAnalyseData.bFourFirst[0]];
|
||
BYTE cbFirstCardValue = bFirstList[FirstAnalyseData.bFourFirst[0]];
|
||
|
||
//CC_//ASSERT(cbNextCardValue != cbFirstCardValue);
|
||
if (cbNextCardValue == cbFirstCardValue) return false;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(cbNextCardValue);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(cbFirstCardValue);
|
||
|
||
if (cbNextLogicValue == cbFirstLogicValue)
|
||
{
|
||
//比较花色;
|
||
return GetCardColor(cbNextCardValue) > GetCardColor(cbFirstCardValue);
|
||
}
|
||
else
|
||
{
|
||
//比较数值;
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
case CT_FIVE_STRAIGHT_FLUSH_NO_A: //没A同花顺;
|
||
case CT_FIVE_STRAIGHT_FLUSH_FIRST_A://A在前同花顺;
|
||
case CT_FIVE_STRAIGHT_FLUSH_BACK_A: //A在后同花顺;
|
||
{
|
||
//数据验证;
|
||
//CC_//ASSERT(bNextList[0] != bFirstList[0]);
|
||
if(bNextList[0]==bFirstList[0]) return false ;
|
||
|
||
BYTE cbNextLogicValue = GetCardLogicValue(bNextList[0]);
|
||
BYTE cbFirstLogicValue = GetCardLogicValue(bFirstList[0]);
|
||
|
||
//zyy 如果顺子有王 就比第二张;
|
||
if (cbNextLogicValue == CARD_DW||cbNextLogicValue == CARD_XW||cbFirstLogicValue == CARD_DW||cbFirstLogicValue == CARD_XW)
|
||
{
|
||
BYTE cbNextCard1Color = GetCardColor(bNextList[1]);
|
||
BYTE cbFirstCard1Color = GetCardColor(bFirstList[1]);
|
||
|
||
//先比花色;
|
||
if (cbNextCard1Color != cbFirstCard1Color)
|
||
{
|
||
//比较花色;
|
||
return cbNextCard1Color > cbFirstCard1Color;
|
||
}
|
||
|
||
//比较数值;
|
||
for(BYTE i=2; i<5; ++i)
|
||
{
|
||
cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return cbNextCard1Color > cbFirstCard1Color;
|
||
}
|
||
|
||
BYTE cbNextCardColor = GetCardColor(bNextList[0]);
|
||
BYTE cbFirstCardColor = GetCardColor(bFirstList[0]);
|
||
|
||
//先比花色;
|
||
if (cbNextCardColor != cbFirstCardColor)
|
||
{
|
||
//比较花色;
|
||
return cbNextCardColor > cbFirstCardColor;
|
||
}
|
||
|
||
//比较数值;
|
||
for(BYTE i=0; i<5; ++i)
|
||
{
|
||
cbNextLogicValue = GetCardLogicValue(bNextList[i]);
|
||
cbFirstLogicValue = GetCardLogicValue(bFirstList[i]);
|
||
|
||
if (cbNextLogicValue != cbFirstLogicValue)
|
||
{
|
||
return cbNextLogicValue > cbFirstLogicValue;
|
||
}
|
||
}
|
||
|
||
//比较花色;
|
||
return cbNextCardColor > cbFirstCardColor;
|
||
}
|
||
default:
|
||
// #ifdef _DEBUG
|
||
// AfxMessageBox("错误扑克类型！") ;
|
||
// #endif
|
||
return false ;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
|
||
//同花顺牌
|
||
//if( bNextType==CT_FIVE_STRAIGHT_FLUSH_FIRST_A || bNextType==CT_FIVE_STRAIGHT_FLUSH)
|
||
//{
|
||
// if(CT_FIVE_STRAIGHT_FLUSH_FIRST_A==bFirstType || CT_FIVE_STRAIGHT_FLUSH==bFirstType)
|
||
// {
|
||
// if(bNextType!=bFirstType)
|
||
// return bNextType > bFirstType ;
|
||
//
|
||
// //比较数值
|
||
// for(BYTE i=0; i<5; ++i)
|
||
// if(GetCardLogicValue(bNextList[i]) != GetCardLogicValue(bFirstList[i]))
|
||
// return GetCardLogicValue(bNextList[i]) > GetCardLogicValue(bFirstList[i]) ;
|
||
//
|
||
// //比较花色
|
||
// return GetCardColor(bNextList[0]) > GetCardColor(bFirstList[0]) ;
|
||
//
|
||
// }
|
||
//}
|
||
if (m_bClassicRule)
|
||
{
|
||
return bNextType > bFirstType;
|
||
}
|
||
else
|
||
{
|
||
if ((bFirstType == CT_FIVE_MIXED_FLUSH_NO_A&&bNextType == CT_FIVE_MIXED_FLUSH_FIRST_A) ||
|
||
(bFirstType == CT_FIVE_MIXED_FLUSH_FIRST_A&&bNextType == CT_FIVE_MIXED_FLUSH_NO_A))
|
||
{
|
||
return bNextType < bFirstType;
|
||
}
|
||
else
|
||
{
|
||
return bNextType > bFirstType;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
return false;
|
||
}
|
||
|
||
/*
|
||
* 分析扑克的单张，一对。。。的数目，并记录下每种类型扑克的第一张牌（也就是最大的牌）位置以便比较大小，同时判断同一花色是否有五张
|
||
*/
|
||
//分析扑克
|
||
//分析扑克
|
||
void CGameLogic::AnalyseCard(const BYTE bCardDataList[] , const BYTE bCardCount , tagAnalyseData& AnalyseData)
|
||
{
|
||
//排列扑克
|
||
BYTE bCardData[13] ;
|
||
CopyMemory(bCardData , bCardDataList , bCardCount) ;
|
||
SortCardList(bCardData , bCardCount , enDescend) ;
|
||
|
||
//变量定义
|
||
BYTE bSameCount = 1 , bCardValueTemp=0, bSameColorCount = 1 , bFirstCardIndex = 0 ; //记录下标
|
||
|
||
ASSERT(3==bCardCount || 5==bCardCount||13==bCardCount) ;
|
||
|
||
//设置结果
|
||
memset(&AnalyseData,0,sizeof(AnalyseData));
|
||
|
||
if (((GetCardLogicValue(bCardData[0])==CARD_DW || GetCardLogicValue(bCardData[0]) == CARD_XW)) && GetCardLogicValue(bCardData[1])<CARD_XW)
|
||
{
|
||
BYTE bLogicValue=GetCardLogicValue(bCardData[1]);
|
||
BYTE bCardColor = GetCardColor(bCardData[1]) ;
|
||
bFirstCardIndex=1;
|
||
//扑克分析
|
||
for (BYTE i=2;i<bCardCount;i++)
|
||
{
|
||
//获取扑克
|
||
bCardValueTemp=GetCardLogicValue(bCardData[i]);
|
||
|
||
if (bCardValueTemp==bLogicValue) bSameCount++;
|
||
|
||
//保存结果
|
||
if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
|
||
{
|
||
switch (bSameCount)
|
||
{
|
||
case 1: //一张
|
||
break;
|
||
case 2: //两张
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount] = bFirstCardIndex ;
|
||
AnalyseData.bTwoCount++ ;
|
||
break;
|
||
}
|
||
case 3: //三张
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
|
||
AnalyseData.bThreeCount++ ;
|
||
break;
|
||
}
|
||
case 4: //四张
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount] = bFirstCardIndex ;
|
||
AnalyseData.bFourCount++ ;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//设置变量
|
||
if (bCardValueTemp!=bLogicValue)
|
||
{
|
||
if(bSameCount==1)
|
||
{
|
||
if(i!=bCardCount-1)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
else
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = i ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(i==bCardCount-1)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = i ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
}
|
||
bSameCount=1;
|
||
bLogicValue=bCardValueTemp;
|
||
bFirstCardIndex = i ;
|
||
}
|
||
if(GetCardColor(bCardData[i])!=bCardColor ) bSameColorCount = 1 ;
|
||
else ++bSameColorCount ;
|
||
}
|
||
|
||
//是否同花
|
||
AnalyseData.bStraight = ((bCardCount-1)==bSameColorCount) ? true : false ;
|
||
|
||
//开始分析
|
||
switch (bCardCount)
|
||
{
|
||
case 3: //三条类型
|
||
{
|
||
|
||
//如果有一个对子的话 剩下一个王正好组成三条
|
||
if(AnalyseData.bTwoCount ==1){ AnalyseData.bTwoCount=0; AnalyseData.bThreeCount =1;AnalyseData.bThreeFirst[0]=AnalyseData.bTwoFirst[0];}
|
||
//如果两张都是单牌的话就组成一个对子
|
||
if(AnalyseData.bOneCount == 2)
|
||
{
|
||
AnalyseData.bOneCount=1;
|
||
AnalyseData.bTwoCount=1;
|
||
AnalyseData.bTwoFirst[0]=AnalyseData.bOneFirst[0];
|
||
AnalyseData.bOneFirst[0]=AnalyseData.bOneFirst[1];
|
||
}
|
||
return ;
|
||
}
|
||
case 5: //五张牌型
|
||
{
|
||
//把四带一变成五相
|
||
if (AnalyseData.bFourCount==1)
|
||
{
|
||
AnalyseData.bFourCount = 0;
|
||
AnalyseData.bFiveCount =1;
|
||
AnalyseData.bFiveFirst[0] = AnalyseData.bFourFirst[0];
|
||
}
|
||
//把三带一变成4带1
|
||
if (AnalyseData.bThreeCount==1 && AnalyseData.bOneCount==1)
|
||
{
|
||
AnalyseData.bThreeCount=0;
|
||
AnalyseData.bFourCount=1;
|
||
AnalyseData.bFourFirst[0]=AnalyseData.bThreeFirst[0];
|
||
}//把两队改三条一对
|
||
else if(AnalyseData.bTwoCount==2)
|
||
{
|
||
AnalyseData.bTwoCount=1;
|
||
AnalyseData.bThreeCount=1;
|
||
AnalyseData.bThreeFirst[0]=AnalyseData.bTwoFirst[0];
|
||
AnalyseData.bTwoFirst[0]=AnalyseData.bTwoFirst[1];
|
||
}//一对两单改成三条带单
|
||
else if (AnalyseData.bTwoCount==1 && AnalyseData.bOneCount ==2 )
|
||
{
|
||
AnalyseData.bTwoCount=0;
|
||
AnalyseData.bThreeCount=1;
|
||
AnalyseData.bThreeFirst[0]=AnalyseData.bTwoFirst[0];
|
||
|
||
}
|
||
else if (AnalyseData.bOneCount==4 )
|
||
{
|
||
AnalyseData.bOneCount=3;
|
||
AnalyseData.bTwoFirst[0]=AnalyseData.bOneFirst[0];
|
||
AnalyseData.bOneFirst[0]=AnalyseData.bOneFirst[1];
|
||
AnalyseData.bOneFirst[1]=AnalyseData.bOneFirst[2];
|
||
AnalyseData.bOneFirst[2]=AnalyseData.bOneFirst[3];
|
||
AnalyseData.bTwoCount=1;
|
||
}
|
||
return;
|
||
}
|
||
case 13://13张特殊牌型
|
||
{
|
||
//除了一张大小王 还有12张牌
|
||
//12张 改成 13水
|
||
if(AnalyseData.bOneCount==12)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount++]=0;
|
||
}
|
||
///////////////////////////////三个炸弹///////////////////////////////
|
||
if(AnalyseData.bFourCount==2 && AnalyseData.bThreeCount==1)
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
|
||
}
|
||
///////////////////////////////四套冲三/////////////////////////////////
|
||
if(AnalyseData.bThreeCount==3 && AnalyseData.bTwoCount==1&&AnalyseData.bOneCount==1)
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
}
|
||
///////////////////////////////五对冲三/////////////////////////////////
|
||
if (AnalyseData.bTwoCount == 6)
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++] = AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
}
|
||
|
||
if (AnalyseData.bTwoCount == 4 && AnalyseData.bThreeCount == 1 )
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
if (AnalyseData.bTwoCount == 3 && AnalyseData.bThreeCount ==2 )
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
|
||
}
|
||
if (AnalyseData.bTwoCount == 2 && AnalyseData.bFourCount ==1 && AnalyseData.bThreeCount ==1)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
if( AnalyseData.bTwoCount == 2 && AnalyseData.bFourCount== 2 )
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
}
|
||
if(AnalyseData.bFourCount == 2 && AnalyseData.bThreeCount == 1)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
///////////////////////////////六对半 /////////////////////////////////
|
||
if (AnalyseData.bTwoCount == 5 && AnalyseData.bOneCount == 2)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
|
||
if (AnalyseData.bTwoCount ==1 && AnalyseData.bFourCount == 2)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
else if (GetCardLogicValue(bCardData[0])==CARD_DW && GetCardLogicValue(bCardData[1]) == CARD_XW)
|
||
{
|
||
BYTE bLogicValue=GetCardLogicValue(bCardData[2]);
|
||
BYTE bCardColor = GetCardColor(bCardData[2]) ;
|
||
bFirstCardIndex=2;
|
||
if (bCardCount != 3)
|
||
{
|
||
//扑克分析
|
||
for (BYTE i=3;i<bCardCount;i++)
|
||
{
|
||
//获取扑克
|
||
bCardValueTemp=GetCardLogicValue(bCardData[i]);
|
||
|
||
if (bCardValueTemp==bLogicValue) bSameCount++;
|
||
|
||
//保存结果
|
||
if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
|
||
{
|
||
switch (bSameCount)
|
||
{
|
||
case 1: //一张
|
||
break;
|
||
case 2: //两张
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount] = bFirstCardIndex ;
|
||
AnalyseData.bTwoCount++ ;
|
||
break;
|
||
}
|
||
case 3: //三张
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
|
||
AnalyseData.bThreeCount++ ;
|
||
break;
|
||
}
|
||
case 4: //四张
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount] = bFirstCardIndex ;
|
||
AnalyseData.bFourCount++ ;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//设置变量
|
||
if (bCardValueTemp!=bLogicValue)
|
||
{
|
||
if(bSameCount==1)
|
||
{
|
||
if(i!=bCardCount-1)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
else
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = i ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(i==bCardCount-1)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = i ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
}
|
||
bSameCount=1;
|
||
bLogicValue=bCardValueTemp;
|
||
bFirstCardIndex = i ;
|
||
}
|
||
if(GetCardColor(bCardData[i])!=bCardColor ) bSameColorCount = 1 ;
|
||
else ++bSameColorCount ;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//zyy
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
|
||
AnalyseData.bThreeCount++ ;
|
||
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
|
||
}
|
||
|
||
|
||
//是否同花
|
||
AnalyseData.bStraight = ((bCardCount-2)==bSameColorCount) ? true : false ;
|
||
|
||
//开始分析
|
||
switch (bCardCount)
|
||
{
|
||
case 3: //三条类型
|
||
{
|
||
//一共就三张牌 大小王两张 就剩下一张了 组成个三条吧
|
||
if(AnalyseData.bOneCount ==1)
|
||
{
|
||
AnalyseData.bOneCount=0;
|
||
AnalyseData.bThreeCount =1;
|
||
AnalyseData.bThreeFirst[0]=AnalyseData.bOneFirst[0];
|
||
}
|
||
return ;
|
||
}
|
||
case 5: //五张牌型
|
||
{
|
||
/////////////////一共就5张牌 大小王两张 剩下三张了/////////////////////////////
|
||
//这三张是三条的话 就只能组成 五相
|
||
if(AnalyseData.bThreeCount==1)
|
||
{
|
||
AnalyseData.bThreeCount=0;
|
||
AnalyseData.bFiveCount=1;
|
||
AnalyseData.bFiveFirst[0]=AnalyseData.bThreeFirst[0];
|
||
}
|
||
else if(AnalyseData.bTwoCount==1 && AnalyseData.bOneCount==1)
|
||
{
|
||
AnalyseData.bTwoCount=0;
|
||
AnalyseData.bFourCount=1;
|
||
AnalyseData.bFourFirst[0]=AnalyseData.bTwoFirst[0];
|
||
}//这三张是单牌 就组成三带二
|
||
else if (AnalyseData.bOneCount==3)
|
||
{
|
||
AnalyseData.bOneCount=2;
|
||
AnalyseData.bThreeCount=1;
|
||
AnalyseData.bThreeFirst[0]=AnalyseData.bOneFirst[0];
|
||
AnalyseData.bOneFirst[0]=AnalyseData.bOneFirst[1];
|
||
AnalyseData.bOneFirst[1]=AnalyseData.bOneFirst[2];
|
||
AnalyseData.bOneFirst[2]=AnalyseData.bOneFirst[3];
|
||
}
|
||
return;
|
||
}
|
||
case 13://13张特殊牌型
|
||
{
|
||
//11张改成13水
|
||
if (AnalyseData.bOneCount==11)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount++]=0;
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount++]=1;
|
||
}
|
||
///////////////////////////////三个炸弹///////////////////////////////
|
||
|
||
if (AnalyseData.bFourCount==2&& AnalyseData.bThreeCount==1) //2个4张+1个3张
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
|
||
}
|
||
|
||
if (AnalyseData.bFourCount==2&& AnalyseData.bTwoCount==1)//2个4张+1个2张+1个1张
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
}
|
||
|
||
if (AnalyseData.bFourCount==1&& AnalyseData.bThreeCount==2)//1个4张+2个3张
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
|
||
}
|
||
|
||
///////////////////////////////四套冲三///////////////////////////////// 4个3张
|
||
if(AnalyseData.bThreeCount==3 && AnalyseData.bTwoCount==1)//3个3张+1个2张
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
}
|
||
|
||
if(AnalyseData.bThreeCount==3 && AnalyseData.bOneCount==2)//3个3张+2个1张
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
|
||
if(AnalyseData.bThreeCount==2 && AnalyseData.bTwoCount==2)//2个3张+2个2张
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++]=AnalyseData.bTwoFirst[--AnalyseData.bTwoCount];
|
||
}
|
||
|
||
///////////////////////////////五对冲三/////////////////////////////////
|
||
if (AnalyseData.bTwoCount == 5 && AnalyseData.bOneCount ==1)
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++] = AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
|
||
if (AnalyseData.bTwoCount== 4 && AnalyseData.bThreeCount==1)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++] = 0;
|
||
}
|
||
|
||
if (AnalyseData.bTwoCount == 3 && AnalyseData.bThreeCount ==1)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
|
||
if (AnalyseData.bTwoCount == 2 && AnalyseData.bThreeCount ==2)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount++]=AnalyseData.bThreeFirst[--AnalyseData.bThreeCount];
|
||
}
|
||
|
||
if(AnalyseData.bTwoCount ==2 && AnalyseData.bFourCount ==1 && AnalyseData.bThreeCount==1)
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=0;
|
||
}
|
||
|
||
if ((AnalyseData.bTwoCount== 3 && AnalyseData.bFourCount==1)
|
||
||(AnalyseData.bTwoCount ==1 && AnalyseData.bFourCount ==2))
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount++] = AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
|
||
///////////////////////////////六对半 /////////////////////////////////
|
||
if ((AnalyseData.bTwoCount == 4 && AnalyseData.bOneCount == 3)
|
||
||(AnalyseData.bFourCount == 2 && AnalyseData.bOneCount == 3))
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount++]=AnalyseData.bOneFirst[--AnalyseData.bOneCount];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
BYTE bLogicValue=GetCardLogicValue(bCardData[0]);
|
||
BYTE bCardColor = GetCardColor(bCardData[0]) ;
|
||
//扑克分析
|
||
for (BYTE i=1;i<bCardCount;i++)
|
||
{
|
||
//获取扑克
|
||
bCardValueTemp=GetCardLogicValue(bCardData[i]);
|
||
|
||
if (bCardValueTemp==bLogicValue ) bSameCount++;
|
||
|
||
//保存结果
|
||
if ((bCardValueTemp!=bLogicValue)||(i==(bCardCount-1)))
|
||
{
|
||
switch (bSameCount)
|
||
{
|
||
case 1: //一张
|
||
break;
|
||
case 2: //两张
|
||
{
|
||
AnalyseData.bTwoFirst[AnalyseData.bTwoCount] = bFirstCardIndex ;
|
||
AnalyseData.bTwoCount++ ;
|
||
break;
|
||
}
|
||
case 3: //三张
|
||
{
|
||
AnalyseData.bThreeFirst[AnalyseData.bThreeCount] = bFirstCardIndex ;
|
||
AnalyseData.bThreeCount++ ;
|
||
break;
|
||
}
|
||
case 4: //四张
|
||
{
|
||
AnalyseData.bFourFirst[AnalyseData.bFourCount] = bFirstCardIndex ;
|
||
AnalyseData.bFourCount++ ;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//设置变量
|
||
if (bCardValueTemp!=bLogicValue)
|
||
{
|
||
if(bSameCount==1)
|
||
{
|
||
if(i!=bCardCount-1)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
else
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = bFirstCardIndex ;
|
||
AnalyseData.bOneCount++ ;
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = i ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(i==bCardCount-1)
|
||
{
|
||
AnalyseData.bOneFirst[AnalyseData.bOneCount] = i ;
|
||
AnalyseData.bOneCount++ ;
|
||
}
|
||
}
|
||
bSameCount=1;
|
||
bLogicValue=bCardValueTemp;
|
||
bFirstCardIndex = i ;
|
||
}
|
||
if(GetCardColor(bCardData[i])!= bCardColor ) bSameColorCount = 1 ;
|
||
else ++bSameColorCount ;
|
||
}
|
||
|
||
//是否同花
|
||
AnalyseData.bStraight = (bCardCount==bSameColorCount) ? true : false ;
|
||
|
||
}
|
||
|
||
|
||
return;
|
||
}
|
||
|
||
//分析扑克
|
||
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;
|
||
}
|
||
|
||
tagAnalyseType CGameLogic::GetType( BYTE bCardData[], BYTE bCardCount )
|
||
{
|
||
tagAnalyseType Type;
|
||
ZeroMemory(&Type,sizeof(Type));
|
||
if(bCardCount==0)
|
||
{
|
||
ZeroMemory(&Type,sizeof(Type));
|
||
return Type;
|
||
}
|
||
//排列扑克;
|
||
BYTE CardData[13] ;
|
||
CopyMemory(CardData , bCardData , bCardCount) ;
|
||
SortCardList(CardData , bCardCount , enDescend) ;
|
||
|
||
BYTE Index[13]={0};
|
||
BYTE Number=0;
|
||
BYTE SameValueCount=1;
|
||
|
||
BYTE Num[9]={0};
|
||
if (GetCardLogicValue(CardData[0]) >=CARD_XW && GetCardLogicValue(CardData[1]) <CARD_XW)
|
||
{
|
||
//判断数值相同的牌
|
||
BYTE bLogicValue=GetCardLogicValue(CardData[1]);
|
||
Index[Number++]=1;
|
||
for(BYTE i=2;i<bCardCount;i++)
|
||
{
|
||
if(bLogicValue==GetCardLogicValue(CardData[i]))
|
||
{
|
||
SameValueCount++;
|
||
Index[Number++]=i;
|
||
}
|
||
if( bLogicValue!=GetCardLogicValue(CardData[i])||i==bCardCount-1)
|
||
{
|
||
if(SameValueCount==1)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
|
||
Type.cbOnePare[Num[0]++]=0;
|
||
Type.btOnePare++;
|
||
}
|
||
else if(SameValueCount==2)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
|
||
Type.btOnePare++;
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
|
||
Type.cbThreeSame[Num[2]++]=0;
|
||
Type.btThreeSame++;
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
}
|
||
else if(SameValueCount==3)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
|
||
Type.btThreeSame++;
|
||
Type.bFourSame=true;
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
|
||
Type.cbFourSame[Num[6]++]=0;
|
||
Type.btFourSame++;
|
||
}
|
||
else if(SameValueCount==4)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-4];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-4];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.bFourSame=true;
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-4];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
|
||
Type.btFourSame++;
|
||
|
||
Type.bFiveSame = true;
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-4];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-3];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-2];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-1];
|
||
Type.cbFiveSame[Num[8]++] = 0;
|
||
Type.btFiveSame++;
|
||
|
||
|
||
}
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
SameValueCount=1;
|
||
bLogicValue=GetCardLogicValue(CardData[i]);
|
||
}
|
||
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(CardData[0]) ==CARD_DW && GetCardLogicValue(CardData[1]) ==CARD_XW)
|
||
{
|
||
//判断数值相同的牌
|
||
BYTE bLogicValue=GetCardLogicValue(CardData[2]);
|
||
Index[Number++]=2;
|
||
for(BYTE i=3;i<bCardCount;i++)
|
||
{
|
||
if(bLogicValue==GetCardLogicValue(CardData[i]))
|
||
{
|
||
SameValueCount++;
|
||
Index[Number++]=i;
|
||
}
|
||
if( bLogicValue!=GetCardLogicValue(CardData[i])||i==bCardCount-1)
|
||
{
|
||
if(SameValueCount==1)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
|
||
Type.cbOnePare[Num[0]++]=0;
|
||
Type.btOnePare++;
|
||
/*Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
|
||
Type.cbThreeSame[Num[2]++]=0;
|
||
Type.cbThreeSame[Num[2]++]=1;
|
||
Type.btThreeSame++;*/
|
||
}
|
||
else if(SameValueCount==2)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
|
||
Type.btOnePare++;
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
|
||
Type.cbThreeSame[Num[2]++]=0;
|
||
Type.btThreeSame++;
|
||
Type.bFourSame=true;
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
|
||
Type.cbFourSame[Num[6]++]=0;
|
||
Type.cbFourSame[Num[6]++]=1;
|
||
Type.btFourSame++;
|
||
}
|
||
else if(SameValueCount==3)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
|
||
Type.btThreeSame++;
|
||
Type.bFourSame=true;
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
|
||
Type.cbFourSame[Num[6]++]=0;
|
||
Type.btFourSame++;
|
||
|
||
Type.bFiveSame = true;
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-3];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-2];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-1];
|
||
Type.cbFiveSame[Num[8]++] = 0;
|
||
Type.cbFiveSame[Num[8]++] = 1;
|
||
Type.btFiveSame++;
|
||
}
|
||
else if(SameValueCount==4)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-4];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-4];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.bFourSame=true;
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-4];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
|
||
Type.btFourSame++;
|
||
|
||
Type.bFiveSame = true;
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-4];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-3];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-2];
|
||
Type.cbFiveSame[Num[8]++] = Index[SameValueCount-1];
|
||
Type.cbFiveSame[Num[8]++] = 0;
|
||
Type.btFiveSame++;
|
||
|
||
|
||
}
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
SameValueCount=1;
|
||
bLogicValue=GetCardLogicValue(CardData[i]);
|
||
}
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//判断数值相同的牌
|
||
BYTE bLogicValue=GetCardLogicValue(CardData[0]);
|
||
Index[Number++]=0;
|
||
for(BYTE i=1;i<bCardCount;i++)
|
||
{
|
||
if(bLogicValue==GetCardLogicValue(CardData[i]))
|
||
{
|
||
SameValueCount++;
|
||
Index[Number++]=i;
|
||
}
|
||
if(bLogicValue!=GetCardLogicValue(CardData[i])||i==bCardCount-1)
|
||
{
|
||
if(SameValueCount==1)
|
||
{
|
||
|
||
}
|
||
else if(SameValueCount==2)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-1];
|
||
Type.btOnePare++;
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
}
|
||
else if(SameValueCount==3)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-2];
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-1];
|
||
Type.btThreeSame++;
|
||
}
|
||
else if(SameValueCount==4)
|
||
{
|
||
Type.bOnePare=true;
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-4];
|
||
Type.cbOnePare[Num[0]++]=Index[SameValueCount-3];
|
||
//printf("%d,%d ",Index[0],Index[1]);
|
||
Type.bThreeSame=true;
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-4];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-3];
|
||
Type.cbThreeSame[Num[2]++]=Index[SameValueCount-2];
|
||
Type.bFourSame=true;
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-4];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-3];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-2];
|
||
Type.cbFourSame[Num[6]++]=Index[SameValueCount-1];
|
||
Type.btFourSame++;
|
||
}
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
SameValueCount=1;
|
||
bLogicValue=GetCardLogicValue(CardData[i]);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//判断两对
|
||
BYTE OnePareCount=Num[0]/2;
|
||
BYTE ThreeSameCount=Num[2]/3;
|
||
if(OnePareCount>=2)
|
||
{
|
||
Type.bTwoPare=false;
|
||
for(BYTE i=0;i<OnePareCount;i++)
|
||
{
|
||
for(BYTE j=i+1;j<OnePareCount;j++)
|
||
{
|
||
if (CardData[Type.cbOnePare[i*2]] == CardData[Type.cbOnePare[i*2+1]] || CardData[Type.cbOnePare[i*2]] == CardData[Type.cbOnePare[j*2]]
|
||
|| CardData[Type.cbOnePare[i*2+1]] == CardData[Type.cbOnePare[j*2]] || CardData[Type.cbOnePare[i*2+1]] == CardData[Type.cbOnePare[j*2+1]]
|
||
|| CardData[Type.cbOnePare[j*2+1]] == CardData[Type.cbOnePare[i*2]] || CardData[Type.cbOnePare[j*2+1]] == CardData[Type.cbOnePare[j*2]]) continue;
|
||
Type.cbTwoPare[Num[1]++]=Type.cbOnePare[i*2];
|
||
Type.cbTwoPare[Num[1]++]=Type.cbOnePare[i*2+1];
|
||
Type.cbTwoPare[Num[1]++]=Type.cbOnePare[j*2];
|
||
Type.cbTwoPare[Num[1]++]=Type.cbOnePare[j*2+1];
|
||
Type.btTwoPare++;
|
||
Type.bTwoPare=true;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//判断葫芦
|
||
if(OnePareCount>0&&ThreeSameCount>0)
|
||
{
|
||
for(BYTE i=0;i<ThreeSameCount;i++)
|
||
{
|
||
for(BYTE j=0;j<OnePareCount;j++)
|
||
{
|
||
if(bCardData [Type.cbThreeSame[i*3]] == bCardData [Type.cbThreeSame[i*3+1]]
|
||
|| bCardData [Type.cbThreeSame[i*3]] == bCardData[Type.cbThreeSame[i*3+2]]
|
||
|| bCardData [Type.cbThreeSame[i*3]] == bCardData [Type.cbOnePare[j*2]]
|
||
|| bCardData [Type.cbThreeSame[i*3]] == bCardData [Type.cbOnePare[j*2+1]]
|
||
|| bCardData [Type.cbThreeSame[i*3+1]] == bCardData[Type.cbThreeSame[i*3+2]]
|
||
|| bCardData [Type.cbThreeSame[i*3+1]] == bCardData [Type.cbOnePare[j*2]]
|
||
|| bCardData [Type.cbThreeSame[i*3+1]] == bCardData [Type.cbOnePare[j*2+1]]
|
||
|| bCardData [Type.cbThreeSame[i*3+2]] == bCardData [Type.cbOnePare[j*2]]
|
||
|| bCardData [Type.cbThreeSame[i*3+2]] == bCardData [Type.cbOnePare[j*2+1]]
|
||
|| bCardData [Type.cbOnePare[j*2]] == bCardData[Type.cbThreeSame[i*3+2]])
|
||
{
|
||
continue;
|
||
}
|
||
|
||
/*if (bCardData [Type.cbThreeSame[i*3]] != bCardData [Type.cbOnePare[j*2]]
|
||
&& bCardData [Type.cbThreeSame[i*3]] != bCardData [Type.cbOnePare[j*2+1]]
|
||
&& bCardData [Type.cbThreeSame[i*3+1]] != bCardData [Type.cbOnePare[j*2]]
|
||
&& bCardData [Type.cbThreeSame[i*3+1]] != bCardData [Type.cbOnePare[j*2+1]]
|
||
&& bCardData [Type.cbThreeSame[i*3+2]] != bCardData [Type.cbOnePare[j*2]]
|
||
&& bCardData [Type.cbThreeSame[i*3+2]] != bCardData [Type.cbOnePare[j*2+1]])*/
|
||
{
|
||
Type.bGourd=true;
|
||
Type.cbGourd[Num[5]++]=Type.cbThreeSame[i*3];
|
||
Type.cbGourd[Num[5]++]=Type.cbThreeSame[i*3+1];
|
||
Type.cbGourd[Num[5]++]=Type.cbThreeSame[i*3+2];
|
||
Type.cbGourd[Num[5]++]=Type.cbOnePare[j*2];
|
||
Type.cbGourd[Num[5]++]=Type.cbOnePare[j*2+1];
|
||
Type.btGourd++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//判断顺子及同花顺
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
BYTE Straight=1;
|
||
BYTE bStraight=GetCardLogicValue(CardData[0]);
|
||
if (GetCardLogicValue(CardData[0]) >=CARD_XW && GetCardLogicValue(CardData[1]) <CARD_XW)
|
||
{
|
||
bStraight=GetCardLogicValue(CardData[1]);
|
||
Index[Number++]=1;
|
||
bool bUsedW = false;
|
||
for(BYTE i=2;i<bCardCount;i++)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])+1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
else if ((bStraight==GetCardLogicValue(CardData[i])+2)&&(bUsedW == false))
|
||
{
|
||
bUsedW = true;
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
|
||
{
|
||
if (Straight == 4 && bUsedW == false)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
}
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<Straight;j++)
|
||
{
|
||
if(Straight-j>=5)
|
||
{
|
||
if (bCardData[Index[j]] == bCardData[Index[j+1]] || bCardData[Index[j]] == bCardData[Index[j+2]]
|
||
|| bCardData[Index[j]] == bCardData[Index[j+3]] || bCardData[Index[j]] == bCardData[Index[j+4]]
|
||
|| bCardData[Index[j+1]] == bCardData[Index[j+2]] || bCardData[Index[j+1]] == bCardData[Index[j+3]]
|
||
|| bCardData[Index[j+1]] == bCardData[Index[j+4]] || bCardData[Index[j+2]] == bCardData[Index[j+3]]
|
||
|| bCardData[Index[j+2]] == bCardData[Index[j+4]] || bCardData[Index[j+3]] == bCardData[Index[j+4]]
|
||
)
|
||
{
|
||
continue;
|
||
}
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
Type.cbStraight[Num[3]++]=Index[j+1];
|
||
Type.cbStraight[Num[3]++]=Index[j+2];
|
||
Type.cbStraight[Num[3]++]=Index[j+3];
|
||
Type.cbStraight[Num[3]++]=Index[j+4];
|
||
Type.btStraight++;
|
||
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=j;k<j+5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=j;n<j+5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
if(bCardCount-i<5)
|
||
{
|
||
break;
|
||
}
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
Straight=1;
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
bUsedW = false;
|
||
}
|
||
}
|
||
|
||
|
||
//存在2 检测A2345顺子
|
||
if(GetCardLogicValue(CardData[bCardCount-1])==2)
|
||
{
|
||
Number=0;
|
||
Straight=2;
|
||
bStraight=GetCardLogicValue(CardData[1]);
|
||
ZeroMemory(Index,sizeof(Index));
|
||
bool bFind = false;
|
||
|
||
if (bStraight==14)
|
||
{
|
||
Index[Number++]=1;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
|
||
bUsedW = false;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
continue;
|
||
}
|
||
|
||
if((bStraight==GetCardLogicValue(CardData[i])-2)
|
||
&&(false == bUsedW))//保证鬼只使用一次
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
bUsedW = true;
|
||
}
|
||
}
|
||
|
||
if (Straight == 4 && bUsedW == false)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Index[Number++]=0;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<5;j++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
}
|
||
Type.btStraight++;
|
||
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=0;k<5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=0;n<5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
//存在3并且存在A 检测A2345顺子
|
||
if((GetCardLogicValue(CardData[bCardCount-1])==3)
|
||
&&(GetCardLogicValue(CardData[1])==14))
|
||
{
|
||
Number=0;
|
||
Straight=3;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
|
||
Index[Number++]=0;
|
||
Index[Number++]=1;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
|
||
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<5;j++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
}
|
||
Type.btStraight++;
|
||
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=0;k<5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=0;n<5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(CardData[0]) ==CARD_DW && GetCardLogicValue(CardData[1]) ==CARD_XW)
|
||
{
|
||
bStraight=GetCardLogicValue(CardData[2]);
|
||
Index[Number++]=2;
|
||
|
||
bool bUsedDW = false;
|
||
bool bUsedXW = false;
|
||
for(BYTE i=3;i<bCardCount;i++)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])+1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
else if ((bStraight==GetCardLogicValue(CardData[i])+2)&&((bUsedDW==false)||(bUsedXW==false)))
|
||
{
|
||
if (bUsedDW == false)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
bUsedDW = true;
|
||
}
|
||
else if (bUsedXW == false)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=1;
|
||
bUsedXW = true;
|
||
}
|
||
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
else if ((bStraight == GetCardLogicValue(CardData[i]+3))&&(bUsedDW==false)&&(bUsedXW==false))
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=1;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
bUsedDW = true;
|
||
bUsedXW = true;
|
||
}
|
||
if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
|
||
{
|
||
if (Straight==4&&((bUsedDW==false)||(bUsedXW==false)))
|
||
{
|
||
if (bUsedDW == false)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
bUsedDW = true;
|
||
}
|
||
else if (bUsedXW == false)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=1;
|
||
bUsedXW = true;
|
||
}
|
||
}
|
||
|
||
if (Straight==3&&((bUsedDW==false)&&(bUsedXW==false)))
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=1;
|
||
}
|
||
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<Straight;j++)
|
||
{
|
||
if(Straight-j>=5)
|
||
{
|
||
if (bCardData[Index[j]] == bCardData[Index[j+1]] || bCardData[Index[j]] == bCardData[Index[j+2]]
|
||
|| bCardData[Index[j]] == bCardData[Index[j+3]] || bCardData[Index[j]] == bCardData[Index[j+4]]
|
||
|| bCardData[Index[j+1]] == bCardData[Index[j+2]] || bCardData[Index[j+1]] == bCardData[Index[j+3]]
|
||
|| bCardData[Index[j+1]] == bCardData[Index[j+4]] || bCardData[Index[j+2]] == bCardData[Index[j+3]]
|
||
|| bCardData[Index[j+2]] == bCardData[Index[j+4]] || bCardData[Index[j+3]] == bCardData[Index[j+4]]
|
||
)
|
||
{
|
||
continue;
|
||
}
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
Type.cbStraight[Num[3]++]=Index[j+1];
|
||
Type.cbStraight[Num[3]++]=Index[j+2];
|
||
Type.cbStraight[Num[3]++]=Index[j+3];
|
||
Type.cbStraight[Num[3]++]=Index[j+4];
|
||
Type.btStraight++;
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=j;k<j+5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=j;n<j+5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
if(bCardCount-i<5)
|
||
{
|
||
break;
|
||
}
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
Straight=1;
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
bUsedDW = false;
|
||
bUsedXW = false;
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//存在2 检测A2345顺子
|
||
if(GetCardLogicValue(CardData[bCardCount-1])==2)
|
||
{
|
||
Number=0;
|
||
Straight=2;
|
||
bStraight=GetCardLogicValue(CardData[2]);
|
||
ZeroMemory(Index,sizeof(Index));
|
||
bool bFind = false;
|
||
if (bStraight==14)
|
||
{
|
||
//Index[Number++]=1;
|
||
Index[Number++]=2; //下标0,1位置是鬼，所以是从下标2位置的A开始
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
|
||
bool bDWused = false;
|
||
bool bXWused = false;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
continue;
|
||
}
|
||
else if((bStraight==GetCardLogicValue(CardData[i])-2)
|
||
&&((false == bDWused)||(false == bDWused)))//保证大小鬼只使用一次
|
||
{
|
||
if (bDWused == false)
|
||
{
|
||
bDWused = true;
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
else if (bXWused == false)
|
||
{
|
||
bXWused = true;
|
||
Straight++;
|
||
Index[Number++]=1;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
else if ((bStraight == GetCardLogicValue(CardData[i]-3))
|
||
&&(false == bDWused)&&(false == bDWused))//保证大小鬼只使用一次
|
||
{
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=1;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Index[Number++]=rand()%2;//大小鬼任取一张
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<5;j++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
}
|
||
Type.btStraight++;
|
||
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=0;k<5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=0;n<5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
//存在3 检测A2345顺子
|
||
if(GetCardLogicValue(CardData[bCardCount-1])==3)
|
||
{
|
||
Number=0;
|
||
Straight=3;
|
||
bStraight=GetCardLogicValue(CardData[2]);
|
||
ZeroMemory(Index,sizeof(Index));
|
||
bool bFind = false;
|
||
if (bStraight==14)
|
||
{
|
||
Index[Number++]=1;
|
||
Index[Number++] = 2;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
|
||
bool bDWused = false;
|
||
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
continue;
|
||
}
|
||
else if((bStraight==GetCardLogicValue(CardData[i])-2)
|
||
&&(false == bDWused))//保证大鬼只使用一次
|
||
{
|
||
if (bDWused == false)
|
||
{
|
||
bDWused = true;
|
||
Straight++;
|
||
Index[Number++]=0;
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Index[Number++]=0;
|
||
Index[Number++]=1;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<5;j++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
}
|
||
Type.btStraight++;
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=0;k<5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=0;n<5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//存在4和A 检测A2345顺子
|
||
if((GetCardLogicValue(CardData[bCardCount-1])==4)
|
||
&&(GetCardLogicValue(CardData[2])==14))
|
||
{
|
||
Number=0;
|
||
Straight=4;
|
||
bStraight=GetCardLogicValue(CardData[2]);
|
||
ZeroMemory(Index,sizeof(Index));
|
||
|
||
Index[Number++]=0;
|
||
Index[Number++]=1;
|
||
Index[Number++]=2;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<5;j++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
}
|
||
Type.btStraight++;
|
||
|
||
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=0;k<5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=0;n<5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
}
|
||
else //没有王的
|
||
{
|
||
|
||
bStraight=GetCardLogicValue(CardData[0]);
|
||
Index[Number++]=0;
|
||
if(bStraight!=14)
|
||
{
|
||
for(BYTE i=1;i<bCardCount;i++)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])+1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
|
||
{
|
||
if(Straight>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<Straight;j++)
|
||
{
|
||
if(Straight-j>=5)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
Type.cbStraight[Num[3]++]=Index[j+1];
|
||
Type.cbStraight[Num[3]++]=Index[j+2];
|
||
Type.cbStraight[Num[3]++]=Index[j+3];
|
||
Type.cbStraight[Num[3]++]=Index[j+4];
|
||
Type.btStraight++;
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=j;k<j+5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=j;n<j+5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
if(bCardCount-i<5)
|
||
{
|
||
break;
|
||
}
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
Straight=1;
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
}
|
||
}
|
||
|
||
}
|
||
if(bStraight==14) ///zyy 要是出现A的 就会有问题
|
||
{
|
||
for(BYTE i=1;i<bCardCount;i++)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])+1)
|
||
{
|
||
Straight++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
|
||
}
|
||
if(bStraight>GetCardLogicValue(CardData[i])+1||i==bCardCount-1)
|
||
{
|
||
if(Straight>=5)
|
||
{
|
||
|
||
Type.bStraight=true;
|
||
for(BYTE j=0;j<Straight;j++)
|
||
{
|
||
if(Straight-j>=5 )
|
||
{
|
||
|
||
Type.cbStraight[Num[3]++]=Index[j];
|
||
Type.cbStraight[Num[3]++]=Index[j+1];
|
||
Type.cbStraight[Num[3]++]=Index[j+2];
|
||
Type.cbStraight[Num[3]++]=Index[j+3];
|
||
Type.cbStraight[Num[3]++]=Index[j+4];
|
||
Type.btStraight++;
|
||
//从手牌中找到和顺子5张中其中一张数值相同的牌，组成另一种顺子
|
||
for(int k=j;k<j+5;k++)
|
||
{
|
||
for(int m=0;m<bCardCount;m++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[k]])==GetCardLogicValue(CardData[m])&&GetCardColor(CardData[Index[k]])!=GetCardColor(CardData[m]))
|
||
{
|
||
for(int n=j;n<j+5;n++)
|
||
{
|
||
if(n==k)
|
||
{
|
||
Type.cbStraight[Num[3]++]=m;
|
||
}
|
||
else
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[n];
|
||
}
|
||
}
|
||
Type.btStraight++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if((bCardCount-i)<5)
|
||
{
|
||
break;
|
||
}
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
Straight=1;
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=i;
|
||
}
|
||
}
|
||
|
||
if(GetCardLogicValue(CardData[bCardCount-1])==2)
|
||
{
|
||
Number=0;
|
||
BYTE BackA=1;
|
||
BYTE FrontA=1;
|
||
bStraight=GetCardLogicValue(CardData[0]);
|
||
ZeroMemory(Index,sizeof(Index));
|
||
Index[Number++]=0;
|
||
bStraight=GetCardLogicValue(CardData[bCardCount-1]);
|
||
Index[Number++]=bCardCount-1;
|
||
for(int i=bCardCount-2;i>=0;i--)
|
||
{
|
||
if(bStraight==GetCardLogicValue(CardData[i])-1)
|
||
{
|
||
FrontA++;
|
||
Index[Number++]=i;
|
||
bStraight=GetCardLogicValue(CardData[i]);
|
||
}
|
||
}
|
||
if(FrontA+BackA>=5)
|
||
{
|
||
Type.bStraight=true;
|
||
for(BYTE i=BackA;i>0;i--)
|
||
{
|
||
for(BYTE j=1;j<=FrontA;j++)
|
||
{
|
||
if(i+j==5)
|
||
{
|
||
for(BYTE k=0;k<i;k++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[k];
|
||
}
|
||
for(BYTE k=0;k<j;k++)
|
||
{
|
||
Type.cbStraight[Num[3]++]=Index[k+BackA];
|
||
}
|
||
|
||
Type.btStraight++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
//判断同花
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
SortCardList(CardData , bCardCount , enColor) ;
|
||
BYTE cbCardData[13];
|
||
CopyMemory(cbCardData , bCardData , bCardCount) ;
|
||
SortCardList(cbCardData , bCardCount , enDescend) ;
|
||
if (GetCardLogicValue(CardData[0]) >=CARD_XW && GetCardLogicValue(CardData[1]) <CARD_XW)
|
||
{
|
||
BYTE SameColorCount=1;
|
||
BYTE bCardColor = GetCardColor(CardData[1]) ;
|
||
Index[Number++]=1;
|
||
|
||
for(BYTE i=2;i<bCardCount;i++)
|
||
{
|
||
if(bCardColor==GetCardColor(CardData[i]))
|
||
{
|
||
SameColorCount++;
|
||
Index[Number++]=i;
|
||
}
|
||
if(bCardColor!=GetCardColor(CardData[i])||i==bCardCount-1)
|
||
{
|
||
if (SameColorCount==4)
|
||
{
|
||
SameColorCount++;
|
||
Index[Number++]=0;
|
||
}
|
||
if(SameColorCount>=5)
|
||
{
|
||
Type.bFlush=true;
|
||
//切换位置
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
for(BYTE k=0;k<bCardCount;k++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[j]])==GetCardLogicValue(cbCardData[k])
|
||
&&GetCardColor(CardData[Index[j]])==GetCardColor(cbCardData[k]))
|
||
{
|
||
Index[j]=k;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//排序位置
|
||
BYTE SaveIndex=0;
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
for(BYTE k=j+1;k<SameColorCount;k++)
|
||
{
|
||
if(Index[j]>Index[k])
|
||
{
|
||
SaveIndex=Index[j];
|
||
Index[j]=Index[k];
|
||
Index[k]=SaveIndex;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//同花顺
|
||
if (GetCardLogicValue(cbCardData[Index[0]])>=CARD_XW)
|
||
{
|
||
if (((GetCardLogicValue(cbCardData[Index[1]])==14)&&((GetCardLogicValue(cbCardData[Index[2]])==5)||(GetCardLogicValue(cbCardData[Index[2]])==4)))
|
||
||(4>=(GetCardLogicValue(cbCardData[Index[1]])-GetCardLogicValue(cbCardData[Index[4]]))))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];
|
||
Type.cbStraightFlush[Num[7]++]=Index[1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[3];
|
||
Type.cbStraightFlush[Num[7]++]=Index[4];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//同花A2345特殊处理
|
||
if (GetCardLogicValue(cbCardData[Index[0]])==14)
|
||
{
|
||
for (BYTE i=1;i<SameColorCount;i++)
|
||
{
|
||
|
||
if(GetCardLogicValue(cbCardData[Index[i]])==5)
|
||
{
|
||
if (SameColorCount-i==4)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (SameColorCount-i==3)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.btStraightFlush++;
|
||
}
|
||
|
||
}
|
||
|
||
if(GetCardLogicValue(cbCardData[Index[i]])==4)
|
||
{
|
||
if (SameColorCount-i==3)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
for (BYTE i=0;i<SameColorCount;i++)
|
||
{
|
||
if (SameColorCount-i>=5)
|
||
{
|
||
if (4==(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+4]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+4];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.btStraightFlush++;
|
||
}
|
||
|
||
}
|
||
else if(SameColorCount-i==4)
|
||
{
|
||
if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
if(SameColorCount-j>=5)
|
||
{
|
||
Type.cbFlush[Num[4]++]=Index[j];
|
||
Type.cbFlush[Num[4]++]=Index[j+1];
|
||
Type.cbFlush[Num[4]++]=Index[j+2];
|
||
Type.cbFlush[Num[4]++]=Index[j+3];
|
||
Type.cbFlush[Num[4]++]=Index[j+4];
|
||
Type.btFlush++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(bCardCount-i<4)
|
||
{
|
||
break;
|
||
}
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
SameColorCount=1;
|
||
Index[Number++]=i;
|
||
bCardColor=GetCardColor(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(CardData[0]) ==CARD_DW && GetCardLogicValue(CardData[1]) ==CARD_XW)
|
||
{
|
||
BYTE SameColorCount=1;
|
||
BYTE bCardColor = GetCardColor(CardData[2]) ;
|
||
Index[Number++]=2;
|
||
|
||
for(BYTE i=3;i<bCardCount;i++)
|
||
{
|
||
if(bCardColor==GetCardColor(CardData[i]))
|
||
{
|
||
SameColorCount++;
|
||
Index[Number++]=i;
|
||
}
|
||
if(bCardColor!=GetCardColor(CardData[i])||i==bCardCount-1)
|
||
{
|
||
if (SameColorCount==4)
|
||
{
|
||
SameColorCount++;
|
||
Index[Number++]=0;
|
||
}
|
||
if (SameColorCount == 3)
|
||
{
|
||
SameColorCount++;
|
||
Index[Number++]=0;
|
||
SameColorCount++;
|
||
Index[Number++]=1;
|
||
}
|
||
if(SameColorCount>=5)
|
||
{
|
||
Type.bFlush=true;
|
||
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
for(BYTE k=0;k<bCardCount;k++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[j]])==GetCardLogicValue(cbCardData[k])
|
||
&&GetCardColor(CardData[Index[j]])==GetCardColor(cbCardData[k]))
|
||
{
|
||
Index[j]=k;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
BYTE SaveIndex=0;
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
for(BYTE k=j+1;k<SameColorCount;k++)
|
||
{
|
||
if(Index[j]>Index[k])
|
||
{
|
||
SaveIndex=Index[j];
|
||
Index[j]=Index[k];
|
||
Index[k]=SaveIndex;
|
||
}
|
||
}
|
||
}
|
||
|
||
//同花顺
|
||
if (GetCardLogicValue(cbCardData[Index[0]]) ==CARD_DW && GetCardLogicValue(cbCardData[Index[1]]) ==CARD_XW)
|
||
{
|
||
if (((GetCardLogicValue(cbCardData[Index[2]])==14)&&((GetCardLogicValue(cbCardData[Index[3]])==5)||(GetCardLogicValue(cbCardData[Index[3]])==4)||(GetCardLogicValue(cbCardData[Index[3]])==3)))
|
||
||(4>=(GetCardLogicValue(cbCardData[Index[2]])-GetCardLogicValue(cbCardData[Index[4]]))))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];
|
||
Type.cbStraightFlush[Num[7]++]=Index[1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[3];
|
||
Type.cbStraightFlush[Num[7]++]=Index[4];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(cbCardData[Index[0]])>=CARD_XW && GetCardLogicValue(cbCardData[Index[1]]) <CARD_XW)
|
||
{
|
||
if (((GetCardLogicValue(cbCardData[Index[1]])==14)&&((GetCardLogicValue(cbCardData[Index[2]])==5)||(GetCardLogicValue(cbCardData[Index[2]])==4)))
|
||
||(4>=(GetCardLogicValue(cbCardData[Index[1]])-GetCardLogicValue(cbCardData[Index[4]]))))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];
|
||
Type.cbStraightFlush[Num[7]++]=Index[1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[3];
|
||
Type.cbStraightFlush[Num[7]++]=Index[4];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//同花A2345特殊处理
|
||
if (GetCardLogicValue(cbCardData[Index[0]])==14)
|
||
{
|
||
for (BYTE i=1;i<SameColorCount;i++)
|
||
{
|
||
|
||
if(GetCardLogicValue(cbCardData[Index[i]])==5)
|
||
{
|
||
if (SameColorCount-i==4)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (SameColorCount-i==3)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (SameColorCount-i==2)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=1;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.btStraightFlush++;
|
||
}
|
||
|
||
}
|
||
else if(GetCardLogicValue(cbCardData[Index[i]])==4)
|
||
{
|
||
if (SameColorCount-i==3)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (SameColorCount-i==2)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=1;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
else if(GetCardLogicValue(cbCardData[Index[i]])==3)
|
||
{
|
||
if (SameColorCount-i==2)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;//鬼
|
||
Type.cbStraightFlush[Num[7]++]=1;
|
||
Type.cbStraightFlush[Num[7]++]=Index[0];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
for (BYTE i=0;i<SameColorCount;i++)
|
||
{
|
||
if (SameColorCount-i>=5)
|
||
{
|
||
if (4==(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+4]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+4];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+2]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=1;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.btStraightFlush++;
|
||
}
|
||
|
||
}
|
||
else if(SameColorCount-i==4)
|
||
{
|
||
if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+3]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];
|
||
Type.btStraightFlush++;
|
||
}
|
||
else if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+2]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=1;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
else if(SameColorCount-i==3)
|
||
{
|
||
if (4>=(GetCardLogicValue(cbCardData[Index[i]])-GetCardLogicValue(cbCardData[Index[i+2]])))
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=0;
|
||
Type.cbStraightFlush[Num[7]++]=1;
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];
|
||
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
if(SameColorCount-j>=5)
|
||
{
|
||
Type.cbFlush[Num[4]++]=Index[j];
|
||
Type.cbFlush[Num[4]++]=Index[j+1];
|
||
Type.cbFlush[Num[4]++]=Index[j+2];
|
||
Type.cbFlush[Num[4]++]=Index[j+3];
|
||
Type.cbFlush[Num[4]++]=Index[j+4];
|
||
Type.btFlush++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(bCardCount-i<3)
|
||
{
|
||
break;
|
||
}
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
SameColorCount=1;
|
||
Index[Number++]=i;
|
||
bCardColor=GetCardColor(CardData[i]);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
BYTE SameColorCount=1;
|
||
BYTE bCardColor = GetCardColor(CardData[0]) ;
|
||
Index[Number++]=0;
|
||
|
||
for(BYTE i=1;i<bCardCount;i++)
|
||
{
|
||
if(bCardColor==GetCardColor(CardData[i]))
|
||
{
|
||
SameColorCount++;
|
||
Index[Number++]=i;
|
||
}
|
||
if(bCardColor!=GetCardColor(CardData[i])||i==bCardCount-1)
|
||
{
|
||
if(SameColorCount>=5)
|
||
{
|
||
Type.bFlush=true;
|
||
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
for(BYTE k=0;k<bCardCount;k++)
|
||
{
|
||
if(GetCardLogicValue(CardData[Index[j]])==GetCardLogicValue(cbCardData[k])
|
||
&&GetCardColor(CardData[Index[j]])==GetCardColor(cbCardData[k]))
|
||
{
|
||
Index[j]=k;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
BYTE SaveIndex=0;
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
for(BYTE k=j+1;k<SameColorCount;k++)
|
||
{
|
||
if(Index[j]>Index[k])
|
||
{
|
||
SaveIndex=Index[j];
|
||
Index[j]=Index[k];
|
||
Index[k]=SaveIndex;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
for(BYTE j=0;j<SameColorCount;j++)
|
||
{
|
||
if(SameColorCount-j>=5)
|
||
{
|
||
Type.cbFlush[Num[4]++]=Index[j];
|
||
Type.cbFlush[Num[4]++]=Index[j+1];
|
||
Type.cbFlush[Num[4]++]=Index[j+2];
|
||
Type.cbFlush[Num[4]++]=Index[j+3];
|
||
Type.cbFlush[Num[4]++]=Index[j+4];
|
||
Type.btFlush++;
|
||
|
||
//同花A2345特殊处理
|
||
if (GetCardLogicValue(cbCardData[Index[j]])==14)
|
||
{
|
||
for (BYTE i=j+1;i<SameColorCount;i++)
|
||
{
|
||
|
||
if(GetCardLogicValue(cbCardData[Index[i]])==5)
|
||
{
|
||
if (SameColorCount-i>=4)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[j];//A
|
||
Type.cbStraightFlush[Num[7]++]=Index[i];//5
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+1];//4
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+2];//3
|
||
Type.cbStraightFlush[Num[7]++]=Index[i+3];//2
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
if(GetCardLogicValue(cbCardData[Index[j]])-GetCardLogicValue(cbCardData[Index[j+4]])==4)
|
||
{
|
||
Type.bStraightFlush=true;
|
||
Type.cbStraightFlush[Num[7]++]=Index[j];
|
||
Type.cbStraightFlush[Num[7]++]=Index[j+1];
|
||
Type.cbStraightFlush[Num[7]++]=Index[j+2];
|
||
Type.cbStraightFlush[Num[7]++]=Index[j+3];
|
||
Type.cbStraightFlush[Num[7]++]=Index[j+4];
|
||
Type.btStraightFlush++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(bCardCount-i<5)
|
||
{
|
||
break;
|
||
}
|
||
Number=0;
|
||
ZeroMemory(Index,sizeof(Index));
|
||
SameColorCount=1;
|
||
Index[Number++]=i;
|
||
bCardColor=GetCardColor(CardData[i]);
|
||
}
|
||
}
|
||
|
||
}
|
||
return Type;
|
||
}
|
||
|
||
bool CGameLogic::AppendCard( const BYTE bAppendCard[],BYTE bAppendCount,BYTE bCardData[],BYTE &bCardCount )
|
||
{
|
||
ASSERT(bAppendCount+bCardCount<=13);
|
||
for(int i=0;i<bAppendCount;i++)
|
||
{
|
||
bCardData[bCardCount+i]=bAppendCard[i];
|
||
}
|
||
bCardCount+=bAppendCount;
|
||
return true;
|
||
}
|
||
|
||
BYTE CGameLogic::GetCardCount( BYTE bCardData[] )
|
||
{
|
||
BYTE Number=0;
|
||
if(0==GetCardLogicValue(bCardData[1])&&0==GetCardLogicValue(bCardData[2]))
|
||
{
|
||
return 0;
|
||
}
|
||
else
|
||
{
|
||
for(BYTE i=0;i<5;i++)
|
||
{
|
||
if(GetCardLogicValue(bCardData[i])>0)
|
||
{
|
||
Number++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return Number;
|
||
}
|
||
|
||
//void CGameLogic::TheBestCard(tagAnalyseType tagCardType,BYTE btHandCardData[],BYTE btHandCardCount,BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[] )
|
||
//{
|
||
// if(btHandCardCount!=13)
|
||
// {
|
||
// return;
|
||
// }
|
||
// BYTE btCardCount=btHandCardCount;
|
||
// BYTE btCardData[13];
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// BYTE btCardData1[13];
|
||
// BYTE btCardData2[13];
|
||
// ZeroMemory(btCardData1,sizeof(btCardData1));
|
||
// ZeroMemory(btCardData2,sizeof(btCardData2));
|
||
// BYTE btCardCount1=0;
|
||
// BYTE btCardCount2=0;
|
||
// BYTE FrontCard[3];
|
||
// BYTE MidCard[5];
|
||
// BYTE BackCard[5];
|
||
// BYTE btAllShuiShu=0;
|
||
// ZeroMemory(FrontCard,sizeof(FrontCard));
|
||
// ZeroMemory(MidCard,sizeof(MidCard));
|
||
// ZeroMemory(BackCard,sizeof(BackCard));
|
||
// BYTE FrontFrontCard[3];
|
||
// BYTE FrontMidCard[5];
|
||
// BYTE FrontBackCard[5];
|
||
// BYTE btFrontAllShuiShu=0;
|
||
// ZeroMemory(FrontFrontCard,sizeof(FrontFrontCard));
|
||
// ZeroMemory(FrontMidCard,sizeof(FrontMidCard));
|
||
// ZeroMemory(FrontBackCard,sizeof(FrontBackCard));
|
||
// bool bCycling=true;
|
||
// bool bFront=false;
|
||
// bool bMid=false;
|
||
// bool bBack=false;
|
||
// bool bFirst=true;
|
||
// BYTE btFront=0;
|
||
// BYTE btMid=0;
|
||
// BYTE btBack=0;
|
||
// tagAnalyseType tagCardType1;
|
||
// tagAnalyseType tagCardType2;
|
||
// ZeroMemory(&tagCardType1,sizeof(tagCardType1));
|
||
// ZeroMemory(&tagCardType2,sizeof(tagCardType2));
|
||
// BYTE btTemp[13];
|
||
// ZeroMemory(btTemp,sizeof(btTemp));
|
||
//
|
||
// if(tagCardType.bStraightFlush) //有同花顺
|
||
// {
|
||
// for(int i=0;i<tagCardType.btStraightFlush;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbStraightFlush[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1= btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bStraightFlush) //有同花顺
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraightFlush;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraightFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[k];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bFourSame) //有铁支
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFourSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFourSame[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbThreeSame[0]]))
|
||
// {
|
||
// btTemp[0]=MidCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else if(tagCardType2.bTwoPare)//剩下两对
|
||
// {
|
||
// MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
|
||
// FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
|
||
// FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
|
||
// }
|
||
// else if(tagCardType2.bOnePare)//剩下一对
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
|
||
// {
|
||
// btTemp[0]=MidCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
// MidCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagCardType1.bGourd) //有葫芦
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //前敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(MidCard,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false) //前敦不能为三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btGourd;j++) //中敦葫芦
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bFlush) //有同花
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //前敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(MidCard,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false) //前敦不能为三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++) //中敦同花
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++) //中敦顺子
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //中敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// MidCard[3]=btCardData1[3];
|
||
// MidCard[4]=btCardData1[4];
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //前敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(MidCard,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false) //前敦不能为三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++) //中敦顺子
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //中敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// MidCard[3]=btCardData1[3];
|
||
// MidCard[4]=btCardData1[4];
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //中敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// MidCard[3]=btCardData1[3];
|
||
// MidCard[4]=btCardData1[4];
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //有两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++) //中敦两对
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //剩下两对
|
||
// {
|
||
// MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
|
||
// FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
|
||
// FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //剩下一对
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
|
||
// {
|
||
// btTemp[0]=MidCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
// MidCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //有一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++) //中敦一对
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
//
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// }
|
||
// else if(tagCardType.bFourSame) //铁支
|
||
// {
|
||
// for(int i=0;i<tagCardType.btFourSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<4;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbFourSame[i*4+j]];
|
||
// }
|
||
// RemoveCard(BackCard,4,btCardData,btCardCount);
|
||
// btCardCount1= btCardCount-=4;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bFourSame) //有铁支
|
||
// {
|
||
//
|
||
// for(int j=0;j<tagCardType1.btFourSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFourSame[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bFourSame) //剩下铁支
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[0])==GetCardLogicValue(btCardData2[1]))
|
||
// {
|
||
// BackCard[4]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else
|
||
// {
|
||
// BackCard[4]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[4];
|
||
// CopyMemory(FrontCard,&btCardData2[1],sizeof(FrontCard));
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bGourd) //剩下葫芦
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbGourd[4]];
|
||
// MidCard[4]=btCardData2[tagCardType2.cbGourd[3]];
|
||
// FrontCard[0]=btCardData2[tagCardType2.cbGourd[0]];
|
||
// FrontCard[1]=btCardData2[tagCardType2.cbGourd[1]];
|
||
// FrontCard[2]=btCardData2[tagCardType2.cbGourd[2]];
|
||
// }
|
||
// else if(tagCardType2.bFlush) //剩下同花
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbFlush[4]];
|
||
// MidCard[4]=btCardData2[tagCardType2.cbFlush[3]];
|
||
// FrontCard[0]=btCardData2[tagCardType2.cbFlush[0]];
|
||
// FrontCard[1]=btCardData2[tagCardType2.cbFlush[1]];
|
||
// FrontCard[2]=btCardData2[tagCardType2.cbFlush[2]];
|
||
// }
|
||
// else if(tagCardType2.bStraight) //剩下顺子
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbStraight[4]];
|
||
// MidCard[4]=btCardData2[tagCardType2.cbStraight[3]];
|
||
// FrontCard[0]=btCardData2[tagCardType2.cbStraight[0]];
|
||
// FrontCard[1]=btCardData2[tagCardType2.cbStraight[1]];
|
||
// FrontCard[2]=btCardData2[tagCardType2.cbStraight[2]];
|
||
// }
|
||
// else if(tagCardType2.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(btTemp,3,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare)//剩下两对
|
||
// {
|
||
// for(int k=4;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbTwoPare[0]])
|
||
// &&GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbTwoPare[2]]))
|
||
// {
|
||
// btTemp[0]=BackCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// //RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
|
||
// FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
|
||
// FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
|
||
// }
|
||
// else if(tagCardType2.bOnePare)//剩下一对
|
||
// {
|
||
// btTemp[0]=FrontCard[0]=btCardData2[tagCardType2.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData2[tagCardType2.cbOnePare[1]];
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// BackCard[4]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
// BackCard[4]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
//
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagCardType1.bGourd) //有葫芦
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //前敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bGourd) //剩下葫芦
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbGourd[k]];
|
||
// }
|
||
// RemoveCard(btTemp,5,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bFlush) //剩下同花
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbFlush[k]];
|
||
// }
|
||
// RemoveCard(btTemp,5,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bStraight) //剩下顺子
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbStraight[k]];
|
||
// }
|
||
// RemoveCard(btTemp,5,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(btTemp,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[4]=btCardData2[2];
|
||
// }
|
||
// else //其他
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false) //前敦不能为三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btGourd;j++) //中敦葫芦
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=5;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //剩下两对
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //剩下一对
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
|
||
// {
|
||
// btTemp[0]=BackCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
//
|
||
// BackCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bFlush) //有同花
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //前敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bFlush) //剩下同花
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbFlush[k]];
|
||
// }
|
||
// RemoveCard(btTemp,5,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bStraight) //剩下顺子
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbStraight[k]];
|
||
// }
|
||
// RemoveCard(btTemp,5,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else //其他
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false) //前敦不能为三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++) //中敦同花
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=5;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //剩下两对
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //剩下一对
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
|
||
// {
|
||
// btTemp[0]=BackCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
// //这里有问题 zyy
|
||
// BackCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++) //中敦顺子
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=5;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //剩下两对
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //剩下一对
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
|
||
// {
|
||
// btTemp[0]=BackCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
//
|
||
// BackCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //中敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// MidCard[3]=btCardData1[3];
|
||
// MidCard[4]=btCardData1[4];
|
||
// btCardCount2=btCardCount1-=5;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// //剩下散牌
|
||
// BackCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //前敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
//
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bStraight) //剩下顺子
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// btTemp[k]=MidCard[k]=btCardData2[tagCardType2.cbStraight[k]];
|
||
// }
|
||
// RemoveCard(btTemp,5,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else //其他
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false) //前敦不能为三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++) //中敦顺子
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=5;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //剩下两对
|
||
// {
|
||
// BackCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //剩下一对
|
||
// {
|
||
// for(int k=3;k>=0;k--)
|
||
// {
|
||
// if(GetCardLogicValue(btCardData2[k])!=GetCardLogicValue(btCardData2[tagCardType2.cbOnePare[0]]))
|
||
// {
|
||
// btTemp[0]=BackCard[4]=btCardData2[k];
|
||
// break;
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,1,btCardData2,btCardCount2);
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
// BackCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //中敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// MidCard[3]=btCardData1[3];
|
||
// MidCard[4]=btCardData1[4];
|
||
// btCardCount2=btCardCount1-=5;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// //剩下散牌
|
||
// BackCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++) //中敦三条
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// MidCard[3]=btCardData1[3];
|
||
// MidCard[4]=btCardData1[4];
|
||
// BackCard[4]=btCardData1[5];
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //有两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[4]=btCardData1[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++) //中敦两对
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //剩下两对
|
||
// {
|
||
// btTemp[0]=MidCard[4]=btCardData2[tagCardType2.cbTwoPare[3]];
|
||
// btTemp[1]=FrontCard[0]=btCardData2[tagCardType2.cbTwoPare[0]];
|
||
// btTemp[2]=FrontCard[1]=btCardData2[tagCardType2.cbTwoPare[1]];
|
||
// btTemp[3]=FrontCard[2]=btCardData2[tagCardType2.cbTwoPare[2]];
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //剩下一对
|
||
// {
|
||
// btTemp[0]=FrontCard[0]=btCardData2[tagCardType2.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData2[tagCardType2.cbOnePare[1]];
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[4]=btCardData2[2];
|
||
// }
|
||
// else //剩下散牌
|
||
// {
|
||
// BackCard[4]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //有一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++) //中敦一对
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// BackCard[4]=btCardData2[6];
|
||
// MidCard[2]=btCardData2[5];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[3];
|
||
// CopyMemory(FrontCard,btCardData2,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// BackCard[4]=btCardData1[8];
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
//
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&(btAllShuiShu>btFrontAllShuiShu
|
||
// ||(CompareCard(FrontFrontCard,FrontCard,3,3,false)&&btAllShuiShu==btFrontAllShuiShu)))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// }
|
||
//
|
||
// else if(tagCardType.bGourd) //有葫芦
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// for(int i=0;i<tagCardType.btThreeSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<3;j++)
|
||
// {
|
||
// FrontCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bGourd) //有葫芦
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btGourd;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(MidCard,btCardData1,sizeof(MidCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bFlush) //有同花
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(MidCard,btCardData1,sizeof(MidCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(MidCard,btCardData1,sizeof(MidCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(BackCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame)
|
||
// {
|
||
// for(int k=0;k<tagCardType2.btThreeSame;k++)
|
||
// {
|
||
// for(int m=0;m<3;m++)
|
||
// {
|
||
// MidCard[m]=btCardData2[tagCardType2.cbThreeSame[k*3+m]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData2,btCardCount2);
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false)
|
||
// {
|
||
// for(int i=0;i<tagCardType.btGourd;i++) //第三敦为葫芦
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbGourd[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bGourd) //剩下葫芦
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btGourd;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbGourd[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bFlush) //剩下同花
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bStraight) //剩下顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bFlush) //第三敦为同花
|
||
// {
|
||
// for(int i=0;i<tagCardType.btFlush;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbFlush[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bFlush) //剩下同花
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bStraight) //剩下顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
//
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bStraight) //第三敦为顺子
|
||
// {
|
||
// for(int i=0;i<tagCardType.btStraight;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbStraight[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bStraight) //剩下顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bThreeSame) //第三敦为三条
|
||
// {
|
||
// for(int i=0;i<tagCardType.btThreeSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<3;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
|
||
// }
|
||
// RemoveCard(BackCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=BackCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// BackCard[3]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[3]=btCardData2[3];
|
||
// MidCard[4]=btCardData2[4];
|
||
// BackCard[3]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[3]=btCardData1[2];
|
||
// BackCard[4]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[3]=btCardData2[0];
|
||
// BackCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[3]=btCardData2[4];
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[3]=btCardData2[4];
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[3]=btCardData2[6];
|
||
// BackCard[4]=btCardData2[7];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[3]=btCardData1[8];
|
||
// BackCard[4]=btCardData1[9];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bTwoPare) //第三敦为两对
|
||
// {
|
||
// if(tagCardType.btOnePare<4)
|
||
// {
|
||
// for(int i=0;i<tagCardType.btTwoPare;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<4;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbTwoPare[i*4+j]];
|
||
// }
|
||
// RemoveCard(BackCard,4,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=4;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[4]=btCardData1[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[4]=btCardData1[8];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagCardType.btOnePare==4)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[0]=btCardData[0];
|
||
// FrontCard[1]=btCardData[1];
|
||
// FrontCard[2]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
|
||
// {
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[2]=btCardData[1];
|
||
// MidCard[3]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.btOnePare==5)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=FrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[3]=MidCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[4]=MidCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[5]=MidCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[6]=BackCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=BackCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[8]=BackCard[2]=btCardData[tagCardType.cbOnePare[8]];
|
||
// btTemp[9]=BackCard[3]=btCardData[tagCardType.cbOnePare[9]];
|
||
// RemoveCard(btTemp,10,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[4]=btCardData[1];
|
||
// BackCard[4]=btCardData[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bOnePare) //第三敦为一对
|
||
// {
|
||
// for(int i=0;i<tagCardType.btOnePare;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<2;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbOnePare[i*2+j]];
|
||
// }
|
||
// RemoveCard(BackCard,2,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=2;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[2]=btCardData2[4];
|
||
// BackCard[3]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[2]=btCardData2[6];
|
||
// BackCard[3]=btCardData2[7];
|
||
// BackCard[4]=btCardData2[8];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
//
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
//// for(int m=0;m<3;m++)
|
||
//// {
|
||
//// printf("FrontFrontCard[%d]=%d ",m,FrontFrontCard[m]);
|
||
//// }
|
||
//// for(int m=0;m<5;m++)
|
||
//// {
|
||
//// printf("FrontMidCard[%d]=%d ",m,FrontMidCard[m]);
|
||
//// }
|
||
//// for(int m=0;m<5;m++)
|
||
//// {
|
||
//// printf("FrontBackCard[%d]=%d ",m,FrontBackCard[m]);
|
||
//// }
|
||
//// printf("\n");
|
||
//// for(int m=0;m<3;m++)
|
||
//// {
|
||
//// printf("FrontCard[%d]=%d ",m,FrontCard[m]);
|
||
//// }
|
||
//// for(int m=0;m<5;m++)
|
||
//// {
|
||
//// printf("MidCard[%d]=%d ",m,MidCard[m]);
|
||
//// }
|
||
//// for(int m=0;m<5;m++)
|
||
//// {
|
||
//// printf("BackCard[%d]=%d ",m,BackCard[m]);
|
||
//// }
|
||
//// printf("\n");
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[2]=btCardData1[8];
|
||
// BackCard[3]=btCardData1[9];
|
||
// BackCard[4]=btCardData1[10];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.bFlush) //有同花
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// for(int i=0;i<tagCardType.btThreeSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<3;j++)
|
||
// {
|
||
// FrontCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bFlush) //有同花
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(MidCard,btCardData1,sizeof(MidCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(MidCard,btCardData1,sizeof(MidCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(BackCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame)
|
||
// {
|
||
// for(int k=0;k<tagCardType2.btThreeSame;k++)
|
||
// {
|
||
// for(int m=0;m<3;m++)
|
||
// {
|
||
// MidCard[m]=btCardData2[tagCardType2.cbThreeSame[k*3+m]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData2,btCardCount2);
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false)
|
||
// {
|
||
// if(tagCardType.bFlush) //第三敦为同花
|
||
// {
|
||
// for(int i=0;i<tagCardType.btFlush;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbFlush[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bFlush) //剩下同花
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btFlush;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbFlush[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bStraight) //剩下顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bStraight) //第三敦为顺子
|
||
// {
|
||
// for(int i=0;i<tagCardType.btStraight;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbStraight[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bStraight) //剩下顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bThreeSame) //第三敦为三条
|
||
// {
|
||
// for(int i=0;i<tagCardType.btThreeSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<3;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
|
||
// }
|
||
// RemoveCard(BackCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=BackCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// BackCard[3]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[3]=btCardData2[3];
|
||
// MidCard[4]=btCardData2[4];
|
||
// BackCard[3]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[3]=btCardData1[2];
|
||
// BackCard[4]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[3]=btCardData2[0];
|
||
// BackCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[3]=btCardData2[4];
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[3]=btCardData2[4];
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[3]=btCardData2[6];
|
||
// BackCard[4]=btCardData2[7];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[3]=btCardData1[8];
|
||
// BackCard[4]=btCardData1[9];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bTwoPare) //第三敦为两对
|
||
// {
|
||
// if(tagCardType.btOnePare<4)
|
||
// {
|
||
// for(int i=0;i<tagCardType.btTwoPare;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<4;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbTwoPare[i*4+j]];
|
||
// }
|
||
// RemoveCard(BackCard,4,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=4;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[4]=btCardData1[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[4]=btCardData1[8];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagCardType.btOnePare==4)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[0]=btCardData[0];
|
||
// FrontCard[1]=btCardData[1];
|
||
// FrontCard[2]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
|
||
// {
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[2]=btCardData[1];
|
||
// MidCard[3]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.btOnePare==5)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=FrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[3]=MidCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[4]=MidCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[5]=MidCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[6]=BackCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=BackCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[8]=BackCard[2]=btCardData[tagCardType.cbOnePare[8]];
|
||
// btTemp[9]=BackCard[3]=btCardData[tagCardType.cbOnePare[9]];
|
||
// RemoveCard(btTemp,10,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[4]=btCardData[1];
|
||
// BackCard[4]=btCardData[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bOnePare) //第三敦为一对
|
||
// {
|
||
// for(int i=0;i<tagCardType.btOnePare;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<2;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbOnePare[i*2+j]];
|
||
// }
|
||
// RemoveCard(BackCard,2,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=2;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[2]=btCardData2[4];
|
||
// BackCard[3]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[2]=btCardData2[6];
|
||
// BackCard[3]=btCardData2[7];
|
||
// BackCard[4]=btCardData2[8];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[2]=btCardData1[8];
|
||
// BackCard[3]=btCardData1[9];
|
||
// BackCard[4]=btCardData1[10];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.bStraight)//有顺子
|
||
// {
|
||
// bool bThreeSame=false;
|
||
// for(int i=0;i<tagCardType.btThreeSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<3;j++)
|
||
// {
|
||
// FrontCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bStraight) //有顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(MidCard,btCardData1,sizeof(MidCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType1.bThreeSame) //有三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// BackCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(BackCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame)
|
||
// {
|
||
// for(int k=0;k<tagCardType2.btThreeSame;k++)
|
||
// {
|
||
// for(int m=0;m<3;m++)
|
||
// {
|
||
// MidCard[m]=btCardData2[tagCardType2.cbThreeSame[k*3+m]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData2,btCardCount2);
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// bThreeSame=true;
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bThreeSame==false)
|
||
// {
|
||
// if(tagCardType.bStraight) //第三敦为顺子
|
||
// {
|
||
// for(int i=0;i<tagCardType.btStraight;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<5;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbStraight[i*5+j]];
|
||
// }
|
||
// RemoveCard(BackCard,5,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=5;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bStraight) //剩下顺子
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btStraight;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbStraight[j*5+k]];
|
||
// }
|
||
// RemoveCard(MidCard,5,btCardData1,btCardCount1);
|
||
// CopyMemory(FrontCard,btCardData1,sizeof(FrontCard));
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<5;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k+1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// for(int k=0;k<6;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// FrontCard[k]=btCardData2[k];
|
||
// }
|
||
// else
|
||
// {
|
||
// MidCard[k-1]=btCardData2[k];
|
||
// }
|
||
// }
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bThreeSame) //第三敦为三条
|
||
// {
|
||
// for(int i=0;i<tagCardType.btThreeSame;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<3;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbThreeSame[i*3+j]];
|
||
// }
|
||
// RemoveCard(BackCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bThreeSame) //剩下三条
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btThreeSame;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbThreeSame[j*3+k]];
|
||
// }
|
||
// RemoveCard(MidCard,3,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=3;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bThreeSame) //三条
|
||
// {
|
||
// for(int k=0;k<3;k++)
|
||
// {
|
||
// FrontCard[k]=btCardData2[tagCardType2.cbThreeSame[k]];
|
||
// }
|
||
// RemoveCard(FrontCard,3,btCardData2,btCardCount2);
|
||
// MidCard[3]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// }
|
||
// else if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<2)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=BackCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[3]=btCardData2[1];
|
||
// MidCard[4]=btCardData2[2];
|
||
// BackCard[3]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[3]=btCardData2[3];
|
||
// MidCard[4]=btCardData2[4];
|
||
// BackCard[3]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[3]=btCardData1[2];
|
||
// BackCard[4]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[3]=btCardData2[0];
|
||
// BackCard[4]=btCardData2[1];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[3]=btCardData2[2];
|
||
// BackCard[4]=btCardData2[3];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[3]=btCardData2[4];
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[3]=btCardData2[4];
|
||
// BackCard[4]=btCardData2[5];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[3]=btCardData2[6];
|
||
// BackCard[4]=btCardData2[7];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[3]=btCardData1[8];
|
||
// BackCard[4]=btCardData1[9];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bTwoPare) //第三敦为两对
|
||
// {
|
||
// if(tagCardType.btOnePare<4)
|
||
// {
|
||
// for(int i=0;i<tagCardType.btTwoPare;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<4;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbTwoPare[i*4+j]];
|
||
// }
|
||
// RemoveCard(BackCard,4,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=4;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bTwoPare) //剩下两对
|
||
// {
|
||
// if(tagCardType1.btOnePare>=3)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// btTemp[0]=FrontCard[0]=btCardData1[tagCardType1.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData1[tagCardType1.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData1[tagCardType1.cbOnePare[2]];
|
||
// btTemp[3]=MidCard[1]=btCardData1[tagCardType1.cbOnePare[3]];
|
||
// btTemp[4]=MidCard[2]=btCardData1[tagCardType1.cbOnePare[4]];
|
||
// btTemp[5]=MidCard[3]=btCardData1[tagCardType1.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData1,btCardCount1);
|
||
// FrontCard[2]=btCardData1[0];
|
||
// MidCard[4]=btCardData1[1];
|
||
// BackCard[4]=btCardData1[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=ThreeDunAllShuiShu(FrontFrontCard,FrontMidCard,FrontBackCard);
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btAllShuiShu=ThreeDunAllShuiShu(FrontCard,MidCard,BackCard);
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// btFrontAllShuiShu=btAllShuiShu;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btTwoPare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbTwoPare[j*4+k]];
|
||
// }
|
||
// RemoveCard(MidCard,4,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=4;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bTwoPare) //两对
|
||
// {
|
||
// for(int k=0;k<4;k++)
|
||
// {
|
||
// if(k<3)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// else
|
||
// {
|
||
// btTemp[k]=MidCard[k+1]=btCardData2[tagCardType2.cbTwoPare[k]];
|
||
// }
|
||
// }
|
||
// RemoveCard(btTemp,4,btCardData2,btCardCount2);
|
||
// BackCard[4]=btCardData2[0];
|
||
// }
|
||
// else if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[4]=btCardData2[1];
|
||
// BackCard[4]=btCardData2[2];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// }
|
||
// else if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[4]=btCardData2[4];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[4]=btCardData1[8];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagCardType.btOnePare==4)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[0]=btCardData[0];
|
||
// FrontCard[1]=btCardData[1];
|
||
// FrontCard[2]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
|
||
// {
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[2]=btCardData[1];
|
||
// MidCard[3]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.btOnePare==5)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=FrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=FrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=MidCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[3]=MidCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[4]=MidCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[5]=MidCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[6]=BackCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=BackCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[8]=BackCard[2]=btCardData[tagCardType.cbOnePare[8]];
|
||
// btTemp[9]=BackCard[3]=btCardData[tagCardType.cbOnePare[9]];
|
||
// RemoveCard(btTemp,10,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[4]=btCardData[1];
|
||
// BackCard[4]=btCardData[2];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// if(tagCardType.bOnePare) //第三敦为一对
|
||
// {
|
||
// for(int i=0;i<tagCardType.btOnePare;i++)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int j=0;j<2;j++)
|
||
// {
|
||
// BackCard[j]=btCardData[tagCardType.cbOnePare[i*2+j]];
|
||
// }
|
||
// RemoveCard(BackCard,2,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=2;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// tagCardType1=GetType(btCardData1,btCardCount1);
|
||
// if(tagCardType1.bOnePare) //剩下一对
|
||
// {
|
||
// for(int j=0;j<tagCardType1.btOnePare;j++)
|
||
// {
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// MidCard[k]=btCardData1[tagCardType1.cbOnePare[j*2+k]];
|
||
// }
|
||
// RemoveCard(MidCard,2,btCardData1,btCardCount1);
|
||
// btCardCount2=btCardCount1-=2;
|
||
// CopyMemory(btCardData2,btCardData1,sizeof(btCardData1[0])*btCardCount2);
|
||
// tagCardType2=GetType(btCardData2,btCardCount2);
|
||
// if(tagCardType2.bOnePare) //一对
|
||
// {
|
||
// for(int k=0;k<2;k++)
|
||
// {
|
||
// btTemp[k]=FrontCard[k]=btCardData2[tagCardType2.cbOnePare[k]];
|
||
// }
|
||
// RemoveCard(btTemp,2,btCardData2,btCardCount2);
|
||
// FrontCard[2]=btCardData2[0];
|
||
// MidCard[2]=btCardData2[1];
|
||
// MidCard[3]=btCardData2[2];
|
||
// MidCard[4]=btCardData2[3];
|
||
// BackCard[2]=btCardData2[4];
|
||
// BackCard[3]=btCardData2[5];
|
||
// BackCard[4]=btCardData2[6];
|
||
// }
|
||
// else //散牌
|
||
// {
|
||
// FrontCard[0]=btCardData2[0];
|
||
// FrontCard[1]=btCardData2[1];
|
||
// FrontCard[2]=btCardData2[2];
|
||
// MidCard[2]=btCardData2[3];
|
||
// MidCard[3]=btCardData2[4];
|
||
// MidCard[4]=btCardData2[5];
|
||
// BackCard[2]=btCardData2[6];
|
||
// BackCard[3]=btCardData2[7];
|
||
// BackCard[4]=btCardData2[8];
|
||
// }
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// //散牌
|
||
// btCardCount1=btCardCount;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// MidCard[0]=btCardData1[0];
|
||
// MidCard[1]=btCardData1[4];
|
||
// MidCard[2]=btCardData1[5];
|
||
// MidCard[3]=btCardData1[6];
|
||
// MidCard[4]=btCardData1[7];
|
||
// BackCard[2]=btCardData1[8];
|
||
// BackCard[3]=btCardData1[9];
|
||
// BackCard[4]=btCardData1[10];
|
||
// FrontCard[0]=btCardData1[1];
|
||
// FrontCard[1]=btCardData1[2];
|
||
// FrontCard[2]=btCardData1[3];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.bThreeSame)//有三条
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// for(int i=0;i<3;i++)
|
||
// {
|
||
// FrontBackCard[i]=btCardData[tagCardType.cbThreeSame[i]];
|
||
// }
|
||
// RemoveCard(FrontBackCard,3,btCardData,btCardCount);
|
||
// btCardCount1=btCardCount-=3;
|
||
// CopyMemory(btCardData1,btCardData,sizeof(btCardData[0])*btCardCount1);
|
||
// FrontFrontCard[0]=btCardData1[1];
|
||
// FrontFrontCard[1]=btCardData1[2];
|
||
// FrontFrontCard[2]=btCardData1[3];
|
||
// FrontMidCard[0]=btCardData1[0];
|
||
// FrontMidCard[1]=btCardData1[4];
|
||
// FrontMidCard[2]=btCardData1[5];
|
||
// FrontMidCard[3]=btCardData1[6];
|
||
// FrontMidCard[4]=btCardData1[7];
|
||
// FrontBackCard[3]=btCardData1[8];
|
||
// FrontBackCard[4]=btCardData1[9];
|
||
//
|
||
// }
|
||
// else if(tagCardType.bTwoPare)//有两对
|
||
// {
|
||
// if(tagCardType.btOnePare==2)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=FrontBackCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=FrontBackCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=FrontMidCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[3]=FrontMidCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// RemoveCard(btTemp,4,btCardData,btCardCount);
|
||
// FrontFrontCard[0]=btCardData[0];
|
||
// FrontFrontCard[1]=btCardData[1];
|
||
// FrontFrontCard[2]=btCardData[2];
|
||
// FrontMidCard[2]=btCardData[3];
|
||
// FrontMidCard[3]=btCardData[4];
|
||
// FrontMidCard[4]=btCardData[5];
|
||
// FrontBackCard[2]=btCardData[6];
|
||
// FrontBackCard[3]=btCardData[7];
|
||
// FrontBackCard[4]=btCardData[8];
|
||
// }
|
||
// else if(tagCardType.btOnePare==3)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
//
|
||
// btTemp[0]=FrontBackCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=FrontBackCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=FrontMidCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[3]=FrontMidCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[4]=FrontFrontCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[5]=FrontFrontCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// RemoveCard(btTemp,6,btCardData,btCardCount);
|
||
// FrontFrontCard[2]=btCardData[0];
|
||
// FrontMidCard[2]=btCardData[1];
|
||
// FrontMidCard[3]=btCardData[2];
|
||
// FrontMidCard[4]=btCardData[3];
|
||
// FrontBackCard[2]=btCardData[4];
|
||
// FrontBackCard[3]=btCardData[5];
|
||
// FrontBackCard[4]=btCardData[6];
|
||
// }
|
||
// else if(tagCardType.btOnePare==4)
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[6]=MidCard[2]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[7]=MidCard[3]=btCardData[tagCardType.cbOnePare[5]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[0]=btCardData[0];
|
||
// FrontCard[1]=btCardData[1];
|
||
// FrontCard[2]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(GetCardLogicValue(FrontCard[0])==14&&GetCardLogicValue(FrontCard[1])==13)
|
||
// {
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=BackCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[1]=BackCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[2]=BackCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[3]=BackCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[4]=MidCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[5]=MidCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[6]=FrontCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=FrontCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// RemoveCard(btTemp,8,btCardData,btCardCount);
|
||
// FrontCard[2]=btCardData[0];
|
||
// MidCard[2]=btCardData[1];
|
||
// MidCard[3]=btCardData[2];
|
||
// MidCard[4]=btCardData[3];
|
||
// BackCard[4]=btCardData[4];
|
||
// if(bFirst)
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// bFirst=false;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(CompareCard(FrontCard,MidCard,3,5,false)&&CompareCard(MidCard,BackCard,5,5,false)&&
|
||
// IsBiggerThanFront(FrontFrontCard,FrontMidCard,FrontBackCard,FrontCard,MidCard,BackCard))
|
||
// {
|
||
// CopyMemory(FrontFrontCard,FrontCard,sizeof(FrontCard));
|
||
// CopyMemory(FrontMidCard,MidCard,sizeof(MidCard));
|
||
// CopyMemory(FrontBackCard,BackCard,sizeof(BackCard));
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// else if(tagCardType.btOnePare==5)
|
||
// {
|
||
//
|
||
// CopyMemory(btCardData,btHandCardData,sizeof(btCardData));
|
||
// btCardCount=btHandCardCount;
|
||
// btTemp[0]=FrontFrontCard[0]=btCardData[tagCardType.cbOnePare[0]];
|
||
// btTemp[1]=FrontFrontCard[1]=btCardData[tagCardType.cbOnePare[1]];
|
||
// btTemp[2]=FrontMidCard[0]=btCardData[tagCardType.cbOnePare[4]];
|
||
// btTemp[3]=FrontMidCard[1]=btCardData[tagCardType.cbOnePare[5]];
|
||
// btTemp[4]=FrontMidCard[2]=btCardData[tagCardType.cbOnePare[6]];
|
||
// btTemp[5]=FrontMidCard[3]=btCardData[tagCardType.cbOnePare[7]];
|
||
// btTemp[6]=FrontBackCard[0]=btCardData[tagCardType.cbOnePare[2]];
|
||
// btTemp[7]=FrontBackCard[1]=btCardData[tagCardType.cbOnePare[3]];
|
||
// btTemp[8]=FrontBackCard[2]=btCardData[tagCardType.cbOnePare[8]];
|
||
// btTemp[9]=FrontBackCard[3]=btCardData[tagCardType.cbOnePare[9]];
|
||
// RemoveCard(btTemp,10,btCardData,btCardCount);
|
||
// FrontFrontCard[2]=btCardData[0];
|
||
// FrontMidCard[4]=btCardData[1];
|
||
// FrontBackCard[4]=btCardData[2];
|
||
// }
|
||
// }
|
||
//
|
||
// SortCardList(FrontFrontCard,3);
|
||
// SortCardList(FrontMidCard,5);
|
||
// SortCardList(FrontBackCard,5);
|
||
// CopyMemory(btFrontCard,FrontFrontCard,sizeof(FrontFrontCard));
|
||
// CopyMemory(btMidCard,FrontMidCard,sizeof(FrontMidCard));
|
||
// CopyMemory(btBackCard,FrontBackCard,sizeof(FrontBackCard));
|
||
//}
|
||
//
|
||
//BYTE CGameLogic::ThreeDunAllShuiShu( BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[] )
|
||
//{
|
||
// BYTE AllShuiShu=0;
|
||
// tagAnalyseType tagCardType1;
|
||
// tagAnalyseType tagCardType2;
|
||
// tagAnalyseType tagCardType3;
|
||
// ZeroMemory(&tagCardType1,sizeof(tagCardType1));
|
||
// ZeroMemory(&tagCardType2,sizeof(tagCardType2));
|
||
// ZeroMemory(&tagCardType3,sizeof(tagCardType3));
|
||
// tagCardType1=GetType(btFrontCard,3);
|
||
// tagCardType2=GetType(btMidCard,5);
|
||
// tagCardType3=GetType(btBackCard,5);
|
||
// if(tagCardType1.bThreeSame)
|
||
// {
|
||
// AllShuiShu+=3;
|
||
// }
|
||
// else
|
||
// {
|
||
// AllShuiShu+=1;
|
||
// }
|
||
//
|
||
// if(tagCardType2.btFiveSame)
|
||
// {
|
||
// AllShuiShu+=20;
|
||
// }
|
||
// else if(tagCardType2.bStraightFlush)
|
||
// {
|
||
// AllShuiShu+=10;
|
||
// }
|
||
// else if(tagCardType2.bFourSame)
|
||
// {
|
||
// AllShuiShu+=8;
|
||
// }
|
||
// else if(tagCardType2.bGourd)
|
||
// {
|
||
// AllShuiShu+=2;
|
||
// }
|
||
// else
|
||
// {
|
||
// AllShuiShu+=1;
|
||
// }
|
||
//
|
||
// if (tagCardType3.btFiveSame)
|
||
// {
|
||
// AllShuiShu+=10;
|
||
// }
|
||
// if(tagCardType3.bStraightFlush)
|
||
// {
|
||
// AllShuiShu+=5;
|
||
// }
|
||
// else if(tagCardType3.bFourSame)
|
||
// {
|
||
// AllShuiShu+=4;
|
||
// }
|
||
// else
|
||
// {
|
||
// AllShuiShu+=1;
|
||
// }
|
||
// return AllShuiShu;
|
||
//}
|
||
//
|
||
//bool CGameLogic::IsBiggerThanFront( BYTE btFrontFrontCard[],BYTE btFrontMidCard[],BYTE btFrontBackCard[],BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[])
|
||
//{
|
||
// int btFrontShuiShu=ThreeDunAllShuiShu(btFrontFrontCard,btFrontMidCard,btFrontBackCard);
|
||
// int btShuiShu=ThreeDunAllShuiShu(btFrontCard,btMidCard,btBackCard);
|
||
// tagAnalyseType tagFrontFrontCardType;
|
||
// tagAnalyseType tagFrontMidCardType;
|
||
// tagAnalyseType tagFrontBackCardType;
|
||
// tagAnalyseType tagFrontCardType;
|
||
// tagAnalyseType tagMidCardType;
|
||
// tagAnalyseType tagBackCardType;
|
||
// ZeroMemory(&tagFrontFrontCardType,sizeof(tagFrontFrontCardType));
|
||
// ZeroMemory(&tagFrontMidCardType,sizeof(tagFrontMidCardType));
|
||
// ZeroMemory(&tagFrontBackCardType,sizeof(tagFrontBackCardType));
|
||
// ZeroMemory(&tagFrontCardType,sizeof(tagFrontCardType));
|
||
// ZeroMemory(&tagMidCardType,sizeof(tagMidCardType));
|
||
// ZeroMemory(&tagBackCardType,sizeof(tagBackCardType));
|
||
// tagFrontFrontCardType=GetType(btFrontFrontCard,3);
|
||
// tagFrontMidCardType=GetType(btFrontMidCard,5);
|
||
// tagFrontBackCardType=GetType(btFrontBackCard,5);
|
||
// tagFrontCardType=GetType(btFrontCard,3);
|
||
// tagMidCardType=GetType(btMidCard,5);
|
||
// tagBackCardType=GetType(btBackCard,5);
|
||
// int btFrontWin=0;
|
||
// int btWin=0;
|
||
// int btCompare=0;
|
||
//
|
||
// int btFrontCanWin=0;
|
||
// int btCanWin=0;
|
||
// if(IsSameCardData(btFrontFrontCard,btFrontCard,3,3)==false)
|
||
// {
|
||
// if(!(tagFrontFrontCardType.bThreeSame&&tagFrontCardType.bThreeSame))
|
||
// {
|
||
// if(CompareCard(btFrontFrontCard,btFrontCard,3,3,true))
|
||
// {
|
||
//
|
||
// btCompare++;
|
||
// }
|
||
// else
|
||
// {
|
||
// btCompare--;
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// if(IsSameCardData(btFrontMidCard,btMidCard,5,5)==false)
|
||
// {
|
||
// if(!(tagFrontMidCardType.bThreeSame&&tagMidCardType.bThreeSame))
|
||
// {
|
||
// if(CompareCard(btFrontMidCard,btMidCard,5,5,true))
|
||
// {
|
||
// btCompare++;
|
||
// }
|
||
// else
|
||
// {
|
||
// btCompare--;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// BYTE btSpecialCard[13];
|
||
// ZeroMemory(btSpecialCard,sizeof(btSpecialCard));
|
||
// if(GetCardType(btMidCard,5,btSpecialCard)>GetCardType(btFrontMidCard,5,btSpecialCard))
|
||
// {
|
||
// btCompare++;
|
||
// }
|
||
// else if(GetCardType(btMidCard,5,btSpecialCard)<GetCardType(btFrontMidCard,5,btSpecialCard))
|
||
// {
|
||
// btCompare--;
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// if(IsSameCardData(btFrontBackCard,btBackCard,5,5)==false)
|
||
// {
|
||
// if(!(tagFrontBackCardType.bThreeSame&&tagBackCardType.bThreeSame))
|
||
// {
|
||
// if(CompareCard(btFrontBackCard,btBackCard,5,5,true))
|
||
// {
|
||
// btCompare++;
|
||
// }
|
||
// else
|
||
// {
|
||
// btCompare--;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// BYTE btSpecialCard[13];
|
||
// ZeroMemory(btSpecialCard,sizeof(btSpecialCard));
|
||
// if(GetCardType(btBackCard,5,btSpecialCard)>GetCardType(btFrontBackCard,5,btSpecialCard))
|
||
// {
|
||
// btCompare++;
|
||
// }
|
||
// else if(GetCardType(btBackCard,5,btSpecialCard)<GetCardType(btFrontBackCard,5,btSpecialCard))
|
||
// {
|
||
// btCompare--;
|
||
// }
|
||
// }
|
||
// }
|
||
// //前面的牌
|
||
// if(tagFrontFrontCardType.bThreeSame)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=3;
|
||
// }
|
||
// else if(tagFrontFrontCardType.bOnePare)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=1;
|
||
// }
|
||
// else
|
||
// {
|
||
// if(GetCardLogicValue(btFrontFrontCard[0])==14)
|
||
// {
|
||
// btFrontWin+=0;
|
||
// btFrontCanWin+=0;
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontWin+=-1;
|
||
// btFrontCanWin+=-1;
|
||
// }
|
||
//
|
||
// }
|
||
// //第二敦
|
||
// if(tagFrontMidCardType.bFiveSame)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=20;
|
||
// }
|
||
// if(tagFrontMidCardType.bStraightFlush)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=10;
|
||
// }
|
||
// else if(tagFrontMidCardType.bFourSame)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=8;
|
||
// }
|
||
// else if(tagFrontMidCardType.bGourd)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=5;
|
||
// }
|
||
// else if(tagFrontMidCardType.bFlush)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=4;
|
||
// }
|
||
// else if(tagFrontMidCardType.bStraight)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=3;
|
||
// }
|
||
// else if(tagFrontMidCardType.bThreeSame)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=2;
|
||
// }
|
||
// else if(tagFrontMidCardType.bTwoPare)
|
||
// {
|
||
// if(GetCardLogicValue(btFrontMidCard[tagFrontMidCardType.cbTwoPare[0]])<6)
|
||
// {
|
||
// btFrontWin+=0;
|
||
// btFrontCanWin+=0;
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=1;
|
||
// }
|
||
// }
|
||
// else if(tagFrontMidCardType.bOnePare)
|
||
// {
|
||
// if(GetCardLogicValue(btFrontMidCard[tagFrontMidCardType.cbOnePare[0]])<12)
|
||
// {
|
||
// btFrontWin+=-1;
|
||
// btFrontCanWin+=-1;
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontWin+=0;
|
||
// btFrontCanWin+=0;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontWin+=-1;
|
||
// btFrontCanWin+=-2;
|
||
// }
|
||
//
|
||
// //第三敦
|
||
// if (tagFrontBackCardType.bFiveSame)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=10;
|
||
// }
|
||
// if(tagFrontBackCardType.bStraightFlush)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=5;
|
||
// }
|
||
// else if(tagFrontBackCardType.bFourSame)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=4;
|
||
// }
|
||
// else if(tagFrontBackCardType.bGourd)
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=3;
|
||
// }
|
||
// else if(tagFrontBackCardType.bFlush)
|
||
// {
|
||
// if(GetCardLogicValue(btFrontBackCard[tagFrontBackCardType.cbFlush[0]])<11)
|
||
// {
|
||
// btFrontWin+=0;
|
||
// btFrontCanWin+=1;
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontWin+=1;
|
||
// btFrontCanWin+=2;
|
||
// }
|
||
// }
|
||
// else if(tagFrontBackCardType.bStraight)
|
||
// {
|
||
// if(GetCardLogicValue(btFrontBackCard[tagFrontBackCardType.cbStraight[0]])<11)
|
||
// {
|
||
// btFrontWin+=-1;
|
||
// btFrontCanWin+=-1;
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontWin+=0;
|
||
// btFrontCanWin+=0;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagFrontBackCardType.bThreeSame)
|
||
// {
|
||
// btFrontCanWin+=-2;
|
||
// }
|
||
// else if(tagFrontBackCardType.bTwoPare)
|
||
// {
|
||
// btFrontCanWin+=-3;
|
||
// }
|
||
// else if(tagFrontBackCardType.bOnePare)
|
||
// {
|
||
// btFrontCanWin+=-4;
|
||
// }
|
||
// else
|
||
// {
|
||
// btFrontCanWin+=-5;
|
||
// }
|
||
// btFrontWin+=-1;
|
||
// }
|
||
// //现在的牌
|
||
// if(tagFrontCardType.bThreeSame)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=3;
|
||
// }
|
||
// else if(tagFrontCardType.bOnePare)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=1;
|
||
// }
|
||
// else
|
||
// {
|
||
// if(GetCardLogicValue(btFrontCard[0])==14)
|
||
// {
|
||
// btWin+=0;
|
||
// btCanWin+=0;
|
||
// }
|
||
// else
|
||
// {
|
||
// btWin+=-1;
|
||
// btCanWin+=-1;
|
||
// }
|
||
// }
|
||
// //第二敦
|
||
// if(tagMidCardType.bFiveSame)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=20;
|
||
// }
|
||
// if(tagMidCardType.bStraightFlush)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=10;
|
||
// }
|
||
// else if(tagMidCardType.bFourSame)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=8;
|
||
// }
|
||
// else if(tagMidCardType.bGourd)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=5;
|
||
// }
|
||
// else if(tagMidCardType.bFlush)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=4;
|
||
// }
|
||
// else if(tagMidCardType.bStraight)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=3;
|
||
// }
|
||
// else if(tagMidCardType.bThreeSame)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=2;
|
||
// }
|
||
// else if(tagMidCardType.bTwoPare)
|
||
// {
|
||
// if(GetCardLogicValue(btMidCard[tagMidCardType.cbTwoPare[0]])<6)
|
||
// {
|
||
// btWin+=0;
|
||
// btCanWin+=0;
|
||
// }
|
||
// else
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=1;
|
||
// }
|
||
// }
|
||
// else if(tagMidCardType.bOnePare)
|
||
// {
|
||
// if(GetCardLogicValue(btMidCard[tagMidCardType.cbOnePare[0]])<12)
|
||
// {
|
||
// btWin+=-1;
|
||
// btCanWin+=-1;
|
||
// }
|
||
// else
|
||
// {
|
||
// btWin+=0;
|
||
// btCanWin+=0;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// btWin+=-1;
|
||
// btCanWin+=-2;
|
||
// }
|
||
// //第三敦
|
||
// if(tagBackCardType.bFiveSame)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=10;
|
||
// }
|
||
// if(tagBackCardType.bStraightFlush)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=5;
|
||
// }
|
||
// else if(tagBackCardType.bFourSame)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=4;
|
||
// }
|
||
// else if(tagBackCardType.bGourd)
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=3;
|
||
// }
|
||
// else if(tagBackCardType.bFlush)
|
||
// {
|
||
// if(GetCardLogicValue(btBackCard[tagBackCardType.cbFlush[0]])<11)
|
||
// {
|
||
// btWin+=0;
|
||
// btCanWin+=1;
|
||
// }
|
||
// else
|
||
// {
|
||
// btWin+=1;
|
||
// btCanWin+=2;
|
||
// }
|
||
// }
|
||
// else if(tagBackCardType.bStraight)
|
||
// {
|
||
// if(GetCardLogicValue(btBackCard[tagBackCardType.cbStraight[0]])<11)
|
||
// {
|
||
// btWin+=-1;
|
||
// btCanWin+=-1;
|
||
// }
|
||
// else
|
||
// {
|
||
// btWin+=0;
|
||
// btCanWin+=0;
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(tagBackCardType.bThreeSame)
|
||
// {
|
||
// btCanWin+=-2;
|
||
// }
|
||
// else if(tagBackCardType.bTwoPare)
|
||
// {
|
||
// btCanWin+=-3;
|
||
// }
|
||
// else if(tagBackCardType.bOnePare)
|
||
// {
|
||
// btCanWin+=-4;
|
||
// }
|
||
// else
|
||
// {
|
||
// btCanWin+=-5;
|
||
// }
|
||
// btWin+=-1;
|
||
// }
|
||
//
|
||
// if(btShuiShu==btFrontShuiShu)
|
||
// {
|
||
// if(btWin>btFrontWin)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// else if(btWin==btFrontWin)
|
||
// {
|
||
// if(btCompare>=1)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// else
|
||
// {
|
||
// if(btCanWin>btFrontCanWin)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// else
|
||
// {
|
||
// return false;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// return false;
|
||
// }
|
||
// }
|
||
// else if(btShuiShu==btFrontShuiShu+1)
|
||
// {
|
||
// if(btFrontWin-btWin>=4)
|
||
// {
|
||
// return false;
|
||
// }
|
||
// else
|
||
// {
|
||
// return true;
|
||
// }
|
||
// }
|
||
// else if(btShuiShu+1==btFrontShuiShu)
|
||
// {
|
||
// if(btWin-btFrontWin>=4)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// else
|
||
// {
|
||
// return false;
|
||
// }
|
||
// }
|
||
// else if(btShuiShu>btFrontShuiShu)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// else if(btShuiShu<btFrontShuiShu)
|
||
// {
|
||
// return false;
|
||
// }
|
||
// return false;
|
||
//}
|
||
|
||
bool CGameLogic::IsSameCardData( BYTE btFirstCard[],BYTE btNextCard[],BYTE btFirstCount,BYTE btNextCount)
|
||
{
|
||
if(btNextCount!=btFirstCount)
|
||
{
|
||
return false;
|
||
}
|
||
for(int i=0;i<btFirstCount;i++)
|
||
{
|
||
if(btFirstCard[i]!=btNextCard[i])
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
//自动摆牌
|
||
void CGameLogic::AutoPutCard(BYTE btHandCardData[],BYTE btHandCardCount,BYTE btFrontCard[],BYTE btMidCard[],BYTE btBackCard[])
|
||
{
|
||
//定义变量
|
||
BYTE bCardList[13] = {0};
|
||
memcpy(bCardList, btHandCardData, sizeof(BYTE)*13);
|
||
BYTE bLeftCCount = 13;
|
||
BYTE bTempCard[3][5] = {0};
|
||
BYTE bTempCCount[3] = {0};
|
||
BYTE bSigCCount = 0; //用于散牌填充时的计数
|
||
BYTE bCardType[3] = {0};
|
||
|
||
|
||
//摆牌开始
|
||
for (int i = 0; i < 3; i++)
|
||
{
|
||
bCardType[i] = GetMaxCardData(bCardList, bLeftCCount, bTempCard[i], bTempCCount[i], (i==2?3:5));
|
||
RemoveCard(bTempCard[i], bTempCCount[i], bCardList, bLeftCCount);
|
||
bLeftCCount -= bTempCCount[i];
|
||
}
|
||
|
||
ASSERT(bLeftCCount+bTempCCount[0]+bTempCCount[1]+bTempCCount[2] == 13);
|
||
ASSERT(bTempCCount[0]<=5&&bTempCCount[1]<=5&&bTempCCount[2]<=3);
|
||
|
||
if (bLeftCCount == 0)
|
||
return;
|
||
|
||
SortCardList(bCardList, bLeftCCount, enDescend);
|
||
|
||
|
||
//散牌填充
|
||
while (bTempCCount[2] < 3)
|
||
{
|
||
bTempCard[2][bTempCCount[2]++] = bCardList[bSigCCount++];
|
||
}
|
||
while (bTempCCount[0] < 5)
|
||
{
|
||
bTempCard[0][bTempCCount[0]++] = bCardList[bSigCCount++];
|
||
}
|
||
while (bTempCCount[1] < 5)
|
||
{
|
||
bTempCard[1][bTempCCount[1]++] = bCardList[bSigCCount++];
|
||
}
|
||
ASSERT(bSigCCount == bLeftCCount);
|
||
|
||
//牌组填充
|
||
memcpy(btFrontCard, bTempCard[2], sizeof(BYTE)*3);
|
||
memcpy(btMidCard, bTempCard[1], sizeof(BYTE)*5);
|
||
memcpy(btBackCard, bTempCard[0], sizeof(BYTE)*5);
|
||
|
||
//if( bCardType[2] != GetCardType(bTempCard[2], 3) ||
|
||
// bCardType[0] != GetCardType(bTempCard[0], 5) ||
|
||
// bCardType[1] != GetCardType(bTempCard[1], 5))
|
||
// MyMsgBox(_T("前[%d %d (%x %x %x)] 中[%d %d (%x %x %x %x %x)] 后[%d %d (%x %x %x %x %x)]"),
|
||
// bCardType[2], GetCardType(bTempCard[2], 3), bTempCard[2][0], bTempCard[2][1], bTempCard[2][2],
|
||
// bCardType[1], GetCardType(bTempCard[1], 5), bTempCard[1][0], bTempCard[1][1], bTempCard[1][2], bTempCard[1][3], bTempCard[1][4],
|
||
// bCardType[0], GetCardType(bTempCard[0], 5), bTempCard[0][0], bTempCard[0][1], bTempCard[0][2], bTempCard[0][3], bTempCard[0][4]);
|
||
|
||
return;
|
||
}
|
||
|
||
/****************************************************
|
||
*函数名：GetMaxCardData
|
||
*功能： 从得定牌组中抽取出最大牌型的牌 JJ
|
||
*参数： cbCardData 原牌(3< <=13) IN
|
||
cbCardCount 原牌数目 IN
|
||
cbMaxCardData 取出的最大牌(<=5) OUT
|
||
bMaxCardCount 取出牌数目(1<= <=5) OUT
|
||
*返回值：最大类型 (用于单元测试做校验,实际无用,不能做为可靠数据)
|
||
****************************************************/
|
||
BYTE CGameLogic::GetMaxCardData(const BYTE cbCardData[], const BYTE cbCardCount, BYTE bMaxCardData[], BYTE & bMaxCardCount, BYTE bNeedCCount)
|
||
{
|
||
//校验数据
|
||
ASSERT(cbCardCount <= 13 || cbCardCount > 3);
|
||
|
||
//定义变量
|
||
BYTE bKCount = 0;
|
||
CList<BYTE> evCardList[15]; //0位存王牌,1位保留,其他位按逻辑值存放
|
||
CList<BYTE> evColorList[4]; //方梅红黑
|
||
BYTE bCardArray[13] = {0};
|
||
memcpy(bCardArray, cbCardData, sizeof(BYTE)*cbCardCount);
|
||
|
||
SortCardList(bCardArray, cbCardCount, enDescend);
|
||
|
||
//分析扑克
|
||
for (int i = 0; i < cbCardCount; i++)
|
||
{
|
||
//保存王牌
|
||
if (bCardArray[i] == 0x41 || bCardArray[i] == 0x42)
|
||
{
|
||
evCardList[0].AddTail(bCardArray[i]);
|
||
continue;
|
||
}
|
||
|
||
//保存其他
|
||
BYTE bLogicNum = GetCardLogicValue(bCardArray[i]);
|
||
BYTE bColor = GetCardColor(bCardArray[i]);
|
||
|
||
ASSERT(bLogicNum>1 && bLogicNum<15 && bColor>=0 && bColor<=3);
|
||
ASSERT(evCardList[bLogicNum].Find(bCardArray[i]) == NULL);
|
||
|
||
evCardList[bLogicNum].AddTail(bCardArray[i]);
|
||
evColorList[bColor].AddTail(bCardArray[i]);
|
||
}
|
||
|
||
ASSERT(evCardList[0].GetCount() <= 2);
|
||
|
||
//寻找同顺
|
||
if (bNeedCCount == 5)
|
||
{
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (evColorList[i].GetCount()+evCardList[0].GetCount() >= 5) //同花+王牌数大于等于5
|
||
{
|
||
BYTE bCount = 0;
|
||
if (evCardList[0].GetCount() >= 0 && evColorList[i].GetCount() >= 5) //不带王
|
||
{
|
||
|
||
if (GetCardValue(evColorList[i].GetHead()) == 1 && //A在后同花顺
|
||
GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-4))) != 5)
|
||
{
|
||
|
||
BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(0));
|
||
BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(4));
|
||
|
||
if (GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 4)
|
||
{
|
||
for (int k = 0; k < 5; k++)
|
||
bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_BACK_A;
|
||
}
|
||
|
||
}
|
||
else if (GetCardValue(evColorList[i].GetHead()) == 1 && //检查A2345顺
|
||
GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-4))) == 5)
|
||
{
|
||
bMaxCardData[0] = evColorList[i].GetHead();
|
||
for (int k = 1; k < 5; k++)
|
||
bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
|
||
}
|
||
else
|
||
{
|
||
for (int j = 0; j < evColorList[i].GetCount()-4; j++)
|
||
{
|
||
BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j));
|
||
BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j+4));
|
||
|
||
if (GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 4)
|
||
{
|
||
for (int k = 0; k < 5; k++)
|
||
bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(j+k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_NO_A;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
if (evCardList[0].GetCount() >= 1 && evColorList[i].GetCount() >= 4) //带单王
|
||
{
|
||
if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(3))) >=10)
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
bMaxCardData[1] = evColorList[i].GetHead();
|
||
for (int k = 1; k < 4; k++)
|
||
bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_BACK_A;
|
||
}
|
||
else if (GetCardValue(evColorList[i].GetHead()) == 1 && //检查A2345顺
|
||
GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-3))) <= 5)
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
bMaxCardData[1] = evColorList[i].GetHead();
|
||
for (int k = 1; k < 4; k++)
|
||
bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
|
||
}
|
||
else if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-4))) <= 5) //检查A2345顺
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
for (int k = 1; k < 5; k++)
|
||
bMaxCardData[k] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
|
||
}
|
||
else
|
||
{
|
||
for (int j = 0; j < evColorList[i].GetCount()-3; j++)
|
||
{
|
||
BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j));
|
||
BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j+3));
|
||
|
||
if ( (GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 3) ||
|
||
(GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 4) )
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
for (int k = 0; k < 4; k++)
|
||
bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(j+k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_NO_A;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (evCardList[0].GetCount() == 2 && evColorList[i].GetCount() >= 3) //带双王
|
||
{
|
||
if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(2))) >=10)
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
bMaxCardData[1] = evCardList[0].GetTail();
|
||
for (int k = 1; k < 4; k++)
|
||
bMaxCardData[k+1] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_BACK_A;
|
||
}
|
||
else if (GetCardValue(evColorList[i].GetHead()) == 1 && //检查A2345顺
|
||
GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-2))) <= 5)
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
bMaxCardData[1] = evCardList[0].GetTail();
|
||
bMaxCardData[2] = evColorList[i].GetHead();
|
||
for (int k = 1; k < 3; k++)
|
||
bMaxCardData[k+2] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
|
||
}
|
||
else if (GetCardLogicValue(evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-3))) <= 5) //检查A2345顺
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
bMaxCardData[1] = evCardList[0].GetTail();
|
||
for (int k = 1; k < 4; k++)
|
||
bMaxCardData[k+2] = evColorList[i].GetAt(evColorList[i].FindIndex(evColorList[i].GetCount()-k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_FIRST_A;
|
||
}
|
||
else
|
||
{
|
||
for (int j = 0; j < evColorList[i].GetCount()-2; j++)
|
||
{
|
||
BYTE bFstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j));
|
||
BYTE bLstCard = evColorList[i].GetAt(evColorList[i].FindIndex(j+2));
|
||
|
||
if ( (GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 2) ||
|
||
(GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 3) ||
|
||
(GetCardLogicValue(bFstCard) - GetCardLogicValue(bLstCard) == 4))
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetHead();
|
||
bMaxCardData[1] = evCardList[0].GetTail();
|
||
for (int k = 0; k < 3; k++)
|
||
bMaxCardData[k+2] = evColorList[i].GetAt(evColorList[i].FindIndex(j+k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_STRAIGHT_FLUSH_NO_A;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//寻找五相
|
||
if (bNeedCCount == 5)
|
||
{
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount()== 4 && evCardList[0].GetCount() > 0)
|
||
{
|
||
bMaxCardData[0] = evCardList[0].GetAt(evCardList[0].FindIndex(0));
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[1+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_BOMB;
|
||
}
|
||
}
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount()== 3 && evCardList[0].GetCount() == 2)
|
||
{
|
||
bMaxCardData[0] = 0x42;
|
||
bMaxCardData[1] = 0x41;
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[2+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_BOMB;
|
||
}
|
||
}
|
||
}
|
||
|
||
//寻找炸弹
|
||
if (bNeedCCount == 5)
|
||
{
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount() + evCardList[0].GetCount() >= 4)
|
||
{
|
||
ASSERT(evCardList[i].GetCount()<=4&&evCardList[i].GetCount()>=2);
|
||
int j = 0;
|
||
for (; j < 4 - evCardList[i].GetCount(); j++)
|
||
{
|
||
bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
bMaxCardCount = 4;
|
||
return CT_FIVE_FOUR_ONE;
|
||
}
|
||
}
|
||
}
|
||
|
||
//寻找葫芦
|
||
if (bNeedCCount == 5)
|
||
{
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount() + evCardList[0].GetCount() == 3)
|
||
{
|
||
ASSERT(evCardList[i].GetCount()<=3&&evCardList[i].GetCount()>=1);
|
||
//寻找一对
|
||
BYTE bDoubleLogicCard = 0;
|
||
for (int k = 2; k < 15; k++)
|
||
{
|
||
if (k == i) continue;
|
||
if (evCardList[k].GetCount() >= 2)
|
||
{
|
||
bDoubleLogicCard = k;
|
||
break;
|
||
}
|
||
}
|
||
if (bDoubleLogicCard == 0) break;
|
||
|
||
int j = 0;
|
||
for (; j < 3 - evCardList[i].GetCount(); j++)
|
||
{
|
||
bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
bMaxCardData[3] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(0));
|
||
bMaxCardData[4] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(1));
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_THREE_DEOUBLE;
|
||
}
|
||
}
|
||
}
|
||
|
||
//寻找同花
|
||
if (bNeedCCount == 5)
|
||
{
|
||
BYTE bPossibleCard[4][5] = {0}; //各个能组成同花的牌组
|
||
CList<BYTE> maxCardColorList;
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (evColorList[i].GetCount() + evCardList[0].GetCount() >= 5)
|
||
{
|
||
if (evColorList[i].GetCount() >= 5)
|
||
{
|
||
for (int k = 0; k < 5; k++)
|
||
{
|
||
bPossibleCard[i][k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
int j = 0;
|
||
for (; j < 5 - evColorList[i].GetCount(); j++)
|
||
{
|
||
bPossibleCard[i][j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
|
||
for (int k = 0; k < evColorList[i].GetCount(); k++)
|
||
{
|
||
bPossibleCard[i][j + k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
|
||
}
|
||
}
|
||
maxCardColorList.AddTail(i);
|
||
}
|
||
}
|
||
if (maxCardColorList.GetCount() != 0)
|
||
{
|
||
BYTE bMax = maxCardColorList.GetAt(maxCardColorList.FindIndex(0));
|
||
for (int i = 1; i < maxCardColorList.GetCount(); i++)
|
||
{
|
||
BYTE bColor = maxCardColorList.GetAt(maxCardColorList.FindIndex(i));
|
||
if (CompareCard(bPossibleCard[bMax], bPossibleCard[bColor], 5, 5, true))
|
||
{
|
||
bMax = bColor;
|
||
}
|
||
}
|
||
memcpy(bMaxCardData, bPossibleCard[bMax], sizeof(BYTE)*5);
|
||
bMaxCardCount = 5;
|
||
return CT_FIVE_FLUSH;
|
||
}
|
||
}
|
||
|
||
//寻找顺子
|
||
if (bNeedCCount == 5)
|
||
{
|
||
for (int i = 14; i > 4; i--)
|
||
{
|
||
BYTE bHaveCard[5] = {0};
|
||
for (int k = 0; k < 4; k++)
|
||
{
|
||
bHaveCard[k] = (evCardList[i - k].GetCount()>0);
|
||
}
|
||
|
||
bHaveCard[4] = ( ((i == 5)?evCardList[14].GetCount():evCardList[i-4].GetCount()) > 0 );
|
||
BYTE bCount = (bHaveCard[0]?1:0) + (bHaveCard[1]?1:0) + (bHaveCard[2]?1:0) + (bHaveCard[3]?1:0) + (bHaveCard[4]?1:0);
|
||
if (bCount + evCardList[0].GetCount() >= 5)
|
||
{
|
||
ASSERT(bCount>=3&&bCount<=5);
|
||
int j = 0;
|
||
for (; j < 5 - bCount; j++)
|
||
{
|
||
bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < 4; k++)
|
||
{
|
||
if (bHaveCard[k])
|
||
{
|
||
bMaxCardData[j++] = evCardList[i-k].GetHead();
|
||
}
|
||
}
|
||
|
||
BYTE bFirstCardNum = ( (i == 5)?14:i-4 );
|
||
if (bHaveCard[4])
|
||
{
|
||
bMaxCardData[4] = evCardList[bFirstCardNum].GetHead();
|
||
}
|
||
|
||
bMaxCardCount = 5;
|
||
|
||
return ((i==14)?CT_FIVE_MIXED_FLUSH_BACK_A:( (i == 5)?CT_FIVE_MIXED_FLUSH_FIRST_A:CT_FIVE_MIXED_FLUSH_NO_A ));
|
||
}
|
||
}
|
||
}
|
||
|
||
//寻找三条
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount() + evCardList[0].GetCount() == 3)
|
||
{
|
||
ASSERT(evCardList[i].GetCount()<=3&&evCardList[i].GetCount()>=1);
|
||
|
||
int j = 0;
|
||
for (; j < 3 - evCardList[i].GetCount(); j++)
|
||
{
|
||
bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
bMaxCardCount = 3;
|
||
return CT_THREE;
|
||
}
|
||
}
|
||
|
||
//寻找两对
|
||
if (bNeedCCount == 5)
|
||
{
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount() + evCardList[0].GetCount() == 2)
|
||
{
|
||
ASSERT(evCardList[i].GetCount()<=2&&evCardList[i].GetCount()>=0);
|
||
|
||
//寻找一对
|
||
BYTE bDoubleLogicCard = 0;
|
||
for (int k = 2; k < 15; k++)
|
||
{
|
||
if (k == i) continue;
|
||
if (evCardList[k].GetCount() >= 2)
|
||
{
|
||
bDoubleLogicCard = k;
|
||
break;
|
||
}
|
||
}
|
||
if (bDoubleLogicCard == 0) break;
|
||
|
||
int j = 0;
|
||
for (; j < 2 - evCardList[i].GetCount(); j++)
|
||
{
|
||
bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
|
||
bMaxCardData[2] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(0));
|
||
bMaxCardData[3] = evCardList[bDoubleLogicCard].GetAt(evCardList[bDoubleLogicCard].FindIndex(1));
|
||
|
||
bMaxCardCount = 4;
|
||
return CT_FIVE_TWO_DOUBLE;
|
||
}
|
||
}
|
||
}
|
||
|
||
//寻找对子
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount() + evCardList[0].GetCount() == 2)
|
||
{
|
||
ASSERT(evCardList[i].GetCount()<=2&&evCardList[i].GetCount()>=0);
|
||
|
||
int j = 0;
|
||
for (; j < 2 - evCardList[i].GetCount(); j++)
|
||
{
|
||
bMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < evCardList[i].GetCount(); k++)
|
||
bMaxCardData[j+k] = evCardList[i].GetAt(evCardList[i].FindIndex(k));
|
||
|
||
bMaxCardCount = 2;
|
||
return CT_ONE_DOUBLE;
|
||
}
|
||
}
|
||
|
||
//寻找散牌
|
||
for (int i = 14; i > 1; i--)
|
||
{
|
||
if (evCardList[i].GetCount() == 1)
|
||
{
|
||
bMaxCardCount = 1;
|
||
bMaxCardData[0] = evCardList[i].GetHead();
|
||
return CT_SINGLE;
|
||
}
|
||
}
|
||
|
||
//MyMsgBox(_T("CGameLogic::GetMaxCardData Error!"));
|
||
|
||
return CT_INVALID;
|
||
}
|
||
|
||
bool CGameLogic::IsFlush(const BYTE cbCardData[], const BYTE cbCardCount, BYTE bMaxCardData[], BYTE & bMaxCardCount, BYTE bNeedCCount)
|
||
{
|
||
//校验数据
|
||
ASSERT(cbCardCount <= 13 || cbCardCount > 3);
|
||
|
||
//定义变量
|
||
BYTE bKCount = 0;
|
||
CList<BYTE> evCardList[15]; //0位存王牌,1位保留,其他位按逻辑值存放
|
||
CList<BYTE> evColorList[4]; //方梅红黑
|
||
BYTE bCardArray[13] = {0};
|
||
memcpy(bCardArray, cbCardData, sizeof(BYTE)*cbCardCount);
|
||
|
||
SortCardList(bCardArray, cbCardCount, enDescend);
|
||
|
||
//分析扑克
|
||
for (int i = 0; i < cbCardCount; i++)
|
||
{
|
||
//保存王牌
|
||
if (bCardArray[i] == 0x41 || bCardArray[i] == 0x42)
|
||
{
|
||
evCardList[0].AddTail(bCardArray[i]);
|
||
continue;
|
||
}
|
||
|
||
//保存其他
|
||
BYTE bLogicNum = GetCardLogicValue(bCardArray[i]);
|
||
BYTE bColor = GetCardColor(bCardArray[i]);
|
||
|
||
ASSERT(bLogicNum>1 && bLogicNum<15 && bColor>=0 && bColor<=3);
|
||
ASSERT(evCardList[bLogicNum].Find(bCardArray[i]) == NULL);
|
||
|
||
evCardList[bLogicNum].AddTail(bCardArray[i]);
|
||
evColorList[bColor].AddTail(bCardArray[i]);
|
||
}
|
||
|
||
ASSERT(evCardList[0].GetCount() <= 2);
|
||
|
||
//寻找同花
|
||
BYTE bPossibleCard[4][5] = {0}; //各个能组成同花的牌组
|
||
CList<BYTE> maxCardColorList;
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
if (evColorList[i].GetCount() + evCardList[0].GetCount() >= bNeedCCount)
|
||
{
|
||
if (evColorList[i].GetCount() >= bNeedCCount)
|
||
{
|
||
for (int k = 0; k < bNeedCCount; k++)
|
||
bPossibleCard[i][k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
|
||
}
|
||
else
|
||
{
|
||
int j = 0;
|
||
for (; j < bNeedCCount - evColorList[i].GetCount(); j++)
|
||
{
|
||
bPossibleCard[i][j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < evColorList[i].GetCount(); k++)
|
||
bPossibleCard[i][j+k] = evColorList[i].GetAt(evColorList[i].FindIndex(k));
|
||
}
|
||
maxCardColorList.AddTail(i);
|
||
}
|
||
}
|
||
if (maxCardColorList.GetCount() != 0)
|
||
{
|
||
BYTE bMax = maxCardColorList.GetAt(maxCardColorList.FindIndex(0));
|
||
for (int i = 1; i < maxCardColorList.GetCount(); i++)
|
||
{
|
||
BYTE bColor = maxCardColorList.GetAt(maxCardColorList.FindIndex(i));
|
||
if (CompareCard(bPossibleCard[bMax], bPossibleCard[bColor], bNeedCCount, bNeedCCount, true))
|
||
bMax = bColor;
|
||
}
|
||
memcpy(bMaxCardData, bPossibleCard[bMax], sizeof(BYTE)*bNeedCCount);
|
||
bMaxCardCount = bNeedCCount;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//是否顺子
|
||
bool CGameLogic::IsStraight(const BYTE cbCardData[], const BYTE cbCardCount, BYTE cbMaxCardData[], BYTE & bMaxCardCount, BYTE bNeedCCount)
|
||
{
|
||
//校验数据
|
||
ASSERT(cbCardCount <= 13 || cbCardCount > 3);
|
||
|
||
//定义变量
|
||
BYTE bKCount = 0;
|
||
CList<BYTE> evCardList[15]; //0位存王牌,1位保留,其他位按逻辑值存放
|
||
CList<BYTE> evColorList[4]; //方梅红黑
|
||
BYTE bCardArray[13] = {0};
|
||
memcpy(bCardArray, cbCardData, sizeof(BYTE)*cbCardCount);
|
||
|
||
SortCardList(bCardArray, cbCardCount, enDescend);
|
||
|
||
//分析扑克
|
||
for (int i = 0; i < cbCardCount; i++)
|
||
{
|
||
//保存王牌
|
||
if (bCardArray[i] == 0x41 || bCardArray[i] == 0x42)
|
||
{
|
||
evCardList[0].AddTail(bCardArray[i]);
|
||
continue;
|
||
}
|
||
|
||
//保存其他
|
||
BYTE bLogicNum = GetCardLogicValue(bCardArray[i]);
|
||
BYTE bColor = GetCardColor(bCardArray[i]);
|
||
|
||
ASSERT(bLogicNum>1 && bLogicNum<15 && bColor>=0 && bColor<=3);
|
||
ASSERT(evCardList[bLogicNum].Find(bCardArray[i]) == NULL);
|
||
|
||
evCardList[bLogicNum].AddTail(bCardArray[i]);
|
||
evColorList[bColor].AddTail(bCardArray[i]);
|
||
}
|
||
|
||
ASSERT(evCardList[0].GetCount() <= 2);
|
||
|
||
//寻找顺子
|
||
for (int i = 14; i > bNeedCCount-1; i--)
|
||
{
|
||
BYTE bHaveCard[5] = {0};
|
||
for (int k = 0; k < bNeedCCount-1; k++)
|
||
bHaveCard[k] = (evCardList[i-k].GetCount()>0);
|
||
bHaveCard[bNeedCCount-1] = ( ((i == bNeedCCount)?evCardList[14].GetCount():evCardList[i-bNeedCCount+1].GetCount()) > 0 );
|
||
|
||
BYTE bCount = 0;
|
||
for (int m=0;m<bNeedCCount-1;m++)
|
||
{
|
||
bCount += (bHaveCard[m]?1:0) ;
|
||
}
|
||
|
||
if (bCount + evCardList[0].GetCount() >= bNeedCCount)
|
||
{
|
||
ASSERT(bCount>=bNeedCCount-2&&bCount<=bNeedCCount);
|
||
int j = 0;
|
||
for (; j < bNeedCCount - bCount; j++)
|
||
{
|
||
cbMaxCardData[j] = evCardList[0].GetAt(evCardList[0].FindIndex(j));
|
||
}
|
||
for (int k = 0; k < bNeedCCount-1; k++)
|
||
{
|
||
if (bHaveCard[k])
|
||
cbMaxCardData[j++] = evCardList[i-k].GetHead();
|
||
}
|
||
|
||
BYTE bFirstCardNum = ( (i == bNeedCCount)?14:i-bNeedCCount+1 );
|
||
if (bHaveCard[bNeedCCount-1])
|
||
cbMaxCardData[bNeedCCount-1] = evCardList[bFirstCardNum].GetHead();
|
||
|
||
bMaxCardCount = bNeedCCount;
|
||
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
//是否是三同花顺
|
||
bool CGameLogic::IsThreeFlushStraight(const BYTE cbCardData[], const BYTE cbCardCount)
|
||
{
|
||
//校验数据
|
||
ASSERT(cbCardCount <= 13 || cbCardCount>3);
|
||
|
||
BYTE bCardList[13] = {0};
|
||
memcpy(bCardList,cbCardData,sizeof(BYTE)*cbCardCount);
|
||
SortCardList(bCardList,cbCardCount);
|
||
BYTE bLeftCount = cbCardCount;
|
||
BYTE cbStraightFlush[5] = {0};
|
||
BYTE bTempCount = 5;
|
||
|
||
tagAnalyseType tagCardType = GetType(bCardList,bLeftCount);
|
||
if (tagCardType.bStraightFlush)
|
||
{
|
||
for (BYTE i = 0;i<tagCardType.btStraightFlush;++i)
|
||
{
|
||
CopyMemory(bCardList,cbCardData,sizeof(bCardList));
|
||
bLeftCount = 13;
|
||
SortCardList(bCardList,13);
|
||
ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
|
||
cbStraightFlush[0]=bCardList[tagCardType.cbStraightFlush[i*5]];
|
||
cbStraightFlush[1]=bCardList[tagCardType.cbStraightFlush[i*5+1]];
|
||
cbStraightFlush[2]=bCardList[tagCardType.cbStraightFlush[i*5+2]];
|
||
cbStraightFlush[3]=bCardList[tagCardType.cbStraightFlush[i*5+3]];
|
||
cbStraightFlush[4]=bCardList[tagCardType.cbStraightFlush[i*5+4]];
|
||
|
||
//移除第一个同花顺
|
||
RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
|
||
bLeftCount -= bTempCount;
|
||
|
||
//备份剩余牌
|
||
BYTE bLeftCardList[13] = {0};
|
||
CopyMemory(bLeftCardList,bCardList,bLeftCount);
|
||
BYTE bLeftCount1 =bLeftCount;
|
||
|
||
tagAnalyseType tagCardType1 = GetType(bCardList,bLeftCount);
|
||
if (tagCardType1.bStraightFlush)
|
||
{
|
||
for (BYTE j = 0;j<tagCardType1.btStraightFlush;++j)
|
||
{
|
||
//重新赋值
|
||
CopyMemory(bCardList,bLeftCardList,bLeftCount1);
|
||
ZeroMemory(cbStraightFlush,sizeof(cbStraightFlush));
|
||
bLeftCount =bLeftCount1;
|
||
cbStraightFlush[0]=bCardList[tagCardType1.cbStraightFlush[j*5]];
|
||
cbStraightFlush[1]=bCardList[tagCardType1.cbStraightFlush[j*5+1]];
|
||
cbStraightFlush[2]=bCardList[tagCardType1.cbStraightFlush[j*5+2]];
|
||
cbStraightFlush[3]=bCardList[tagCardType1.cbStraightFlush[j*5+3]];
|
||
cbStraightFlush[4]=bCardList[tagCardType1.cbStraightFlush[j*5+4]];
|
||
//移除第二个同花顺
|
||
RemoveCard(cbStraightFlush, bTempCount, bCardList, bLeftCount);
|
||
bLeftCount -= bTempCount;
|
||
|
||
|
||
//判断剩余3张是否也符合同花顺
|
||
bool bThreeStraightFlush = false;
|
||
SortCardList(bCardList , bLeftCount, enDescend) ;
|
||
|
||
if (GetCardLogicValue(bCardList[0]) >=CARD_XW && GetCardLogicValue(bCardList[1]) <CARD_XW)
|
||
{
|
||
if((GetCardColor(bCardList[1]) == GetCardColor(bCardList[2]))&&
|
||
(GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==1
|
||
|| GetCardLogicValue(bCardList[1])-GetCardLogicValue(bCardList[2])==2
|
||
|| (GetCardLogicValue(bCardList[1]) == 14 &&GetCardLogicValue(bCardList[2])<=3))
|
||
)
|
||
{
|
||
bThreeStraightFlush = true;
|
||
}
|
||
}
|
||
else if (GetCardLogicValue(bCardList[0]) ==CARD_DW && GetCardLogicValue(bCardList[1]) ==CARD_XW)
|
||
{
|
||
bThreeStraightFlush = true;
|
||
}
|
||
else
|
||
{
|
||
if((GetCardColor(bCardList[0]) == GetCardColor(bCardList[1]) && GetCardColor(bCardList[0]) == GetCardColor(bCardList[2]))&&
|
||
((GetCardLogicValue(bCardList[0])==GetCardLogicValue(bCardList[1])+1 && GetCardLogicValue(bCardList[1])==GetCardLogicValue(bCardList[2])+1)
|
||
|| (GetCardLogicValue(bCardList[0]) == 14 &&GetCardLogicValue(bCardList[1])==3 &&GetCardLogicValue(bCardList[2])==2)))
|
||
{
|
||
bThreeStraightFlush = true;
|
||
}
|
||
}
|
||
if (bThreeStraightFlush)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
|
||
}
|
||
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|