带财神和白搭胡牌算法

//分析扑克
bool CGameLogic::AnalyseCard(const 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];
tagKindItem KindItem[27*2+7+28];
ZeroMemory(KindItem,sizeof(KindItem));


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


BYTE byGodsIndex = SwitchToCardIndex(m_byGodsCardData);


BYTE m_BaiBanIndex=SwitchToCardIndex(BAIBAN_CARD_DATA);


//单吊判断
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);


if(cbCardIndex[byGodsIndex]>0 && i!=byGodsIndex && cbCardIndex[i]==1)
{
  AnalyseItem.cbEye=SwitchToCardData(byGodsIndex);
  AnalyseItem.cbMyEye=true;
}


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


return true;
}
}
return false;
}




BYTE   magicCount=0;
magicCount=cbCardIndex[SwitchToCardIndex(m_byGodsCardData)];


把白板转换为财神
//int cbTemp1=cbCardIndex[SwitchToCardIndex(m_byGodsCardData)];  //财神数
//int cbTemp2=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]; //白板数






cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)];


转换数
//int bConverNum=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)];
财神数 =财神+白板数
//cbTemp1+=bConverNum;




//拆分分析
//BYTE cbMagicCardIndex[MAX_INDEX];
//CopyMemory(cbMagicCardIndex,cbCardIndex,sizeof(cbMagicCardIndex));
如果有财神
//BYTE cbMagicCardCount = 0;
//if( m_cbMagicIndex != MAX_INDEX )
//{
// cbMagicCardCount = cbCardIndex[m_cbMagicIndex];
// //如果财神有代替牌，财神与代替牌转换
// if( INDEX_REPLACE_CARD != MAX_INDEX )
// {
// cbMagicCardIndex[m_cbMagicIndex] = cbMagicCardIndex[INDEX_REPLACE_CARD];
// cbMagicCardIndex[INDEX_REPLACE_CARD] = cbMagicCardCount;
// }
//}


//白板个数
int cbBaiBan=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)];




// 拆分分析
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);
}*/
// log.Log("报错",信息);
//log.Log(i,信息);
/*for(int t=0;t<14;++t)
{   
log.Log(t,信息);
log.Log(cbCardIndex[t],信息);
}*/
// log.Log(cbCardIndex[i],信息);
//同牌判断
if(cbCardIndex[i]+cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]>=3)
{   


KindItem[cbKindItemCount].cbCardIndex[0]=i;//cbCardIndex[i]>0?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[1]=i;//cbCardIndex[i]>1?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[2]=i;//cbCardIndex[i]>2?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
KindItem[cbKindItemCount].cbValidIndex[0] = cbCardIndex[i]>0?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbValidIndex[1] = cbCardIndex[i]>1?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbValidIndex[2] = cbCardIndex[i]>2?i:SwitchToCardIndex(m_byGodsCardData);
cbKindItemCount++;




if(cbCardIndex[i]+cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]>=6)
{
 KindItem[cbKindItemCount].cbCardIndex[0]=i;//cbCardIndex[i]>3?i:SwitchToCardIndex(m_byGodsCardData);
 KindItem[cbKindItemCount].cbCardIndex[1]=i;//SwitchToCardIndex(m_byGodsCardData);
 KindItem[cbKindItemCount].cbCardIndex[2]=i;//SwitchToCardIndex(m_byGodsCardData);
 KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
 KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);  
 KindItem[cbKindItemCount].cbValidIndex[0] = cbCardIndex[i]>3?i:SwitchToCardIndex(m_byGodsCardData);
 KindItem[cbKindItemCount].cbValidIndex[1] = SwitchToCardIndex(m_byGodsCardData);
 KindItem[cbKindItemCount].cbValidIndex[2] = SwitchToCardIndex(m_byGodsCardData);
 cbKindItemCount++;
}
}




