1376 lines
39 KiB
C++
1376 lines
39 KiB
C++
#include "DDZ_GameLogic.h"
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
//静态变量
|
|
|
|
//索引变量
|
|
const uint8 cbIndexCount=5;
|
|
|
|
//扑克数据
|
|
const uint8 CDDZGameLogic::m_cbCardData[DDZ_FULL_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
|
|
0x4E,0x4F,
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//构造函数
|
|
CDDZGameLogic::CDDZGameLogic()
|
|
{
|
|
}
|
|
|
|
//析构函数
|
|
CDDZGameLogic::~CDDZGameLogic()
|
|
{
|
|
}
|
|
|
|
//获取类型
|
|
uint8 CDDZGameLogic::GetCardType(const uint8 cbCardData[], uint8 cbCardCount)
|
|
{
|
|
//简单牌型
|
|
switch (cbCardCount)
|
|
{
|
|
case 0: //空牌
|
|
{
|
|
return DDZ_CT_ERROR;
|
|
}
|
|
case 1: //单牌
|
|
{
|
|
return DDZ_CT_SINGLE;
|
|
}
|
|
case 2: //对牌火箭
|
|
{
|
|
//牌型判断
|
|
if ((cbCardData[0] == 0x4F) && (cbCardData[1] == 0x4E)) return DDZ_CT_MISSILE_CARD;
|
|
if (GetCardLogicValue(cbCardData[0]) == GetCardLogicValue(cbCardData[1])) return DDZ_CT_DOUBLE;
|
|
|
|
return DDZ_CT_ERROR;
|
|
}
|
|
}
|
|
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult;
|
|
AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);
|
|
|
|
//四牌判断
|
|
if (AnalyseResult.cbBlockCount[3] > 0)
|
|
{
|
|
//牌型判断
|
|
if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount == 4)) return DDZ_CT_BOMB_CARD;
|
|
if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount == 6)) return DDZ_CT_FOUR_TAKE_ONE;
|
|
if ((AnalyseResult.cbBlockCount[3] == 1) && (cbCardCount == 8) && (AnalyseResult.cbBlockCount[1] == 2)) return DDZ_CT_FOUR_TAKE_TWO;
|
|
|
|
return DDZ_CT_ERROR;
|
|
}
|
|
|
|
//三牌判断
|
|
if (AnalyseResult.cbBlockCount[2] > 0)
|
|
{
|
|
//连牌判断
|
|
if (AnalyseResult.cbBlockCount[2] > 1)
|
|
{
|
|
//变量定义
|
|
uint8 cbCardData = AnalyseResult.cbCardData[2][0];
|
|
uint8 cbFirstLogicValue = GetCardLogicValue(cbCardData);
|
|
|
|
//错误过虑
|
|
if (cbFirstLogicValue >= 15) return DDZ_CT_ERROR;
|
|
|
|
//连牌判断
|
|
for (uint8 i = 1; i < AnalyseResult.cbBlockCount[2]; i++)
|
|
{
|
|
uint8 cbCardData = AnalyseResult.cbCardData[2][i * 3];
|
|
if (cbFirstLogicValue != (GetCardLogicValue(cbCardData) + i)) return DDZ_CT_ERROR;
|
|
}
|
|
}
|
|
else if (cbCardCount == 3) return DDZ_CT_THREE;
|
|
|
|
//牌形判断
|
|
if (AnalyseResult.cbBlockCount[2] * 3 == cbCardCount) return DDZ_CT_THREE_LINE;
|
|
if (AnalyseResult.cbBlockCount[2] * 4 == cbCardCount) return DDZ_CT_THREE_TAKE_ONE;
|
|
if ((AnalyseResult.cbBlockCount[2] * 5 == cbCardCount) && (AnalyseResult.cbBlockCount[1] == AnalyseResult.cbBlockCount[2])) return DDZ_CT_THREE_TAKE_TWO;
|
|
|
|
return DDZ_CT_ERROR;
|
|
}
|
|
|
|
//两张类型
|
|
if (AnalyseResult.cbBlockCount[1] >= 3)
|
|
{
|
|
//变量定义
|
|
uint8 cbCardData = AnalyseResult.cbCardData[1][0];
|
|
uint8 cbFirstLogicValue = GetCardLogicValue(cbCardData);
|
|
|
|
//错误过虑
|
|
if (cbFirstLogicValue >= 15) return DDZ_CT_ERROR;
|
|
|
|
//连牌判断
|
|
for (uint8 i = 1; i < AnalyseResult.cbBlockCount[1]; i++)
|
|
{
|
|
uint8 cbCardData = AnalyseResult.cbCardData[1][i * 2];
|
|
if (cbFirstLogicValue != (GetCardLogicValue(cbCardData) + i)) return DDZ_CT_ERROR;
|
|
}
|
|
|
|
//二连判断
|
|
if ((AnalyseResult.cbBlockCount[1] * 2) == cbCardCount) return DDZ_CT_DOUBLE_LINE;
|
|
|
|
return DDZ_CT_ERROR;
|
|
}
|
|
|
|
//单张判断
|
|
if ((AnalyseResult.cbBlockCount[0] >= 5) && (AnalyseResult.cbBlockCount[0] == cbCardCount))
|
|
{
|
|
//变量定义
|
|
uint8 cbCardData = AnalyseResult.cbCardData[0][0];
|
|
uint8 cbFirstLogicValue = GetCardLogicValue(cbCardData);
|
|
|
|
//错误过虑
|
|
if (cbFirstLogicValue >= 15) return DDZ_CT_ERROR;
|
|
|
|
//连牌判断
|
|
for (uint8 i = 1; i < AnalyseResult.cbBlockCount[0]; i++)
|
|
{
|
|
uint8 cbCardData = AnalyseResult.cbCardData[0][i];
|
|
if (cbFirstLogicValue != (GetCardLogicValue(cbCardData) + i)) return DDZ_CT_ERROR;
|
|
}
|
|
|
|
return DDZ_CT_SINGLE_LINE;
|
|
}
|
|
|
|
return DDZ_CT_ERROR;
|
|
}
|
|
|
|
//排列扑克
|
|
void CDDZGameLogic::SortCardList(uint8 cbCardData[], uint8 cbCardCount, uint8 cbSortType)
|
|
{
|
|
//数目过虑
|
|
if (cbCardCount==0) return;
|
|
if (cbSortType == DDZ_ST_CUSTOM) return;
|
|
|
|
//转换数值
|
|
uint8 cbSortValue[DDZ_MAX_COUNT];
|
|
for (uint8 i=0;i<cbCardCount;i++)
|
|
{
|
|
cbSortValue[i]=GetCardLogicValue(cbCardData[i]);
|
|
}
|
|
|
|
//排序操作
|
|
bool bSorted=true;
|
|
uint8 cbSwitchData=0,cbLast=cbCardCount-1;
|
|
do
|
|
{
|
|
bSorted=true;
|
|
for (uint8 i=0;i<cbLast;i++)
|
|
{
|
|
if ((cbSortValue[i]<cbSortValue[i+1])||
|
|
((cbSortValue[i]==cbSortValue[i+1])&&(cbCardData[i]<cbCardData[i+1])))
|
|
{
|
|
//设置标志
|
|
bSorted=false;
|
|
|
|
//扑克数据
|
|
cbSwitchData=cbCardData[i];
|
|
cbCardData[i]=cbCardData[i+1];
|
|
cbCardData[i+1]=cbSwitchData;
|
|
|
|
//排序权位
|
|
cbSwitchData=cbSortValue[i];
|
|
cbSortValue[i]=cbSortValue[i+1];
|
|
cbSortValue[i+1]=cbSwitchData;
|
|
}
|
|
}
|
|
cbLast--;
|
|
} while(bSorted==false);
|
|
|
|
//数目排序
|
|
if (cbSortType == DDZ_ST_COUNT)
|
|
{
|
|
//变量定义
|
|
uint8 cbCardIndex=0;
|
|
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult;
|
|
AnalysebCardData(&cbCardData[cbCardIndex],cbCardCount-cbCardIndex,AnalyseResult);
|
|
|
|
//提取扑克
|
|
for (uint8 i=0;i<CountArray(AnalyseResult.cbBlockCount);i++)
|
|
{
|
|
//拷贝扑克
|
|
uint8 cbIndex=CountArray(AnalyseResult.cbBlockCount)-i-1;
|
|
memcpy(&cbCardData[cbCardIndex],AnalyseResult.cbCardData[cbIndex],AnalyseResult.cbBlockCount[cbIndex]*(cbIndex+1)*sizeof(uint8));
|
|
|
|
//设置索引
|
|
cbCardIndex+=AnalyseResult.cbBlockCount[cbIndex]*(cbIndex+1)*sizeof(uint8);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//混乱扑克
|
|
void CDDZGameLogic::RandCardList(uint8 cbCardBuffer[], uint8 cbBufferCount)
|
|
{
|
|
//混乱准备
|
|
uint8 cbCardData[CountArray(m_cbCardData)];
|
|
memcpy(cbCardData,m_cbCardData,sizeof(m_cbCardData));
|
|
|
|
//混乱扑克
|
|
uint8 cbRandCount=0,cbPosition=0;
|
|
do
|
|
{
|
|
cbPosition=rand()%(cbBufferCount-cbRandCount);
|
|
cbCardBuffer[cbRandCount++]=cbCardData[cbPosition];
|
|
cbCardData[cbPosition]=cbCardData[cbBufferCount-cbRandCount];
|
|
} while (cbRandCount<cbBufferCount);
|
|
|
|
return;
|
|
}
|
|
|
|
//删除扑克
|
|
bool CDDZGameLogic::RemoveCardList(const uint8 cbRemoveCard[], uint8 cbRemoveCount, uint8 cbCardData[], uint8 cbCardCount)
|
|
{
|
|
//检验数据
|
|
assert(cbRemoveCount<=cbCardCount);
|
|
|
|
//定义变量
|
|
uint8 cbDeleteCount=0,cbTempCardData[DDZ_MAX_COUNT];
|
|
if (cbCardCount>CountArray(cbTempCardData)) return false;
|
|
memcpy(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));
|
|
|
|
//置零扑克
|
|
for (uint8 i=0;i<cbRemoveCount;i++)
|
|
{
|
|
for (uint8 j=0;j<cbCardCount;j++)
|
|
{
|
|
if (cbRemoveCard[i]==cbTempCardData[j])
|
|
{
|
|
cbDeleteCount++;
|
|
cbTempCardData[j]=0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (cbDeleteCount!=cbRemoveCount) return false;
|
|
|
|
//清理扑克
|
|
uint8 cbCardPos=0;
|
|
for (uint8 i=0;i<cbCardCount;i++)
|
|
{
|
|
if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//删除扑克
|
|
bool CDDZGameLogic::RemoveCard(const uint8 cbRemoveCard[], uint8 cbRemoveCount, uint8 cbCardData[], uint8 cbCardCount)
|
|
{
|
|
//检验数据
|
|
assert(cbRemoveCount<=cbCardCount);
|
|
|
|
//定义变量
|
|
uint8 cbDeleteCount=0,cbTempCardData[DDZ_MAX_COUNT];
|
|
if (cbCardCount>CountArray(cbTempCardData)) return false;
|
|
memcpy(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));
|
|
|
|
//置零扑克
|
|
for (uint8 i=0;i<cbRemoveCount;i++)
|
|
{
|
|
for (uint8 j=0;j<cbCardCount;j++)
|
|
{
|
|
if (cbRemoveCard[i]==cbTempCardData[j])
|
|
{
|
|
cbDeleteCount++;
|
|
cbTempCardData[j]=0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (cbDeleteCount!=cbRemoveCount) return false;
|
|
|
|
//清理扑克
|
|
uint8 cbCardPos=0;
|
|
for (uint8 i=0;i<cbCardCount;i++)
|
|
{
|
|
if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//排列扑克
|
|
void CDDZGameLogic::SortOutCardList(uint8 cbCardData[], uint8 cbCardCount)
|
|
{
|
|
//获取牌型
|
|
uint8 cbCardType = GetCardType(cbCardData, cbCardCount);
|
|
|
|
if (cbCardType == DDZ_CT_THREE_TAKE_ONE || cbCardType == DDZ_CT_THREE_TAKE_TWO)
|
|
{
|
|
//分析牌
|
|
tagAnalyseResult AnalyseResult = {};
|
|
AnalysebCardData( cbCardData,cbCardCount,AnalyseResult );
|
|
|
|
cbCardCount = AnalyseResult.cbBlockCount[2]*3;
|
|
memcpy( cbCardData,AnalyseResult.cbCardData[2],sizeof(uint8)*cbCardCount );
|
|
for( int i = CountArray(AnalyseResult.cbBlockCount)-1; i >= 0; i-- )
|
|
{
|
|
if( i == 2 ) continue;
|
|
|
|
if( AnalyseResult.cbBlockCount[i] > 0 )
|
|
{
|
|
memcpy( &cbCardData[cbCardCount],AnalyseResult.cbCardData[i],
|
|
sizeof(uint8)*(i+1)*AnalyseResult.cbBlockCount[i] );
|
|
cbCardCount += (i+1)*AnalyseResult.cbBlockCount[i];
|
|
}
|
|
}
|
|
}
|
|
else if (cbCardType == DDZ_CT_FOUR_TAKE_ONE || cbCardType == DDZ_CT_FOUR_TAKE_TWO)
|
|
{
|
|
//分析牌
|
|
tagAnalyseResult AnalyseResult = {};
|
|
AnalysebCardData( cbCardData,cbCardCount,AnalyseResult );
|
|
|
|
cbCardCount = AnalyseResult.cbBlockCount[3]*4;
|
|
//memcpy(cbCardData, AnalyseResult.cbCardData[3], sizeof(uint8)*cbCardCount);
|
|
memcpy( cbCardData,AnalyseResult.cbCardData[3],sizeof(uint8)*cbCardCount );
|
|
for( int i = CountArray(AnalyseResult.cbBlockCount)-1; i >= 0; i-- )
|
|
{
|
|
if( i == 3 ) continue;
|
|
|
|
if( AnalyseResult.cbBlockCount[i] > 0 )
|
|
{
|
|
memcpy( &cbCardData[cbCardCount],AnalyseResult.cbCardData[i],
|
|
sizeof(uint8)*(i+1)*AnalyseResult.cbBlockCount[i] );
|
|
cbCardCount += (i+1)*AnalyseResult.cbBlockCount[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//逻辑数值
|
|
uint8 CDDZGameLogic::GetCardLogicValue(uint8 cbCardData)
|
|
{
|
|
//扑克属性
|
|
uint8 cbCardColor=GetCardColor(cbCardData);
|
|
uint8 cbCardValue=GetCardValue(cbCardData);
|
|
|
|
//转换数值
|
|
if (cbCardColor==0x40) return cbCardValue+2;
|
|
return (cbCardValue<=2)?(cbCardValue+13):cbCardValue;
|
|
}
|
|
|
|
//对比扑克
|
|
bool CDDZGameLogic::CompareCard(const uint8 cbFirstCard[], const uint8 cbNextCard[], uint8 cbFirstCount, uint8 cbNextCount)
|
|
{
|
|
//获取类型
|
|
uint8 cbNextType = GetCardType(cbNextCard, cbNextCount);
|
|
uint8 cbFirstType = GetCardType(cbFirstCard, cbFirstCount);
|
|
|
|
//类型判断
|
|
if (cbNextType == DDZ_CT_ERROR) return false;
|
|
if (cbNextType == DDZ_CT_MISSILE_CARD) return true;
|
|
|
|
//炸弹判断
|
|
if ((cbFirstType != DDZ_CT_BOMB_CARD) && (cbNextType == DDZ_CT_BOMB_CARD)) return true;
|
|
if ((cbFirstType == DDZ_CT_BOMB_CARD) && (cbNextType != DDZ_CT_BOMB_CARD)) return false;
|
|
|
|
//规则判断
|
|
if ((cbFirstType!=cbNextType)||(cbFirstCount!=cbNextCount)) return false;
|
|
|
|
//开始对比
|
|
switch (cbNextType)
|
|
{
|
|
case DDZ_CT_SINGLE:
|
|
case DDZ_CT_DOUBLE:
|
|
case DDZ_CT_THREE:
|
|
case DDZ_CT_SINGLE_LINE:
|
|
case DDZ_CT_DOUBLE_LINE:
|
|
case DDZ_CT_THREE_LINE:
|
|
case DDZ_CT_BOMB_CARD:
|
|
{
|
|
//获取数值
|
|
uint8 cbNextLogicValue=GetCardLogicValue(cbNextCard[0]);
|
|
uint8 cbFirstLogicValue=GetCardLogicValue(cbFirstCard[0]);
|
|
|
|
//对比扑克
|
|
return cbNextLogicValue>cbFirstLogicValue;
|
|
}
|
|
case DDZ_CT_THREE_TAKE_ONE:
|
|
case DDZ_CT_THREE_TAKE_TWO:
|
|
{
|
|
//分析扑克
|
|
tagAnalyseResult NextResult;
|
|
tagAnalyseResult FirstResult;
|
|
AnalysebCardData(cbNextCard,cbNextCount,NextResult);
|
|
AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);
|
|
|
|
//获取数值
|
|
uint8 cbNextLogicValue=GetCardLogicValue(NextResult.cbCardData[2][0]);
|
|
uint8 cbFirstLogicValue=GetCardLogicValue(FirstResult.cbCardData[2][0]);
|
|
|
|
//对比扑克
|
|
return cbNextLogicValue>cbFirstLogicValue;
|
|
}
|
|
case DDZ_CT_FOUR_TAKE_ONE:
|
|
case DDZ_CT_FOUR_TAKE_TWO:
|
|
{
|
|
//分析扑克
|
|
tagAnalyseResult NextResult;
|
|
tagAnalyseResult FirstResult;
|
|
AnalysebCardData(cbNextCard,cbNextCount,NextResult);
|
|
AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);
|
|
|
|
//获取数值
|
|
uint8 cbNextLogicValue=GetCardLogicValue(NextResult.cbCardData[3][0]);
|
|
uint8 cbFirstLogicValue=GetCardLogicValue(FirstResult.cbCardData[3][0]);
|
|
|
|
//对比扑克
|
|
return cbNextLogicValue>cbFirstLogicValue;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//构造扑克
|
|
uint8 CDDZGameLogic::MakeCardData(uint8 cbValueIndex, uint8 cbColorIndex)
|
|
{
|
|
return (cbColorIndex<<4)|(cbValueIndex+1);
|
|
}
|
|
|
|
//分析扑克
|
|
void CDDZGameLogic::AnalysebCardData(const uint8 cbCardData[], uint8 cbCardCount, tagAnalyseResult & AnalyseResult)
|
|
{
|
|
//设置结果
|
|
zeromemory(&AnalyseResult, sizeof(tagAnalyseResult));
|
|
|
|
//扑克分析
|
|
for (uint8 i=0;i<cbCardCount;i++)
|
|
{
|
|
//变量定义
|
|
uint8 cbSameCount=1;
|
|
uint8 cbLogicValue=GetCardLogicValue(cbCardData[i]);
|
|
|
|
//搜索同牌
|
|
for (uint8 j=i+1;j<cbCardCount;j++)
|
|
{
|
|
//获取扑克
|
|
if (GetCardLogicValue(cbCardData[j])!=cbLogicValue) break;
|
|
|
|
//设置变量
|
|
cbSameCount++;
|
|
}
|
|
|
|
//设置结果
|
|
uint8 cbIndex=AnalyseResult.cbBlockCount[cbSameCount-1]++;
|
|
for (uint8 j=0;j<cbSameCount;j++) AnalyseResult.cbCardData[cbSameCount-1][cbIndex*cbSameCount+j]=cbCardData[i+j];
|
|
|
|
//设置索引
|
|
i+=cbSameCount-1;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//分析分布
|
|
void CDDZGameLogic::AnalysebDistributing(const uint8 cbCardData[], uint8 cbCardCount, tagDistributing & Distributing)
|
|
{
|
|
//设置变量
|
|
zeromemory(&Distributing, sizeof(tagDistributing));
|
|
|
|
//设置变量
|
|
for (uint8 i=0;i<cbCardCount;i++)
|
|
{
|
|
if (cbCardData[i]==0) continue;
|
|
|
|
//获取属性
|
|
uint8 cbCardColor=GetCardColor(cbCardData[i]);
|
|
uint8 cbCardValue=GetCardValue(cbCardData[i]);
|
|
|
|
//分布信息
|
|
Distributing.cbCardCount++;
|
|
Distributing.cbDistributing[cbCardValue-1][cbIndexCount]++;
|
|
Distributing.cbDistributing[cbCardValue-1][cbCardColor>>4]++;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//出牌搜索
|
|
uint8 CDDZGameLogic::SearchOutCard( const uint8 cbHandCardData[], uint8 cbHandCardCount, const uint8 cbTurnCardData[], uint8 cbTurnCardCount,
|
|
tagSearchCardResult *pSearchCardResult )
|
|
{
|
|
//设置结果
|
|
assert( pSearchCardResult != NULL );
|
|
if( pSearchCardResult == NULL ) return 0;
|
|
|
|
zeromemory(pSearchCardResult,sizeof(tagSearchCardResult));
|
|
|
|
//变量定义
|
|
uint8 cbResultCount = 0;
|
|
tagSearchCardResult tmpSearchCardResult = {};
|
|
|
|
//构造扑克
|
|
uint8 cbCardData[DDZ_MAX_COUNT];
|
|
uint8 cbCardCount=cbHandCardCount;
|
|
memcpy(cbCardData,cbHandCardData,sizeof(uint8)*cbHandCardCount);
|
|
|
|
//排列扑克
|
|
SortCardList(cbCardData,cbCardCount,DDZ_ST_ORDER);
|
|
|
|
//获取类型
|
|
uint8 cbTurnOutType = GetCardType(cbTurnCardData, cbTurnCardCount);
|
|
|
|
//出牌分析
|
|
switch (cbTurnOutType)
|
|
{
|
|
case DDZ_CT_ERROR: //错误类型
|
|
{
|
|
//提取各种牌型一组
|
|
assert( pSearchCardResult );
|
|
if( !pSearchCardResult ) return 0;
|
|
|
|
//是否一手出完
|
|
if (GetCardType(cbCardData, cbCardCount) != DDZ_CT_ERROR)
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = cbCardCount;
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],cbCardData,
|
|
sizeof(uint8)*cbCardCount );
|
|
cbResultCount++;
|
|
}
|
|
|
|
//如果最小牌不是单牌，则提取
|
|
uint8 cbSameCount = 0;
|
|
if( cbCardCount > 1 && GetCardValue(cbCardData[cbCardCount-1]) == GetCardValue(cbCardData[cbCardCount-2]) )
|
|
{
|
|
cbSameCount = 1;
|
|
pSearchCardResult->cbResultCard[cbResultCount][0] = cbCardData[cbCardCount-1];
|
|
uint8 cbCardValue = GetCardValue(cbCardData[cbCardCount-1]);
|
|
for( int i = cbCardCount-2; i >= 0; i-- )
|
|
{
|
|
if( GetCardValue(cbCardData[i]) == cbCardValue )
|
|
{
|
|
pSearchCardResult->cbResultCard[cbResultCount][cbSameCount++] = cbCardData[i];
|
|
}
|
|
else break;
|
|
}
|
|
|
|
pSearchCardResult->cbCardCount[cbResultCount] = cbSameCount;
|
|
cbResultCount++;
|
|
}
|
|
|
|
//单牌
|
|
uint8 cbTmpCount = 0;
|
|
if( cbSameCount != 1 )
|
|
{
|
|
cbTmpCount = SearchSameCard( cbCardData,cbCardCount,0,1,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
//对牌
|
|
if( cbSameCount != 2 )
|
|
{
|
|
cbTmpCount = SearchSameCard( cbCardData,cbCardCount,0,2,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
//三条
|
|
if( cbSameCount != 3 )
|
|
{
|
|
cbTmpCount = SearchSameCard( cbCardData,cbCardCount,0,3,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
//三带一单
|
|
cbTmpCount = SearchTakeCardType( cbCardData,cbCardCount,0,3,1,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
|
|
//三带一对
|
|
cbTmpCount = SearchTakeCardType( cbCardData,cbCardCount,0,3,2,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
|
|
//单连
|
|
cbTmpCount = SearchLineCardType( cbCardData,cbCardCount,0,1,0,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
|
|
//连对
|
|
cbTmpCount = SearchLineCardType( cbCardData,cbCardCount,0,2,0,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
|
|
//三连
|
|
cbTmpCount = SearchLineCardType( cbCardData,cbCardCount,0,3,0,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
|
|
////飞机
|
|
//cbTmpCount = SearchThreeTwoLine( cbCardData,cbCardCount,&tmpSearchCardResult );
|
|
//if( cbTmpCount > 0 )
|
|
//{
|
|
// pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
// memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
// sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
// cbResultCount++;
|
|
//}
|
|
|
|
//炸弹
|
|
if( cbSameCount != 4 )
|
|
{
|
|
cbTmpCount = SearchSameCard( cbCardData,cbCardCount,0,4,&tmpSearchCardResult );
|
|
if( cbTmpCount > 0 )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[0];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[0],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[0] );
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
//搜索火箭
|
|
if ((cbCardCount>=2)&&(cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E))
|
|
{
|
|
//设置结果
|
|
pSearchCardResult->cbCardCount[cbResultCount] = 2;
|
|
pSearchCardResult->cbResultCard[cbResultCount][0] = cbCardData[0];
|
|
pSearchCardResult->cbResultCard[cbResultCount][1] = cbCardData[1];
|
|
|
|
cbResultCount++;
|
|
}
|
|
|
|
pSearchCardResult->cbSearchCount = cbResultCount;
|
|
return cbResultCount;
|
|
}
|
|
case DDZ_CT_SINGLE: //单牌类型
|
|
case DDZ_CT_DOUBLE: //对牌类型
|
|
case DDZ_CT_THREE: //三条类型
|
|
{
|
|
//变量定义
|
|
uint8 cbReferCard=cbTurnCardData[0];
|
|
uint8 cbSameCount = 1;
|
|
if (cbTurnOutType == DDZ_CT_DOUBLE) cbSameCount = 2;
|
|
else if (cbTurnOutType == DDZ_CT_THREE) cbSameCount = 3;
|
|
|
|
//搜索相同牌
|
|
cbResultCount = SearchSameCard( cbCardData,cbCardCount,cbReferCard,cbSameCount,pSearchCardResult );
|
|
|
|
break;
|
|
}
|
|
case DDZ_CT_SINGLE_LINE: //单连类型
|
|
case DDZ_CT_DOUBLE_LINE: //对连类型
|
|
case DDZ_CT_THREE_LINE: //三连类型
|
|
{
|
|
//变量定义
|
|
uint8 cbBlockCount = 1;
|
|
if (cbTurnOutType == DDZ_CT_DOUBLE_LINE) cbBlockCount = 2;
|
|
else if (cbTurnOutType == DDZ_CT_THREE_LINE) cbBlockCount = 3;
|
|
|
|
uint8 cbLineCount = cbTurnCardCount/cbBlockCount;
|
|
|
|
//搜索边牌
|
|
cbResultCount = SearchLineCardType( cbCardData,cbCardCount,cbTurnCardData[0],cbBlockCount,cbLineCount,pSearchCardResult );
|
|
|
|
break;
|
|
}
|
|
case DDZ_CT_THREE_TAKE_ONE: //三带一单
|
|
case DDZ_CT_THREE_TAKE_TWO: //三带一对
|
|
{
|
|
//效验牌数
|
|
if( cbCardCount < cbTurnCardCount ) break;
|
|
|
|
//如果是三带一或三带二
|
|
if( cbTurnCardCount == 4 || cbTurnCardCount == 5 )
|
|
{
|
|
uint8 cbTakeCardCount = cbTurnOutType == DDZ_CT_THREE_TAKE_ONE ? 1 : 2;
|
|
|
|
//搜索三带牌型
|
|
cbResultCount = SearchTakeCardType( cbCardData,cbCardCount,cbTurnCardData[2],3,cbTakeCardCount,pSearchCardResult );
|
|
}
|
|
else
|
|
{
|
|
//变量定义
|
|
uint8 cbBlockCount = 3;
|
|
uint8 cbLineCount = cbTurnCardCount / (cbTurnOutType == DDZ_CT_THREE_TAKE_ONE ? 4 : 5);
|
|
uint8 cbTakeCardCount = cbTurnOutType == DDZ_CT_THREE_TAKE_ONE ? 1 : 2;
|
|
|
|
//搜索连牌
|
|
uint8 cbTmpTurnCard[DDZ_MAX_COUNT] = {};
|
|
memcpy( cbTmpTurnCard,cbTurnCardData,sizeof(uint8)*cbTurnCardCount );
|
|
SortOutCardList( cbTmpTurnCard,cbTurnCardCount );
|
|
cbResultCount = SearchLineCardType( cbCardData,cbCardCount,cbTmpTurnCard[0],cbBlockCount,cbLineCount,pSearchCardResult );
|
|
|
|
//提取带牌
|
|
bool bAllDistill = true;
|
|
for( uint8 i = 0; i < cbResultCount; i++ )
|
|
{
|
|
uint8 cbResultIndex = cbResultCount-i-1;
|
|
|
|
//变量定义
|
|
uint8 cbTmpCardData[DDZ_MAX_COUNT];
|
|
uint8 cbTmpCardCount = cbCardCount;
|
|
|
|
//删除连牌
|
|
memcpy( cbTmpCardData,cbCardData,sizeof(uint8)*cbCardCount );
|
|
assert( RemoveCard( pSearchCardResult->cbResultCard[cbResultIndex],pSearchCardResult->cbCardCount[cbResultIndex],
|
|
cbTmpCardData,cbTmpCardCount ) );
|
|
cbTmpCardCount -= pSearchCardResult->cbCardCount[cbResultIndex];
|
|
|
|
//分析牌
|
|
tagAnalyseResult TmpResult = {};
|
|
AnalysebCardData( cbTmpCardData,cbTmpCardCount,TmpResult );
|
|
|
|
//提取牌
|
|
uint8 cbDistillCard[DDZ_MAX_COUNT] = {};
|
|
uint8 cbDistillCount = 0;
|
|
for( uint8 j = cbTakeCardCount-1; j < CountArray(TmpResult.cbBlockCount); j++ )
|
|
{
|
|
if( TmpResult.cbBlockCount[j] > 0 )
|
|
{
|
|
if( j+1 == cbTakeCardCount && TmpResult.cbBlockCount[j] >= cbLineCount )
|
|
{
|
|
uint8 cbTmpBlockCount = TmpResult.cbBlockCount[j];
|
|
memcpy( cbDistillCard,&TmpResult.cbCardData[j][(cbTmpBlockCount-cbLineCount)*(j+1)],
|
|
sizeof(uint8)*(j+1)*cbLineCount );
|
|
cbDistillCount = (j+1)*cbLineCount;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
for( uint8 k = 0; k < TmpResult.cbBlockCount[j]; k++ )
|
|
{
|
|
uint8 cbTmpBlockCount = TmpResult.cbBlockCount[j];
|
|
memcpy( &cbDistillCard[cbDistillCount],&TmpResult.cbCardData[j][(cbTmpBlockCount-k-1)*(j+1)],
|
|
sizeof(uint8)*cbTakeCardCount );
|
|
cbDistillCount += cbTakeCardCount;
|
|
|
|
//提取完成
|
|
if( cbDistillCount == cbTakeCardCount*cbLineCount ) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//提取完成
|
|
if( cbDistillCount == cbTakeCardCount*cbLineCount ) break;
|
|
}
|
|
|
|
//提取完成
|
|
if( cbDistillCount == cbTakeCardCount*cbLineCount )
|
|
{
|
|
//复制带牌
|
|
uint8 cbCount = pSearchCardResult->cbCardCount[cbResultIndex];
|
|
memcpy( &pSearchCardResult->cbResultCard[cbResultIndex][cbCount],cbDistillCard,
|
|
sizeof(uint8)*cbDistillCount );
|
|
pSearchCardResult->cbCardCount[cbResultIndex] += cbDistillCount;
|
|
}
|
|
//否则删除连牌
|
|
else
|
|
{
|
|
bAllDistill = false;
|
|
pSearchCardResult->cbCardCount[cbResultIndex] = 0;
|
|
}
|
|
}
|
|
|
|
//整理组合
|
|
if( !bAllDistill )
|
|
{
|
|
pSearchCardResult->cbSearchCount = cbResultCount;
|
|
cbResultCount = 0;
|
|
for( uint8 i = 0; i < pSearchCardResult->cbSearchCount; i++ )
|
|
{
|
|
if( pSearchCardResult->cbCardCount[i] != 0 )
|
|
{
|
|
tmpSearchCardResult.cbCardCount[cbResultCount] = pSearchCardResult->cbCardCount[i];
|
|
memcpy( tmpSearchCardResult.cbResultCard[cbResultCount],pSearchCardResult->cbResultCard[i],
|
|
sizeof(uint8)*pSearchCardResult->cbCardCount[i] );
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
tmpSearchCardResult.cbSearchCount = cbResultCount;
|
|
memcpy( pSearchCardResult,&tmpSearchCardResult,sizeof(tagSearchCardResult) );
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case DDZ_CT_FOUR_TAKE_ONE: //四带两单
|
|
case DDZ_CT_FOUR_TAKE_TWO: //四带两双
|
|
{
|
|
uint8 cbTakeCount = cbTurnOutType == DDZ_CT_FOUR_TAKE_ONE ? 1 : 2;
|
|
|
|
uint8 cbTmpTurnCard[DDZ_MAX_COUNT] = {};
|
|
memcpy( cbTmpTurnCard,cbTurnCardData,sizeof(uint8)*cbTurnCardCount );
|
|
SortOutCardList( cbTmpTurnCard,cbTurnCardCount );
|
|
|
|
//搜索带牌
|
|
cbResultCount = SearchTakeCardType( cbCardData,cbCardCount,cbTmpTurnCard[0],4,cbTakeCount,pSearchCardResult );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//搜索炸弹
|
|
if ((cbCardCount >= 4) && (cbTurnOutType != DDZ_CT_MISSILE_CARD))
|
|
{
|
|
//变量定义
|
|
uint8 cbReferCard = 0;
|
|
if (cbTurnOutType == DDZ_CT_BOMB_CARD) cbReferCard = cbTurnCardData[0];
|
|
|
|
//搜索炸弹
|
|
uint8 cbTmpResultCount = SearchSameCard( cbCardData,cbCardCount,cbReferCard,4,&tmpSearchCardResult );
|
|
for( uint8 i = 0; i < cbTmpResultCount; i++ )
|
|
{
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSearchCardResult.cbCardCount[i];
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSearchCardResult.cbResultCard[i],
|
|
sizeof(uint8)*tmpSearchCardResult.cbCardCount[i] );
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
//搜索火箭
|
|
if (cbTurnOutType != DDZ_CT_MISSILE_CARD && (cbCardCount >= 2) && (cbCardData[0] == 0x4F) && (cbCardData[1] == 0x4E))
|
|
{
|
|
//设置结果
|
|
pSearchCardResult->cbCardCount[cbResultCount] = 2;
|
|
pSearchCardResult->cbResultCard[cbResultCount][0] = cbCardData[0];
|
|
pSearchCardResult->cbResultCard[cbResultCount][1] = cbCardData[1];
|
|
|
|
cbResultCount++;
|
|
}
|
|
|
|
if ( pSearchCardResult )
|
|
{
|
|
pSearchCardResult->cbSearchCount = cbResultCount;
|
|
}
|
|
|
|
return cbResultCount;
|
|
}
|
|
|
|
//同牌搜索
|
|
uint8 CDDZGameLogic::SearchSameCard( const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbSameCardCount,
|
|
tagSearchCardResult *pSearchCardResult )
|
|
{
|
|
//设置结果
|
|
if (pSearchCardResult)
|
|
{
|
|
zeromemory(pSearchCardResult,sizeof(tagSearchCardResult));
|
|
}
|
|
uint8 cbResultCount = 0;
|
|
|
|
//构造扑克
|
|
uint8 cbCardData[DDZ_MAX_COUNT];
|
|
uint8 cbCardCount=cbHandCardCount;
|
|
memcpy(cbCardData,cbHandCardData,sizeof(uint8)*cbHandCardCount);
|
|
|
|
//排列扑克
|
|
SortCardList(cbCardData,cbCardCount,DDZ_ST_ORDER);
|
|
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult = {};
|
|
AnalysebCardData( cbCardData,cbCardCount,AnalyseResult );
|
|
|
|
uint8 cbReferLogicValue = cbReferCard==0?0:GetCardLogicValue(cbReferCard);
|
|
uint8 cbBlockIndex = cbSameCardCount-1;
|
|
do
|
|
{
|
|
for( uint8 i = 0; i < AnalyseResult.cbBlockCount[cbBlockIndex]; i++ )
|
|
{
|
|
uint8 cbIndex = (AnalyseResult.cbBlockCount[cbBlockIndex]-i-1)*(cbBlockIndex+1);
|
|
if( GetCardLogicValue(AnalyseResult.cbCardData[cbBlockIndex][cbIndex]) > cbReferLogicValue )
|
|
{
|
|
if( pSearchCardResult == NULL ) return 1;
|
|
|
|
assert( cbResultCount < CountArray(pSearchCardResult->cbCardCount) );
|
|
|
|
//复制扑克
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],&AnalyseResult.cbCardData[cbBlockIndex][cbIndex],
|
|
cbSameCardCount*sizeof(uint8) );
|
|
pSearchCardResult->cbCardCount[cbResultCount] = cbSameCardCount;
|
|
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
cbBlockIndex++;
|
|
}while( cbBlockIndex < CountArray(AnalyseResult.cbBlockCount) );
|
|
|
|
if( pSearchCardResult )
|
|
pSearchCardResult->cbSearchCount = cbResultCount;
|
|
return cbResultCount;
|
|
}
|
|
|
|
//带牌类型搜索(三带一，四带一等)
|
|
uint8 CDDZGameLogic::SearchTakeCardType( const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbSameCount, uint8 cbTakeCardCount,
|
|
tagSearchCardResult *pSearchCardResult )
|
|
{
|
|
//设置结果
|
|
if (pSearchCardResult)
|
|
{
|
|
zeromemory(pSearchCardResult, sizeof(tagSearchCardResult));
|
|
}
|
|
|
|
uint8 cbResultCount = 0;
|
|
|
|
//效验
|
|
assert( cbSameCount == 3 || cbSameCount == 4 );
|
|
assert(cbTakeCardCount == 1 || cbTakeCardCount == 2);
|
|
if( cbSameCount != 3 && cbSameCount != 4 )
|
|
return cbResultCount;
|
|
if( cbTakeCardCount != 1 && cbTakeCardCount != 2 )
|
|
return cbResultCount;
|
|
|
|
//长度判断
|
|
if( (cbSameCount == 4 && cbHandCardCount<cbSameCount+cbTakeCardCount*2) ||
|
|
cbHandCardCount < cbSameCount+cbTakeCardCount )
|
|
return cbResultCount;//wangyifei warning
|
|
|
|
//构造扑克
|
|
uint8 cbCardData[DDZ_MAX_COUNT];
|
|
uint8 cbCardCount=cbHandCardCount;
|
|
memcpy(cbCardData,cbHandCardData,sizeof(uint8)*cbHandCardCount);
|
|
|
|
//排列扑克
|
|
SortCardList(cbCardData,cbCardCount,DDZ_ST_ORDER);
|
|
|
|
//搜索同张
|
|
tagSearchCardResult SameCardResult = {};
|
|
uint8 cbSameCardResultCount = SearchSameCard( cbCardData,cbCardCount,cbReferCard,cbSameCount,&SameCardResult );
|
|
|
|
if( cbSameCardResultCount > 0 )
|
|
{
|
|
//分析扑克
|
|
tagAnalyseResult AnalyseResult;
|
|
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
|
|
|
|
//需要牌数
|
|
uint8 cbNeedCount = cbSameCount+cbTakeCardCount;
|
|
if( cbSameCount == 4 ) cbNeedCount += cbTakeCardCount;
|
|
|
|
//提取带牌
|
|
for( uint8 i = 0; i < cbSameCardResultCount; i++ )
|
|
{
|
|
bool bMerge = false;
|
|
|
|
for( uint8 j = cbTakeCardCount-1; j < CountArray(AnalyseResult.cbBlockCount); j++ )
|
|
{
|
|
for( uint8 k = 0; k < AnalyseResult.cbBlockCount[j]; k++ )
|
|
{
|
|
//从小到大
|
|
uint8 cbIndex = (AnalyseResult.cbBlockCount[j]-k-1)*(j+1);
|
|
|
|
//过滤相同牌
|
|
if( GetCardValue(SameCardResult.cbResultCard[i][0]) ==
|
|
GetCardValue(AnalyseResult.cbCardData[j][cbIndex]) )
|
|
continue;
|
|
|
|
//复制带牌
|
|
uint8 cbCount = SameCardResult.cbCardCount[i];
|
|
memcpy( &SameCardResult.cbResultCard[i][cbCount],&AnalyseResult.cbCardData[j][cbIndex],
|
|
sizeof(uint8)*cbTakeCardCount );
|
|
SameCardResult.cbCardCount[i] += cbTakeCardCount;
|
|
|
|
if( SameCardResult.cbCardCount[i] < cbNeedCount ) continue;
|
|
|
|
if( pSearchCardResult == NULL ) return 1;
|
|
|
|
//复制结果
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],SameCardResult.cbResultCard[i],
|
|
sizeof(uint8)*SameCardResult.cbCardCount[i] );
|
|
pSearchCardResult->cbCardCount[cbResultCount] = SameCardResult.cbCardCount[i];
|
|
cbResultCount++;
|
|
|
|
bMerge = true;
|
|
|
|
//下一组合
|
|
break;
|
|
}
|
|
|
|
if( bMerge ) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( pSearchCardResult )
|
|
pSearchCardResult->cbSearchCount = cbResultCount;
|
|
return cbResultCount;
|
|
}
|
|
|
|
//连牌搜索
|
|
uint8 CDDZGameLogic::SearchLineCardType( const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbBlockCount, uint8 cbLineCount,
|
|
tagSearchCardResult *pSearchCardResult )
|
|
{
|
|
//设置结果
|
|
if (pSearchCardResult)
|
|
{
|
|
zeromemory(pSearchCardResult,sizeof(tagSearchCardResult));
|
|
}
|
|
uint8 cbResultCount = 0;
|
|
|
|
//定义变量
|
|
uint8 cbLessLineCount = 0;
|
|
if( cbLineCount == 0 )
|
|
{
|
|
if( cbBlockCount == 1 )
|
|
cbLessLineCount = 5;
|
|
else if( cbBlockCount == 2 )
|
|
cbLessLineCount = 3;
|
|
else cbLessLineCount = 2;
|
|
}
|
|
else cbLessLineCount = cbLineCount;
|
|
|
|
uint8 cbReferIndex = 2;
|
|
if( cbReferCard != 0 )
|
|
{
|
|
assert(GetCardLogicValue(cbReferCard) - cbLessLineCount >= 2);
|
|
cbReferIndex = GetCardLogicValue(cbReferCard)-cbLessLineCount+1;
|
|
}
|
|
//超过A
|
|
if( cbReferIndex+cbLessLineCount > 14 ) return cbResultCount;
|
|
|
|
//长度判断
|
|
if( cbHandCardCount < cbLessLineCount*cbBlockCount ) return cbResultCount;
|
|
|
|
//构造扑克
|
|
uint8 cbCardData[DDZ_MAX_COUNT];
|
|
uint8 cbCardCount=cbHandCardCount;
|
|
memcpy(cbCardData,cbHandCardData,sizeof(uint8)*cbHandCardCount);
|
|
|
|
//排列扑克
|
|
SortCardList(cbCardData,cbCardCount,DDZ_ST_ORDER);
|
|
|
|
//分析扑克
|
|
tagDistributing Distributing = {};
|
|
AnalysebDistributing(cbCardData,cbCardCount,Distributing);
|
|
|
|
//搜索顺子
|
|
uint8 cbTmpLinkCount = 0;
|
|
uint8 cbValueIndex = 0;
|
|
for (cbValueIndex=cbReferIndex;cbValueIndex<13;cbValueIndex++)
|
|
{
|
|
//继续判断
|
|
if ( Distributing.cbDistributing[cbValueIndex][cbIndexCount]<cbBlockCount )
|
|
{
|
|
if( cbTmpLinkCount < cbLessLineCount )
|
|
{
|
|
cbTmpLinkCount=0;
|
|
continue;
|
|
}
|
|
else cbValueIndex--;
|
|
}
|
|
else
|
|
{
|
|
cbTmpLinkCount++;
|
|
//寻找最长连
|
|
if( cbLineCount == 0 ) continue;
|
|
}
|
|
|
|
if( cbTmpLinkCount >= cbLessLineCount )
|
|
{
|
|
if( pSearchCardResult == NULL ) return 1;
|
|
|
|
assert(cbResultCount < CountArray(pSearchCardResult->cbCardCount));
|
|
|
|
//复制扑克
|
|
uint8 cbCount = 0;
|
|
for( uint8 cbIndex = cbValueIndex+1-cbTmpLinkCount; cbIndex <= cbValueIndex; cbIndex++ )
|
|
{
|
|
uint8 cbTmpCount = 0;
|
|
for (uint8 cbColorIndex=0;cbColorIndex<4;cbColorIndex++)
|
|
{
|
|
for( uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3-cbColorIndex]; cbColorCount++ )
|
|
{
|
|
pSearchCardResult->cbResultCard[cbResultCount][cbCount++]=MakeCardData(cbIndex,3-cbColorIndex);
|
|
|
|
if( ++cbTmpCount == cbBlockCount ) break;
|
|
}
|
|
if( cbTmpCount == cbBlockCount ) break;
|
|
}
|
|
}
|
|
|
|
//设置变量
|
|
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
|
cbResultCount++;
|
|
|
|
if( cbLineCount != 0 )
|
|
{
|
|
cbTmpLinkCount--;
|
|
}
|
|
else
|
|
{
|
|
cbTmpLinkCount = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//特殊顺子
|
|
if( cbTmpLinkCount >= cbLessLineCount-1 && cbValueIndex == 13 )
|
|
{
|
|
if( Distributing.cbDistributing[0][cbIndexCount] >= cbBlockCount ||
|
|
cbTmpLinkCount >= cbLessLineCount )
|
|
{
|
|
if( pSearchCardResult == NULL ) return 1;
|
|
|
|
assert(cbResultCount < CountArray(pSearchCardResult->cbCardCount));
|
|
|
|
//复制扑克
|
|
uint8 cbCount = 0;
|
|
uint8 cbTmpCount = 0;
|
|
for( uint8 cbIndex = cbValueIndex-cbTmpLinkCount; cbIndex < 13; cbIndex++ )
|
|
{
|
|
cbTmpCount = 0;
|
|
for (uint8 cbColorIndex=0;cbColorIndex<4;cbColorIndex++)
|
|
{
|
|
for( uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3-cbColorIndex]; cbColorCount++ )
|
|
{
|
|
pSearchCardResult->cbResultCard[cbResultCount][cbCount++]=MakeCardData(cbIndex,3-cbColorIndex);
|
|
|
|
if( ++cbTmpCount == cbBlockCount ) break;
|
|
}
|
|
if( cbTmpCount == cbBlockCount ) break;
|
|
}
|
|
}
|
|
//复制A
|
|
if( Distributing.cbDistributing[0][cbIndexCount] >= cbBlockCount )
|
|
{
|
|
cbTmpCount = 0;
|
|
for (uint8 cbColorIndex=0;cbColorIndex<4;cbColorIndex++)
|
|
{
|
|
for( uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[0][3-cbColorIndex]; cbColorCount++ )
|
|
{
|
|
pSearchCardResult->cbResultCard[cbResultCount][cbCount++]=MakeCardData(0,3-cbColorIndex);
|
|
|
|
if( ++cbTmpCount == cbBlockCount ) break;
|
|
}
|
|
if( cbTmpCount == cbBlockCount ) break;
|
|
}
|
|
}
|
|
|
|
//设置变量
|
|
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
|
cbResultCount++;
|
|
}
|
|
}
|
|
|
|
if( pSearchCardResult )
|
|
pSearchCardResult->cbSearchCount = cbResultCount;
|
|
return cbResultCount;
|
|
}
|
|
|
|
//搜索飞机
|
|
uint8 CDDZGameLogic::SearchThreeTwoLine( const uint8 cbHandCardData[], uint8 cbHandCardCount, tagSearchCardResult *pSearchCardResult )
|
|
{
|
|
//设置结果
|
|
if (pSearchCardResult)
|
|
{
|
|
zeromemory(pSearchCardResult,sizeof(tagSearchCardResult));
|
|
}
|
|
|
|
//变量定义
|
|
tagSearchCardResult tmpSearchResult = {};
|
|
tagSearchCardResult tmpSingleWing = {};
|
|
tagSearchCardResult tmpDoubleWing = {};
|
|
uint8 cbTmpResultCount = 0;
|
|
|
|
//搜索连牌
|
|
cbTmpResultCount = SearchLineCardType( cbHandCardData,cbHandCardCount,0,3,0,&tmpSearchResult );
|
|
|
|
if( cbTmpResultCount > 0 )
|
|
{
|
|
//提取带牌
|
|
for( uint8 i = 0; i < cbTmpResultCount; i++ )
|
|
{
|
|
//变量定义
|
|
uint8 cbTmpCardData[DDZ_MAX_COUNT];
|
|
uint8 cbTmpCardCount = cbHandCardCount;
|
|
|
|
//不够牌
|
|
if( cbHandCardCount-tmpSearchResult.cbCardCount[i] < tmpSearchResult.cbCardCount[i]/3 )
|
|
{
|
|
uint8 cbNeedDelCount = 3;
|
|
while( cbHandCardCount+cbNeedDelCount-tmpSearchResult.cbCardCount[i] < (tmpSearchResult.cbCardCount[i]-cbNeedDelCount)/3 )
|
|
cbNeedDelCount += 3;
|
|
//不够连牌
|
|
if( (tmpSearchResult.cbCardCount[i]-cbNeedDelCount)/3 < 2 )
|
|
{
|
|
//废除连牌
|
|
continue;
|
|
}
|
|
|
|
//拆分连牌
|
|
RemoveCard( tmpSearchResult.cbResultCard[i],cbNeedDelCount,tmpSearchResult.cbResultCard[i],
|
|
tmpSearchResult.cbCardCount[i] );
|
|
tmpSearchResult.cbCardCount[i] -= cbNeedDelCount;
|
|
}
|
|
|
|
if( pSearchCardResult == NULL ) return 1;
|
|
|
|
//删除连牌
|
|
memcpy( cbTmpCardData,cbHandCardData,sizeof(uint8)*cbHandCardCount );
|
|
assert( RemoveCard( tmpSearchResult.cbResultCard[i],tmpSearchResult.cbCardCount[i],
|
|
cbTmpCardData,cbTmpCardCount ) );
|
|
cbTmpCardCount -= tmpSearchResult.cbCardCount[i];
|
|
|
|
//组合飞机
|
|
uint8 cbNeedCount = tmpSearchResult.cbCardCount[i]/3;
|
|
assert(cbNeedCount <= cbTmpCardCount);
|
|
|
|
uint8 cbResultCount = tmpSingleWing.cbSearchCount++;
|
|
memcpy( tmpSingleWing.cbResultCard[cbResultCount],tmpSearchResult.cbResultCard[i],
|
|
sizeof(uint8)*tmpSearchResult.cbCardCount[i] );
|
|
memcpy( &tmpSingleWing.cbResultCard[cbResultCount][tmpSearchResult.cbCardCount[i]],
|
|
&cbTmpCardData[cbTmpCardCount-cbNeedCount],sizeof(uint8)*cbNeedCount );
|
|
tmpSingleWing.cbCardCount[i] = tmpSearchResult.cbCardCount[i]+cbNeedCount;
|
|
|
|
//不够带翅膀
|
|
if( cbTmpCardCount < tmpSearchResult.cbCardCount[i]/3*2 )
|
|
{
|
|
uint8 cbNeedDelCount = 3;
|
|
while( cbTmpCardCount+cbNeedDelCount-tmpSearchResult.cbCardCount[i] < (tmpSearchResult.cbCardCount[i]-cbNeedDelCount)/3*2 )
|
|
cbNeedDelCount += 3;
|
|
//不够连牌
|
|
if( (tmpSearchResult.cbCardCount[i]-cbNeedDelCount)/3 < 2 )
|
|
{
|
|
//废除连牌
|
|
continue;
|
|
}
|
|
|
|
//拆分连牌
|
|
RemoveCard( tmpSearchResult.cbResultCard[i],cbNeedDelCount,tmpSearchResult.cbResultCard[i],
|
|
tmpSearchResult.cbCardCount[i] );
|
|
tmpSearchResult.cbCardCount[i] -= cbNeedDelCount;
|
|
|
|
//重新删除连牌
|
|
memcpy( cbTmpCardData,cbHandCardData,sizeof(uint8)*cbHandCardCount );
|
|
assert( RemoveCard( tmpSearchResult.cbResultCard[i],tmpSearchResult.cbCardCount[i],
|
|
cbTmpCardData,cbTmpCardCount ) );
|
|
cbTmpCardCount = cbHandCardCount-tmpSearchResult.cbCardCount[i];
|
|
}
|
|
|
|
//分析牌
|
|
tagAnalyseResult TmpResult = {};
|
|
AnalysebCardData( cbTmpCardData,cbTmpCardCount,TmpResult );
|
|
|
|
//提取翅膀
|
|
uint8 cbDistillCard[DDZ_MAX_COUNT] = {};
|
|
uint8 cbDistillCount = 0;
|
|
uint8 cbLineCount = tmpSearchResult.cbCardCount[i]/3;
|
|
for( uint8 j = 1; j < CountArray(TmpResult.cbBlockCount); j++ )
|
|
{
|
|
if( TmpResult.cbBlockCount[j] > 0 )
|
|
{
|
|
if( j+1 == 2 && TmpResult.cbBlockCount[j] >= cbLineCount )
|
|
{
|
|
uint8 cbTmpBlockCount = TmpResult.cbBlockCount[j];
|
|
memcpy( cbDistillCard,&TmpResult.cbCardData[j][(cbTmpBlockCount-cbLineCount)*(j+1)],
|
|
sizeof(uint8)*(j+1)*cbLineCount );
|
|
cbDistillCount = (j+1)*cbLineCount;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
for( uint8 k = 0; k < TmpResult.cbBlockCount[j]; k++ )
|
|
{
|
|
uint8 cbTmpBlockCount = TmpResult.cbBlockCount[j];
|
|
memcpy( &cbDistillCard[cbDistillCount],&TmpResult.cbCardData[j][(cbTmpBlockCount-k-1)*(j+1)],
|
|
sizeof(uint8)*2 );
|
|
cbDistillCount += 2;
|
|
|
|
//提取完成
|
|
if( cbDistillCount == 2*cbLineCount ) break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//提取完成
|
|
if( cbDistillCount == 2*cbLineCount ) break;
|
|
}
|
|
|
|
//提取完成
|
|
if( cbDistillCount == 2*cbLineCount )
|
|
{
|
|
//复制翅膀
|
|
cbResultCount = tmpDoubleWing.cbSearchCount++;
|
|
memcpy( tmpDoubleWing.cbResultCard[cbResultCount],tmpSearchResult.cbResultCard[i],
|
|
sizeof(uint8)*tmpSearchResult.cbCardCount[i] );
|
|
memcpy( &tmpDoubleWing.cbResultCard[cbResultCount][tmpSearchResult.cbCardCount[i]],
|
|
cbDistillCard,sizeof(uint8)*cbDistillCount );
|
|
tmpDoubleWing.cbCardCount[i] = tmpSearchResult.cbCardCount[i]+cbDistillCount;
|
|
}
|
|
}
|
|
|
|
//复制结果
|
|
for( uint8 i = 0; i < tmpDoubleWing.cbSearchCount; i++ )
|
|
{
|
|
uint8 cbResultCount = pSearchCardResult->cbSearchCount++;
|
|
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpDoubleWing.cbResultCard[i],
|
|
sizeof(uint8)*tmpDoubleWing.cbCardCount[i] );
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpDoubleWing.cbCardCount[i];
|
|
}
|
|
for( uint8 i = 0; i < tmpSingleWing.cbSearchCount; i++ )
|
|
{
|
|
uint8 cbResultCount = pSearchCardResult->cbSearchCount++;
|
|
|
|
memcpy( pSearchCardResult->cbResultCard[cbResultCount],tmpSingleWing.cbResultCard[i],
|
|
sizeof(uint8)*tmpSingleWing.cbCardCount[i] );
|
|
pSearchCardResult->cbCardCount[cbResultCount] = tmpSingleWing.cbCardCount[i];
|
|
}
|
|
}
|
|
|
|
return pSearchCardResult==NULL?0:pSearchCardResult->cbSearchCount;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////
|