2635 lines
70 KiB
C++
2635 lines
70 KiB
C++
#include "DZ_GameLogic.h"
|
||
|
||
#define IS_BOME_TYPE(x,y) (((x)>>(y))>0)
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
//索引变量
|
||
const uint8 cbIndexCount = 5;
|
||
|
||
//扑克数据
|
||
const uint8 DZ_CGameLogic::m_cbCardData[DZ_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,
|
||
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,
|
||
};
|
||
|
||
//扑克数据
|
||
const uint8 DZ_CGameLogic::m_cbNoJokerCardData[DZ_NO_JOKER_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
|
||
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
|
||
};
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
//构造函数
|
||
DZ_CGameLogic::DZ_CGameLogic()
|
||
{
|
||
|
||
}
|
||
|
||
//析构函数
|
||
DZ_CGameLogic::~DZ_CGameLogic()
|
||
{
|
||
|
||
}
|
||
|
||
int DZ_CGameLogic::GetCardType(const uint8 cbCardData[], uint8 cbCardCount, bool isLastCard)
|
||
{
|
||
//简单牌型
|
||
switch (cbCardCount)
|
||
{
|
||
case 0: //空牌
|
||
{
|
||
return DZ_CT_ERROR;
|
||
}
|
||
case 1: //单牌
|
||
{
|
||
return TransListToInt(0,DZ_CT_SINGLE);
|
||
}
|
||
case 2: //对牌火箭
|
||
{
|
||
//牌型判断
|
||
//if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return TransListToInt(0,DZ_CT_MISSILE_CARD);
|
||
if (GetCardLogicValue(cbCardData[0])==GetCardLogicValue(cbCardData[1])) return TransListToInt(0,DZ_CT_DOUBLE);
|
||
|
||
//赖子判断
|
||
if(GetCardLogicValue(cbCardData[0])!=GetCardLogicValue(cbCardData[1]))
|
||
{
|
||
if (IsLaiZiCard(cbCardData[0]) && !IsLaiZiCard(cbCardData[1]))
|
||
{
|
||
return TransListToInt(0, DZ_CT_DOUBLE);
|
||
}
|
||
else if (!IsLaiZiCard(cbCardData[0]) && IsLaiZiCard(cbCardData[1]))
|
||
{
|
||
return TransListToInt(0, DZ_CT_DOUBLE);
|
||
}
|
||
|
||
//if (IsLaiZiCard(cbCardData[0]) || IsLaiZiCard(cbCardData[1]))
|
||
//{
|
||
// if(((cbCardData[0]!=0x4F) || (cbCardData[0]!=0x4E)) && (cbCardData[1]!=0x4F) && (cbCardData[1]!=0x4E))
|
||
// {
|
||
// return TransListToInt(0,DZ_CT_DOUBLE);
|
||
// }
|
||
//}
|
||
}
|
||
|
||
return DZ_CT_ERROR;
|
||
}
|
||
case 4: //王炸;
|
||
{
|
||
if ((cbCardData[0] == 0x4F) && (cbCardData[1] == 0x4F) && (cbCardData[2] == 0x4E) && (cbCardData[3] == 0x4E))
|
||
{
|
||
return TransListToInt(0, DZ_CT_BOMB_8);
|
||
}
|
||
}
|
||
}
|
||
|
||
int dCardType = DZ_CT_ERROR;
|
||
|
||
// 炸弹分析;
|
||
if (cbCardCount >= 4 && cbCardCount <= 12)
|
||
{
|
||
bool isSameCard = true;
|
||
|
||
// 大小排序王在最前面;
|
||
uint8 cbValue = GetCardValue(cbCardData[cbCardCount - 1]);
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
ASSERT(IsValidCard(cbCardData[i]));
|
||
if (cbValue != GetCardValue(cbCardData[i]) && !IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
isSameCard = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 同牌判断
|
||
if (isSameCard)
|
||
{
|
||
// 4张炸弹做三带一特殊处理;
|
||
if (isLastCard && (cbCardCount == 4))
|
||
{
|
||
dCardType = TransListToInt(dCardType, DZ_CT_THREE_TAKE_TWO);
|
||
}
|
||
|
||
uint8 cbCardType = DZ_CT_BOMB_4 + cbCardCount - 4;
|
||
cbCardType = (cbCardType > DZ_CT_BOMB_10) ? DZ_CT_BOMB_10 : cbCardType;
|
||
dCardType = TransListToInt(dCardType, cbCardType);
|
||
|
||
return dCardType;// TransListToInt(0, cbCardType);
|
||
}
|
||
}
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = {0};
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCardCount++;
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbCardData[i];
|
||
}
|
||
}
|
||
|
||
// 没有癞子;
|
||
if (cbMagicCardCount == 0)
|
||
{
|
||
uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
|
||
CopyMemory(bCardDataTemp, cbCardData, sizeof(uint8)*cbCardCount);
|
||
|
||
//分析扑克
|
||
tagDZAnalyseResult AnalyseResult;
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
|
||
uint8 cbMaxCardData = 0;
|
||
uint8 cbBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);
|
||
|
||
// 不存在该类型时候，增加该类型;
|
||
if ((dCardType&(1 << iCardType)) == 0)
|
||
{
|
||
dCardType = TransListToInt(dCardType, iCardType);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (cbMagicCardCount >= 1)
|
||
{
|
||
tagDZAnalyseResult AnalyseResult;
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
|
||
uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
|
||
CopyMemory(&bCardDataTemp[cbMagicCardCount], cbNormalCard, sizeof(uint8)*cbNormalCardCount);
|
||
|
||
for (uint8 i = 0; i < 13; i++)
|
||
{
|
||
bCardDataTemp[0] = m_cbCardData[i];
|
||
|
||
//两张赖子
|
||
if (cbMagicCardCount >= 2)
|
||
{
|
||
for (uint8 z = 0; z < 13; z++)
|
||
{
|
||
bCardDataTemp[1] = m_cbCardData[z];
|
||
|
||
//三张赖子
|
||
if (cbMagicCardCount >= 3)
|
||
{
|
||
for (uint8 f = 0; f < 13; f++)
|
||
{
|
||
bCardDataTemp[2] = m_cbCardData[f];
|
||
|
||
//四张赖子
|
||
if (cbMagicCardCount == 4)
|
||
{
|
||
for (uint8 l = 0; l < 13; l++)
|
||
{
|
||
bCardDataTemp[3] = m_cbCardData[l];
|
||
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
|
||
//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbMaxCardData = 0;
|
||
uint8 cbBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);
|
||
|
||
if (iCardType == 0) continue;
|
||
|
||
if ((dCardType&(1 << iCardType)) == 0)
|
||
{
|
||
dCardType = TransListToInt(dCardType, iCardType);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
|
||
//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbMaxCardData = 0;
|
||
uint8 cbBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);
|
||
|
||
if (iCardType == 0) continue;
|
||
|
||
if ((dCardType&(1 << iCardType)) == 0)
|
||
{
|
||
dCardType = TransListToInt(dCardType, iCardType);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
|
||
//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbMaxCardData = 0;
|
||
uint8 cbBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);
|
||
|
||
if (iCardType == 0) continue;
|
||
|
||
if ((dCardType&(1 << iCardType)) == 0)
|
||
{
|
||
dCardType = TransListToInt(dCardType, iCardType);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
|
||
//int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbMaxCardData = 0;
|
||
uint8 cbBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResult, bCardDataTemp, cbCardCount, cbMaxCardData, cbBlockCount, isLastCard);
|
||
|
||
if (iCardType == 0) continue;
|
||
|
||
if ((dCardType&(1 << iCardType)) == 0)
|
||
{
|
||
dCardType = TransListToInt(dCardType, iCardType);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return dCardType;
|
||
}
|
||
|
||
//获取类型结果
|
||
int DZ_CGameLogic::GetType(tagDZAnalyseResult& AnalyseResult, const uint8 cbCardData[], uint8 cbCardCount, uint8& cbMaxCardData, uint8 &cbBlockCount, bool isLastCard)
|
||
{
|
||
// 重置牌值;
|
||
cbMaxCardData = 0x0;
|
||
cbBlockCount = 0;
|
||
|
||
//简单牌型
|
||
switch (cbCardCount)
|
||
{
|
||
case 0: //空牌
|
||
{
|
||
return DZ_CT_ERROR;
|
||
}
|
||
case 1: //单牌
|
||
{
|
||
cbMaxCardData = cbCardData[0];
|
||
return DZ_CT_SINGLE;
|
||
}
|
||
case 2: //对牌火箭
|
||
{
|
||
//牌型判断
|
||
//if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return TransListToInt(0,DZ_CT_MISSILE_CARD);
|
||
if (GetCardLogicValue(cbCardData[0]) == GetCardLogicValue(cbCardData[1]))
|
||
{
|
||
cbMaxCardData = cbCardData[0];
|
||
return DZ_CT_DOUBLE;
|
||
}
|
||
|
||
//赖子判断
|
||
if (GetCardLogicValue(cbCardData[0]) != GetCardLogicValue(cbCardData[1]))
|
||
{
|
||
if (IsLaiZiCard(cbCardData[0]) || IsLaiZiCard(cbCardData[1]))
|
||
{
|
||
if ((cbCardData[0] != 0x4F) && (cbCardData[0] != 0x4E) && (cbCardData[0] != 0x4F) && (cbCardData[1] != 0x4E))
|
||
{
|
||
cbMaxCardData = cbCardData[cbCardCount - 1];
|
||
|
||
return DZ_CT_DOUBLE;
|
||
}
|
||
}
|
||
}
|
||
|
||
return DZ_CT_ERROR;
|
||
}
|
||
case 4: //王炸;
|
||
{
|
||
if ((cbCardData[0] == 0x4F) && (cbCardData[1] == 0x4F) && (cbCardData[2] == 0x4E) && (cbCardData[3] == 0x4E))
|
||
{
|
||
cbMaxCardData = cbCardData[0];
|
||
return DZ_CT_BOMB_8;
|
||
}
|
||
}
|
||
}
|
||
|
||
//单张判断
|
||
if ((AnalyseResult.cbBlockCount[BLOCK_ONE] >= 5) && (AnalyseResult.cbBlockCount[BLOCK_ONE] == cbCardCount))
|
||
{
|
||
//变量定义
|
||
uint8 cbFirstLogicValue = GetCardLogicValue(AnalyseResult.cbCardData[BLOCK_ONE][0]);
|
||
|
||
//错误过虑
|
||
if (cbFirstLogicValue > 14) return DZ_CT_ERROR;
|
||
|
||
//连牌判断
|
||
for (uint8 i = 1; i < AnalyseResult.cbBlockCount[BLOCK_ONE]; i++)
|
||
{
|
||
uint8 cbTmpCardData = AnalyseResult.cbCardData[BLOCK_ONE][i];
|
||
if (cbFirstLogicValue != (GetCardLogicValue(cbTmpCardData) + i))
|
||
return DZ_CT_ERROR;
|
||
}
|
||
|
||
cbMaxCardData = cbCardData[0];
|
||
|
||
return DZ_CT_SINGLE_LINE;
|
||
}
|
||
|
||
//两张类型
|
||
if ((AnalyseResult.cbBlockCount[BLOCK_TWO] >= 2) && (AnalyseResult.cbBlockCount[BLOCK_TWO]*2 == cbCardCount))
|
||
{
|
||
//变量定义
|
||
uint8 cbFirstLogicValue = GetCardLogicValue(AnalyseResult.cbCardData[BLOCK_TWO][0]);
|
||
|
||
//错误过虑
|
||
if (cbFirstLogicValue > 14) return DZ_CT_ERROR;
|
||
|
||
//连牌判断
|
||
for (uint8 i = 1; i < AnalyseResult.cbBlockCount[BLOCK_TWO]; i++)
|
||
{
|
||
uint8 cbTmpCardData = AnalyseResult.cbCardData[BLOCK_TWO][i * 2];
|
||
if (cbFirstLogicValue != (GetCardLogicValue(cbTmpCardData) + i))
|
||
return DZ_CT_ERROR;
|
||
}
|
||
|
||
//二连判断
|
||
if ((AnalyseResult.cbBlockCount[BLOCK_TWO] * 2) == cbCardCount)
|
||
{
|
||
cbMaxCardData = cbCardData[0];
|
||
return DZ_CT_DOUBLE_LINE;
|
||
}
|
||
|
||
return DZ_CT_ERROR;
|
||
}
|
||
|
||
// 其他牌型都判断完了，如果还有5张以上牌直接返回DZ_CT_ERROR;
|
||
for (int i = BLOCK_FIVE; i <= BLOCK_TWELVE; i++)
|
||
{
|
||
if (AnalyseResult.cbBlockCount[i] > 0)
|
||
{
|
||
return DZ_CT_ERROR;
|
||
}
|
||
}
|
||
|
||
//三带二
|
||
if (AnalyseResult.cbBlockCount[BLOCK_THREE] == 1 && cbCardCount == 5)
|
||
{
|
||
cbMaxCardData = AnalyseResult.cbCardData[BLOCK_THREE][0];
|
||
return DZ_CT_THREE_TAKE_TWO;
|
||
}
|
||
|
||
//三带二
|
||
if (isLastCard && AnalyseResult.cbBlockCount[BLOCK_THREE] == 1 && cbCardCount <= 5)
|
||
{
|
||
cbMaxCardData = AnalyseResult.cbCardData[BLOCK_THREE][0];
|
||
return DZ_CT_THREE_TAKE_TWO;
|
||
}
|
||
|
||
//三带二
|
||
if ((AnalyseResult.cbBlockCount[BLOCK_FOUR] == 1) && (cbCardCount == 5))
|
||
{
|
||
cbMaxCardData = AnalyseResult.cbCardData[BLOCK_FOUR][0];
|
||
return DZ_CT_THREE_TAKE_TWO;
|
||
}
|
||
|
||
//三带二
|
||
if (isLastCard && AnalyseResult.cbBlockCount[BLOCK_FOUR] == 1 && cbCardCount <= 5)
|
||
{
|
||
cbMaxCardData = AnalyseResult.cbCardData[BLOCK_FOUR][0];
|
||
return DZ_CT_THREE_TAKE_TWO;
|
||
}
|
||
|
||
//三连判断;
|
||
if (AnalyseResult.cbBlockCount[BLOCK_THREE] + AnalyseResult.cbBlockCount[BLOCK_FOUR] > 1)
|
||
{
|
||
// 不是最后一手牌，三连必须是5的倍数;
|
||
if (!isLastCard && (cbCardCount % 5 != 0)) return DZ_CT_ERROR;
|
||
uint8 cbCardType = DZ_CT_ERROR;
|
||
|
||
uint8 cbLineCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbLineLength = 0;
|
||
|
||
// 目前只从3取到5张相同牌(将3到5张相同的牌放到同一个数组，用来检测是不是连牌);
|
||
for (uint8 i = BLOCK_THREE; i <= BLOCK_FOUR; i++)
|
||
{
|
||
if (AnalyseResult.cbBlockCount[i] > 0)
|
||
{
|
||
for (uint8 j = 0; j < AnalyseResult.cbBlockCount[i]; j++)
|
||
{
|
||
uint8 cbTmpCardDate = AnalyseResult.cbCardData[i][j*(i + 1)];
|
||
// 连牌不带2;
|
||
if (GetCardLogicValue(cbTmpCardDate) > 14) continue;
|
||
|
||
cbLineCardData[cbLineLength] = cbTmpCardDate;
|
||
cbLineLength++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 重新排序;
|
||
SortCardList(cbLineCardData, cbLineLength, DZ_ST_ORDER);
|
||
|
||
uint8 cbLastValue = GetCardLogicValue(cbLineCardData[0]);
|
||
//错误过虑(3~A)
|
||
if (cbLastValue > 14) return DZ_CT_ERROR;
|
||
|
||
// 查找三连数量;
|
||
uint8 cbMaxThreeLength = 1;
|
||
uint8 cbThreeLength = 1;
|
||
uint8 cbMaxThreeCardData = cbLineCardData[0];
|
||
|
||
for (uint8 i = 1; i < cbLineLength; i++)
|
||
{
|
||
uint8 cbTmpValue = GetCardLogicValue(cbLineCardData[i]);
|
||
|
||
// 不连续
|
||
if (cbLastValue != (cbTmpValue + 1))
|
||
{
|
||
if (cbMaxThreeLength < cbThreeLength)
|
||
{
|
||
cbMaxThreeLength = cbThreeLength;
|
||
cbMaxThreeCardData = cbLineCardData[i - cbMaxThreeLength];
|
||
}
|
||
|
||
cbThreeLength = 1;
|
||
}
|
||
else
|
||
{
|
||
cbThreeLength++;
|
||
}
|
||
|
||
cbLastValue = cbTmpValue;
|
||
}
|
||
|
||
// 最后一个
|
||
if (cbMaxThreeLength < cbThreeLength)
|
||
{
|
||
cbMaxThreeLength = cbThreeLength;
|
||
cbMaxThreeCardData = cbLineCardData[cbLineLength - cbMaxThreeLength];
|
||
}
|
||
|
||
// 最后一手牌;
|
||
if (isLastCard && (cbMaxThreeLength * 5 >= cbCardCount))
|
||
{
|
||
cbBlockCount = cbMaxThreeLength;
|
||
cbMaxCardData = cbMaxThreeCardData;
|
||
cbCardType = DZ_CT_THREE_LINE;
|
||
}
|
||
else if (!isLastCard)
|
||
{
|
||
// 计算几个三带二
|
||
uint8 cbTmpBlockCount = cbCardCount / 5;
|
||
if ((cbTmpBlockCount * 5 == cbCardCount) && (cbMaxThreeLength >= cbTmpBlockCount))
|
||
{
|
||
cbBlockCount = cbTmpBlockCount;
|
||
cbMaxCardData = cbMaxThreeCardData;
|
||
cbCardType = DZ_CT_THREE_LINE;
|
||
}
|
||
}
|
||
|
||
return cbCardType;
|
||
}
|
||
|
||
return DZ_CT_ERROR;
|
||
}
|
||
|
||
//排列扑克
|
||
void DZ_CGameLogic::SortCardList(uint8 cbCardData[], uint8 cbCardCount, uint8 cbSortType)
|
||
{
|
||
//数目过虑
|
||
if (cbCardCount == 0) return;
|
||
|
||
if (cbSortType == DZ_ST_ORDER)
|
||
{
|
||
//转换数值
|
||
BYTE cbSortValue[DZ_MAX_COUNT];
|
||
for (BYTE 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);
|
||
}
|
||
//数目排序
|
||
else if (cbSortType == DZ_ST_COUNT)
|
||
{
|
||
//变量定义
|
||
uint8 cbCardIndex = 0;
|
||
|
||
//分析扑克
|
||
tagDZAnalyseResult AnalyseResult;
|
||
zeromemory(&AnalyseResult, sizeof(AnalyseResult));
|
||
AnalysebCardData(&cbCardData[cbCardIndex], cbCardCount - cbCardIndex, AnalyseResult);
|
||
|
||
//提取扑克
|
||
for (uint8 i = 0; i < CountArray(AnalyseResult.cbBlockCount); i++)
|
||
{
|
||
//拷贝扑克
|
||
uint8 cbIndex = CountArray(AnalyseResult.cbBlockCount) - i - 1;
|
||
CopyMemory(&cbCardData[cbCardIndex], AnalyseResult.cbCardData[cbIndex], AnalyseResult.cbBlockCount[cbIndex] * (cbIndex + 1)*sizeof(uint8));
|
||
|
||
//设置索引
|
||
cbCardIndex += AnalyseResult.cbBlockCount[cbIndex] * (cbIndex + 1)*sizeof(uint8);
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
//混乱扑克
|
||
void DZ_CGameLogic::RandCardList(uint8 cbCardBuffer[], uint8 cbBufferCount)
|
||
{
|
||
//混乱准备
|
||
uint8 cbCardData[CountArray(m_cbCardData)];
|
||
CopyMemory(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;
|
||
}
|
||
|
||
//混乱扑克
|
||
void DZ_CGameLogic::RandNoJokerCardList(uint8 cbCardBuffer[], uint8 cbBufferCount)
|
||
{
|
||
//混乱准备
|
||
uint8 cbCardData[CountArray(m_cbNoJokerCardData)];
|
||
CopyMemory(cbCardData, m_cbNoJokerCardData, sizeof(m_cbNoJokerCardData));
|
||
|
||
//混乱扑克
|
||
uint8 cbRandCount = 0, cbPosition = 0;
|
||
do
|
||
{
|
||
cbPosition = rand() % (cbBufferCount - cbRandCount);
|
||
cbCardBuffer[cbRandCount++] = cbCardData[cbPosition];
|
||
cbCardData[cbPosition] = cbCardData[cbBufferCount - cbRandCount];
|
||
} while (cbRandCount < cbBufferCount);
|
||
|
||
return;
|
||
}
|
||
|
||
//删除扑克
|
||
bool DZ_CGameLogic::RemoveCard(const uint8 cbRemoveCard[], uint8 cbRemoveCount, uint8 cbCardData[], uint8 cbCardCount)
|
||
{
|
||
//检验数据
|
||
ASSERT(cbRemoveCount<=cbCardCount);
|
||
if(cbRemoveCount>cbCardCount)
|
||
return false ;
|
||
|
||
//定义变量
|
||
uint8 cbDeleteCount=0,cbTempCardData[DZ_MAX_COUNT];
|
||
if (cbCardCount>CountArray(cbTempCardData)) return false;
|
||
CopyMemory(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;
|
||
|
||
//清理扑克
|
||
zeromemory(cbCardData, sizeof(uint8)*cbCardCount);
|
||
|
||
uint8 cbCardPos=0;
|
||
for (uint8 i=0;i<cbCardCount;i++)
|
||
{
|
||
if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//有效判断
|
||
bool DZ_CGameLogic::IsValidCard(uint8 cbCardData)
|
||
{
|
||
//获取属性
|
||
uint8 cbCardColor=GetCardColor(cbCardData);
|
||
uint8 cbCardValue=GetCardValue(cbCardData);
|
||
|
||
//有效判断
|
||
if ((cbCardData==0x4E)||(cbCardData==0x4F)) return true;
|
||
if ((cbCardColor<=0x30)&&(cbCardValue>=0x01)&&(cbCardValue<=0x0D)) return true;
|
||
|
||
return false;
|
||
}
|
||
|
||
//逻辑数值
|
||
uint8 DZ_CGameLogic::GetCardLogicValue(uint8 cbCardData)
|
||
{
|
||
if (!IsValidCard(cbCardData)) return 0;
|
||
|
||
//扑克属性
|
||
uint8 cbCardColor=GetCardColor(cbCardData);
|
||
uint8 cbCardValue=GetCardValue(cbCardData);
|
||
|
||
//#ifdef _DEBUG
|
||
// if(cbCardValue<=0 || cbCardValue>(DZ_MASK_VALUE&0x4f))
|
||
// return 0 ;
|
||
//#endif
|
||
|
||
ASSERT(cbCardValue>0 && cbCardValue <= (DZ_MASK_VALUE & 0x4f));
|
||
|
||
//转换数值
|
||
if (cbCardColor==0x40) return cbCardValue+2;
|
||
|
||
return (cbCardValue<=2)?(cbCardValue+13):cbCardValue;
|
||
}
|
||
|
||
//对比扑克
|
||
bool DZ_CGameLogic::CompareCard(const DZ_CMD_C_OutCard* pFirstOutCard, const DZ_CMD_C_OutCard* pNextOutCard)
|
||
{
|
||
if (pFirstOutCard == nullptr || pNextOutCard == nullptr) return false;
|
||
|
||
//获取类型
|
||
int cbFirstType = pFirstOutCard->cbCardType;
|
||
int cbNextType = pNextOutCard->cbCardType;
|
||
|
||
//类型判断
|
||
if (cbNextType == DZ_CT_ERROR) return false;
|
||
|
||
uint8 cbFirstCount = pFirstOutCard->cbCardCount;
|
||
uint8 cbNextCount = pNextOutCard->cbCardCount;
|
||
bool isFirstLastCard = pFirstOutCard->isLastCard;
|
||
bool isNextLastCard = pNextOutCard->isLastCard;
|
||
|
||
uint8 cbFirstCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbNextCard[DZ_MAX_COUNT] = { 0 };
|
||
CopyMemory(cbFirstCard, pFirstOutCard->cbCardData, sizeof(uint8)*cbFirstCount);
|
||
CopyMemory(cbNextCard, pNextOutCard->cbCardData, sizeof(uint8)*cbNextCount);
|
||
|
||
//炸弹过虑
|
||
int cbTmpFirstType = (cbFirstType >> DZ_CT_BOMB_4);
|
||
int cbTmpNextType = (cbNextType >> DZ_CT_BOMB_4);
|
||
|
||
if (cbTmpFirstType > 0 || cbTmpNextType > 0)
|
||
{
|
||
// 当前牌不是炸弹则打不到上一手炸弹牌;
|
||
if (cbTmpNextType < 0) return false;
|
||
//if (cbTmpFirstType > 0) return true;
|
||
|
||
//星级比较
|
||
if (cbTmpFirstType != cbTmpNextType)
|
||
{
|
||
return cbTmpNextType > cbTmpFirstType;
|
||
}
|
||
else
|
||
{
|
||
// 取最后一张，一定不是癞子;如果还是癞子，那就是4王炸;
|
||
uint8 cbConsultNext = GetCardLogicValue(cbNextCard[cbNextCount - 1]);
|
||
uint8 cbConsultFirst = GetCardLogicValue(cbFirstCard[cbFirstCount - 1]);
|
||
|
||
return cbConsultNext > cbConsultFirst;
|
||
}
|
||
}
|
||
|
||
//不同类型
|
||
if (cbFirstType != cbNextType) return false;
|
||
|
||
//获取数值
|
||
uint8 cbNextLogicValue = 0;
|
||
uint8 cbFirstLogicValue = 0;
|
||
|
||
//分析扑克
|
||
uint8 NextResult[DZ_CT_COUNT] = {0};
|
||
uint8 FirstResult[DZ_CT_COUNT] = { 0 };
|
||
|
||
// 单牌;
|
||
if ((cbNextType&(1 << DZ_CT_SINGLE)) != 0 && cbFirstCount == cbNextCount)
|
||
{
|
||
if (cbFirstCount != 1) return false;
|
||
|
||
//获取数值
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCard[0]);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCard[0]);
|
||
|
||
if (cbNextLogicValue > cbFirstLogicValue) return true;
|
||
}
|
||
else if ((cbNextType&(1 << DZ_CT_DOUBLE)) != 0 && cbFirstCount == cbNextCount)
|
||
{
|
||
if (cbFirstCount != 2) return false;
|
||
|
||
//获取数值
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCard[1]);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCard[1]);
|
||
|
||
if (cbNextLogicValue > cbFirstLogicValue) return true;
|
||
}
|
||
else if ((cbNextType&(1 << DZ_CT_THREE_TAKE_TWO)) != 0)
|
||
{
|
||
// 三带二牌数判断;
|
||
if (cbFirstCount < 3 || cbFirstCount > 5) return false;
|
||
if (cbNextCount < 3 || cbNextCount > 5) return false;
|
||
|
||
// 不是最后一手牌必须是5张;
|
||
if (!isFirstLastCard && cbFirstCount != 5) return false;
|
||
if (!isNextLastCard && cbNextCount != 5) return false;
|
||
|
||
uint8 cbNextBlockCount = 0, cbFirstBlockCount = 0;
|
||
if (!AnalysebCompare(cbNextCard, cbNextCount, NextResult, cbNextBlockCount, DZ_CT_THREE_TAKE_TWO, isNextLastCard))return false;
|
||
if (!AnalysebCompare(cbFirstCard, cbFirstCount, FirstResult, cbFirstBlockCount, DZ_CT_THREE_TAKE_TWO, isFirstLastCard))return false;
|
||
|
||
//获取数值
|
||
cbNextLogicValue = GetCardLogicValue(NextResult[DZ_CT_THREE_TAKE_TWO]);
|
||
cbFirstLogicValue = GetCardLogicValue(FirstResult[DZ_CT_THREE_TAKE_TWO]);
|
||
|
||
if (cbNextLogicValue > cbFirstLogicValue) return true;
|
||
}
|
||
else if ((cbNextType&(1 << DZ_CT_SINGLE_LINE)) != 0 && cbFirstCount == cbNextCount)
|
||
{
|
||
if (cbFirstCount < 5) return false;
|
||
|
||
//获取数值
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCard[cbNextCount - 1]);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCard[cbFirstCount - 1]);
|
||
|
||
if (cbNextLogicValue > cbFirstLogicValue) return true;
|
||
|
||
}
|
||
else if ((cbNextType&(1 << DZ_CT_DOUBLE_LINE)) != 0 && cbFirstCount == cbNextCount)
|
||
{
|
||
if ((cbFirstCount < 4) || (cbFirstCount%2)!=0) return false;
|
||
|
||
//获取数值
|
||
cbNextLogicValue = GetCardLogicValue(cbNextCard[cbNextCount - 1]);
|
||
cbFirstLogicValue = GetCardLogicValue(cbFirstCard[cbFirstCount - 1]);
|
||
|
||
if (cbNextLogicValue > cbFirstLogicValue) return true;
|
||
|
||
}
|
||
else if ((cbNextType&(1 << DZ_CT_THREE_LINE)) != 0)
|
||
{
|
||
// 三带二牌数判断;
|
||
if (cbFirstCount < 6 || cbNextCount < 6) return false;
|
||
|
||
// 不是最后一手牌必须是5的倍数;
|
||
if (!isFirstLastCard && (cbFirstCount%5) != 0) return false;
|
||
if (!isNextLastCard && (cbNextCount%5) != 0) return false;
|
||
|
||
// 都不是最后一手牌，两个牌数必须相同;
|
||
if (!isFirstLastCard &&!isNextLastCard && (cbNextCount != cbFirstCount)) return false;
|
||
|
||
uint8 cbNextBlockCount = 0, cbFirstBlockCount = 0;
|
||
if (!AnalysebCompare(cbNextCard, cbNextCount, NextResult, cbNextBlockCount, DZ_CT_THREE_LINE, isNextLastCard))return false;
|
||
if (!AnalysebCompare(cbFirstCard, cbFirstCount, FirstResult, cbFirstBlockCount, DZ_CT_THREE_LINE, isFirstLastCard))return false;
|
||
|
||
if (cbNextBlockCount != cbFirstBlockCount) return false;
|
||
|
||
//获取数值
|
||
cbNextLogicValue = GetCardLogicValue(NextResult[DZ_CT_THREE_LINE]);
|
||
cbFirstLogicValue = GetCardLogicValue(FirstResult[DZ_CT_THREE_LINE]);
|
||
|
||
if (cbNextLogicValue > cbFirstLogicValue) return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//赖子数目
|
||
uint8 DZ_CGameLogic::GetLaiZiCount(const uint8 cbHandCardData[], uint8 cbHandCardCount)
|
||
{
|
||
uint8 bLaiZiCount=0;
|
||
for(uint8 i=0;i<cbHandCardCount;i++)
|
||
{
|
||
if (IsLaiZiCard(cbHandCardData[i]))
|
||
bLaiZiCount++;
|
||
}
|
||
|
||
return bLaiZiCount;
|
||
}
|
||
|
||
//是否癞子牌
|
||
bool DZ_CGameLogic::IsLaiZiCard(uint8 cbCard)
|
||
{
|
||
ASSERT(IsValidCard(cbCard));
|
||
|
||
if (0x40 == GetCardColor(cbCard))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//分析扑克
|
||
void DZ_CGameLogic::AnalysebCardData(const uint8 cbCardData[], uint8 cbCardCount, tagDZAnalyseResult & AnalyseResult)
|
||
{
|
||
//设置变量
|
||
uint8 cbTmpCardData[DZ_MAX_COUNT] = { 0 };
|
||
CopyMemory(cbTmpCardData, cbCardData, sizeof(uint8)*cbCardCount);
|
||
|
||
SortCardList(cbTmpCardData, cbCardCount, DZ_ST_ORDER);
|
||
|
||
//扑克分析
|
||
for (uint8 i=0;i<cbCardCount;i++)
|
||
{
|
||
//变量定义
|
||
uint8 cbSameCount=1,cbCardValueTemp=0;
|
||
uint8 cbLogicValue = GetCardLogicValue(cbTmpCardData[i]);
|
||
|
||
//搜索同牌
|
||
for (uint8 j=i+1;j<cbCardCount;j++)
|
||
{
|
||
//获取扑克
|
||
if (GetCardLogicValue(cbTmpCardData[j]) != cbLogicValue) break;
|
||
|
||
//设置变量
|
||
cbSameCount++;
|
||
}
|
||
|
||
//设置结果
|
||
uint8 cbIndex = AnalyseResult.cbBlockCount[cbSameCount - 1]++;
|
||
for (uint8 j = 0; j < cbSameCount; j++)
|
||
{
|
||
AnalyseResult.cbCardData[cbSameCount - 1][cbIndex*cbSameCount + j] = cbTmpCardData[i + j];
|
||
}
|
||
|
||
//设置索引
|
||
i+=cbSameCount-1;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
//分析比较
|
||
bool DZ_CGameLogic::AnalysebCompare(const uint8 cbCardData[], uint8 cbCardCount, uint8 cbMaxCardData[DZ_CT_COUNT], uint8 &cbBlockCount, int dCardType, bool isLastCard)
|
||
{
|
||
// 重置;
|
||
cbBlockCount = 0;
|
||
zeromemory(cbMaxCardData, sizeof(cbMaxCardData));
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCardCount++;
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbCardData[i];
|
||
}
|
||
}
|
||
|
||
int dCardTypeTemp = DZ_CT_ERROR;
|
||
dCardTypeTemp = (1 << dCardType);
|
||
|
||
// 没有癞子;
|
||
if (cbMagicCardCount == 0)
|
||
{
|
||
uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
|
||
CopyMemory(bCardDataTemp, cbCardData, sizeof(uint8)*cbCardCount);
|
||
|
||
//分析扑克
|
||
tagDZAnalyseResult AnalyseResultTemp;
|
||
zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);
|
||
|
||
//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);
|
||
|
||
if ((dCardTypeTemp&(1 << iCardType)) != 0)
|
||
{
|
||
//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
|
||
{
|
||
cbBlockCount = cbTmpBlockCount;
|
||
cbMaxCardData[iCardType] = cbTmpMaxCardData;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (cbMagicCardCount >= 1)
|
||
{
|
||
tagDZAnalyseResult AnalyseResultTemp;
|
||
zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));
|
||
|
||
uint8 bCardDataTemp[DZ_MAX_COUNT] = { 0 };
|
||
CopyMemory(&bCardDataTemp[cbMagicCardCount], cbNormalCard, sizeof(uint8)*cbNormalCardCount);
|
||
|
||
for (uint8 i = 0; i < 13; i++)
|
||
{
|
||
bCardDataTemp[0] = m_cbCardData[i];
|
||
|
||
//两张赖子
|
||
if (cbMagicCardCount >= 2)
|
||
{
|
||
for (uint8 z = 0; z < 13; z++)
|
||
{
|
||
bCardDataTemp[1] = m_cbCardData[z];
|
||
|
||
//三张赖子
|
||
if (cbMagicCardCount >= 3)
|
||
{
|
||
for (uint8 f = 0; f < 13; f++)
|
||
{
|
||
bCardDataTemp[2] = m_cbCardData[f];
|
||
|
||
//四张赖子
|
||
if (cbMagicCardCount == 4)
|
||
{
|
||
for (uint8 l = 0; l < 13; l++)
|
||
{
|
||
bCardDataTemp[3] = m_cbCardData[l];
|
||
|
||
zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);
|
||
|
||
//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);
|
||
|
||
if ((dCardTypeTemp&(1 << iCardType)) != 0)
|
||
{
|
||
//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
|
||
if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
|
||
{
|
||
cbBlockCount = cbTmpBlockCount;
|
||
cbMaxCardData[iCardType] = cbTmpMaxCardData;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);
|
||
|
||
//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);
|
||
|
||
if ((dCardTypeTemp&(1 << iCardType)) != 0)
|
||
{
|
||
//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
|
||
if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
|
||
{
|
||
cbBlockCount = cbTmpBlockCount;
|
||
cbMaxCardData[iCardType] = cbTmpMaxCardData;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);
|
||
|
||
//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);
|
||
|
||
if ((dCardTypeTemp&(1 << iCardType)) != 0)
|
||
{
|
||
//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
|
||
if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
|
||
{
|
||
cbBlockCount = cbTmpBlockCount;
|
||
cbMaxCardData[iCardType] = cbTmpMaxCardData;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
zeromemory(&AnalyseResultTemp, sizeof(AnalyseResultTemp));
|
||
|
||
AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResultTemp);
|
||
|
||
//int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, isLastCard);
|
||
uint8 cbTmpMaxCardData = 0, cbTmpBlockCount = 0;
|
||
int iCardType = GetType(AnalyseResultTemp, bCardDataTemp, cbCardCount, cbTmpMaxCardData, cbTmpBlockCount, isLastCard);
|
||
|
||
if ((dCardTypeTemp&(1 << iCardType)) != 0)
|
||
{
|
||
//AnalysebCardData(bCardDataTemp, cbCardCount, AnalyseResult);
|
||
//if (cbMaxCardData[iCardType] < cbTmpMaxCardData)
|
||
if (GetCardLogicValue(cbMaxCardData[iCardType]) < GetCardLogicValue(cbTmpMaxCardData))
|
||
{
|
||
cbBlockCount = cbTmpBlockCount;
|
||
cbMaxCardData[iCardType] = cbTmpMaxCardData;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//随机扑克
|
||
uint8 DZ_CGameLogic::GetRandomCard(void)
|
||
{
|
||
size_t cbIndex = rand()%(sizeof(m_cbCardData)) ;
|
||
return m_cbCardData[cbIndex] ;
|
||
}
|
||
|
||
//排列扑克
|
||
void DZ_CGameLogic::SortOutCardList(uint8 cbCardData[], uint8 cbCardCount, int nCardType, bool isLastCard)
|
||
{
|
||
return;
|
||
}
|
||
|
||
//牌组转换(将32张牌的使用情况转化为一个32位整型)
|
||
int DZ_CGameLogic::TransListToInt(int iOldType,int iNewType)
|
||
{
|
||
//数据校验
|
||
if(iNewType == 0) return 0;
|
||
|
||
//变量定义
|
||
int nList = 0;
|
||
ASSERT(iNewType != -1);
|
||
nList |= (1<<iNewType);
|
||
|
||
return iOldType|nList;
|
||
}
|
||
|
||
//是否包含牌型
|
||
bool DZ_CGameLogic::IsHasCardType(int iCardType, CART_TYPE ct_value)
|
||
{
|
||
if (iCardType == DZ_CT_ERROR) return false;
|
||
|
||
return ((iCardType&(1 << ct_value)) != 0);
|
||
}
|
||
|
||
//是不是炸弹;
|
||
bool DZ_CGameLogic::IsBombType(int iCardType)
|
||
{
|
||
return ((iCardType >> DZ_CT_BOMB_4) > 0);
|
||
}
|
||
|
||
//分析分布
|
||
void DZ_CGameLogic::AnalysebDistributing(const uint8 cbCardData[], uint8 cbCardCount, tagDZDistributing & Distributing)
|
||
{
|
||
//设置变量
|
||
zeromemory(&Distributing, sizeof(tagDZDistributing));
|
||
|
||
//设置变量
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (cbCardData[i] == 0) continue;
|
||
|
||
//获取属性
|
||
uint8 cbCardColor = GetCardColor(cbCardData[i]);
|
||
//uint8 cbCardValue = GetCardValue(cbCardData[i]);
|
||
uint8 cbCardValue = GetCardLogicValue(cbCardData[i]);
|
||
|
||
//分布信息
|
||
Distributing.cbCardCount++;
|
||
Distributing.cbDistributing[cbCardValue][cbIndexCount]++;
|
||
Distributing.cbDistributing[cbCardValue][cbCardColor >> 4]++;
|
||
|
||
//Distributing.cbDistributing[cbCardValue - 1][cbIndexCount]++;
|
||
//Distributing.cbDistributing[cbCardValue - 1][cbCardColor >> 4]++;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
//出牌搜索
|
||
uint8 DZ_CGameLogic::SearchOutCard(const uint8 cbHandCardData[], uint8 cbHandCardCount, const DZ_CMD_C_OutCard* pFirstOutCard, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
//设置结果
|
||
assert(pSearchCardResult != nullptr);
|
||
if (pSearchCardResult == nullptr || pFirstOutCard == nullptr) return 0;
|
||
|
||
//获取类型
|
||
int cbTurnOutType = pFirstOutCard->cbCardType;
|
||
if (cbTurnOutType == DZ_CT_ERROR) return 0;
|
||
|
||
uint8 cbTurnCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbTurnCardCount = pFirstOutCard->cbCardCount;
|
||
CopyMemory(cbTurnCardData, pFirstOutCard->cbCardData, sizeof(uint8)*cbTurnCardCount);
|
||
|
||
//变量定义
|
||
uint8 cbResultCount = 0;
|
||
tagDZSearchCardResult tmpSearchCardResult = {};
|
||
zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
SortCardList(cbCardData, cbCardCount, DZ_ST_ORDER);
|
||
|
||
//是否一手出完
|
||
int iLastCardType = GetCardType(cbCardData, cbCardCount, true);
|
||
if (iLastCardType != DZ_CT_ERROR)
|
||
{
|
||
DZ_CMD_C_OutCard tmpOutCard;
|
||
zeromemory(&tmpOutCard, sizeof(DZ_CMD_C_OutCard));
|
||
tmpOutCard.isLastCard = true;
|
||
tmpOutCard.cbCardCount = cbHandCardCount;
|
||
tmpOutCard.cbCardType = iLastCardType;
|
||
CopyMemory(tmpOutCard.cbCardData, cbCardData, sizeof(uint8)*cbCardCount);
|
||
|
||
if (CompareCard(pFirstOutCard, &tmpOutCard) == true)
|
||
{
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCardCount;
|
||
memcpy(pSearchCardResult->cbResultCard[cbResultCount], cbCardData, sizeof(uint8)*cbCardCount);
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
|
||
// 提示出牌;
|
||
if (IsHasCardType(cbTurnOutType, DZ_CT_SINGLE))
|
||
{
|
||
//变量定义
|
||
uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
|
||
cbResultCount = SearchSingle(cbCardData, cbCardCount, cbReferCard, pSearchCardResult);
|
||
}
|
||
else if (IsHasCardType(cbTurnOutType, DZ_CT_DOUBLE))
|
||
{
|
||
//变量定义
|
||
uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
|
||
cbResultCount = SearchDouble(cbCardData, cbCardCount, cbReferCard, pSearchCardResult);
|
||
}
|
||
else if (IsHasCardType(cbTurnOutType, DZ_CT_SINGLE_LINE))
|
||
{
|
||
//变量定义
|
||
uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
|
||
cbResultCount = SearchSingleLine(cbCardData, cbCardCount, cbReferCard, cbTurnCardCount, pSearchCardResult);
|
||
}
|
||
else if (IsHasCardType(cbTurnOutType, DZ_CT_DOUBLE_LINE))
|
||
{
|
||
//变量定义
|
||
uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
|
||
uint8 cbLineCount = cbTurnCardCount / 2;
|
||
cbResultCount = SearchDoubleLine(cbCardData, cbCardCount, cbReferCard, cbLineCount, pSearchCardResult);
|
||
}
|
||
else if (IsHasCardType(cbTurnOutType, DZ_CT_THREE_TAKE_TWO))
|
||
{
|
||
//效验牌数
|
||
if (cbCardCount < 5) return cbResultCount;
|
||
|
||
uint8 cbFirstLogicValue = 0, cbBlockCount = 0;
|
||
uint8 FirstResult[DZ_CT_COUNT] = { 0 };
|
||
if (!AnalysebCompare(cbTurnCardData, cbTurnCardCount, FirstResult, cbBlockCount, DZ_CT_THREE_TAKE_TWO, pFirstOutCard->isLastCard))return 0;
|
||
|
||
//获取数值
|
||
cbFirstLogicValue = GetCardLogicValue(FirstResult[DZ_CT_THREE_TAKE_TWO]);
|
||
|
||
//带癞子搜索;
|
||
cbResultCount = SearchThreeTakeTwo(cbCardData, cbCardCount, cbFirstLogicValue, pSearchCardResult);
|
||
}
|
||
else if (IsHasCardType(cbTurnOutType, DZ_CT_THREE_LINE))
|
||
{
|
||
//效验牌数
|
||
if (cbCardCount < 6) return cbResultCount;
|
||
|
||
uint8 cbFirstLogicValue = 0;
|
||
uint8 cbBlockCount = 0;
|
||
uint8 FirstResult[DZ_CT_COUNT] = { 0 };
|
||
if (!AnalysebCompare(cbTurnCardData, cbTurnCardCount, FirstResult, cbBlockCount, DZ_CT_THREE_LINE, pFirstOutCard->isLastCard))return 0;
|
||
|
||
//带癞子搜索(要算出最小牌);
|
||
cbFirstLogicValue = (GetCardLogicValue(FirstResult[DZ_CT_THREE_LINE]) - cbBlockCount + 1);
|
||
cbResultCount = SearchThreeLineTakeTwo(cbCardData, cbCardCount, cbFirstLogicValue, cbBlockCount, pSearchCardResult);
|
||
}
|
||
|
||
//搜索炸弹
|
||
if (cbCardCount >= 4)
|
||
{
|
||
//变量定义
|
||
uint8 cbReferCard = cbTurnCardData[cbTurnCardCount - 1];
|
||
SearchBomb(cbCardData, cbCardCount, cbReferCard, cbTurnCardCount, cbTurnOutType, pSearchCardResult, cbResultCount);
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索单牌(不考虑癞子);
|
||
uint8 DZ_CGameLogic::SearchSingle(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
//设置结果
|
||
if (pSearchCardResult) zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
//分析结果
|
||
uint8 cbResultCount = 0;
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
|
||
//排列扑克
|
||
SortCardList(cbCardData, cbCardCount, DZ_ST_ORDER);
|
||
|
||
//分析扑克
|
||
tagDZAnalyseResult AnalyseResult = {};
|
||
AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);
|
||
|
||
//比较牌逻辑值;
|
||
uint8 cbReferLogicValue = (cbReferCard == 0) ? 0 : GetCardLogicValue(cbReferCard);
|
||
uint8 cbBlockIndex = BLOCK_ONE;
|
||
|
||
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], sizeof(uint8));
|
||
pSearchCardResult->cbCardCount[cbResultCount] = 1;
|
||
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
|
||
cbBlockIndex++;
|
||
|
||
} while (cbBlockIndex < CountArray(AnalyseResult.cbBlockCount));
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索对子;
|
||
uint8 DZ_CGameLogic::SearchDouble(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
//设置结果
|
||
if (pSearchCardResult) zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
//分析结果
|
||
uint8 cbResultCount = 0;
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
|
||
//排列扑克
|
||
SortCardList(cbCardData, cbCardCount, DZ_ST_ORDER);
|
||
|
||
//分析扑克
|
||
tagDZAnalyseResult AnalyseResult = {};
|
||
AnalysebCardData(cbCardData, cbCardCount, AnalyseResult);
|
||
|
||
//比较牌逻辑值;
|
||
uint8 cbReferLogicValue = (cbReferCard == 0) ? 0 : GetCardLogicValue(cbReferCard);
|
||
uint8 cbBlockIndex = BLOCK_TWO;
|
||
|
||
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], sizeof(uint8)*2);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = 2;
|
||
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
|
||
cbBlockIndex++;
|
||
|
||
} while (cbBlockIndex < CountArray(AnalyseResult.cbBlockCount));
|
||
|
||
// 一个癞子，加一张单牌的情况;
|
||
uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCard[cbMagicCardCount] = cbCardData[i];
|
||
|
||
cbMagicCardCount++;
|
||
}
|
||
}
|
||
|
||
// 有一张癞子;
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 i = 0; i < AnalyseResult.cbBlockCount[BLOCK_ONE]; i++)
|
||
{
|
||
// 从小到大取牌;
|
||
uint8 cbIndex = (AnalyseResult.cbBlockCount[BLOCK_ONE] - i - 1);
|
||
|
||
if (IsLaiZiCard(AnalyseResult.cbCardData[BLOCK_ONE][cbIndex])) continue;
|
||
|
||
if (GetCardLogicValue(AnalyseResult.cbCardData[BLOCK_ONE][cbIndex]) > cbReferLogicValue)
|
||
{
|
||
if (pSearchCardResult == NULL) return 1;
|
||
|
||
assert(cbResultCount < CountArray(pSearchCardResult->cbCardCount));
|
||
|
||
//复制扑克
|
||
pSearchCardResult->cbResultCard[cbResultCount][0] = cbMagicCard[cbMagicCardCount - 1];
|
||
pSearchCardResult->cbResultCard[cbResultCount][1] = AnalyseResult.cbCardData[BLOCK_ONE][cbIndex];
|
||
pSearchCardResult->cbCardCount[cbResultCount] = 2;
|
||
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索单顺;
|
||
uint8 DZ_CGameLogic::SearchSingleLine(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbLineCount, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
//设置结果
|
||
if (pSearchCardResult == nullptr) return 0;
|
||
if (!IsValidCard(cbReferCard)) return 0;
|
||
if (cbLineCount < 5) return 0;
|
||
|
||
//定义变量
|
||
uint8 cbResultCount = 0;
|
||
uint8 cbReferIndex = GetCardLogicValue(cbReferCard)+1; // 最后一张牌;
|
||
zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
//超过A
|
||
if (cbReferIndex + cbLineCount > GetCardLogicValue(0x01) + 1)
|
||
{
|
||
return cbResultCount;
|
||
}
|
||
|
||
//长度判断
|
||
if (cbHandCardCount < cbLineCount)
|
||
{
|
||
return cbResultCount;
|
||
}
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCard[cbMagicCardCount++] = cbCardData[i];
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbCardData[i];
|
||
}
|
||
}
|
||
|
||
//排列扑克
|
||
SortCardList(cbNormalCard, cbNormalCardCount, DZ_ST_ORDER);
|
||
|
||
//分析扑克
|
||
tagDZDistributing Distributing = {};
|
||
AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);
|
||
|
||
//搜索顺子
|
||
uint8 cbMaxIndex = GetCardLogicValue(0x01) - cbLineCount + 1;
|
||
|
||
// 不带癞子;
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;
|
||
|
||
uint8 cbTmpLinkCount = 0; // 当前最大连牌数;
|
||
|
||
for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
|
||
{
|
||
//继续判断
|
||
if (Distributing.cbDistributing[j][cbIndexCount] < 1)
|
||
{
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
cbTmpLinkCount++;
|
||
}
|
||
|
||
// 找到足够大的连牌;
|
||
if (cbTmpLinkCount >= cbLineCount)
|
||
{
|
||
//复制扑克
|
||
uint8 cbCount = 0;
|
||
for (uint8 cbIndex = i; cbIndex <= j; 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 == 1) break;
|
||
}
|
||
|
||
if (cbTmpCount == 1) break;
|
||
}
|
||
}
|
||
|
||
//// 加入癞子;
|
||
//for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
|
||
//{
|
||
// pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
|
||
//}
|
||
|
||
//设置变量
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
||
cbResultCount++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 带癞子;
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;
|
||
|
||
uint8 cbTmpLinkCount = 0; // 当前最大连牌数;
|
||
uint8 cbUseMagicCount = 0; // 已经使用癞子数量;
|
||
|
||
for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
|
||
{
|
||
//继续判断
|
||
if (Distributing.cbDistributing[j][cbIndexCount] < 1)
|
||
{
|
||
// 是否有癞子;
|
||
if (cbUseMagicCount < cbMagicCardCount)
|
||
{
|
||
cbTmpLinkCount++;
|
||
cbUseMagicCount++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
cbTmpLinkCount++;
|
||
}
|
||
|
||
// 找到足够大的连牌;
|
||
if (cbTmpLinkCount >= cbLineCount)
|
||
{
|
||
// 带癞子分析，如果不包含癞子，就不需要，防止重复分析;
|
||
if (cbUseMagicCount <= 0) break;
|
||
|
||
//复制扑克
|
||
uint8 cbCount = 0;
|
||
for (uint8 cbIndex = i; cbIndex <= j; 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 == 1) break;
|
||
}
|
||
|
||
if (cbTmpCount == 1) break;
|
||
}
|
||
}
|
||
|
||
// 加入癞子;
|
||
for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
|
||
{
|
||
pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
|
||
}
|
||
|
||
//设置变量
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
||
cbResultCount++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索双顺;
|
||
uint8 DZ_CGameLogic::SearchDoubleLine(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbLineCount, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
//设置结果
|
||
if (pSearchCardResult == nullptr) return 0;
|
||
if (!IsValidCard(cbReferCard)) return 0;
|
||
if (cbLineCount < 2) return 0;
|
||
|
||
//定义变量
|
||
uint8 cbResultCount = 0;
|
||
uint8 cbReferIndex = GetCardLogicValue(cbReferCard) + 1; // 最后一张牌;
|
||
zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
//超过A
|
||
if (cbReferIndex + cbLineCount > GetCardLogicValue(0x01) + 1)
|
||
{
|
||
return cbResultCount;
|
||
}
|
||
|
||
//长度判断
|
||
if (cbHandCardCount < cbLineCount * 2)
|
||
{
|
||
return cbResultCount;
|
||
}
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCard[cbMagicCardCount++] = cbCardData[i];
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbCardData[i];
|
||
}
|
||
}
|
||
|
||
//排列扑克
|
||
SortCardList(cbNormalCard, cbNormalCardCount, DZ_ST_ORDER);
|
||
|
||
//分析扑克
|
||
tagDZDistributing Distributing = {};
|
||
AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);
|
||
|
||
//搜索顺子
|
||
uint8 cbMaxIndex = GetCardLogicValue(0x01) - cbLineCount + 1;
|
||
|
||
// 不带癞子;
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;
|
||
|
||
uint8 cbTmpLinkCount = 0; // 当前最大连牌数;
|
||
uint8 cbUseMagicCount = 0; // 已经使用癞子数量;
|
||
|
||
for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
|
||
{
|
||
// 有2张牌;
|
||
if (Distributing.cbDistributing[j][cbIndexCount] >= 2)
|
||
{
|
||
cbTmpLinkCount++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
|
||
// 找到足够大的连牌;
|
||
if (cbTmpLinkCount >= cbLineCount)
|
||
{
|
||
//复制扑克
|
||
uint8 cbCount = 0;
|
||
for (uint8 cbIndex = i; cbIndex <= j; 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 == 2) break;
|
||
}
|
||
|
||
if (cbTmpCount == 2) break;
|
||
}
|
||
}
|
||
|
||
//// 加入癞子;
|
||
//for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
|
||
//{
|
||
// pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
|
||
//}
|
||
|
||
//设置变量
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
||
cbResultCount++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 带癞子;
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;
|
||
|
||
uint8 cbTmpLinkCount = 0; // 当前最大连牌数;
|
||
uint8 cbUseMagicCount = 0; // 已经使用癞子数量;
|
||
|
||
for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
|
||
{
|
||
// 有2张牌;
|
||
if (Distributing.cbDistributing[j][cbIndexCount] >= 2)
|
||
{
|
||
cbTmpLinkCount++;
|
||
}
|
||
// 只有一张;
|
||
else if (Distributing.cbDistributing[j][cbIndexCount] == 1)
|
||
{
|
||
// 是否还有癞子;
|
||
if (cbUseMagicCount < cbMagicCardCount)
|
||
{
|
||
cbTmpLinkCount++;
|
||
cbUseMagicCount++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
// 一张都没有;
|
||
else
|
||
{
|
||
// 是否还有2张癞子;
|
||
if (cbUseMagicCount + 2 <= cbMagicCardCount)
|
||
{
|
||
cbTmpLinkCount++;
|
||
cbUseMagicCount += 2;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 找到足够大的连牌;
|
||
if (cbTmpLinkCount >= cbLineCount)
|
||
{
|
||
// 带癞子分析，如果不包含癞子，就不需要，防止重复分析;
|
||
if (cbUseMagicCount <= 0) break;
|
||
|
||
//复制扑克
|
||
uint8 cbCount = 0;
|
||
for (uint8 cbIndex = i; cbIndex <= j; 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 == 2) break;
|
||
}
|
||
|
||
if (cbTmpCount == 2) break;
|
||
}
|
||
}
|
||
|
||
// 加入癞子;
|
||
for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
|
||
{
|
||
pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
|
||
}
|
||
|
||
//设置变量
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
||
cbResultCount++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索三带二;
|
||
uint8 DZ_CGameLogic::SearchThreeTakeTwo(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
if (cbHandCardCount < 5) return 0;
|
||
if (pSearchCardResult == nullptr) return 0;
|
||
if (!IsValidCard(cbReferCard)) return 0;
|
||
|
||
//定义变量
|
||
uint8 cbResultCount = 0;
|
||
uint8 cbReferIndex = GetCardLogicValue(cbReferCard) + 1; // 最后一张牌;
|
||
zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
if (cbReferIndex > GetCardLogicValue(0x02)) return 0;
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCard[cbMagicCardCount++] = cbCardData[i];
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbCardData[i];
|
||
}
|
||
}
|
||
|
||
//排列扑克
|
||
SortCardList(cbNormalCard, cbNormalCardCount, DZ_ST_ORDER);
|
||
|
||
//只有癞子和同牌，就是炸弹;
|
||
if (GetCardLogicValue(cbNormalCard[0]) == GetCardLogicValue(cbNormalCard[cbNormalCardCount - 1]))
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
//分析扑克
|
||
tagDZDistributing Distributing = {};
|
||
AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);
|
||
|
||
//分析扑克
|
||
tagDZAnalyseResult AnalyseResult = {};
|
||
AnalysebCardData(cbNormalCard, cbNormalCardCount, AnalyseResult);
|
||
|
||
uint8 cbMinIndex = 0x03;
|
||
uint8 cbMaxIndex = GetCardLogicValue(0x02);
|
||
|
||
// 不带癞子搜索;
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
// 没有不做变幻;
|
||
if (Distributing.cbDistributing[i][cbIndexCount] == 0) continue;
|
||
|
||
// 三带二
|
||
if (Distributing.cbDistributing[i][cbIndexCount] == 3)
|
||
{
|
||
// 先找带牌，如果找不到带牌，则牌型不成立;
|
||
uint8 cbTmpCount = 0;
|
||
uint8 cbTakeCard[5] = {0};
|
||
|
||
//复制扑克
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTakeCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
|
||
for (uint8 j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
|
||
{
|
||
for (uint8 k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
|
||
{
|
||
// 带牌的起始位置;
|
||
uint8 cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);
|
||
|
||
// 过滤相同牌;
|
||
if (i == GetCardLogicValue(AnalyseResult.cbCardData[j][cbIndex]))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 提取带牌;
|
||
for (uint8 n = 0; n < j+1; n++)
|
||
{
|
||
cbTakeCard[cbTmpCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
|
||
if (cbTmpCount == 5) break;
|
||
}
|
||
|
||
if (cbTmpCount == 5) break;
|
||
}
|
||
|
||
if (cbTmpCount == 5) break;
|
||
}
|
||
|
||
// 只有一张带牌，把癞子做带牌;
|
||
if (cbTmpCount == 4 && cbMagicCardCount > 0)
|
||
{
|
||
cbTakeCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - 1];
|
||
}
|
||
|
||
if (cbTmpCount == 5)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTakeCard, sizeof(uint8)*cbTmpCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 对子带癞子搜索;
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
// 没有不做变幻;
|
||
if (Distributing.cbDistributing[i][cbIndexCount] == 0) continue;
|
||
|
||
// 带癞子;
|
||
if (Distributing.cbDistributing[i][cbIndexCount] == 2 && (Distributing.cbDistributing[i][cbIndexCount] + cbMagicCardCount) >= 3)
|
||
{
|
||
// 先找带牌，如果找不到带牌，则牌型不成立;
|
||
uint8 cbTmpCount = 0;
|
||
uint8 cbTakeCard[5] = { 0 };
|
||
|
||
//复制扑克
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTakeCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
|
||
// 加癞子;
|
||
uint8 cbUseMagicCardCount = 0;
|
||
if (cbTmpCount < 3)
|
||
{
|
||
for (uint8 cbMagicIndex = 0; cbMagicIndex < cbMagicCardCount; cbMagicIndex++)
|
||
{
|
||
// 从小到大;
|
||
cbTakeCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - cbMagicIndex - 1];
|
||
cbUseMagicCardCount++;
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
}
|
||
|
||
// 提取带牌;
|
||
for (uint8 j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
|
||
{
|
||
for (uint8 k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
|
||
{
|
||
// 带牌的起始位置;
|
||
uint8 cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);
|
||
|
||
uint8 cbLogicValue = GetCardLogicValue(AnalyseResult.cbCardData[j][cbIndex]);
|
||
|
||
// 过滤相同牌;
|
||
if (i == cbLogicValue) continue;
|
||
|
||
// 如果带一个对子比三个头大，则不合理;
|
||
if (j > 0 && cbTmpCount == 3 && cbLogicValue > i) continue;
|
||
|
||
// 提取带牌;
|
||
for (uint8 n = 0; n < j + 1; n++)
|
||
{
|
||
cbTakeCard[cbTmpCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
|
||
if (cbTmpCount == 5) break;
|
||
}
|
||
|
||
if (cbTmpCount == 5) break;
|
||
}
|
||
|
||
if (cbTmpCount == 5) break;
|
||
}
|
||
|
||
if (cbTmpCount == 5)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTakeCard, sizeof(uint8)*cbTmpCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索飞机;
|
||
uint8 DZ_CGameLogic::SearchThreeLineTakeTwo(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard,
|
||
uint8 cbBlockCount, tagDZSearchCardResult *pSearchCardResult)
|
||
{
|
||
//设置结果
|
||
if (pSearchCardResult == nullptr) return 0;
|
||
if (!IsValidCard(cbReferCard)) return 0;
|
||
if (cbHandCardCount < cbBlockCount*5) return 0;
|
||
|
||
// 要打到上家牌，最小连牌值;
|
||
uint8 cbReferIndex = GetCardLogicValue(cbReferCard) + 1; // 最后一张牌;
|
||
|
||
//超过A
|
||
//if (cbReferIndex + cbBlockCount > 14) return 0;
|
||
if (cbReferIndex + cbBlockCount > GetCardLogicValue(0x01) + 1) return 0;
|
||
|
||
zeromemory(pSearchCardResult, sizeof(tagDZSearchCardResult));
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbHandCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbHandCardData[i]))
|
||
{
|
||
cbMagicCard[cbMagicCardCount++] = cbHandCardData[i];
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbHandCardData[i];
|
||
}
|
||
}
|
||
|
||
//排列扑克
|
||
SortCardList(cbNormalCard, cbNormalCardCount, DZ_ST_ORDER);
|
||
|
||
//定义变量
|
||
uint8 cbResultCount = 0;
|
||
|
||
//分析扑克
|
||
tagDZDistributing Distributing = {};
|
||
AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);
|
||
|
||
//搜索顺子
|
||
uint8 cbMaxIndex = GetCardLogicValue(0x01) - cbBlockCount + 1;
|
||
|
||
// 不考虑癞子;
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;
|
||
|
||
uint8 cbTmpLinkCount = 0; // 当前最大连牌数;
|
||
uint8 cbUseMagicCount = 0; // 已经使用癞子数量;
|
||
uint8 cbTmpCard[DZ_MAX_COUNT] = { 0 };
|
||
|
||
for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
|
||
{
|
||
// 有2张牌;
|
||
if (Distributing.cbDistributing[j][cbIndexCount] >= 3)
|
||
{
|
||
cbTmpLinkCount++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
|
||
// 找到足够大的连牌;
|
||
if (cbTmpLinkCount >= cbBlockCount)
|
||
{
|
||
//复制扑克
|
||
uint8 cbCount = 0;
|
||
for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
|
||
{
|
||
uint8 cbTmpCount = 0;
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTmpCard[cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);
|
||
|
||
if (++cbTmpCount == 3) break;
|
||
}
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
}
|
||
|
||
// 加入尾巴;
|
||
uint8 cbTakeCard[DZ_MAX_COUNT] = {0};
|
||
uint8 cbTakeCardCount = cbNormalCardCount;
|
||
CopyMemory(cbTakeCard, cbNormalCard, sizeof(uint8)*cbNormalCardCount);
|
||
|
||
// 将已经取出的牌删除;
|
||
if (RemoveCard(cbTmpCard, cbCount, cbTakeCard, cbNormalCardCount))
|
||
{
|
||
cbTakeCardCount -= cbCount;
|
||
}
|
||
|
||
// 分析剩余牌;
|
||
tagDZAnalyseResult AnalyseResult = {};
|
||
AnalysebCardData(cbTakeCard, cbTakeCardCount, AnalyseResult);
|
||
|
||
for (uint8 j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
|
||
{
|
||
for (uint8 k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
|
||
{
|
||
// 带牌的起始位置;
|
||
uint8 cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);
|
||
|
||
// 提取带牌;
|
||
for (uint8 n = 0; n < j + 1; n++)
|
||
{
|
||
cbTmpCard[cbCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
|
||
if (cbCount == cbBlockCount * 5) break;
|
||
}
|
||
|
||
if (cbCount == cbBlockCount * 5) break;
|
||
}
|
||
|
||
if (cbCount == cbBlockCount * 5) break;
|
||
}
|
||
|
||
// 牌数不对;
|
||
if (cbCount != cbBlockCount * 5) break;
|
||
|
||
int iCardType = GetCardType(cbTmpCard, cbCount, false);
|
||
if (!IsHasCardType(iCardType, DZ_CT_THREE_LINE)) break;
|
||
|
||
// 找到牌型;
|
||
if (cbCount == cbBlockCount * 5)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpCard, sizeof(uint8)*cbCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
||
cbResultCount++;
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 带癞子分析;
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 i = cbReferIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] < 1) && (i != cbMaxIndex)) continue;
|
||
|
||
uint8 cbTmpLinkCount = 0; // 当前最大连牌数;
|
||
uint8 cbUseMagicCount = 0; // 已经使用癞子数量;
|
||
uint8 cbTmpCard[DZ_MAX_COUNT] = { 0 };
|
||
|
||
for (uint8 j = i; j <= GetCardLogicValue(0x01); j++)
|
||
{
|
||
// 有2张牌;
|
||
if (Distributing.cbDistributing[j][cbIndexCount] >= 3)
|
||
{
|
||
cbTmpLinkCount++;
|
||
}
|
||
// 只有2张;
|
||
else if (Distributing.cbDistributing[j][cbIndexCount] == 2)
|
||
{
|
||
// 是否还有癞子;
|
||
if (cbUseMagicCount < cbMagicCardCount)
|
||
{
|
||
cbTmpLinkCount++;
|
||
cbUseMagicCount++;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
// 只有一张;
|
||
else if (Distributing.cbDistributing[j][cbIndexCount] == 1)
|
||
{
|
||
// 是否还有癞子;
|
||
if (cbUseMagicCount + 2 <= cbMagicCardCount)
|
||
{
|
||
cbTmpLinkCount++;
|
||
cbUseMagicCount += 2;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
// 一张都没有;
|
||
else
|
||
{
|
||
// 是否还有2张癞子;
|
||
if (cbUseMagicCount + 3 <= cbMagicCardCount)
|
||
{
|
||
cbTmpLinkCount++;
|
||
cbUseMagicCount += 3;
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
// 找到足够大的连牌;
|
||
if (cbTmpLinkCount >= cbBlockCount)
|
||
{
|
||
// 带癞子分析，如果不包含癞子，就不需要，防止重复分析;
|
||
if (cbUseMagicCount <= 0) break;
|
||
|
||
//复制扑克
|
||
uint8 cbCount = 0;
|
||
for (uint8 cbIndex = i; cbIndex <= j; cbIndex++)
|
||
{
|
||
uint8 cbTmpCount = 0;
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[cbIndex][3 - cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTmpCard[cbCount++] = MakeCardData(cbIndex, 3 - cbColorIndex);
|
||
|
||
if (++cbTmpCount == 3) break;
|
||
}
|
||
|
||
if (cbTmpCount == 3) break;
|
||
}
|
||
}
|
||
|
||
// 加入尾巴;
|
||
uint8 cbTakeCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbTakeCardCount = cbNormalCardCount;
|
||
CopyMemory(cbTakeCard, cbNormalCard, sizeof(uint8)*cbNormalCardCount);
|
||
|
||
// 将已经取出的牌删除;
|
||
if (RemoveCard(cbTmpCard, cbCount, cbTakeCard, cbNormalCardCount))
|
||
{
|
||
// 加入癞子;
|
||
for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
|
||
{
|
||
cbTmpCard[cbCount++] = cbMagicCard[cbMagic];
|
||
}
|
||
|
||
cbTakeCardCount -= cbCount;
|
||
}
|
||
|
||
// 分析剩余牌;
|
||
tagDZAnalyseResult AnalyseResult = {};
|
||
AnalysebCardData(cbTakeCard, cbTakeCardCount, AnalyseResult);
|
||
|
||
for (uint8 j = 0; j < CountArray(AnalyseResult.cbBlockCount); j++)
|
||
{
|
||
for (uint8 k = 0; k < AnalyseResult.cbBlockCount[j]; k++)
|
||
{
|
||
// 带牌的起始位置;
|
||
uint8 cbIndex = (AnalyseResult.cbBlockCount[j] - k - 1)*(j + 1);
|
||
|
||
// 提取带牌;
|
||
for (uint8 n = 0; n < j + 1; n++)
|
||
{
|
||
cbTmpCard[cbCount++] = AnalyseResult.cbCardData[j][cbIndex + n];
|
||
if (cbCount == cbBlockCount * 5) break;
|
||
}
|
||
|
||
if (cbCount == cbBlockCount * 5) break;
|
||
}
|
||
|
||
if (cbCount == cbBlockCount * 5) break;
|
||
}
|
||
|
||
//// 加入癞子;
|
||
//for (uint8 cbMagic = 0; cbMagic < cbUseMagicCount; cbMagic++)
|
||
//{
|
||
// pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbMagic];
|
||
//}
|
||
|
||
// 带牌不够，加入癞子;
|
||
if (cbCount < cbBlockCount * 5)
|
||
{
|
||
uint8 cbNeedCardCount = cbBlockCount * 5 - cbCount;
|
||
|
||
// 剩余癞子数量够不够;
|
||
if (cbUseMagicCount + cbNeedCardCount <= cbMagicCardCount)
|
||
{
|
||
for (uint8 cbMagic = 0; cbMagic < cbNeedCardCount; cbMagic++)
|
||
{
|
||
//pSearchCardResult->cbResultCard[cbResultCount][cbCount++] = cbMagicCard[cbUseMagicCount + cbMagic];
|
||
cbTmpCard[cbCount++] = cbMagicCard[cbUseMagicCount + cbMagic];
|
||
}
|
||
}
|
||
}
|
||
|
||
// 牌数不对;
|
||
if (cbCount != cbBlockCount * 5) break;
|
||
|
||
int iCardType = GetCardType(cbTmpCard, cbCount, false);
|
||
if (!IsHasCardType(iCardType, DZ_CT_THREE_LINE)) break;
|
||
|
||
// 找到牌型;
|
||
if (cbCount == cbBlockCount * 5)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpCard, sizeof(uint8)*cbCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbCount;
|
||
cbResultCount++;
|
||
}
|
||
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//搜索炸弹;
|
||
uint8 DZ_CGameLogic::SearchBomb(const uint8 cbHandCardData[], uint8 cbHandCardCount, uint8 cbReferCard, uint8 cbReferCount, int iReferCardType, tagDZSearchCardResult *pSearchCardResult, uint8 &cbResultCount)
|
||
{
|
||
if (cbHandCardCount < 4) return cbResultCount;
|
||
if (pSearchCardResult == nullptr) return cbResultCount;
|
||
if (!IsValidCard(cbReferCard)) return cbResultCount;
|
||
|
||
// 要打的牌是不是炸弹;
|
||
bool isTurnBomb = ((iReferCardType >> DZ_CT_BOMB_4) > 0) ? true : false;
|
||
uint8 cbTurnLogicValue = GetCardLogicValue(cbReferCard) + 1; // 最后一张牌;
|
||
|
||
//构造扑克
|
||
uint8 cbCardData[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbCardCount = cbHandCardCount;
|
||
memcpy(cbCardData, cbHandCardData, sizeof(uint8)*cbHandCardCount);
|
||
|
||
// 癞子分析;
|
||
uint8 cbNormalCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCard[DZ_MAX_COUNT] = { 0 };
|
||
uint8 cbMagicCardCount = 0; // 大小王数量;
|
||
uint8 cbNormalCardCount = 0; // 正常牌数量;
|
||
|
||
//变幻准备
|
||
for (uint8 i = 0; i < cbCardCount; i++)
|
||
{
|
||
if (IsLaiZiCard(cbCardData[i]))
|
||
{
|
||
cbMagicCard[cbMagicCardCount++] = cbCardData[i];
|
||
}
|
||
else
|
||
{
|
||
cbNormalCard[cbNormalCardCount++] = cbCardData[i];
|
||
}
|
||
}
|
||
|
||
//排列扑克
|
||
SortCardList(cbNormalCard, cbNormalCardCount, DZ_ST_ORDER);
|
||
|
||
//分析扑克
|
||
tagDZDistributing Distributing = {};
|
||
AnalysebDistributing(cbNormalCard, cbNormalCardCount, Distributing);
|
||
|
||
uint8 cbMinIndex = 0x03;
|
||
uint8 cbMaxIndex = GetCardLogicValue(0x02);
|
||
|
||
// 不是炸弹，搜索所有炸弹;
|
||
if (!isTurnBomb)
|
||
{
|
||
// 不带癞子搜索(4~8张);
|
||
for (uint8 cbBombCardCount = 4; cbBombCardCount < 8; cbBombCardCount++)
|
||
{
|
||
for (uint8 i = cbMinIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
if (Distributing.cbDistributing[i][cbIndexCount] == cbBombCardCount)
|
||
{
|
||
uint8 cbTmpCount = 0;
|
||
uint8 cbTmpBombCard[12] = { 0 };
|
||
|
||
//复制扑克
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTmpBombCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
|
||
}
|
||
}
|
||
|
||
if (cbTmpCount == cbBombCardCount)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpBombCard, sizeof(uint8)*cbTmpCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 带癞子搜索(4~12张);
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 cbBombCardCount = 4; cbBombCardCount < 12; cbBombCardCount++)
|
||
{
|
||
for (uint8 i = cbMinIndex; i <= cbMaxIndex; i++)
|
||
{
|
||
// 没有牌不变幻;
|
||
if (Distributing.cbDistributing[i][cbIndexCount] <= 0) continue;
|
||
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] + cbMagicCardCount) == cbBombCardCount)
|
||
{
|
||
uint8 cbTmpCount = 0;
|
||
uint8 cbTmpBombCard[12] = { 0 };
|
||
|
||
//复制扑克
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTmpBombCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
|
||
}
|
||
}
|
||
|
||
// 复制癞子;
|
||
for (uint8 cbMagicIndex = 0; cbMagicIndex < cbMagicCardCount; cbMagicIndex++)
|
||
{
|
||
// 从小到大;
|
||
cbTmpBombCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - cbMagicIndex - 1];
|
||
|
||
if (cbTmpCount == cbBombCardCount) break;
|
||
}
|
||
|
||
if (cbTmpCount == cbBombCardCount)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpBombCard, sizeof(uint8)*cbTmpCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
bool isJokerBomb = (cbReferCount == 4 && IsHasCardType(iReferCardType, DZ_CT_BOMB_8));
|
||
|
||
// 不带癞子，王炸最大;
|
||
if (!isJokerBomb)
|
||
{
|
||
// 不带癞子搜索(4~8张);
|
||
for (uint8 cbBombCardCount = cbReferCount; cbBombCardCount < 8; cbBombCardCount++)
|
||
{
|
||
uint8 i = cbMinIndex;
|
||
if (cbBombCardCount == cbReferCount)
|
||
{
|
||
i = cbTurnLogicValue;
|
||
}
|
||
|
||
for (; i <= cbMaxIndex; i++)
|
||
{
|
||
if (Distributing.cbDistributing[i][cbIndexCount] == cbBombCardCount)
|
||
{
|
||
uint8 cbTmpCount = 0;
|
||
uint8 cbTmpBombCard[12] = { 0 };
|
||
|
||
//复制扑克
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTmpBombCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
|
||
}
|
||
}
|
||
|
||
if (cbTmpCount == cbBombCardCount)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpBombCard, sizeof(uint8)*cbTmpCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 不带癞子搜索(4~12张);
|
||
if (cbMagicCardCount > 0)
|
||
{
|
||
for (uint8 cbBombCardCount = cbReferCount; cbBombCardCount < 12; cbBombCardCount++)
|
||
{
|
||
uint8 i = cbMinIndex;
|
||
if (cbBombCardCount == cbReferCount)
|
||
{
|
||
i = cbTurnLogicValue;
|
||
}
|
||
|
||
for (; i <= cbMaxIndex; i++)
|
||
{
|
||
// 没有牌不变幻;
|
||
if (Distributing.cbDistributing[i][cbIndexCount] <= 0) continue;
|
||
|
||
if ((Distributing.cbDistributing[i][cbIndexCount] + cbMagicCardCount) == cbBombCardCount)
|
||
{
|
||
uint8 cbTmpCount = 0;
|
||
uint8 cbTmpBombCard[12] = { 0 };
|
||
|
||
//复制扑克
|
||
for (uint8 cbColorIndex = 0; cbColorIndex < 4; cbColorIndex++)
|
||
{
|
||
for (uint8 cbColorCount = 0; cbColorCount < Distributing.cbDistributing[i][cbColorIndex]; cbColorCount++)
|
||
{
|
||
cbTmpBombCard[cbTmpCount++] = MakeCardData(i, cbColorIndex);
|
||
}
|
||
}
|
||
|
||
// 复制癞子;
|
||
for (uint8 cbMagicIndex = 0; cbMagicIndex < cbMagicCardCount; cbMagicIndex++)
|
||
{
|
||
// 从小到大;
|
||
cbTmpBombCard[cbTmpCount++] = cbMagicCard[cbMagicCardCount - cbMagicIndex - 1];
|
||
|
||
if (cbTmpCount == cbBombCardCount) break;
|
||
}
|
||
|
||
if (cbTmpCount == cbBombCardCount)
|
||
{
|
||
//设置变量
|
||
CopyMemory(pSearchCardResult->cbResultCard[cbResultCount], cbTmpBombCard, sizeof(uint8)*cbTmpCount);
|
||
pSearchCardResult->cbCardCount[cbResultCount] = cbTmpCount;
|
||
cbResultCount++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pSearchCardResult)
|
||
{
|
||
pSearchCardResult->cbSearchCount = cbResultCount;
|
||
}
|
||
|
||
return cbResultCount;
|
||
}
|
||
|
||
//构造扑克
|
||
uint8 DZ_CGameLogic::MakeCardData(uint8 cbLogicValue, uint8 cbColorIndex)
|
||
{
|
||
uint8 cbCardColor = (cbColorIndex << 4);
|
||
|
||
//转换数值
|
||
if (cbCardColor == 0x40)
|
||
{
|
||
cbLogicValue -= 2;
|
||
}
|
||
else if (cbLogicValue > 0x0D)
|
||
{
|
||
cbLogicValue -= 0x0D;
|
||
}
|
||
|
||
return (cbCardColor | cbLogicValue);
|
||
} |