// log.Log("同牌",信息);
//同牌判断
//如果是财神,并且财神数小于3,则不进行组合
//if( cbMagicCardIndex[i] >= 3 || ( cbMagicCardIndex[i]+cbMagicCardCount >= 3 &&
// ( /*( INDEX_REPLACE_CARD!=MAX_INDEX && */i != INDEX_REPLACE_CARD ) /*|| ( INDEX_REPLACE_CARD==MAX_INDEX && i != m_cbMagicIndex )*/ ) )
//
//{
// int nTempIndex = cbMagicCardIndex[i];
// do
// {
// ASSERT( cbKindItemCount < CountArray(KindItem) );
// BYTE cbIndex = i;
// BYTE cbCenterCard = SwitchToCardData(i);
// //如果是财神且财神有代替牌,则换成代替牌
// if( i == m_cbMagicIndex && INDEX_REPLACE_CARD != MAX_INDEX )
// {
// cbIndex = INDEX_REPLACE_CARD;
// cbCenterCard = SwitchToCardData(INDEX_REPLACE_CARD);
// }
// KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
// KindItem[cbKindItemCount].cbCenterCard=cbCenterCard;
// KindItem[cbKindItemCount].cbValidIndex[0] = nTempIndex>0?cbIndex:m_cbMagicIndex;
// KindItem[cbKindItemCount].cbValidIndex[1] = nTempIndex>1?cbIndex:m_cbMagicIndex;
// KindItem[cbKindItemCount].cbValidIndex[2] = nTempIndex>2?cbIndex:m_cbMagicIndex;
// cbKindItemCount++;


// //如果是财神,则退出
// if( i == INDEX_REPLACE_CARD || (i == m_cbMagicIndex && INDEX_REPLACE_CARD == MAX_INDEX) )
// break;


// nTempIndex -= 3;
// //如果刚好搭配全部，则退出
// if( nTempIndex == 0 ) break;


// }while( nTempIndex+cbMagicCardCount >= 3 );
//}



//如果是财神,变成白板
/*if(i==SwitchToCardIndex(m_byGodsCardData))
{


}*/

// 连牌判断
//if ((i<(MAX_INDEX-/*MAX_HUA_CARD*/-9))&&((i%9)<7))
//{
// //只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合
// if( cbMagicCardCount+cbMagicCardIndex[i]+cbMagicCardIndex[i+1]+cbMagicCardIndex[i+2] >= 3 )
// {
// BYTE cbIndex[3] = { cbMagicCardIndex[i],cbMagicCardIndex[i+1],cbMagicCardIndex[i+2] };
// int nMagicCountTemp = cbMagicCardCount;
// BYTE cbValidIndex[3];
// while( nMagicCountTemp+cbIndex[0]+cbIndex[1]+cbIndex[2] >= 3 )
// {
// for( BYTE j = 0; j < CountArray(cbIndex); j++ )
// {
// if( cbIndex[j] > 0 ) 
// {
// cbIndex[j]--;
// cbValidIndex[j] = (i+j==m_cbMagicIndex&&INDEX_REPLACE_CARD!=MAX_INDEX)?INDEX_REPLACE_CARD:i+j;
// }
// else 
// {
// nMagicCountTemp--;
// cbValidIndex[j] = m_cbMagicIndex;
// }
// }
// if( nMagicCountTemp >= 0 )
// {
// ASSERT( cbKindItemCount < CountArray(KindItem) );
// KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
// KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
// CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
// cbKindItemCount++;
// }
// else break;
// }
// }
//}
if((i<27)&&(i%9)<7)
{    


     if((cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]+cbCardIndex[i]+cbCardIndex[i+1]+cbCardIndex[i+2])>=3
 ||(cbCardIndex[i]+cbCardIndex[i+1]+cbCardIndex[i+2]+cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)])>=3 )
 {
 /* BYTE cbIndex[3]={i==SwitchToCardIndex(m_byGodsCardData)?0:cbCardIndex[i],(i+1)==SwitchToCardIndex(m_byGodsCardData)?0:cbCardIndex[i+1],
 (i+2)==SwitchToCardIndex(m_byGodsCardData)?0:cbCardIndex[i+2]};*/


 
 //如果连牌是财神,判断有没有白板,有白板则用白板换
  BYTE cbIndex[3]={i==SwitchToCardIndex(m_byGodsCardData)?cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]:cbCardIndex[i],
  (i+1)==SwitchToCardIndex(m_byGodsCardData)?cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]:cbCardIndex[i+1],
  (i+2)==SwitchToCardIndex(m_byGodsCardData)?cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]:cbCardIndex[i+2]};
     
 int magicCount=cbCardIndex[SwitchToCardIndex(m_byGodsCardData)];
 BYTE cbValidIndex[3];
 int  bl=1;
 while((bl=(magicCount+cbIndex[0]+cbIndex[1]+cbIndex[2]))>=3)
 {
     for(BYTE j=0;j<3;++j)
 {
      if(cbIndex[j]>0)
  {
       cbIndex[j]--;
//如果是财神,换成白板
cbValidIndex[j]=(i+j)==SwitchToCardIndex(m_byGodsCardData)?SwitchToCardIndex(BAIBAN_CARD_DATA):(i+j);
  }
  else
  {
      magicCount--;
  cbValidIndex[j]=SwitchToCardIndex(m_byGodsCardData);
  }  
 }


 if(magicCount>=0)
 {
     KindItem[cbKindItemCount].cbCardIndex[0]=i;//cbCardIndex[i]>3?i:SwitchToCardIndex(m_byGodsCardData);
             KindItem[cbKindItemCount].cbCardIndex[1]=i+1;//SwitchToCardIndex(m_byGodsCardData);
             KindItem[cbKindItemCount].cbCardIndex[2]=i+2;//SwitchToCardIndex(m_byGodsCardData);
             KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
             KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);  
 CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
     cbKindItemCount++;
 
 }
 else break;
       
 }
 
 
 }

}


