麻将的胡牌算法

//分析扑克
bool CGameLogic::AnalyseCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)
{
//计算数目
BYTE cbCardCount=0;
for (BYTE i=0;i<MAX_INDEX;i++) 
cbCardCount+=cbCardIndex[i];


//效验数目
ASSERT((cbCardCount>=2)&&(cbCardCount<=MAX_COUNT)&&((cbCardCount-2)%3==0));
if ((cbCardCount<2)||(cbCardCount>MAX_COUNT)||((cbCardCount-2)%3!=0))
return false;


//变量定义
BYTE cbKindItemCount=0;
tagKindItem KindItem[MAX_COUNT-2];
ZeroMemory(KindItem,sizeof(KindItem));


//需求判断
BYTE cbLessKindItem=(cbCardCount-2)/3;
ASSERT((cbLessKindItem+cbWeaveCount)==MAX_WEAVE);


BYTE byGodsIndex = SwitchToCardIndex(m_byGodsCardData);
//单吊判断
if (cbLessKindItem==0)
{
//效验参数
ASSERT((cbCardCount==2)&&(cbWeaveCount==MAX_WEAVE));


//牌眼判断
for (BYTE i=0;i<MAX_INDEX;i++)
{
if ((cbCardIndex[i]==2)
|| ((cbCardIndex[i]==1)
&& (i != byGodsIndex)
&& (cbCardIndex[byGodsIndex]>0)))
{
//变量定义
tagAnalyseItem AnalyseItem;
ZeroMemory(&AnalyseItem,sizeof(AnalyseItem));


//设置结果
for (BYTE j=0;j<cbWeaveCount;j++)
{
AnalyseItem.cbWeaveKind[j]=WeaveItem[j].cbWeaveKind;
AnalyseItem.cbCenterCard[j]=WeaveItem[j].cbCenterCard;
}
AnalyseItem.cbCardEye=SwitchToCardData(i);


//插入结果
AnalyseItemArray.Add(AnalyseItem);


return true;
}
}
return false;
}


// 拆分分析
if (cbCardCount>=3)
{
for (BYTE i=0;i<MAX_INDEX;i++)
{
//同牌判断
if (cbCardIndex[i]>=3)
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;
KindItem[cbKindItemCount].cbCardIndex[1]=i;
KindItem[cbKindItemCount].cbCardIndex[2]=i;
KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
}

// 连牌判断
if ((i<(MAX_INDEX-9))&&(cbCardIndex[i]>0)&&((i%9)<7))
{
for (BYTE j=1;j<=cbCardIndex[i];j++)
{
if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;
KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
}
}
}
}
}


//组合分析
if (cbKindItemCount>=cbLessKindItem)
{
//变量定义
BYTE cbCardIndexTemp[MAX_INDEX];
ZeroMemory(cbCardIndexTemp,sizeof(cbCardIndexTemp));


//变量定义
BYTE cbIndex[MAX_WEAVE]={0,1,2,3,4};
tagKindItem * pKindItem[MAX_WEAVE];
ZeroMemory(&pKindItem,sizeof(pKindItem));


//开始组合
do
{
//设置变量
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
for (BYTE i=0;i<cbLessKindItem;i++)
pKindItem[i]=&KindItem[cbIndex[i]];


//数量判断
bool bEnoughCard=true;
for (BYTE i=0;i<cbLessKindItem*3;i++)
{
//存在判断
BYTE cbCardIndex=pKindItem[i/3]->cbCardIndex[i%3]; 
if (cbCardIndexTemp[cbCardIndex]==0)
{
bEnoughCard=false;
break;
}
else 
cbCardIndexTemp[cbCardIndex]--;
}


//胡牌判断
if (bEnoughCard==true)
{
//牌眼判断
BYTE cbCardEye=0;
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndexTemp[i]==2)
{
cbCardEye=SwitchToCardData(i);
break;
}
}


//组合类型
if (cbCardEye!=0)
{
//变量定义
tagAnalyseItem AnalyseItem;
ZeroMemory(&AnalyseItem,sizeof(AnalyseItem));


//设置组合
for (BYTE i=0;i<cbWeaveCount;i++)
{
AnalyseItem.cbWeaveKind[i]=WeaveItem[i].cbWeaveKind;
AnalyseItem.cbCenterCard[i]=WeaveItem[i].cbCenterCard;
}


//设置牌型
for (BYTE i=0;i<cbLessKindItem;i++) 
{
AnalyseItem.cbWeaveKind[i+cbWeaveCount]=pKindItem[i]->cbWeaveKind;
AnalyseItem.cbCenterCard[i+cbWeaveCount]=pKindItem[i]->cbCenterCard;
}


//设置牌眼
AnalyseItem.cbCardEye=cbCardEye;


//插入结果
AnalyseItemArray.Add(AnalyseItem);
}
}


//设置索引
if (cbIndex[cbLessKindItem-1]==(cbKindItemCount-1))
{
for (BYTE i=cbLessKindItem-1;i>0;i--)
{
if ((cbIndex[i-1]+1)!=cbIndex[i])
{
BYTE cbNewIndex=cbIndex[i-1];
for (BYTE j=(i-1);j<cbLessKindItem;j++) 
cbIndex[j]=cbNewIndex+j-i+2;
break;
}
}
if (i==0)
break;
}
else
cbIndex[cbLessKindItem-1]++;

} while (true);


}


return (AnalyseItemArray.GetCount()>0);
}