//分析扑克
bool CGameLogic::AnalyseCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
//设置结果
ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));
//花色判断
AnalyseResult.cbCardColor=GetCardLogicColor(cbCardData,cbCardCount);
if (AnalyseResult.cbCardColor==COLOR_ERROR) return false;
//变量定义
BYTE cbAnalyseCard[MAX_COUNT];
BYTE cbAnalyseCount=cbCardCount;
CopyMemory(cbAnalyseCard,cbCardData,cbCardCount*sizeof(BYTE));
//提取扑克
for (BYTE i=2; i>=2; i--)
{
//提取拖牌
tagTractorDataInfo * pTractorDataInfo=&AnalyseResult.TractorDataInfo[i-2];
DistillTrackorByCount(cbAnalyseCard,cbAnalyseCount,i,AnalyseResult.TractorDataInfo[i-2]);
//拖牌处理
if (pTractorDataInfo->cbTractorCount>0)
{
BYTE cbIndex=0,cbRemoveCount=0;
for (BYTE j=0; j<pTractorDataInfo->cbTractorCount; j++)
{
//变量计算
cbRemoveCount=pTractorDataInfo->cbTractorData[cbIndex]*i;
//删除扑克
cbAnalyseCount-=cbRemoveCount;
RemoveCard(&pTractorDataInfo->cbTractorData[cbIndex+2],cbRemoveCount,cbAnalyseCard,cbAnalyseCount+cbRemoveCount);
//设置变量
cbIndex+=cbRemoveCount+2;
}
}
//提取同牌
tagSameDataInfo * pSameDataInfo=&AnalyseResult.SameDataInfo[i-1];
DistillCardByCount(cbAnalyseCard,cbAnalyseCount,i,AnalyseResult.SameDataInfo[i-1]);
//删除扑克
if (pSameDataInfo->cbBlockCount>0)
{
cbAnalyseCount-=pSameDataInfo->cbCardCount;
RemoveCard(pSameDataInfo->cbSameData,pSameDataInfo->cbCardCount,cbAnalyseCard,cbAnalyseCount+pSameDataInfo->cbCardCount);
}
}
//提取单牌
AnalyseResult.SameDataInfo[0].cbCardCount=cbAnalyseCount;
AnalyseResult.SameDataInfo[0].cbBlockCount=cbAnalyseCount;
CopyMemory(AnalyseResult.SameDataInfo[0].cbSameData,cbAnalyseCard,cbAnalyseCount*sizeof(BYTE));
return true;
}
Card PlayingCards::RemoveCard(const Card &cCard)
{
return RemoveCard(cCard.Rank(), cCard.Suit());
}
//出牌搜索
bool CGameLogic::SearchOutCard(const BYTE cbHandCardData[], BYTE cbHandCardCount, const BYTE cbTurnCardData[], BYTE cbTurnCardCount, tagOutCardResult & OutCardResult)
{
//设置结果
ZeroMemory(&OutCardResult,sizeof(OutCardResult));
//构造扑克
BYTE cbCardData[MAX_COUNT];
BYTE cbCardCount=cbHandCardCount;
CopyMemory(cbCardData,cbHandCardData,sizeof(BYTE)*cbHandCardCount);
//排列扑克
SortCardList(cbCardData,cbCardCount,ST_ORDER);
//获取类型
BYTE cbTurnOutType=GetCardType(cbTurnCardData,cbTurnCardCount);
//出牌分析
switch (cbTurnOutType)
{
case CT_ERROR: //错误类型
{
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbCardData[cbCardCount-1]);
//多牌判断
BYTE cbSameCount=1;
for (BYTE i=1;i<cbCardCount;i++)
{
if (GetCardLogicValue(cbCardData[cbCardCount-i-1])==cbLogicValue) cbSameCount++;
else break;
}
//完成处理
if (cbSameCount>1)
{
OutCardResult.cbCardCount=cbSameCount;
for (BYTE j=0;j<cbSameCount;j++) OutCardResult.cbResultCard[j]=cbCardData[cbCardCount-1-j];
return true;
}
//单牌处理
OutCardResult.cbCardCount=1;
OutCardResult.cbResultCard[0]=cbCardData[cbCardCount-1];
return true;
}
case CT_SINGLE: //单牌类型
case CT_DOUBLE: //对牌类型
case CT_THREE: //三条类型
{
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//分析扑克
tagAnalyseResult AnalyseResult;
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
//寻找单牌
if (cbTurnCardCount<=1)
{
for (BYTE i=0;i<AnalyseResult.cbSignedCount;i++)
{
BYTE cbIndex=AnalyseResult.cbSignedCount-i-1;
if (GetCardLogicValue(AnalyseResult.cbSignedCardData[cbIndex])>cbLogicValue)
{
//设置结果
OutCardResult.cbCardCount=cbTurnCardCount;
CopyMemory(OutCardResult.cbResultCard,&AnalyseResult.cbSignedCardData[cbIndex],sizeof(BYTE)*cbTurnCardCount);
return true;
}
}
}
//寻找对牌
if (cbTurnCardCount<=2)
{
for (BYTE i=0;i<AnalyseResult.cbDoubleCount;i++)
{
BYTE cbIndex=(AnalyseResult.cbDoubleCount-i-1)*2;
if (GetCardLogicValue(AnalyseResult.cbDoubleCardData[cbIndex])>cbLogicValue)
{
//设置结果
OutCardResult.cbCardCount=cbTurnCardCount;
CopyMemory(OutCardResult.cbResultCard,&AnalyseResult.cbDoubleCardData[cbIndex],sizeof(BYTE)*cbTurnCardCount);
return true;
}
}
}
//寻找三牌
if (cbTurnCardCount<=3)
{
for (BYTE i=0;i<AnalyseResult.cbThreeCount;i++)
{
BYTE cbIndex=(AnalyseResult.cbThreeCount-i-1)*3;
if (GetCardLogicValue(AnalyseResult.cbThreeCardData[cbIndex])>cbLogicValue)
{
//设置结果
OutCardResult.cbCardCount=cbTurnCardCount;
CopyMemory(OutCardResult.cbResultCard,&AnalyseResult.cbThreeCardData[cbIndex],sizeof(BYTE)*cbTurnCardCount);
return true;
}
}
}
break;
}
case CT_SINGLE_LINE: //单连类型
{
//长度判断
if (cbCardCount<cbTurnCardCount) break;
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//搜索连牌
for (BYTE i=(cbTurnCardCount-1);i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue>=15) break;
if (cbHandLogicValue<=cbLogicValue) continue;
//搜索连牌
BYTE cbLineCount=0;
for (BYTE j=(cbCardCount-i-1);j<cbCardCount;j++)
{
if ((GetCardLogicValue(cbCardData[j])+cbLineCount)==cbHandLogicValue)
{
//增加连数
OutCardResult.cbResultCard[cbLineCount++]=cbCardData[j];
//完成判断
if (cbLineCount==cbTurnCardCount)
{
OutCardResult.cbCardCount=cbTurnCardCount;
return true;
}
}
}
}
break;
}
case CT_DOUBLE_LINE: //对连类型
{
//长度判断
if (cbCardCount<cbTurnCardCount) break;
//获取数值
BYTE cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//搜索连牌
for (BYTE i=(cbTurnCardCount-1);i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue<=cbLogicValue) continue;
if ((cbTurnCardCount>1)&&(cbHandLogicValue>=15)) break;
//搜索连牌
BYTE cbLineCount=0;
for (BYTE j=(cbCardCount-i-1);j<(cbCardCount-1);j++)
{
if (((GetCardLogicValue(cbCardData[j])+cbLineCount)==cbHandLogicValue)
&&((GetCardLogicValue(cbCardData[j+1])+cbLineCount)==cbHandLogicValue))
{
//增加连数
OutCardResult.cbResultCard[cbLineCount*2]=cbCardData[j];
OutCardResult.cbResultCard[(cbLineCount++)*2+1]=cbCardData[j+1];
//完成判断
if (cbLineCount*2==cbTurnCardCount)
{
OutCardResult.cbCardCount=cbTurnCardCount;
return true;
}
}
}
}
break;
}
case CT_THREE_LINE: //三连类型
case CT_THREE_LINE_TAKE_ONE: //三带一单
case CT_THREE_LINE_TAKE_TWO: //三带一对
{
//长度判断
if (cbCardCount<cbTurnCardCount) break;
//获取数值
BYTE cbLogicValue=0;
for (BYTE i=0;i<cbTurnCardCount-2;i++)
{
cbLogicValue=GetCardLogicValue(cbTurnCardData[i]);
if (GetCardLogicValue(cbTurnCardData[i+1])!=cbLogicValue) continue;
if (GetCardLogicValue(cbTurnCardData[i+2])!=cbLogicValue) continue;
break;
}
//属性数值
BYTE cbTurnLineCount=0;
if (cbTurnOutType==CT_THREE_LINE_TAKE_ONE) cbTurnLineCount=cbTurnCardCount/4;
else if (cbTurnOutType==CT_THREE_LINE_TAKE_TWO) cbTurnLineCount=cbTurnCardCount/5;
else cbTurnLineCount=cbTurnCardCount/3;
//搜索连牌
for (BYTE i=cbTurnLineCount*3-1;i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue<=cbLogicValue) continue;
if ((cbTurnLineCount>1)&&(cbHandLogicValue>=15)) break;
//搜索连牌
BYTE cbLineCount=0;
for (BYTE j=(cbCardCount-i-1);j<(cbCardCount-2);j++)
{
//设置变量
OutCardResult.cbCardCount=0;
//三牌判断
if ((GetCardLogicValue(cbCardData[j])+cbLineCount)!=cbHandLogicValue) continue;
if ((GetCardLogicValue(cbCardData[j+1])+cbLineCount)!=cbHandLogicValue) continue;
if ((GetCardLogicValue(cbCardData[j+2])+cbLineCount)!=cbHandLogicValue) continue;
//增加连数
OutCardResult.cbResultCard[cbLineCount*3]=cbCardData[j];
OutCardResult.cbResultCard[cbLineCount*3+1]=cbCardData[j+1];
OutCardResult.cbResultCard[(cbLineCount++)*3+2]=cbCardData[j+2];
//完成判断
if (cbLineCount==cbTurnLineCount)
{
//连牌设置
OutCardResult.cbCardCount=cbLineCount*3;
//构造扑克
BYTE cbLeftCardData[MAX_COUNT];
BYTE cbLeftCount=cbCardCount-OutCardResult.cbCardCount;
CopyMemory(cbLeftCardData,cbCardData,sizeof(BYTE)*cbCardCount);
RemoveCard(OutCardResult.cbResultCard,OutCardResult.cbCardCount,cbLeftCardData,cbCardCount);
//分析扑克
tagAnalyseResult AnalyseResultLeft;
AnalysebCardData(cbLeftCardData,cbLeftCount,AnalyseResultLeft);
//单牌处理
if (cbTurnOutType==CT_THREE_LINE_TAKE_ONE)
{
//提取单牌
for (BYTE k=0;k<AnalyseResultLeft.cbSignedCount;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=AnalyseResultLeft.cbSignedCount-k-1;
BYTE cbSignedCard=AnalyseResultLeft.cbSignedCardData[cbIndex];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbSignedCard;
}
//提取对牌
for (BYTE k=0;k<AnalyseResultLeft.cbDoubleCount*2;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=(AnalyseResultLeft.cbDoubleCount*2-k-1);
BYTE cbSignedCard=AnalyseResultLeft.cbDoubleCardData[cbIndex];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbSignedCard;
}
//提取三牌
for (BYTE k=0;k<AnalyseResultLeft.cbThreeCount*3;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=(AnalyseResultLeft.cbThreeCount*3-k-1);
BYTE cbSignedCard=AnalyseResultLeft.cbThreeCardData[cbIndex];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbSignedCard;
}
//提取四牌
for (BYTE k=0;k<AnalyseResultLeft.cbFourCount*4;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=(AnalyseResultLeft.cbFourCount*4-k-1);
BYTE cbSignedCard=AnalyseResultLeft.cbFourCardData[cbIndex];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbSignedCard;
}
}
//对牌处理
if (cbTurnOutType==CT_THREE_LINE_TAKE_TWO)
{
//提取对牌
for (BYTE k=0;k<AnalyseResultLeft.cbDoubleCount;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=(AnalyseResultLeft.cbDoubleCount-k-1)*2;
BYTE cbCardData1=AnalyseResultLeft.cbDoubleCardData[cbIndex];
BYTE cbCardData2=AnalyseResultLeft.cbDoubleCardData[cbIndex+1];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData1;
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData2;
}
//提取三牌
for (BYTE k=0;k<AnalyseResultLeft.cbThreeCount;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=(AnalyseResultLeft.cbThreeCount-k-1)*3;
BYTE cbCardData1=AnalyseResultLeft.cbThreeCardData[cbIndex];
BYTE cbCardData2=AnalyseResultLeft.cbThreeCardData[cbIndex+1];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData1;
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData2;
}
//提取四牌
for (BYTE k=0;k<AnalyseResultLeft.cbFourCount;k++)
{
//中止判断
if (OutCardResult.cbCardCount==cbTurnCardCount) break;
//设置扑克
BYTE cbIndex=(AnalyseResultLeft.cbFourCount-k-1)*4;
BYTE cbCardData1=AnalyseResultLeft.cbFourCardData[cbIndex];
BYTE cbCardData2=AnalyseResultLeft.cbFourCardData[cbIndex+1];
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData1;
OutCardResult.cbResultCard[OutCardResult.cbCardCount++]=cbCardData2;
}
}
//完成判断
if (OutCardResult.cbCardCount==cbTurnCardCount) return true;
}
}
}
break;
}
}
//搜索炸弹
if ((cbCardCount>=4)&&(cbTurnOutType!=CT_MISSILE_CARD))
{
//变量定义
BYTE cbLogicValue=0;
if (cbTurnOutType==CT_BOMB_CARD) cbLogicValue=GetCardLogicValue(cbTurnCardData[0]);
//搜索炸弹
for (BYTE i=3;i<cbCardCount;i++)
{
//获取数值
BYTE cbHandLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
//构造判断
if (cbHandLogicValue<=cbLogicValue) continue;
//炸弹判断
BYTE cbTempLogicValue=GetCardLogicValue(cbCardData[cbCardCount-i-1]);
BYTE j=1;
for (;j<4;j++)
{
if (GetCardLogicValue(cbCardData[cbCardCount+j-i-1])!=cbTempLogicValue) break;
}
if (j!=4) continue;
//设置结果
OutCardResult.cbCardCount=4;
OutCardResult.cbResultCard[0]=cbCardData[cbCardCount-i-1];
OutCardResult.cbResultCard[1]=cbCardData[cbCardCount-i];
OutCardResult.cbResultCard[2]=cbCardData[cbCardCount-i+1];
OutCardResult.cbResultCard[3]=cbCardData[cbCardCount-i+2];
return true;
}
}
//搜索火箭
if ((cbCardCount>=2)&&(cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E))
{
//设置结果
OutCardResult.cbCardCount=2;
OutCardResult.cbResultCard[0]=cbCardData[0];
OutCardResult.cbResultCard[1]=cbCardData[1];
return true;
}
return false;
}
//模拟操作
void CAndroidAIBase::SetAction( BYTE byActionMask,BYTE byActionCard )
{
//验证
ASSERT( byActionCard >=0 && byActionCard < 34 );
//枚举
BYTE byIndex = 0xff;
switch( byActionMask )
{
case WIK_LEFT:
{
m_nActionScore = 300;
byIndex = FindIndex(byActionCard+1);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard+2);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
break;
}
case WIK_CENTER:
{
m_nActionScore = 300;
byIndex = FindIndex(byActionCard-1);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard+1);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
break;
}
case WIK_RIGHT:
{
m_nActionScore = 300;
byIndex = FindIndex(byActionCard-2);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard-1);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
break;
}
case WIK_PENG:
{
m_nActionScore = 300;
byIndex = FindIndex(byActionCard);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
break;
}
case WIK_GANG:
{
m_nActionScore = 300;
byIndex = FindIndex(byActionCard);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard);
if( byIndex != 0xff )
{
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard);
ASSERT( byIndex != 0xff );
VERIFY( RemoveCard(byIndex) );
byIndex = FindIndex(byActionCard);
if( byIndex != 0xff )
VERIFY( RemoveCard(byIndex) );
}
break;
}
default:
ASSERT( FALSE );
}
}
//出牌判断
bool CGameLogic::SearchOutCard(const BYTE cbHandCardData[], BYTE cbHandCardCount,const BYTE cbTurnCardData[], BYTE cbTurnCardCount, tagOutCardResult & OutCardResult)
{
//设置变量
ZeroMemory(&OutCardResult,sizeof(OutCardResult));
//首出用户
if (cbTurnCardCount==0)
{
for (BYTE i=2; i>=2; i--)
{
//提取拖牌
tagTractorDataInfo TractorDataInfo;
DistillTrackorByCount(cbHandCardData,cbHandCardCount,i,TractorDataInfo);
//拖牌判断
if (TractorDataInfo.cbTractorCount>0)
{
//获取属性
BYTE cbLineCount=TractorDataInfo.cbTractorData[0];
BYTE cbSameCount=TractorDataInfo.cbTractorData[1];
//构造结果
OutCardResult.cbCardCount=cbLineCount*cbSameCount;
CopyMemory(OutCardResult.cbResultCard,&TractorDataInfo.cbTractorData[2],sizeof(BYTE)*OutCardResult.cbCardCount);
return true;
}
//提取同牌
tagSameDataInfo SameDataInfo;
DistillCardByCount(cbHandCardData,cbHandCardCount,i,SameDataInfo);
//同牌判断
if (SameDataInfo.cbCardCount>0)
{
//构造结果
OutCardResult.cbCardCount=i;
CopyMemory(OutCardResult.cbResultCard,&SameDataInfo.cbSameData[0],sizeof(BYTE)*i);
return true;
}
}
//提取单牌
OutCardResult.cbCardCount=1;
OutCardResult.cbResultCard[0]=cbHandCardData[0];
return true;
}
//分析扑克
tagAnalyseResult AnalyseResult;
AnalyseCardData(cbTurnCardData,cbTurnCardCount,AnalyseResult);
//提取扑克
BYTE cbAnalyseCard[MAX_COUNT];
BYTE cbAnalyseCardCount=DistillCardByColor(cbHandCardData,cbHandCardCount,GetCardLogicColor(cbTurnCardData[0]),cbAnalyseCard);
//数目判断
if (cbTurnCardCount>=cbAnalyseCardCount)
{
//构造扑克
OutCardResult.cbCardCount=cbAnalyseCardCount;
CopyMemory(OutCardResult.cbResultCard,cbAnalyseCard,sizeof(BYTE)*cbAnalyseCardCount);
//剩余扑克
if (cbTurnCardCount>cbAnalyseCardCount)
{
//变量定义
BYTE cbSourceCount=OutCardResult.cbCardCount;
BYTE cbLeaveCount=(cbTurnCardCount-cbAnalyseCardCount);
//构造扑克
BYTE cbCardDataTemp[MAX_COUNT];
BYTE cbCardCountTemp=cbHandCardCount;
CopyMemory(cbCardDataTemp,cbHandCardData,sizeof(BYTE)*cbHandCardCount);
//删除扑克
cbCardCountTemp-=cbAnalyseCardCount;
RemoveCard(cbAnalyseCard,cbAnalyseCardCount,cbCardDataTemp,cbCardCountTemp+cbAnalyseCardCount);
//构造结果
OutCardResult.cbCardCount+=cbLeaveCount;
CopyMemory(&OutCardResult.cbResultCard[cbSourceCount],&cbCardDataTemp[cbCardCountTemp-cbLeaveCount],sizeof(BYTE)*cbLeaveCount);
}
return true;
}
//需求变量
tagDemandInfo DemandInfo;
ZeroMemory(&DemandInfo,sizeof(DemandInfo));
//需求分析
for (BYTE i=2; i>=2; i--)
{
//变量定义
tagSameDataInfo * pSameDataInfo=&AnalyseResult.SameDataInfo[i-1];
tagTractorDataInfo * pTractorDataInfo=&AnalyseResult.TractorDataInfo[i-2];
//拖牌需求
if (pTractorDataInfo->cbTractorCount>0)
{
DemandInfo.cbTractorCardCount[i-2]=pTractorDataInfo->cbCardCount;
DemandInfo.cbMaxTractor[i-2]=pTractorDataInfo->cbTractorMaxLength;
}
//同牌需求
if (pSameDataInfo->cbBlockCount>0) DemandInfo.cbSameCardCount[i-1]=pSameDataInfo->cbCardCount;
}
//单牌需求
if (AnalyseResult.SameDataInfo[0].cbCardCount>0) DemandInfo.cbSameCardCount[0]=AnalyseResult.SameDataInfo[0].cbCardCount;
//出牌搜索
for (BYTE i=2; i>=2; i--)
{
//拖牌判断
if (DemandInfo.cbTractorCardCount[i-2]>0)
{
//提取拖牌
tagTractorDataInfo TractorDataInfo;
DistillTrackorByCount(cbAnalyseCard,cbAnalyseCardCount,i,TractorDataInfo);
//变量定义
BYTE cbIndex=0;
BYTE cbLeaveCount=DemandInfo.cbTractorCardCount[i-2];
//提取扑克
for (BYTE j=0; j<TractorDataInfo.cbTractorCount; j++)
{
//调整索引
if (j==0) cbIndex=TractorDataInfo.cbTractorMaxIndex;
if ((j==1)&&(TractorDataInfo.cbTractorMaxIndex!=0)) cbIndex=0;
//调整索引
if ((j!=0)&&(cbIndex==TractorDataInfo.cbTractorMaxIndex))
{
//获取属性
BYTE cbLineCount=TractorDataInfo.cbTractorData[cbIndex];
BYTE cbSameCount=TractorDataInfo.cbTractorData[cbIndex+1];
//设置索引
cbIndex+=cbLineCount*cbSameCount+2;
}
//获取属性
BYTE cbLineCount=TractorDataInfo.cbTractorData[cbIndex];
BYTE cbSameCount=TractorDataInfo.cbTractorData[cbIndex+1];
//提取变量
BYTE cbTractorCardCount=cbLineCount*cbSameCount;
BYTE cbTakeCardCount=__min(cbTractorCardCount,cbLeaveCount);
//提取扑克
OutCardResult.cbCardCount+=cbTakeCardCount;
CopyMemory(&OutCardResult.cbResultCard[OutCardResult.cbCardCount-cbTakeCardCount],
&TractorDataInfo.cbTractorData[cbIndex+2+cbTractorCardCount-cbTakeCardCount],sizeof(BYTE)*cbTakeCardCount);
//删除扑克
cbLeaveCount-=cbTakeCardCount;
cbAnalyseCardCount-=cbTakeCardCount;
RemoveCard(&TractorDataInfo.cbTractorData[cbIndex+2+cbTractorCardCount-cbTakeCardCount],cbTakeCardCount,
cbAnalyseCard,cbAnalyseCardCount+cbTakeCardCount);
//设置索引
cbIndex+=cbLineCount*cbSameCount+2;
}
//设置需求
DemandInfo.cbSameCardCount[i-1]+=cbLeaveCount;
}
//同牌判断
if (DemandInfo.cbSameCardCount[i-1]>0)
{
//提取同牌
tagSameDataInfo SameDataInfo;
DistillCardByCount(cbAnalyseCard,cbAnalyseCardCount,i,SameDataInfo);
//提取分析
BYTE cbTakeCardCount=__min(SameDataInfo.cbCardCount,DemandInfo.cbSameCardCount[i-1]);
cbTakeCardCount=cbTakeCardCount-cbTakeCardCount%i;
//构造结果
OutCardResult.cbCardCount+=cbTakeCardCount;
CopyMemory(&OutCardResult.cbResultCard[OutCardResult.cbCardCount-cbTakeCardCount],
&SameDataInfo.cbSameData[SameDataInfo.cbCardCount-cbTakeCardCount],sizeof(BYTE)*cbTakeCardCount);
//删除扑克
cbAnalyseCardCount-=cbTakeCardCount;
RemoveCard(&SameDataInfo.cbSameData[SameDataInfo.cbCardCount-cbTakeCardCount],cbTakeCardCount,cbAnalyseCard,cbAnalyseCardCount+cbTakeCardCount);
//设置需求
DemandInfo.cbSameCardCount[i-2]+=(DemandInfo.cbSameCardCount[i-1]-cbTakeCardCount);
}
}
//提取单牌
if (DemandInfo.cbSameCardCount[0]>0)
{
//变量定义
BYTE cbSourceCount=OutCardResult.cbCardCount;
BYTE cbLeaveCount=DemandInfo.cbSameCardCount[0];
//构造结果
OutCardResult.cbCardCount+=cbLeaveCount;
CopyMemory(&OutCardResult.cbResultCard[cbSourceCount],&cbAnalyseCard[cbAnalyseCardCount-cbLeaveCount],sizeof(BYTE)*cbLeaveCount);
}
return true;
}