// log.Log("连牌",信息);



/*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]=SwitchToCardIndex(i)-1;
KindItem[cbKindItemCount].cbCardIndex[2]=SwitchToCardIndex(i)-1;
KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
}
}
}*/






//连牌判断
/*if((i)==SwitchToCardData(BAIBAN_CARD_DATA))
{

}*/






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




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




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


}
}


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


//变量定义
BYTE cbIndex[MAX_WEAVE]={0,1,2,3};
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]; 
BYTE cbCardIndex=pKindItem[i/3]->cbValidIndex[i%3];
if (cbCardIndexTemp[cbCardIndex]==0)
{   

if(cbCardIndexTemp[SwitchToCardIndex(m_byGodsCardData)]>0)
{
   cbCardIndexTemp[SwitchToCardIndex(m_byGodsCardData)]--;
// pKindItem[i/3]->cbValidIndex[i%3] =SwitchToCardIndex(m_byGodsCardData);
}
else
{
   bEnoughCard=false;
break;
}
}
else 
cbCardIndexTemp[cbCardIndex]--;
}


//胡牌判断
if (bEnoughCard==true)
{   
//log.Log("判胡",信息);
//牌眼判断
BYTE cbCardEye=0;
BYTE cbEye=0;
bool cbMyEye=false;
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndexTemp[i]==2)
{
   
cbCardEye=SwitchToCardData(i);
break;
}


   else if(cbCardIndexTemp[i]+cbCardIndexTemp[SwitchToCardIndex(m_byGodsCardData)]==2  && (i!=SwitchToCardIndex(m_byGodsCardData)))
{
   cbCardEye=SwitchToCardData(i);
//cbCardEye=m_byGodsCardData;
cbEye=m_byGodsCardData;
cbMyEye=true;
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;
}
//设置牌型
/*for(BYTE i=0;i<cbLessKindItem;++i)
{
  AnalyseItem.cbWeaveKind[i+cbWeaveCount]=WeaveItem[i].cbWeaveKind;
  AnalyseItem.cbCardData[i+cbWeaveCount][0]=SwitchToCardData(pKindItem[i].cbValidIndex[0]);
  AnalyseItem.cbCardData[i+cbWeaveCount][1]=SwitchToCardData(pKindItem[i].cbValidIndex[0]);
  AnalyseItem.cbCardData[i+cbWeaveCount][2]=SwitchToCardData(pKindItem[i].cbValidIndex[0]);
}*/




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


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


//设置索引
if (cbIndex[cbLessKindItem-1]==(cbKindItemCount-1))
{
BYTE i=0;
for (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);


}


// log.Log("胡牌判完",信息);
return (AnalyseItemArray.GetCount()>0);
}