//吃胡分析
BYTE CGameLogic::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, CChiHuRight &ChiHuRight)
{
//变量定义
BYTE cbChiHuKind=WIK_NULL;
CAnalyseItemArray AnalyseItemArray;
//设置变量
AnalyseItemArray.RemoveAll();
ChiHuRight.SetEmpty();
//构造扑克
BYTE cbCardIndexTemp[MAX_INDEX];
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
//构造扑克
BYTE cbCardIndexTemp2[MAX_INDEX];
ZeroMemory(cbCardIndexTemp2,sizeof(cbCardIndexTemp2));
m_cbGenCount = 0;
BYTE cbFanShu = 0;
CChiHuRight tmpChiHuRight;
//cbCurrentCard一定不为0 !!!!!!!!!
ASSERT( cbCurrentCard != 0 );
if( cbCurrentCard == 0 ) return WIK_NULL;
/*
// 特殊番型
*/
//七小对牌
if( IsQiXiaoDui(cbCardIndex,WeaveItem,cbWeaveCount,cbCurrentCard) )
{
ChiHuRight |= CHR_QI_XIAO_DUI;
}
if( !ChiHuRight.IsEmpty() )
cbChiHuKind = WIK_CHI_HU;
//插入扑克
if (cbCurrentCard!=0)
cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
//必须缺一门
if( IsHuaZhu(cbCardIndexTemp,WeaveItem,cbWeaveCount) )
{
return WIK_NULL;
}
//胡牌分析
if((ChiHuRight&CHR_QI_XIAO_DUI).IsEmpty())
{
//分析扑克
AnalyseCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,AnalyseItemArray);
if (AnalyseItemArray.GetCount()>0)
{
cbChiHuKind = WIK_CHI_HU;
//牌型分析
for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)
{
//变量定义
tagAnalyseItem * pAnalyseItem=&AnalyseItemArray[i];
ZeroMemory(cbCardIndexTemp2,sizeof(cbCardIndexTemp2));
cbCardIndexTemp2[SwitchToCardIndex(pAnalyseItem->cbCardEye)] = 2;
BYTE cbTmpFanShu = 0;
tmpChiHuRight.SetEmpty();
for (BYTE k =0;k<4;k++)
{
if (pAnalyseItem->cbWeaveKind[k] == WIK_LEFT)
{
BYTE cbTmpIndex = SwitchToCardIndex(pAnalyseItem->cbCenterCard[k]);
for (BYTE t = 0;t < 3;t ++)
{
cbCardIndexTemp2[cbTmpIndex]++;
cbTmpIndex++;
}
}else if (pAnalyseItem->cbWeaveKind[k] == WIK_PENG || pAnalyseItem->cbWeaveKind[k] == WIK_TIE_PAI)
{
BYTE cbTmpIndex = SwitchToCardIndex(pAnalyseItem->cbCenterCard[k]);
for (BYTE t = 0;t < 3;t ++)
{
cbCardIndexTemp2[cbTmpIndex]++;
}
}else if (pAnalyseItem->cbWeaveKind[k] == WIK_GANG)
{
BYTE cbTmpIndex = SwitchToCardIndex(pAnalyseItem->cbCenterCard[k]);
for (BYTE t = 0;t < 4;t ++)
{
cbCardIndexTemp2[cbTmpIndex]++;
}
}
}
// 分析根
BYTE tmpCount = 0;
for (BYTE k = 0;k<MAX_INDEX;k++)
{
// 分析碰贴牌，在手上牌中查找是否有根
if (cbCardIndexTemp2[k] == 4)
{
tmpCount++;
cbTmpFanShu++;
}
}
// 判断是否有3个牌精
if (HaveThreePaiJin(cbCardIndexTemp2,WeaveItem,cbWeaveCount))
{
tmpChiHuRight |= CHR_WITH_THREE_PAI_JIN;
cbTmpFanShu = (cbTmpFanShu == 0)?2:(cbTmpFanShu+=1);
}
/*
// 判断番型
*/
//碰碰和
if( IsPengPeng(pAnalyseItem) )
{
tmpChiHuRight |= CHR_DA_DUI_ZI;
cbTmpFanShu+=3;
}
if(cbTmpFanShu>cbFanShu)
{
cbFanShu = cbTmpFanShu;
DWORD wRightData =0;
tmpChiHuRight.GetRightData(&wRightData, MAX_RIGHT_COUNT);
ChiHuRight.SetRightData(&wRightData, MAX_RIGHT_COUNT);
m_cbGenCount = tmpCount;
}
#if 0
//带幺
if( IsDaiYao(pAnalyseItem) )
ChiHuRight |= CHR_DAI_YAO;
//将对
if( IsJiangDui(pAnalyseItem) )
ChiHuRight |= CHR_JIANG_DUI;
#endif
}
}
}
if(!(ChiHuRight&CHR_QI_XIAO_DUI).IsEmpty())
{
BYTE cbTingYongCardCount = cbCardIndexTemp[m_cbMagicIndex];
BYTE cbOneCount = 0,cbThreeCount = 0;
ChiHuRight &=~CHR_DA_DUI_ZI;
for(BYTE k = 0;k<MAX_INDEX-7;k++)
{
if( k == m_cbMagicIndex ) continue;
if(cbCardIndexTemp[k] == 4)
{
m_cbGenCount++;
}
BYTE cbCardCount=cbCardIndexTemp[k];
if(cbCardCount == 1)
{
cbOneCount++;
}else if(cbCardCount == 3)
{
cbThreeCount++;
}
}
switch (cbTingYongCardCount)
{
case 1:
if (cbThreeCount == 1)
m_cbGenCount++;
break;
case 2:
if (cbThreeCount == 2 && cbOneCount == 0)
m_cbGenCount+=2;
else if (cbThreeCount == 1 && cbOneCount == 1)
m_cbGenCount++;
break;
case 3:
if (cbThreeCount == 1 && cbOneCount == 0)
m_cbGenCount+=2;
else if (cbThreeCount == 3 && cbOneCount == 0)
m_cbGenCount+=cbThreeCount;
else if ( cbThreeCount == 2 && cbOneCount == 1)
m_cbGenCount+=cbThreeCount;
else if (cbThreeCount == 1 && cbOneCount == 2)
m_cbGenCount+=cbThreeCount;
break;
case 4:
if (cbThreeCount == 2 && cbOneCount == 0)
m_cbGenCount+=3;
else if (cbThreeCount == 1 && cbOneCount == 1)
m_cbGenCount+=2;
else if ( cbThreeCount == 2 && cbOneCount == 2)
m_cbGenCount+=cbThreeCount;
else if (cbThreeCount == 1 && cbOneCount == 3)
m_cbGenCount+=cbThreeCount;
break;
default:
break;
}
}
if( cbChiHuKind == WIK_CHI_HU )
{
//清一色牌
if( IsQingYiSe(cbCardIndex,WeaveItem,cbWeaveCount,cbCurrentCard) )
{
ChiHuRight |= CHR_QING_YI_SE;
}
if (!HaveMagicCard(cbCardIndex,WeaveItem,cbWeaveCount) && IsMagicCard(cbCurrentCard)==false) // 缺听用
{
ChiHuRight |= CHR_WITHOUT_TING_YONG;
}
if (IsDaDanDiao(cbCardIndex,cbWeaveCount)) // 大单吊
{
ChiHuRight |= CHR_DA_DAN_DIAO;
}
switch(m_cbGenCount)
{
case 1:
ChiHuRight|= CHR_GENG_COUNT_ONE;
break;
case 2:
ChiHuRight|= CHR_GENG_COUNT_TWO;
break;
case 3:
ChiHuRight|= CHR_GENG_COUNT_THREE;
break;
case 4:
ChiHuRight|= CHR_GENG_COUNT_FOUR;
break;
}
//素番
if( cbChiHuKind == WIK_CHI_HU && ChiHuRight.IsEmpty() )
ChiHuRight |= CHR_SHU_FAN;
}
return cbChiHuKind;
}
//吃胡分析
BYTE CGameLogic::AnalyseChiHuCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult & ChiHuResult,BYTE cbGoldCard[],BYTE cbGoldCount,bool &bGoldCardEye)
{
//变量定义
WORD wChiHuKind=CHK_NULL;
static CAnalyseItemArray AnalyseItemArray;
//设置变量
AnalyseItemArray.RemoveAll();
ZeroMemory(&ChiHuResult,sizeof(ChiHuResult));
bGoldCardEye = false;
//构造麻将
BYTE cbCardIndexTemp[MAX_INDEX];
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
//插入麻将
if (cbCurrentCard!=0) cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
//金牌数目
BYTE bGetCount=0;
bGetCount = GetGoldCardCount(cbCardIndexTemp,WeaveItem,cbWeaveCount,cbGoldCard,cbGoldCount);
//特殊牌型
//天游牌型
if(bGetCount==3)wChiHuKind|=CHK_SKY_SWIM;
//单游牌型
if(wChiHuRight==CHR_SINGLE_SWIM)wChiHuKind|=CHK_SINGLE_SWIM;
//双游牌型
else if(wChiHuRight==CHR_DOUBLE_SWIM)wChiHuKind|=CHK_DOUBLE_SWIM;
//三游牌型
else if(wChiHuRight==CHR_THREE_SWIM)wChiHuKind|=CHK_THREE_SWIM;
/*if(bGetCount==1)
wChiHuRight|=CHR_SINGLE_SWIM;//游金权位
else if(bGetCount==2)
wChiHuRight|=CHR_DOUBLE_SWIM;//双游权位
else if(bGetCount>2)
wChiHuRight|=CHR_THREE_SWIM;//三游权位*/
//分析麻将
AnalyseCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,AnalyseItemArray);
//胡牌分析
if (AnalyseItemArray.GetCount()>0)
{
//眼牌需求
bool bNeedSymbol=((wChiHuRight&0xFF00)==0);
//牌型分析
for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)
{
//变量定义
bool bLianCard=false,bPengCard=false;
tagAnalyseItem * pAnalyseItem=&AnalyseItemArray[i];
//牌眼类型
BYTE cbEyeValue=pAnalyseItem->cbCardEye&MASK_VALUE;
//牌型分析
for (BYTE j=0;j<CountArray(pAnalyseItem->cbWeaveKind);j++)
{
BYTE cbWeaveKind=pAnalyseItem->cbWeaveKind[j];
bPengCard=((cbWeaveKind&(WIK_GANG|WIK_PENG))!=0)?true:bPengCard;
bLianCard=((cbWeaveKind&(WIK_LEFT|WIK_CENTER|WIK_RIGHT))!=0)?true:bLianCard;
}
//牌眼分析
for(BYTE i=0;i<cbGoldCount;i++)
{
if(pAnalyseItem->cbCardEye==cbGoldCard[i])
{
bGoldCardEye=true;
break;
}
}
//牌型判断
ASSERT((bLianCard==true)||(bPengCard==true));
if (bLianCard==true) wChiHuKind|=CHK_PING_HU;
else if ((bLianCard==false)&&(bPengCard==true)) wChiHuKind|=CHK_PING_HU;
//碰碰牌型
//if ((bLianCard==false)&&(bPengCard==true)) wChiHuKind|=CHK_PENG_PENG;
}
}
//结果判断
if (wChiHuKind!=CHK_NULL)
{
//设置结果
ChiHuResult.wChiHuKind=wChiHuKind;
ChiHuResult.wChiHuRight=wChiHuRight;
return WIK_CHI_HU;
}
return WIK_NULL;
}
//分析扑克
bool CGameLogic::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)
{
//计算数目
BYTE cbCardCount=GetCardCount(cbCardIndex);
//效验数目
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;
#if 1
tagKindItem KindItem[220]; // 最大组合12选3 = 12!/(9!*3!) = 220
#else
tagKindItem KindItem[27*2+7+14];
#endif
ZeroMemory(KindItem,sizeof(KindItem));
//需求判断
BYTE cbLessKindItem=(cbCardCount-2)/3;
ASSERT((cbLessKindItem+cbWeaveCount)==4);
//单吊判断
if (cbLessKindItem==0)
{
//效验参数
ASSERT((cbCardCount==2)&&(cbWeaveCount==4));
//牌眼判断
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndex[i]==2 ||
( m_cbMagicIndex != MAX_INDEX && i != m_cbMagicIndex && cbCardIndex[m_cbMagicIndex]+cbCardIndex[i]==2 ) )
{
//变量定义
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;
GetWeaveCard( WeaveItem[j].cbWeaveKind,WeaveItem[j].cbCenterCard,AnalyseItem.cbCardData[j] );
}
AnalyseItem.cbCardEye=SwitchToCardData(i);
if( cbCardIndex[i] < 2 || i == m_cbMagicIndex )
AnalyseItem.bMagicEye = true;
else AnalyseItem.bMagicEye = false;
//插入结果
AnalyseItemArray.Add(AnalyseItem);
return true;
}
}
return false;
}
//拆分分析
BYTE cbMagicCardIndex[MAX_INDEX];
CopyMemory(cbMagicCardIndex,cbCardIndex,sizeof(cbMagicCardIndex));
BYTE cbMagicCardCount = 0;
if( m_cbMagicIndex != MAX_INDEX )
{
cbMagicCardCount = cbCardIndex[m_cbMagicIndex];
if( cbMagicCardIndex[m_cbMagicIndex] ) cbMagicCardIndex[m_cbMagicIndex] = 1; //减小多余组合
}
if (cbCardCount>=3)
{
for (BYTE i=0;i<MAX_INDEX;i++)
{
//同牌判断
if (cbMagicCardIndex[i]+cbMagicCardCount>=3)
{
ASSERT( cbKindItemCount < CountArray(KindItem) );
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);
KindItem[cbKindItemCount].cbValidIndex[0] = cbMagicCardIndex[i]>0?i:m_cbMagicIndex;
KindItem[cbKindItemCount].cbValidIndex[1] = cbMagicCardIndex[i]>1?i:m_cbMagicIndex;
KindItem[cbKindItemCount].cbValidIndex[2] = cbMagicCardIndex[i]>2?i:m_cbMagicIndex;
cbKindItemCount++;
if(cbMagicCardIndex[i]+cbMagicCardCount>=6) // 如果可以分析为2个碰组
{
ASSERT( cbKindItemCount < CountArray(KindItem) ); // 第2组
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);
KindItem[cbKindItemCount].cbValidIndex[0] = cbMagicCardIndex[i]>3?i:m_cbMagicIndex;
KindItem[cbKindItemCount].cbValidIndex[1] = m_cbMagicIndex;
KindItem[cbKindItemCount].cbValidIndex[2] = m_cbMagicIndex;
cbKindItemCount++;
}
}
//连牌判断
if ((i<(MAX_INDEX-9))&&((i%9)<7))
{
//只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合
if( cbMagicCardCount+cbMagicCardIndex[i]+cbMagicCardIndex[i+1]+cbMagicCardIndex[i+2] >= 3 )
{
BYTE cbIndex[3] = { i==m_cbMagicIndex?0:cbMagicCardIndex[i],(i+1)==m_cbMagicIndex?0:cbMagicCardIndex[i+1],
(i+2)==m_cbMagicIndex?0: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;
}
else
{
nMagicCountTemp--;
cbValidIndex[j] = m_cbMagicIndex;
}
}
if( nMagicCountTemp >= 0 )
{
ASSERT( cbKindItemCount < CountArray(KindItem) );
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);
CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
cbKindItemCount++;
}
else break;
}
if (cbMagicCardIndex[i]>=1 && cbMagicCardIndex[i+1]>=1&&cbMagicCardCount>0)
{
cbValidIndex[0] = i;cbValidIndex[1] = i+1;cbValidIndex[2] = m_cbMagicIndex;
ASSERT( cbKindItemCount < CountArray(KindItem) );
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);
CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
cbKindItemCount++;
}
if (cbMagicCardIndex[i+1]>=1 && cbMagicCardIndex[i+2]>=1&&cbMagicCardCount>0)
{
cbValidIndex[0] = m_cbMagicIndex;cbValidIndex[1] = i+1;cbValidIndex[2] = i+2;
ASSERT( cbKindItemCount < CountArray(KindItem) );
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);
CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
cbKindItemCount++;
}
if (cbMagicCardIndex[i]>=1 && cbMagicCardIndex[i+2]>=1&&cbMagicCardCount>0)
{
cbValidIndex[0] = i;cbValidIndex[1] = m_cbMagicIndex;cbValidIndex[2] = i+2;
ASSERT( cbKindItemCount < CountArray(KindItem) );
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);
CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
cbKindItemCount++;
}
}
}
}
}
//组合分析
if (cbKindItemCount>=cbLessKindItem)
{
//变量定义
BYTE cbCardIndexTemp[MAX_INDEX];
ZeroMemory(cbCardIndexTemp,sizeof(cbCardIndexTemp));
//变量定义
BYTE cbIndex[4]={0,1,2,3};
tagKindItem * pKindItem[4];
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]->cbValidIndex[i%3];
if (cbCardIndexTemp[cbCardIndex]==0)
{
bEnoughCard=false;
break;
}
else
cbCardIndexTemp[cbCardIndex]--;
}
//胡牌判断
if (bEnoughCard==true)
{
//牌眼判断
BYTE cbCardEye=0;
bool bMagicEye = false;
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndexTemp[i]==2)
{
cbCardEye=SwitchToCardData(i);
if( i == m_cbMagicIndex ) bMagicEye = true;
break;
}
else if( i!=m_cbMagicIndex &&
m_cbMagicIndex != MAX_INDEX && cbCardIndexTemp[i]+cbCardIndexTemp[m_cbMagicIndex]==2 )
{
cbCardEye = SwitchToCardData(i);
bMagicEye = true;
}
}
//组合类型
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;
GetWeaveCard( WeaveItem[i].cbWeaveKind,WeaveItem[i].cbCenterCard,
AnalyseItem.cbCardData[i] );
}
//设置牌型
for (BYTE i=0;i<cbLessKindItem;i++)
{
AnalyseItem.cbWeaveKind[i+cbWeaveCount]=pKindItem[i]->cbWeaveKind;
AnalyseItem.cbCenterCard[i+cbWeaveCount]=pKindItem[i]->cbCenterCard;
AnalyseItem.cbCardData[cbWeaveCount+i][0] = SwitchToCardData(pKindItem[i]->cbValidIndex[0]);
AnalyseItem.cbCardData[cbWeaveCount+i][1] = SwitchToCardData(pKindItem[i]->cbValidIndex[1]);
AnalyseItem.cbCardData[cbWeaveCount+i][2] = SwitchToCardData(pKindItem[i]->cbValidIndex[2]);
}
//设置牌眼
AnalyseItem.cbCardEye=cbCardEye;
AnalyseItem.bMagicEye = bMagicEye;
//插入结果
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);
}
return (AnalyseItemArray.GetCount()>0);
}
//分析麻将
bool CGameLogic::AnalyseCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)
{
CString strFile,strTemp;
CTime tmCur = CTime::GetCurrentTime();
CString strTime = tmCur.Format("%m%d");
strFile.Format("log\\%sAnalyseCard.log",strTime);
// 0, 1, 2
strTemp.Format("AnalyseCard cbWeaveCount=%d", cbWeaveCount);
WriteLog(strFile, strTemp);
//计算数目
BYTE cbCardCount=0;
BYTE i = 0;
for (i=0;i<MAX_INDEX;i++)
{
strTemp.Format("cbCardIndex[%d]=%d", i,cbCardIndex[i]);
// WriteLog(strFile, strTemp);
//0,1
cbCardCount+=cbCardIndex[i];
}//End if
strTemp.Format("AnalyseCard cbCardCount=%d", cbCardCount);
WriteLog(strFile, strTemp);
//效验数目
ASSERT((cbCardCount>=2)&&(cbCardCount<=MAX_COUNT)&&((cbCardCount-2)%3==0));
//11,14
if ((cbCardCount<2)||(cbCardCount>MAX_COUNT)||((cbCardCount-2)%3!=0))
{
strTemp.Format("AnalyseCard 返回！");
WriteLog(strFile, strTemp);
return false;
}
//变量定义
BYTE cbKindItemCount=0;
tagKindItem KindItem[MAX_COUNT-2];
ZeroMemory(KindItem,sizeof(KindItem));
//需求判断
BYTE cbLessKindItem=(cbCardCount-2)/3;
ASSERT((cbLessKindItem+cbWeaveCount)==4);
//3,4
strTemp.Format("cbLessKindItem=%d", cbLessKindItem);
WriteLog(strFile, strTemp);
//单吊判断
if (cbLessKindItem==0)
{
strTemp.Format("单吊判断");
WriteLog(strFile, strTemp);
//效验参数
ASSERT((cbCardCount==2)&&(cbWeaveCount==4));
//牌眼判断
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndex[i]==2)
{
//变量定义
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;
}//End for
AnalyseItem.cbCardEye=SwitchToCardData(i);
//插入结果
AnalyseItemArray.Add(AnalyseItem);
strTemp.Format("AnalyseCard 返回22！");
WriteLog(strFile, strTemp);
return true;
}//End if (cbCardIndex[i]==2)
}//End for (BYTE i=0;i<MAX_INDEX;i++)
strTemp.Format("AnalyseCard 返回2！");
WriteLog(strFile, strTemp);
return false;
}//End if
//拆分分析
if (cbCardCount>=3)
{
strTemp.Format("拆分分析");
WriteLog(strFile, strTemp);
for (BYTE i=0;i<MAX_INDEX;i++)
{
//同牌判断
if (cbCardIndex[i]>=3)
{
KindItem[cbKindItemCount].cbCenterCard=i;
KindItem[cbKindItemCount].cbCardIndex[0]=i;
KindItem[cbKindItemCount].cbCardIndex[1]=i;
KindItem[cbKindItemCount].cbCardIndex[2]=i;
KindItem[cbKindItemCount++].cbWeaveKind=WIK_PENG;
strTemp.Format("同牌判断");
WriteLog(strFile, strTemp);
}//End if (cbCardIndex[i]>=3)
//连牌判断
if ((i<(MAX_INDEX-2))&&(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].cbCenterCard=i;
KindItem[cbKindItemCount].cbCardIndex[0]=i;
KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
KindItem[cbKindItemCount++].cbWeaveKind=WIK_LEFT;
}//End if
}//End for (BYTE j=1;j<=cbCardIndex[i];j++)
strTemp.Format("连牌判断");
WriteLog(strFile, strTemp);
}//End if
}//End for (BYTE i=0;i<MAX_INDEX;i++)
}//End if (cbCardCount>=3)
strTemp.Format("cbKindItemCount=%d, cbLessKindItem=%d", cbKindItemCount,cbLessKindItem);
WriteLog(strFile, strTemp);
//组合分析
if (cbKindItemCount>=cbLessKindItem)
{
strTemp.Format("组合分析");
WriteLog(strFile, strTemp);
//变量定义
BYTE cbCardIndexTemp[MAX_INDEX];
ZeroMemory(cbCardIndexTemp,sizeof(cbCardIndexTemp));
//变量定义
BYTE cbIndex[4]={0,1,2,3};
tagKindItem * pKindItem[4];
ZeroMemory(&pKindItem,sizeof(pKindItem));
//开始组合
do
{
//设置变量
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
for (i=0;i<cbLessKindItem;i++) pKindItem[i]=&KindItem[cbIndex[i]];
//数量判断
bool bEnoughCard=true;
for (i=0;i<cbLessKindItem*3;i++)
{
//存在判断
BYTE cbCardIndex=pKindItem[i/3]->cbCardIndex[i%3];
if (cbCardIndexTemp[cbCardIndex]==0)
{
bEnoughCard=false;
break;
}
else cbCardIndexTemp[cbCardIndex]--;
}//End for (i=0;i<cbLessKindItem*3;i++)
//胡牌判断
if (bEnoughCard==true)
{
strTemp.Format("胡牌判断");
WriteLog(strFile, strTemp);
//牌眼判断
BYTE cbCardEye=0;
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndexTemp[i]==2)
{
cbCardEye=SwitchToCardData(i);
break;
}
}//End for
strTemp.Format("cbCardEye=%d", cbCardEye);
WriteLog(strFile, strTemp);
//组合类型
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;
}//End for
//设置牌型
for (BYTE i=0;i<cbLessKindItem;i++)
{
AnalyseItem.cbWeaveKind[i+cbWeaveCount]=pKindItem[i]->cbWeaveKind;
AnalyseItem.cbCenterCard[i+cbWeaveCount]=pKindItem[i]->cbCenterCard;
}//End for
//设置牌眼
AnalyseItem.cbCardEye=cbCardEye;
//插入结果
AnalyseItemArray.Add(AnalyseItem);
}//End if
}//End if (bEnoughCard==true)
//设置索引
if (cbIndex[cbLessKindItem-1]==(cbKindItemCount-1))
{
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);
}
return (AnalyseItemArray.GetCount()>0);
}
//吃胡分析
BYTE CGameLogic::AnalyseChiHuCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult & ChiHuResult)
{
CString strFile,strTemp;
CTime tmCur = CTime::GetCurrentTime();
CString strTime = tmCur.Format("%m%d");
strFile.Format("log\\%sAnalyseChiHuCard.log",strTime);
strTemp.Format("AnalyseChiHuCard cbWeaveCount=%d, cbCurrentCard=%d", cbWeaveCount, cbCurrentCard);
WriteLog(strFile, strTemp);
//变量定义
WORD wChiHuKind=CHK_NULL;
static CAnalyseItemArray AnalyseItemArray;
//设置变量
AnalyseItemArray.RemoveAll();
ZeroMemory(&ChiHuResult,sizeof(ChiHuResult));
//构造麻将
BYTE cbCardIndexTemp[MAX_INDEX];
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
//插入麻将
if (cbCurrentCard!=0) cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
//权位处理
if ((cbCurrentCard!=0)&&(cbWeaveCount==4)) wChiHuRight|=CHK_QUAN_QIU_REN;
if (IsQingYiSe(cbCardIndexTemp,WeaveItem,cbWeaveCount)==true) wChiHuRight|=CHK_QING_YI_SE;
strTemp.Format("wChiHuRight=%d", wChiHuRight);
WriteLog(strFile, strTemp);
//分析麻将
AnalyseCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,AnalyseItemArray);
strTemp.Format("AnalyseItemArray.GetCount()=%d", AnalyseItemArray.GetCount());
WriteLog(strFile, strTemp);
//胡牌分析
if (AnalyseItemArray.GetCount()>0)
{
//眼牌需求
bool bNeedSymbol=((wChiHuRight&0xFF00)==0);
bNeedSymbol = false;//固定
//牌型分析
for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)
{
//变量定义
bool bLianCard=false,bPengCard=false;
tagAnalyseItem * pAnalyseItem=&AnalyseItemArray[i];
//牌眼类型
BYTE cbEyeValue=pAnalyseItem->cbCardEye&MASK_VALUE;
//2,5,8将
bool bSymbolEye=((cbEyeValue==2)||(cbEyeValue==5)||(cbEyeValue==8));
//没有将！！
bSymbolEye = true;
//牌型分析
for (BYTE j=0;j<CountArray(pAnalyseItem->cbWeaveKind);j++)
{
BYTE cbWeaveKind=pAnalyseItem->cbWeaveKind[j];
bPengCard=((cbWeaveKind&(WIK_GANG|WIK_FILL|WIK_PENG))!=0)?true:bPengCard;
bLianCard=((cbWeaveKind&(WIK_LEFT|WIK_CENTER|WIK_RIGHT))!=0)?true:bLianCard;
}//End for
//牌型判断
ASSERT((bLianCard==true)||(bPengCard==true));
//碰碰牌型
if ((bLianCard==false)&&(bPengCard==true)) wChiHuKind|=CHK_PENG_PENG;
if ((bLianCard==true)&&(bPengCard==true)&&((bSymbolEye==true)||(bNeedSymbol==false))) wChiHuKind|=CHK_JI_HU;
if ((bLianCard==true)&&(bPengCard==false)&&((bSymbolEye==true)||(bNeedSymbol==false))) wChiHuKind|=CHK_PING_HU;
}//End for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)
}//End if (AnalyseItemArray.GetCount()>0)
//结果判断
if (wChiHuKind!=CHK_NULL)
{
//设置结果
ChiHuResult.wChiHuKind=wChiHuKind;
ChiHuResult.wChiHuRight=wChiHuRight;
return WIK_CHI_HU;
}
return WIK_NULL;
}
//吃胡分析
BYTE CGameLogic::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, CChiHuRight &ChiHuRight)
{
//变量定义
BYTE cbChiHuKind=WIK_NULL;
CAnalyseItemArray AnalyseItemArray;
//设置变量
AnalyseItemArray.RemoveAll();
ChiHuRight.SetEmpty();
//构造扑克
BYTE cbCardIndexTemp[MAX_INDEX];
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
//cbCurrentCard一定不为0 !!!!!!!!!
ASSERT( cbCurrentCard != 0 );
if( cbCurrentCard == 0 ) return WIK_NULL;
/*
// 特殊番型
*/
//七小对牌
if( IsQiXiaoDui(cbCardIndex,WeaveItem,cbWeaveCount,cbCurrentCard) )
ChiHuRight |= CHR_QI_XIAO_DUI;
if( !ChiHuRight.IsEmpty() )
cbChiHuKind = WIK_CHI_HU;
//插入扑克
if (cbCurrentCard!=0)
cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
//必须缺一门
if( IsHuaZhu(cbCardIndexTemp,WeaveItem,cbWeaveCount) ) return WIK_NULL;
//分析扑克
AnalyseCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,AnalyseItemArray);
//胡牌分析
if (AnalyseItemArray.GetCount()>0)
{
//
cbChiHuKind = WIK_CHI_HU;
//牌型分析
for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)
{
//变量定义
tagAnalyseItem * pAnalyseItem=&AnalyseItemArray[i];
/*
// 判断番型
*/
//碰碰和
if( IsPengPeng(pAnalyseItem) )
ChiHuRight |= CHR_DA_DUI_ZI;
//带幺
if( IsDaiYao(pAnalyseItem) )
ChiHuRight |= CHR_DAI_YAO;
//将对
if( IsJiangDui(pAnalyseItem) )
ChiHuRight |= CHR_JIANG_DUI;
}
}
//素番
if( cbChiHuKind == WIK_CHI_HU && ChiHuRight.IsEmpty() )
ChiHuRight |= CHR_SHU_FAN;
if( cbChiHuKind == WIK_CHI_HU )
{
//清一色牌
if( IsQingYiSe(cbCardIndex,WeaveItem,cbWeaveCount,cbCurrentCard) )
ChiHuRight |= CHR_QING_YI_SE;
}
return cbChiHuKind;
}
//吃胡分析
BYTE CGameLogic::AnalyseChiHuCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, DWORD dwChiHuRight, tagChiHuResult & ChiHuResult)
{
//变量定义
DWORD dwChiHuKind=CHK_NULL;
static CAnalyseItemArray AnalyseItemArray;
//设置变量
AnalyseItemArray.RemoveAll();
ZeroMemory(&ChiHuResult,sizeof(ChiHuResult));
//构造扑克
BYTE cbCardIndexTemp[MAX_INDEX];
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
//插入扑克
if (cbCurrentCard!=0)
cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
//权位处理
if ((cbCurrentCard!=0)&&(cbWeaveCount==4))
dwChiHuRight|=CHK_QUAN_QIU_REN;
//分析扑克
AnalyseCard(cbCardIndexTemp,WeaveItem,cbWeaveCount,AnalyseItemArray);
//胡牌分析
if (AnalyseItemArray.GetCount()>0)
{
//牌型分析
for (INT_PTR i=0;i<AnalyseItemArray.GetCount();i++)
{
//变量定义
bool bLianCard=false,bPengCard=false;
tagAnalyseItem * pAnalyseItem=&AnalyseItemArray[i];
//牌型分析
for (BYTE j=0;j<CountArray(pAnalyseItem->cbWeaveKind);j++)
{
BYTE cbWeaveKind=pAnalyseItem->cbWeaveKind[j];
bPengCard=((cbWeaveKind&(WIK_GANG|WIK_PENG))!=0)?true:bPengCard;
bLianCard=((cbWeaveKind&(WIK_LEFT|WIK_CENTER|WIK_RIGHT))!=0)?true:bLianCard;
}
//牌型判断
ASSERT((bLianCard==true)||(bPengCard==true));
//碰碰牌型
if ((bLianCard==false)&&(bPengCard==true))
dwChiHuKind|=CHK_PENG_PENG;
if ((bLianCard==true)&&(bPengCard==true))
dwChiHuKind|=CHK_JI_HU;
if ((bLianCard==true)&&(bPengCard==false))
dwChiHuKind|=CHK_PING_HU;
}
}
//牌权判断
if (IsQingYiSe(cbCardIndexTemp,WeaveItem,cbWeaveCount)==true) dwChiHuRight|=CHR_QING_YI_SE;
//大胡牌型
if (IsQiXiaoDui(cbCardIndexTemp,WeaveItem,cbWeaveCount)==true) dwChiHuKind|=CHK_QI_XIAO_DUI;
if (IsShiSanYao(cbCardIndexTemp,WeaveItem,cbWeaveCount)==true) dwChiHuKind|=CHK_SHI_SAN_YAO;
//结果判断
if (dwChiHuKind!=CHK_NULL)
{
//变量定义
WORD wGreatHuCount=0;
DWORD dwGreatKind=dwChiHuKind&CHK_MASK_GREAT;
DWORD dwGreatRight=dwChiHuRight&CHR_MASK_GREAT;
//番数统计
for (BYTE i=0;i<32;i++)
{
//设置变量
dwGreatKind>>=1;
dwGreatRight>>=1;
//结果判断
if ((dwGreatKind&0x00000001)!=0) wGreatHuCount++;
if ((dwGreatRight&0x00000001)!=0) wGreatHuCount++;
}
//设置牌型
ChiHuResult.dwChiHuKind=dwChiHuKind;
ChiHuResult.dwChiHuRight=dwChiHuRight;
//设置番数
if (wGreatHuCount==0) ChiHuResult.dwWinTimes=1;
else if (wGreatHuCount>=1) ChiHuResult.dwWinTimes=2;
return WIK_CHI_HU;
return WIK_CHI_HU;
}
