#include "StdAfx.h"
#include "GameLogic.h"

//////////////////////////////////////////////////////////////////////////
//静态变量

//扑克数据
const BYTE CGameLogic::m_cbCardDataArray[MAX_REPERTORY]=
{
	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
	0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,						//万子
	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子
	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子
	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子
	0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,						//索子
	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子
	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子
	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子
	0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,						//同子
	0x31,0x32,0x33,0x34,0x35,0x36,0x37,									//番子
	0x31,0x32,0x33,0x34,0x35,0x36,0x37,									//番子
	0x31,0x32,0x33,0x34,0x35,0x36,0x37,									//番子
	0x31,0x32,0x33,0x34,0x35,0x36,0x37,									//番子
};

//////////////////////////////////////////////////////////////////////////

//构造函数
CGameLogic::CGameLogic()
{
}

//析构函数
CGameLogic::~CGameLogic()
{
}

//混乱扑克
void CGameLogic::RandCardData(BYTE cbCardData[], BYTE cbMaxCount)
{
	//初始化种子
	srand(GetTickCount() | (rand() << 8));

	//混乱准备
	BYTE cbCardDataTemp[CountArray(m_cbCardDataArray)];
	CopyMemory(cbCardDataTemp,m_cbCardDataArray,sizeof(m_cbCardDataArray));

	//混乱扑克
	BYTE cbRandCount=0,cbPosition=0;
	do
	{
		cbPosition=rand()%(cbMaxCount-cbRandCount);
		cbCardData[cbRandCount++]=cbCardDataTemp[cbPosition];
		cbCardDataTemp[cbPosition]=cbCardDataTemp[cbMaxCount-cbRandCount];
	} while (cbRandCount<cbMaxCount);
	
	return;
}

//删除扑克
bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard)
{
	//效验扑克
	ASSERT(IsValidCard(cbRemoveCard));
	ASSERT(cbCardIndex[SwitchToCardIndex(cbRemoveCard)]>0);

	//删除扑克
	BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);
	if (cbCardIndex[cbRemoveIndex]>0)
	{
		cbCardIndex[cbRemoveIndex]--;
		return true;
	}

	//失败效验
	ASSERT(FALSE);

	return false;
}

//删除扑克
bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard[], BYTE cbRemoveCount)
{
	//删除扑克
	for (BYTE i=0;i<cbRemoveCount;i++)
	{
		//效验扑克
		ASSERT(IsValidCard(cbRemoveCard[i]));
		ASSERT(cbCardIndex[SwitchToCardIndex(cbRemoveCard[i])]>0);

		//删除扑克
		BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard[i]);
		if (cbCardIndex[cbRemoveIndex]==0)
		{
			//错误断言
			ASSERT(FALSE);

			//还原删除
			for (BYTE j=0;j<i;j++) 
			{
				ASSERT(IsValidCard(cbRemoveCard[j]));
				cbCardIndex[SwitchToCardIndex(cbRemoveCard[j])]++;
			}

			return false;
		}
		else 
		{
			//删除扑克
			--cbCardIndex[cbRemoveIndex];
		}
	}

	return true;
}

//删除扑克
bool CGameLogic::RemoveCard(BYTE cbCardData[], BYTE cbCardCount, BYTE cbRemoveCard[], BYTE cbRemoveCount)
{
	//检验数据
	ASSERT(cbCardCount<=MAX_COUNT);
	ASSERT(cbRemoveCount<=cbCardCount);

	//定义变量
	BYTE cbDeleteCount=0,cbTempCardData[MAX_COUNT];
	if (cbCardCount>CountArray(cbTempCardData))	return false;

	CopyMemory(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));

	//置零扑克
	for (BYTE i=0;i<cbRemoveCount;i++)
	{
		for (BYTE j=0;j<cbCardCount;j++)
		{
			if (cbRemoveCard[i]==cbTempCardData[j])
			{
				cbDeleteCount++;
				cbTempCardData[j]=0;
				break;
			}
		}
	}

	//成功判断
	if (cbDeleteCount!=cbRemoveCount) 
	{
		ASSERT(FALSE);
		return false;
	}

	//清理扑克
	BYTE cbCardPos=0;
	for (BYTE i=0;i<cbCardCount;i++)
	{
		if (cbTempCardData[i]!=0) 
			cbCardData[cbCardPos++]=cbTempCardData[i];
	}

	return true;
}

//有效判断
bool CGameLogic::IsValidCard(BYTE cbCardData)
{
	BYTE cbValue=(cbCardData&MASK_VALUE);
	BYTE cbColor=(cbCardData&MASK_COLOR)>>4;
	return (((cbValue>=1)&&(cbValue<=9)&&(cbColor<=2))||((cbValue>=1)&&(cbValue<=7)&&(cbColor==3)));
}

//扑克数目
BYTE CGameLogic::GetCardCount(BYTE cbCardIndex[MAX_INDEX])
{
	//数目统计
	BYTE cbCardCount=0;
	for (BYTE i=0;i<MAX_INDEX;i++) 
		cbCardCount+=cbCardIndex[i];

	return cbCardCount;
}

//获取组合
BYTE CGameLogic::GetWeaveCard(WORD wWeaveKind, BYTE cbCenterCard, BYTE cbCardBuffer[4])
{
	//组合扑克
	switch (wWeaveKind)
	{
	case WIK_LEFT:		//上牌操作
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard+1;
			cbCardBuffer[2]=cbCenterCard+2;
			cbCardBuffer[0]=cbCenterCard;

			return 3;
		}
	case WIK_RIGHT:		//上牌操作
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard-2;
			cbCardBuffer[2]=cbCenterCard-1;
			cbCardBuffer[0]=cbCenterCard;

			return 3;
		}
	case WIK_CENTER:	//上牌操作
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard-1;
			cbCardBuffer[0]=cbCenterCard;
			cbCardBuffer[2]=cbCenterCard+1;

			return 3;
		}
	case WIK_PENG:		//碰牌操作
		{
			//设置变量
			cbCardBuffer[0]=cbCenterCard;
			cbCardBuffer[1]=cbCenterCard;
			cbCardBuffer[2]=cbCenterCard;

			return 3;
		}
	case WIK_GANG:		//杠牌操作
		{
			//设置变量
			cbCardBuffer[0]=cbCenterCard;
			cbCardBuffer[1]=cbCenterCard;
			cbCardBuffer[2]=cbCenterCard;
			cbCardBuffer[3]=cbCenterCard;

			return 4;
		}
	case WIK_DNBL:		//东南北左
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard+1;
			cbCardBuffer[2]=cbCenterCard+3;
			cbCardBuffer[0]=cbCenterCard;

			return 3;
		}
	case WIK_DNBC:		//东南北中
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard-1;
			cbCardBuffer[0]=cbCenterCard;
			cbCardBuffer[2]=cbCenterCard+2;

			return 3;
		}
	case WIK_DNBR:		//东南北右
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard-3;
			cbCardBuffer[2]=cbCenterCard-2;
			cbCardBuffer[0]=cbCenterCard;

			return 3;
		}
	case WIK_DXBL:		//东西北左
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard+2;
			cbCardBuffer[2]=cbCenterCard+3;
			cbCardBuffer[0]=cbCenterCard;

			return 3;
		}
	case WIK_DXBC:		//东西北中
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard-2;
			cbCardBuffer[0]=cbCenterCard;
			cbCardBuffer[2]=cbCenterCard+1;

			return 3;
		}
	case WIK_DXBR:		//东西北右
		{
			//设置变量
			cbCardBuffer[1]=cbCenterCard-3;
			cbCardBuffer[2]=cbCenterCard-1;
			cbCardBuffer[0]=cbCenterCard;

			return 3;
		}
	default:
		{
			ASSERT(FALSE);
		}
	}

	return 0;
}

//动作等级
BYTE CGameLogic::GetUserActionRank(WORD wUserAction)
{
	//胡牌等级
	if (wUserAction&WIK_CHI_HU) { return 4; }

	//杠牌等级
	if (wUserAction&WIK_GANG) { return 3; }

	//碰牌等级
	if (wUserAction&WIK_PENG) { return 2; }

	//上牌等级
	if (wUserAction&(WIK_RIGHT|WIK_CENTER|WIK_LEFT|WIK_DNBL|WIK_DNBC|WIK_DNBR|WIK_DXBL|WIK_DXBC|WIK_DXBR)) { return 1; }

	return 0;
}

//胡牌等级
BYTE CGameLogic::GetChiHuActionRank(tagChiHuResult & ChiHuResult)
{
	//变量定义
	BYTE cbChiHuOrder=0;
	WORD wChiHuRight=ChiHuResult.wChiHuRight;
	WORD wChiHuKind=(ChiHuResult.wChiHuKind&0xFF00)>>4;

	//大胡升级
	for (BYTE i=0;i<8;i++)
	{
		wChiHuKind>>=1;
		if ((wChiHuKind&0x0001)!=0) 
			cbChiHuOrder++;
	}

	//权位升级
	for (BYTE i=0;i<16;i++)
	{
		wChiHuRight>>=1;
		if ((wChiHuRight&0x0001)!=0) 
			cbChiHuOrder++;
	}

	return cbChiHuOrder;
}

//吃牌判断
WORD CGameLogic::EstimateEatCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));


	//变量定义
	BYTE cbExcursion[3]={0,1,2};
	WORD wItemKind[3]={WIK_LEFT,WIK_CENTER,WIK_RIGHT};

	//吃牌判断
	WORD wEatKind=0;
	BYTE cbFirstIndex=0;
	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);
	//中发白
	if(cbCurrentIndex>=31)
	{
		for (BYTE i=0;i<CountArray(wItemKind);i++)
		{
			BYTE cbValueIndex=cbCurrentIndex%9;
			if ((cbValueIndex>=cbExcursion[i])&&((cbValueIndex-cbExcursion[i])<=4))
			{
				//吃牌判断
				cbFirstIndex=cbCurrentIndex-cbExcursion[i];
				//过滤
				if(cbFirstIndex<31) continue;
				if ((cbCurrentIndex!=cbFirstIndex)&&(cbCardIndex[cbFirstIndex]==0))
					continue;
				if ((cbCurrentIndex!=(cbFirstIndex+1))&&(cbCardIndex[cbFirstIndex+1]==0))
					continue;
				if ((cbCurrentIndex!=(cbFirstIndex+2))&&(cbCardIndex[cbFirstIndex+2]==0))
					continue;

				//设置类型
				wEatKind|=wItemKind[i];
			}
		}

	}
	else if(cbCurrentIndex>=27)
	{
		for (BYTE i=0;i<CountArray(wItemKind);i++)
		{
			BYTE cbValueIndex=cbCurrentIndex%9;
			if ((cbValueIndex>=cbExcursion[i])&&((cbValueIndex-cbExcursion[i])<=1))
			{
				//吃牌判断
				cbFirstIndex=cbCurrentIndex-cbExcursion[i];
				if ((cbCurrentIndex!=cbFirstIndex)&&(cbCardIndex[cbFirstIndex]==0))
					continue;
				if ((cbCurrentIndex!=(cbFirstIndex+1))&&(cbCardIndex[cbFirstIndex+1]==0))
					continue;
				if ((cbCurrentIndex!=(cbFirstIndex+2))&&(cbCardIndex[cbFirstIndex+2]==0))
					continue;

				//设置类型
				wEatKind|=wItemKind[i];
			}
		}

	}
	else
	{
		for (BYTE i=0;i<CountArray(wItemKind);i++)
		{
			BYTE cbValueIndex=cbCurrentIndex%9;
			if ((cbValueIndex>=cbExcursion[i])&&((cbValueIndex-cbExcursion[i])<=6))
			{
				//吃牌判断
				cbFirstIndex=cbCurrentIndex-cbExcursion[i];
				if ((cbCurrentIndex!=cbFirstIndex)&&(cbCardIndex[cbFirstIndex]==0))
					continue;
				if ((cbCurrentIndex!=(cbFirstIndex+1))&&(cbCardIndex[cbFirstIndex+1]==0))
					continue;
				if ((cbCurrentIndex!=(cbFirstIndex+2))&&(cbCardIndex[cbFirstIndex+2]==0))
					continue;

				//设置类型
				wEatKind|=wItemKind[i];
			}
		}
	}
	//东南西北中发白的组合
	if(cbCurrentIndex>=27)
	{
		if(cbCurrentIndex==27)
		{
			if(cbCardIndex[28]>0&&cbCardIndex[30]>0)
				wEatKind |=WIK_DNBL;
			if(cbCardIndex[29]>0&&cbCardIndex[30]>0)
				wEatKind |=WIK_DXBL;
		}
		if(cbCurrentIndex==28)
		{
			if(cbCardIndex[27]>0&&cbCardIndex[30]>0)
				wEatKind |=WIK_DNBC;
		}
		if(cbCurrentIndex==29)
		{
			if(cbCardIndex[27]>0&&cbCardIndex[30]>0)
				wEatKind |=WIK_DXBC;
		}
		if(cbCurrentIndex==30)
		{
			if(cbCardIndex[27]>0&&cbCardIndex[28]>0)
				wEatKind |=WIK_DNBR;
			if(cbCardIndex[27]>0&&cbCardIndex[29]>0)
				wEatKind |=WIK_DXBR;
		}
	}

	return wEatKind;
}

//碰牌判断
WORD CGameLogic::EstimatePengCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));

	//碰牌判断
	return (cbCardIndex[SwitchToCardIndex(cbCurrentCard)]>=2)?WIK_PENG:WIK_NULL;
}

//杠牌判断
WORD CGameLogic::EstimateGangCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));

	//杠牌判断
	return (cbCardIndex[SwitchToCardIndex(cbCurrentCard)]==3)?WIK_GANG:WIK_NULL;
}

//杠牌分析
WORD CGameLogic::AnalyseGangCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult)
{
	//设置变量
	WORD wActionMask=WIK_NULL;
	ZeroMemory(&GangCardResult,sizeof(GangCardResult));

	//手上杠牌 
	for (BYTE i=0;i<MAX_INDEX;i++)
	{
		if (cbCardIndex[i]==4)
		{
			wActionMask|=WIK_GANG;
			GangCardResult.cbCardData[GangCardResult.cbCardCount++]=SwitchToCardData(i);
		}
	}

	//组合杠牌
	for (BYTE i=0;i<cbWeaveCount;i++)
	{
		if (WeaveItem[i].wWeaveKind==WIK_PENG)
		{
			if (cbCardIndex[SwitchToCardIndex(WeaveItem[i].cbCenterCard)]==1)
			{
				wActionMask|=WIK_GANG;
				GangCardResult.cbCardData[GangCardResult.cbCardCount++]=WeaveItem[i].cbCenterCard;
			}
		}
	}

	return wActionMask;
}
//分析扑克
bool CGameLogic::AnalyseCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray,BYTE cbCurrentCard,bool bZimo)
{
	//计算数目
	BYTE cbCardCount=0;
	for (BYTE i=0;i<MAX_INDEX;i++) 
		cbCardCount+=cbCardIndex[i];

	//拷贝数据
	BYTE cbTempCardIndex[MAX_INDEX];
	CopyMemory(cbTempCardIndex,cbCardIndex,sizeof(cbTempCardIndex));

	//效验数目
	ASSERT((cbCardCount>=2)&&(cbCardCount<=MAX_COUNT)&&((cbCardCount-2)%3==0));
	if ((cbCardCount<2)||(cbCardCount>MAX_COUNT)||((cbCardCount-2)%3!=0))	return false;

	//变量定义
	BYTE cbKindItemCount=0;
	tagKindItem KindItem[MAX_INDEX*2];
	ZeroMemory(KindItem,sizeof(KindItem));

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

	//单吊判断
	if (cbLessKindItem == 0)
	{
		//效验参数
		ASSERT((cbCardCount == 2) && (cbWeaveCount == 4));

		//牌眼判断
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			if (cbCardIndex[i] == 2)
			{
				//变量定义
				tagAnalyseItem AnalyseItem;
				ZeroMemory(&AnalyseItem, sizeof(AnalyseItem));

				//设置结果
				for (BYTE j = 0; j < cbWeaveCount; j++)
				{
					AnalyseItem.wWeaveKind[j] = WeaveItem[j].wWeaveKind;
					AnalyseItem.cbCenterCard[j] = WeaveItem[j].cbCenterCard;
				}
				AnalyseItem.cbCardEye = SwitchToCardData(i);

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

				return true;
			}
		}

		return false;
	}

	//拆分分析
	if (cbCardCount>=3)
	{
		for (BYTE i=0;i<MAX_INDEX;i++)
		{
			//同牌判断
			if (cbCardIndex[i]>=3)
			{
				ASSERT( cbKindItemCount < CountArray(KindItem) );
				KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
				KindItem[cbKindItemCount].cbCardIndex[0]=i;
				KindItem[cbKindItemCount].cbCardIndex[1]=i;
				KindItem[cbKindItemCount].cbCardIndex[2]=i;
				KindItem[cbKindItemCount++].wWeaveKind=WIK_PENG;
			}

			//连牌判断
			if ((i<(MAX_INDEX-2-7))&&(cbCardIndex[i]>0)&&((i%9)<7))
			{
				for (BYTE j=1;j<=cbCardIndex[i];j++)
				{
					if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
					{
						ASSERT( cbKindItemCount < CountArray(KindItem) );
						KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
						KindItem[cbKindItemCount].cbCardIndex[0]=i;
						KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
						KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
						KindItem[cbKindItemCount++].wWeaveKind=WIK_LEFT;
					}
				}
			}
		}

		//东南西北
		for (BYTE i=MAX_INDEX-7;i<MAX_INDEX-5;i++)
		{
			//变量定义
			BYTE cbCardIndexTemp[MAX_INDEX];

			//设置变量
			CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

			//东南西 南西北
			for (BYTE j=1;j<=cbCardIndex[i]&&cbCardIndex[i]>0;j++)
			{
				if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
				{
					ASSERT( cbKindItemCount < CountArray(KindItem) );
					KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
					KindItem[cbKindItemCount].cbCardIndex[0]=i;
					KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
					KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
					KindItem[cbKindItemCount++].wWeaveKind=WIK_LEFT;
				}
			}

			//东南北
			if(i==MAX_INDEX-7)
			{
				for (BYTE j=1;j<=cbCardIndex[i]&&cbCardIndex[i]>0;j++)
				{
					if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+3]>=j))
					{
						ASSERT( cbKindItemCount < CountArray(KindItem) );
						KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
						KindItem[cbKindItemCount].cbCardIndex[0]=i;
						KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
						KindItem[cbKindItemCount].cbCardIndex[2]=i+3;
						KindItem[cbKindItemCount++].wWeaveKind=WIK_DNBL;
					}
				}

			}
			//东西北
			if(i==MAX_INDEX-7)
			{
				for (BYTE j=1;j<=cbCardIndex[i]&&cbCardIndex[i]>0;j++)
				{
					if ((cbCardIndex[i+2]>=j)&&(cbCardIndex[i+3]>=j))
					{
						ASSERT( cbKindItemCount < CountArray(KindItem) );
						KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
						KindItem[cbKindItemCount].cbCardIndex[0]=i;
						KindItem[cbKindItemCount].cbCardIndex[1]=i+2;
						KindItem[cbKindItemCount].cbCardIndex[2]=i+3;
						KindItem[cbKindItemCount++].wWeaveKind=WIK_DXBL;
					}
				}
			}
		}	

		//中发白
		for (BYTE i=MAX_INDEX-3;i<MAX_INDEX;i++)
		{
			//连牌判断
			if ((i<(MAX_INDEX-2))&&(cbCardIndex[i]>0)&&((i%9)<7))
			{
				for (BYTE j=1;j<=cbCardIndex[i];j++)
				{
					if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
					{
						KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
						KindItem[cbKindItemCount].cbCardIndex[0]=i;
						KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
						KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
						KindItem[cbKindItemCount++].wWeaveKind=WIK_LEFT;
					}
				}
			}

		}
	}

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

		//变量定义
		BYTE cbIndex[MAX_WEAVE]={0,1,2,3};
		tagKindItem * pKindItem[MAX_WEAVE];
		ZeroMemory(&pKindItem,sizeof(pKindItem));

		//开始组合
		do
		{
			//设置变量
			CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
			for (BYTE i=0;i<cbLessKindItem;i++)
				pKindItem[i]=&KindItem[cbIndex[i]];

			//数量判断
			bool bEnoughCard=true;
			for (BYTE i=0;i<cbLessKindItem*3;i++)
			{
				//存在判断
				BYTE cbCardIndex=pKindItem[i/3]->cbCardIndex[i%3]; 
				if (cbCardIndexTemp[cbCardIndex]==0)
				{  
					bEnoughCard=false;
					break;
				}
				else 
					cbCardIndexTemp[cbCardIndex]--;
			}

			//德国判断
			if (bEnoughCard == true)
			{
				//牌眼判断
				BYTE cbCardEye = 0;

				for (BYTE i = 0; i < MAX_INDEX; i++)
				{
					if (cbCardIndexTemp[i] == 2)
					{	//眼牌数据;
						cbCardEye = SwitchToCardData(i);
						break;
					}
				}


				//组合类型
				if (cbCardEye != 0)
				{
					//变量定义
					tagAnalyseItem AnalyseItem;
					ZeroMemory(&AnalyseItem, sizeof(AnalyseItem));

					//设置组合
					for (BYTE i = 0; i < cbWeaveCount; i++)
					{
						AnalyseItem.wWeaveKind[i] = WeaveItem[i].wWeaveKind;
						AnalyseItem.cbCenterCard[i] = WeaveItem[i].cbCenterCard;
					}

					//设置牌型
					for (BYTE i = 0; i < cbLessKindItem; i++)
					{
						AnalyseItem.wWeaveKind[i + cbWeaveCount] = pKindItem[i]->wWeaveKind;
						AnalyseItem.cbCenterCard[i + cbWeaveCount] = pKindItem[i]->cbCenterCard;
					}
					//精牌替换;
					AnalyseItem.cbWeaveKingReplace = 0;

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

					//精牌替换;
					AnalyseItem.cbEyeKingReplace = 0;

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

			//设置索引
			if (cbIndex[cbLessKindItem-1]==(cbKindItemCount-1))
			{
				BYTE i = 0;
				for ( i=cbLessKindItem-1;i>0;i--)
				{
					if ((cbIndex[i-1]+1)!=cbIndex[i])
					{
						BYTE cbNewIndex=cbIndex[i-1];
						for (BYTE j=(i-1);j<cbLessKindItem;j++) 
							cbIndex[j]=cbNewIndex+j-i+2;
						break;
					}
				}
				if (i==0)
					break;
			}
			else
				cbIndex[cbLessKindItem-1]++;

		} while (true);

	}

	
	//硬胡分析
	if (AnalyseItemArray.GetCount()>0)
		return true;
	
	//硬胡清空
	AnalyseItemArray.RemoveAll();

	//变量定义
	cbKindItemCount=0;
	ZeroMemory(KindItem,sizeof(KindItem));
	

	return false;
}


//吃胡分析
WORD CGameLogic::AnalyseChiHuCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult & ChiHuResult, BYTE cbHuRule, bool bZimo, bool bRealHu)
{
	if (cbHuRule == eWNMJHURuleEnum_Invalid)
	{
		return WIK_NULL;
	}

	if (cbHuRule == eWNMJHURuleEnum_YingHU)
	{
		return AnalyseYingHuCard(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, wChiHuRight, ChiHuResult, bZimo, bRealHu);
	}
	else if (cbHuRule == eWNMJHURuleEnum_YiBianDaoHU)
	{
		return AnalyseYiBianDaoHuCard(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, wChiHuRight, ChiHuResult, bZimo, bRealHu);
	}
	else if (cbHuRule == eWNMJHURuleEnum_HunHU)
	{
		WORD wAction = AnalyseYiBianDaoHuCard(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, wChiHuRight, ChiHuResult, bZimo, bRealHu);
		if ( wAction != WIK_NULL )
		{
			return wAction;
		}

		return AnalyseYingHuCard(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, wChiHuRight, ChiHuResult, bZimo, bRealHu);
	}
	
	return WIK_NULL;
}


//扑克转换
BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex)
{
	ASSERT(cbCardIndex<MAX_INDEX);

	ASSERT(cbCardIndex<34);
	return ((cbCardIndex/9)<<4)|(cbCardIndex%9+1);
}

//扑克转换
BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData)
{

	ASSERT(IsValidCard(cbCardData));
	////计算位置
	//BYTE cbValue=cbCardData&MASK_VALUE;
	//BYTE cbColor=(cbCardData&MASK_COLOR)>>4;
	return ((cbCardData&MASK_COLOR)>>4)*9+(cbCardData&MASK_VALUE)-1;
}

//扑克转换
BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT],BYTE bMaxCount)
{
	//转换扑克 精牌放到原来位置
	BYTE bPosition=0;
	for (BYTE i=0;i<MAX_INDEX;i++) 
	{
	
		if (cbCardIndex[i]!=0)
		{
			for (BYTE j=0;j<cbCardIndex[i];j++)
			{
				ASSERT(bPosition<bMaxCount);
				cbCardData[bPosition++]=SwitchToCardData(i);
			}
		}
	}

	return bPosition;
}

//扑克转换
BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX])
{
	//设置变量
	ZeroMemory(cbCardIndex,sizeof(BYTE)*MAX_INDEX);

	//转换扑克
	for (BYTE i=0;i<cbCardCount;i++)
	{
		cbCardIndex[SwitchToCardIndex(cbCardData[i])]++;
	}

	return cbCardCount;
}


//计算积分
LONG CGameLogic::CalScore(tagChiHuResult & ChihuResult, LONG &lScore, LONG &lTimes, LONG &lExtScore, BYTE cbFan, bool bZhiAnGangFanbei)
{
	//胡牌校验
	ASSERT(ChihuResult.wChiHuKind!=CHK_NULL);
	if (ChihuResult.wChiHuKind== CHK_NULL) return 0;

	//赋值初始化;
	lTimes = 1L;
	lExtScore = 0L;

	//抢杠
	if (ChihuResult.wChiHuRight&CHR_QIANG_GANG)
	{
		lTimes *= 1;
	}
	//杠开
	if (ChihuResult.wChiHuRight&CHR_GANG_FLOWER)
	{
		lTimes *= 1;
	}
	//天胡
	if (ChihuResult.wChiHuRight&CHR_TIAN)
	{
		lTimes *= 2;
	}
	//地胡
	if (ChihuResult.wChiHuRight&CHR_DI)
	{
		lTimes *= 2;
	}

	//7对
	if (ChihuResult.wChiHuKind&CHK_QI_DUI)
	{
		lTimes *= 2;
	}
	//13乱
	if (ChihuResult.wChiHuKind&CHK_THIRTEEN)
	{
		lTimes *= 1;
	}
	//七星十三烂;
	if (ChihuResult.wChiHuKind&CHK_SERVEN)
	{
		lTimes *= 2;
	}
	//碰碰胡;
	if (ChihuResult.wChiHuKind&CHK_PENG_PENG)
	{
		lTimes *= 2;
	}
	//混一色;
	if (ChihuResult.wChiHuKind&CHK_HUNYISE)
	{
		lTimes *= 2;
	}
	//清一色;
	if (ChihuResult.wChiHuKind&CHK_QINYISE)
	{
		lTimes *= 4;
	}
	//字一色;
	if (ChihuResult.wChiHuKind&CHK_ZIYISE)
	{
		lTimes *= 16;
	}

	if ( cbFan == eWNMJRuleEnum_OneTwoFAN )
	{
		if (ChihuResult.wChiHuRight&CHR_GANG_FLOWER)
		{
			lTimes *= 2;
		}
		else
		{
			if (ChihuResult.wChiHuRight&CHR_ZI_MO)
			{
				lTimes *= 1;
			}
			else
			{
				lTimes *= 2;
			}
		}
	}
	else if ( cbFan == eWNMJRuleEnum_TwoThreeFAN )
	{
		if (ChihuResult.wChiHuRight&CHR_GANG_FLOWER)
		{
			lTimes *= 3;
		}
		else 
		{
			if (ChihuResult.wChiHuRight&CHR_ZI_MO)
			{
				lTimes *= 2;
			}
			else
			{
				lTimes *= 3;
			}
		}
	}

	//天胡,地胡,抢杠,杠开并且是真胡;
	if (((ChihuResult.wChiHuRight&CHR_TIAN) || (ChihuResult.wChiHuRight&CHR_DI) || (ChihuResult.wChiHuRight&CHR_QIANG_GANG) || (ChihuResult.wChiHuRight&CHR_GANG_FLOWER))
		&& ((ChihuResult.wChiHuRight&CHR_HAS_KING) != CHR_HAS_KING))
	{
		lTimes *= 2;
	}

	if (ChihuResult.wChiHuRight&CHR_GANG_FLOWER && !(ChihuResult.wChiHuRight&CHR_GANG_ZHONGSE))
	{	//明暗杠,没杠到色情况下,获得特殊积分;
		if ((ChihuResult.wChiHuKind&CHK_HUNYISE) || (ChihuResult.wChiHuKind&CHK_QINYISE))
		{
			if (cbFan == eWNMJRuleEnum_OneTwoFAN)
			{
				lTimes = 2;
			}
			else if (cbFan == eWNMJRuleEnum_TwoThreeFAN)
			{
				lTimes = 3;
			}
		}
		else if (ChihuResult.wChiHuKind&CHK_ZIYISE)
		{
			if (cbFan == eWNMJRuleEnum_OneTwoFAN)
			{
				lTimes = 4;
			}
			else if (cbFan == eWNMJRuleEnum_TwoThreeFAN)
			{
				lTimes = 6;
			}
		}
	}

	int nMaxTimes = 0;
	if (cbFan == eWNMJRuleEnum_OneTwoFAN)
	{
		nMaxTimes = 16;
	}
	else if (cbFan == eWNMJRuleEnum_TwoThreeFAN)
	{
		nMaxTimes = 24;
	}

	if (bZhiAnGangFanbei)
	{
		nMaxTimes *= 2;
	}

	if (lTimes > nMaxTimes)
	{
		lTimes = nMaxTimes;
	}

	return lTimes;
}

//13乱
bool CGameLogic::IsNeatAlone(BYTE cbCardIndex[MAX_INDEX],BYTE &cbGerman,BYTE cbCurrentCard,bool bZimo)
{
	BYTE cbTempCardIndex[MAX_INDEX];
	CopyMemory(cbTempCardIndex,cbCardIndex,sizeof(BYTE)*MAX_INDEX);

	//计算数目
	BYTE cbCardCount=0;
	for (BYTE i=0;i<MAX_INDEX;i++) 
		cbCardCount+=cbTempCardIndex[i];
	
	//满牌才能全不靠
	if(cbCardCount<MAX_COUNT) return false;


	//返回值判断
	bool bRet=true;


	//变量处理
	const BYTE COMMON_TYPE_SUM = 9;
	for (BYTE i = 0; i<MAX_INDEX; i++)
	{
		//重复字牌
		if(cbTempCardIndex[i] > 1)
		{
			bRet=false;
			break;
		}
	}
	//牌值必须两两相隔;
	if(bRet)
	{
		BYTE* pKingIndex = 0;
		for(BYTE i=0; i<3; i++)
		{
			pKingIndex = &cbTempCardIndex[i*COMMON_TYPE_SUM];
			for(BYTE j=0; j<COMMON_TYPE_SUM; j++)
			{
				if(pKingIndex[j] > 0)
				{
					for(BYTE k=0; k<2; k++)
					{
						j ++;

						if(j<COMMON_TYPE_SUM)
						{
							if(pKingIndex[j] > 0)
							{
								bRet= false;
								break;
							}
						}
					}

				}
			}
		}
	}

	if(bRet)
	{
		//德国判断
		cbGerman=1;

		return true;
	}

	return false;
}

//3顺 3刻
bool CGameLogic::IsNeat3(const BYTE cbCardIndex[MAX_INDEX],BYTE &cbGerman)
{
	//德国
	cbGerman=1;

	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

	//变量定义
	BYTE cbIndex[4]={0,1,2,3};
	tagKindItem * pKindItem[4];
	ZeroMemory(&pKindItem,sizeof(pKindItem));


	//需求判断
	BYTE cbCardCount = 0;
	for(BYTE i=0; i<MAX_INDEX; i++)
	{
		cbCardCount += cbCardIndexTemp[i];
	}
	//效验数目
	ASSERT(cbCardCount<=14);
	if((cbCardCount%3) != 0)
	{
		return false;
	}

	BYTE cbLessKindItem = cbCardCount/3;
	if (cbLessKindItem == 0)
	{
		return true;
	}

	//变量定义
	BYTE cbKindItemCount=0;
	tagKindItem KindItem[MAX_INDEX-2];
	ZeroMemory(KindItem,sizeof(KindItem));

	for (BYTE i=0;i<MAX_INDEX;i++)
	{
		//同牌判断
		if (cbCardIndex[i]>=3)
		{
			KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
			KindItem[cbKindItemCount].cbCardIndex[0]=i;
			KindItem[cbKindItemCount].cbCardIndex[1]=i;
			KindItem[cbKindItemCount].cbCardIndex[2]=i;
			KindItem[cbKindItemCount++].wWeaveKind=WIK_PENG;
		}

		//连牌判断
		if ((i<(MAX_INDEX-2-7))&&(cbCardIndex[i]>0)&&((i%9)<7))
		{
			for (BYTE j=1;j<=cbCardIndex[i];j++)
			{
				if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
				{
					KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
					KindItem[cbKindItemCount].cbCardIndex[0]=i;
					KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
					KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
					KindItem[cbKindItemCount++].wWeaveKind=WIK_LEFT;
				}
			}
		}

	}
	//东南西北
	for (BYTE i=MAX_INDEX-7;i<MAX_INDEX-5;i++)
	{
		//变量定义
		BYTE cbCardIndexTemp[MAX_INDEX];

		//设置变量
		CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

		//东南西 南西北
		for (BYTE j=1;j<=cbCardIndex[i]&&cbCardIndex[i]>0;j++)
		{
			if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
			{
				KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
				KindItem[cbKindItemCount].cbCardIndex[0]=i;
				KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
				KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
				KindItem[cbKindItemCount++].wWeaveKind=WIK_LEFT;
			}
		}

		//东南北
		if(i==MAX_INDEX-7)
		{
			for (BYTE j=1;j<=cbCardIndex[i]&&cbCardIndex[i]>0;j++)
			{
				if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+3]>=j))
				{
					KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
					KindItem[cbKindItemCount].cbCardIndex[0]=i;
					KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
					KindItem[cbKindItemCount].cbCardIndex[2]=i+3;
					KindItem[cbKindItemCount++].wWeaveKind=WIK_DNBL;
				}
			}

		}
		//东西北
		if(i==MAX_INDEX-7)
		{
			for (BYTE j=1;j<=cbCardIndex[i]&&cbCardIndex[i]>0;j++)
			{
				if ((cbCardIndex[i+2]>=j)&&(cbCardIndex[i+3]>=j))
				{
					KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
					KindItem[cbKindItemCount].cbCardIndex[0]=i;
					KindItem[cbKindItemCount].cbCardIndex[1]=i+2;
					KindItem[cbKindItemCount].cbCardIndex[2]=i+3;
					KindItem[cbKindItemCount++].wWeaveKind=WIK_DXBL;
				}
			}
		}


	}	
	//中发白
	for (BYTE i=MAX_INDEX-3;i<MAX_INDEX;i++)
	{

		//连牌判断
		if ((i<(MAX_INDEX-2))&&(cbCardIndex[i]>0)&&((i%9)<7))
		{
			for (BYTE j=1;j<=cbCardIndex[i];j++)
			{
				if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
				{
					KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
					KindItem[cbKindItemCount].cbCardIndex[0]=i;
					KindItem[cbKindItemCount].cbCardIndex[1]=i+1;
					KindItem[cbKindItemCount].cbCardIndex[2]=i+2;
					KindItem[cbKindItemCount++].wWeaveKind=WIK_LEFT;
				}
			}
		}

	}


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

		//变量定义
		BYTE cbIndex[4]={0,1,2,3};
		tagKindItem * pKindItem[4];
		ZeroMemory(&pKindItem,sizeof(pKindItem));

		//开始组合
		do
		{
			//设置变量
			CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
			for (BYTE i=0;i<cbLessKindItem;i++) 
			{
				pKindItem[i]=&KindItem[cbIndex[i]];
			}

			//数量判断
			bool bEnoughCard=true;
			for (BYTE i=0;i<cbLessKindItem*3;i++)
			{
				//存在判断
				BYTE cbCardIndex=pKindItem[i/3]->cbCardIndex[i%3];
				if (cbCardIndexTemp[cbCardIndex]==0)
				{
					bEnoughCard=false;
					break;
				}
				else 
				{
					cbCardIndexTemp[cbCardIndex]--;
				}
			}
			if(bEnoughCard)
			{
				return true;
			}

			//设置索引
			if (cbIndex[cbLessKindItem-1] == (cbKindItemCount-1))
			{
				BYTE i = 0;
				for (i=cbLessKindItem-1;i>0;i--)
				{
					if ((cbIndex[i-1]+1) != cbIndex[i])
					{
						BYTE cbNewIndex = cbIndex[i-1];
						for (BYTE j=(i-1); j<cbLessKindItem; j++) 
						{
							cbIndex[j]=cbNewIndex+j-i+2;
						}
						break;
					}
				}
				if (i==0)
				{
					break;
				}
			}
			else 
			{
				cbIndex[cbLessKindItem-1]++;
			}

		} while (true);

	}

	//非德国
	cbGerman=0;

	//变量定义
	cbKindItemCount=0;
	ZeroMemory(KindItem,sizeof(KindItem));

	//拆分分析
	if (cbCardCount>=3)
	{
		for (BYTE i=0;i<MAX_INDEX;i++)
		{
			//同牌判断
			if (cbCardIndex[i]>=3)
			{
				ASSERT( cbKindItemCount < CountArray(KindItem) );
				KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
				KindItem[cbKindItemCount].cbCardIndex[0]=i;
				KindItem[cbKindItemCount].cbCardIndex[1]=i;
				KindItem[cbKindItemCount].cbCardIndex[2]=i;
				KindItem[cbKindItemCount++].wWeaveKind=WIK_PENG;
			}
		}
	}

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

		//变量定义
		BYTE cbIndex[MAX_WEAVE]={0,1,2,3};
		tagKindItem * pKindItem[MAX_WEAVE];
		ZeroMemory(&pKindItem,sizeof(pKindItem));

		//开始组合
		do
		{
			//设置变量
			CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
			for (BYTE i=0;i<cbLessKindItem;i++)
				pKindItem[i]=&KindItem[cbIndex[i]];

			//设置索引
			if (cbIndex[cbLessKindItem-1] == (cbKindItemCount-1))
			{
				BYTE i = 0;
				for (i=cbLessKindItem-1;i>0;i--)
				{
					if ((cbIndex[i-1]+1) != cbIndex[i])
					{
						BYTE cbNewIndex = cbIndex[i-1];
						for (BYTE j=(i-1); j<cbLessKindItem; j++) 
						{
							cbIndex[j]=cbNewIndex+j-i+2;
						}
						break;
					}
				}
				if (i==0)
				{
					break;
				}
			}
			else 
			{
				cbIndex[cbLessKindItem-1]++;
			}



		} while (true);

	}


	return false;
}

// 对子 豪华对子
//是否全2
bool CGameLogic::IsNeat2(BYTE cbCardIndex[MAX_INDEX],tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	//倒牌过滤
	if(cbWeaveCount>0) return false;

	//德国判断
	for(BYTE i=0; i<MAX_INDEX; i++)
	{
		if(cbCardIndex[i] != 0 && cbCardIndex[i] != 2 &&cbCardIndex[i] != 4)
		{
			return false;
		}
	}

	return true;
}
//七小对牌
bool CGameLogic::IsQiXiaoDui(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount,const BYTE cbCurrentCard,BYTE &cbGerman,bool bZimo)
{
	//组合判断;
	if (cbWeaveCount!=0) return false;

	//临时数据;
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
	
	//数目验证;
	ASSERT(GetCardCount(cbCardIndexTemp)%2==0);
	if(GetCardCount(cbCardIndexTemp)%2 !=0) return false;
	
	//当前索引;
	BYTE cbCurrentIndex = SwitchToCardIndex(cbCurrentCard);

	//计算单牌;
	for (BYTE i=0;i<MAX_INDEX;i++)
	{
		BYTE cbCardCount=cbCardIndexTemp[i];

		//单牌统计;
		if( cbCardCount == 1 || cbCardCount == 3 ) 	return false;
	}

	return true;

}

//7星
bool CGameLogic::ServenStar(BYTE cbCardIndex[MAX_INDEX], BYTE &cbGerman, BYTE cbCurrentCard, bool bZimo, bool bChongfeng)
{

	cbGerman=0;
	//临时数据
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));

	if (!bChongfeng)
	{	//全不靠;
		bool bRet = false;
		bool bAlone = IsNeatAlone(cbCardIndexTemp, cbGerman, cbCurrentCard, bZimo);
		if (bAlone == false)
		{
			return false;
		}
	}

	//7风记录
	BYTE cbHasFeng[7];
	ZeroMemory(cbHasFeng,sizeof(cbHasFeng));
	for(int i=27; i<34; i++)
	{
		cbHasFeng[i-27]=cbCardIndexTemp[i];

		if (!bChongfeng)
		{
			//重复风牌;
			if (cbHasFeng[i - 27] > 1) return false;
		}
	}

	//7星全
	int j=0;
	for (int i=0;i<7;i++)
	{
		if(cbHasFeng[i]>0)
			j++;
	}
	if(j==7)
	{
		return true;
	}
	return false;

}
//计算副精
BYTE CGameLogic::GetKingFromBrother(BYTE cbBrotherData)
{
	if(IsValidCard(cbBrotherData) == false)
	{
		return 0xFF;
	}
	BYTE cbColor = cbBrotherData & MASK_COLOR;
	BYTE cbValue = (cbBrotherData & MASK_VALUE) + 1;

	//万 索 筒
	if(cbColor != 0x30)
	{
		if(cbValue > 0x09)
		{
			cbValue = 0x01;
		}
	}
	else if(cbValue < 0x06)
	{
		if(cbValue > 0x04)
		{
			cbValue = 0x01;
		}
	}
	else
	{
		if(cbValue > 0x07)
		{
			cbValue = 0x05;
		}
	}

	return (cbColor | cbValue);
}

void CGameLogic::GetCardRemoveRepeat(BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT], BYTE &nCount)
{
	nCount = 0;
	for (BYTE i = 0; i < MAX_INDEX; ++i)
	{
		if (cbCardIndex[i] > 0)
		{
			cbCardData[nCount] = SwitchToCardData(i);
			++nCount;
		}
	}
}

BYTE CGameLogic::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult & ChiHuResult, BYTE cbHuRule, bool bZimo /*= false*/, bool bTurnAll, bool bRealTing)
{	//特殊停牌规则;
	//变量定义;
	WORD wChiHuKind = CHK_NULL;

	//设置变量;
	ZeroMemory(&ChiHuResult, sizeof(ChiHuResult));

	//构造扑克;
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

	BYTE cbRemoveRepeat = 0;
	BYTE cbCardDataRemoveRepeat[MAX_COUNT] = { 0 };

	GetCardRemoveRepeat(cbCardIndexTemp, cbCardDataRemoveRepeat, cbRemoveRepeat);

	//插入扑克;
	if (cbCurrentCard != 0)
		cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

	if ( bZimo )
	{	
		cbCardDataRemoveRepeat[cbRemoveRepeat] = cbCurrentCard;
		++cbRemoveRepeat;
	}

	if (!bTurnAll)
	{
		for (BYTE i = 0; i < cbRemoveRepeat; ++i)
		{
			RemoveCard(cbCardIndexTemp, cbCardDataRemoveRepeat[i]);

			for (BYTE j = 0; j < MAX_INDEX; j++)
			{
				BYTE cbCurrentCardTemp = SwitchToCardData(j);

				if (WIK_CHI_HU == AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCardTemp, wChiHuRight, ChiHuResult, cbHuRule, bZimo, false))
				{
					if (IsCheckZhongSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, ChiHuResult, cbHuRule, bRealTing))
					{
						ChiHuResult.wChiHuRight |= CHR_HAS_KING;
						return WIK_CHI_HU;
					}
				}
			}

			cbCardIndexTemp[SwitchToCardIndex(cbCardDataRemoveRepeat[i])]++;
		}
	}
	else
	{
		tagChiHuResult tempChiHuResult;

		bool bHuPai = false;
		for (BYTE i = 0; i < cbRemoveRepeat; ++i)
		{
			RemoveCard(cbCardIndexTemp, cbCardDataRemoveRepeat[i]);

			for (BYTE j = 0; j < MAX_INDEX; j++)
			{
				BYTE cbCurrentCardTemp = SwitchToCardData(j);

				if (WIK_CHI_HU == AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCardTemp, wChiHuRight, tempChiHuResult, cbHuRule, bZimo, false))
				{
					if (IsCheckZhongSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, tempChiHuResult, cbHuRule, bRealTing))
					{
						bHuPai = true;
						tempChiHuResult.wChiHuRight |= CHR_HAS_KING;

						CompareChiHuResult( ChiHuResult, tempChiHuResult );
					}
				}
			}

			cbCardIndexTemp[SwitchToCardIndex(cbCardDataRemoveRepeat[i])]++;
		}
		if (bHuPai)
		{
			return WIK_CHI_HU;
		}
	}

	return WIK_NULL;
}

bool CGameLogic::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, 
	BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult& ChiHuResult, BYTE cbHuRule, bool bZimo /*= true*/, bool bTurnAll /*= false*/)
{
	//复制数据;
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

	if (!bTurnAll)
	{
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			BYTE cbCurrentCardTemp = SwitchToCardData(i);
			if (WIK_CHI_HU == AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCardTemp, wChiHuRight, ChiHuResult, cbHuRule, bZimo, false))
			{
				if (IsCheckZhongSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, ChiHuResult, cbHuRule, true))
					return true;
			}
		}
	}
	else
	{
		tagChiHuResult tempChiHuResult;

		bool bHuPai = false;

		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			BYTE cbCurrentCardTemp = SwitchToCardData(i);
			if (WIK_CHI_HU == AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCardTemp, wChiHuRight, tempChiHuResult, cbHuRule, bZimo, false))
			{
				if (IsCheckZhongSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard, tempChiHuResult, cbHuRule, true))
				{
					bHuPai = true;
					tempChiHuResult.wChiHuRight |= CHR_HAS_KING;

					CompareChiHuResult(ChiHuResult, tempChiHuResult);
				}
			}
		}
		if (bHuPai)
		{
			return true;
		}
	}

	return false;
}

//清一色牌
bool CGameLogic::IsQingYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount, const BYTE cbCurrentCard)
{
	//胡牌后判断;
	BYTE cbCardColor = 0xFF;

	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		if (cbCardIndex[i] != 0)
		{
			//花色判断;
			if (cbCardColor != 0xFF)
				return false;

			//设置花色;
			cbCardColor = (SwitchToCardData(i)&MASK_COLOR);

			//设置索引;(第一种花色颜色找到后,直接移9位,找到第二种牌值的颜色);
			i = (i / 9 + 1) * 9 - 1;
		}
	}

	if ((cbCurrentCard&MASK_COLOR) != cbCardColor) return false;

	//组合判断;
	for (BYTE i = 0; i < cbItemCount; i++)
	{
		BYTE cbCenterCard = WeaveItem[i].cbCenterCard;
		if ((cbCenterCard&MASK_COLOR) != cbCardColor)	return false;
	}

	return true;
}

bool CGameLogic::IsHunYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount, const BYTE cbCurrentCard)
{
	BYTE cbCardColor = 0xFF;

	BYTE cbCardIndexTemp[MAX_INDEX] = {0};
	memcpy(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

	BYTE cbCardDataIndex = SwitchToCardIndex(cbCurrentCard);
	cbCardIndexTemp[cbCardDataIndex]++;

	//组合判断;
	for (BYTE i = 0; i < cbItemCount; i++)
	{
		BYTE cbCenterCard	 = WeaveItem[i].cbCenterCard;
		BYTE cbCardDataIndex = SwitchToCardIndex(cbCenterCard);
		
		cbCardIndexTemp[cbCardDataIndex]++;
	}

	for (BYTE i = 0; i < (MAX_INDEX - 7); i++)
	{
		if (cbCardIndexTemp[i] != 0)
		{
			//花色判断;
			if (cbCardColor != 0xFF)
				return false;

			//设置花色;
			cbCardColor = (SwitchToCardData(i)&MASK_COLOR);

			//设置索引;(第一种花色颜色找到后,直接移9位,找到第二种牌值的颜色);
			i = (i / 9 + 1) * 9 - 1;
		}
	}

	return true;
}

bool CGameLogic::IsZiPai(BYTE cbCardData)
{
	return ((cbCardData&MASK_COLOR) == 0x30);
}

bool CGameLogic::IsZiYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount, const BYTE cbCurrentCard)
{
	if (!IsZiPai(cbCurrentCard)) return false;
	//组合判断;
	for (BYTE i = 0; i < cbItemCount; i++)
	{
		BYTE cbCenterCard = WeaveItem[i].cbCenterCard;
		if (!IsZiPai(cbCenterCard))	return false;
	}

	for (BYTE i = 0; i < (MAX_INDEX - 7); i++)
	{
		if (cbCardIndex[i] != 0)
		{
			return false;
		}
	}

	return true;
}

WORD CGameLogic::AnalyseYingHuCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult & ChiHuResult, bool bZimo /*= false*/, bool bRealHu /*= true*/)
{
	BYTE cbValue = cbCurrentCard&MASK_VALUE;
	BYTE cbColor = (cbCurrentCard&MASK_COLOR) >> 4;

	if (bRealHu && (cbColor < 3) && (cbValue < 5))
	{	//5以下的不能胡;(东南西北中发白可以胡);
		return WIK_NULL;
	}

	//变量定义
	WORD wChiHuKind = CHK_NULL;

	//设置变量
	ZeroMemory(&ChiHuResult, sizeof(ChiHuResult));

	//构造扑克
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

	//插入扑克
	if (cbCurrentCard != 0)
		cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

	//自模权位
	if (bZimo)
	{
		wChiHuRight |= CHR_ZI_MO;
	}

	//权位调整 杠胡+自摸 = 杠上花
	if ((wChiHuRight&CHR_QIANG_GANG) && (wChiHuRight&CHR_ZI_MO))
	{
		wChiHuRight &= ~CHR_QIANG_GANG;
		wChiHuRight &= ~CHR_ZI_MO;
		wChiHuRight |= CHR_GANG_FLOWER;
	}

	//德国七星
	BYTE bGerman = 0;

	//7星
	if (cbWeaveCount == 0 && ServenStar(cbCardIndexTemp, bGerman, cbCurrentCard, bZimo) == true)
	{
		////真胡去掉有宝权位;
		//wChiHuRight &= ~CHR_HAS_KING;

		ChiHuResult.wChiHuKind = CHK_SERVEN;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}
	bGerman = 0;

	//13离
	if (cbWeaveCount == 0 && IsNeatAlone(cbCardIndexTemp, bGerman, cbCurrentCard, bZimo) == true)
	{
		ChiHuResult.wChiHuKind = CHK_THIRTEEN;
		ChiHuResult.wChiHuRight |= wChiHuRight;
		return WIK_CHI_HU;
	}

	bGerman = 0;
	//7小对分析
	if (cbWeaveCount == 0 && IsQiXiaoDui(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, bGerman, bZimo))
	{
		wChiHuKind = CHK_QI_DUI;

		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}

	//牌型数组
	static CAnalyseItemArray AnalyseItemArray;

	//设置变量
	AnalyseItemArray.RemoveAll();
	ZeroMemory(&ChiHuResult, sizeof(ChiHuResult));

	//分析扑克
	AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray, cbCurrentCard, bZimo);

	//胡牌分析
	if (AnalyseItemArray.GetCount() > 0)
	{
		//牌型分析
		for (INT_PTR i = 0; i < AnalyseItemArray.GetCount(); i++)
		{
			//变量定义
			bool bLianCard = false, bPengCard = false;
			bool bGerman = true;
			tagAnalyseItem * pAnalyseItem = &AnalyseItemArray[i];

			//牌型分析
			for (BYTE j = 0; j < CountArray(pAnalyseItem->wWeaveKind); j++)
			{
				WORD wWeaveKind = pAnalyseItem->wWeaveKind[j];
				bPengCard = ((wWeaveKind&(WIK_GANG | WIK_PENG)) != 0) ? true : bPengCard;
				bLianCard = ((wWeaveKind&(WIK_CHI)) != 0) ? true : bLianCard;
			}
			bGerman = (pAnalyseItem->cbWeaveKingReplace || pAnalyseItem->cbEyeKingReplace) ? false : bGerman;

			//牌型判断
			ASSERT((bLianCard == true) || (bPengCard == true));

			//基胡
			if ((bLianCard == true) && (bPengCard == true))
				wChiHuKind |= CHK_JI_HU;
			if ((bLianCard == true) && (bPengCard == false))
				wChiHuKind |= CHK_JI_HU;
			if ((bLianCard == false) && (bPengCard == true))
				wChiHuKind |= CHK_JI_HU; //wChiHuKind |= CHK_PENG_PENG;
		}
	}

	//结果判断
	if (wChiHuKind != CHK_NULL)
	{
		//设置结果
		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight = wChiHuRight;
		return WIK_CHI_HU;
	}

	return WIK_NULL;
}


WORD CGameLogic::AnalyseYiBianDaoHuCard(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, WORD wChiHuRight, tagChiHuResult & ChiHuResult, bool bZimo /*= false*/, bool bRealHu /*= true*/)
{
	BYTE cbValue = cbCurrentCard&MASK_VALUE;
	BYTE cbColor = (cbCurrentCard&MASK_COLOR) >> 4;

	if (bRealHu && (cbColor < 3) && (cbValue < 5))
	{	//5以下的不能胡;(东南西北中发白可以胡);
		return WIK_NULL;
	}

	//变量定义
	WORD wChiHuKind = CHK_NULL;

	//设置变量
	ZeroMemory(&ChiHuResult, sizeof(ChiHuResult));

	//构造扑克
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

	//插入扑克
	if (cbCurrentCard != 0)
		cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

	//自模权位
	if (bZimo)
	{
		wChiHuRight |= CHR_ZI_MO;
	}

	//权位调整 杠胡+自摸 = 杠上花
	if ((wChiHuRight&CHR_QIANG_GANG) && (wChiHuRight&CHR_ZI_MO))
	{
		wChiHuRight &= ~CHR_QIANG_GANG;
		wChiHuRight &= ~CHR_ZI_MO;
		wChiHuRight |= CHR_GANG_FLOWER;
	}

	//德国七星;
	BYTE bGerman = 0;

	//7星
	if (cbWeaveCount == 0 && ServenStar(cbCardIndexTemp, bGerman, cbCurrentCard, bZimo) == true)
	{
		ChiHuResult.wChiHuKind = CHK_SERVEN;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}

	bGerman = 0;
	//7小对分析
	if (cbWeaveCount == 0 && IsQiXiaoDui(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, bGerman, bZimo))
	{
		if (IsZiYiSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard))
		{
			wChiHuKind = (CHK_QI_DUI | CHK_ZIYISE);
		}
		else if (IsQingYiSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard))
		{
			wChiHuKind = (CHK_QI_DUI | CHK_QINYISE);
		}
		else if (IsHunYiSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard))
		{
			wChiHuKind = (CHK_QI_DUI | CHK_HUNYISE);
		}
		else
		{
			wChiHuKind = CHK_QI_DUI;
		}

		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}

	//牌型数组
	static CAnalyseItemArray AnalyseItemArray;

	//设置变量
	AnalyseItemArray.RemoveAll();
	ZeroMemory(&ChiHuResult, sizeof(ChiHuResult));

	//分析扑克
	AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray, cbCurrentCard, bZimo);

	//胡牌分析
	if (AnalyseItemArray.GetCount() > 0)
	{
		//牌型分析
		for (INT_PTR i = 0; i < AnalyseItemArray.GetCount(); i++)
		{
			//变量定义
			bool bLianCard = false, bPengCard = false;
			bool bGerman = true;
			tagAnalyseItem * pAnalyseItem = &AnalyseItemArray[i];

			//牌型分析
			for (BYTE j = 0; j < CountArray(pAnalyseItem->wWeaveKind); j++)
			{
				WORD wWeaveKind = pAnalyseItem->wWeaveKind[j];
				bPengCard = ((wWeaveKind&(WIK_GANG | WIK_PENG)) != 0) ? true : bPengCard;
				bLianCard = ((wWeaveKind&(WIK_CHI)) != 0) ? true : bLianCard;
			}
			bGerman = (pAnalyseItem->cbWeaveKingReplace || pAnalyseItem->cbEyeKingReplace) ? false : bGerman;

			//牌型判断
			ASSERT((bLianCard == true) || (bPengCard == true));

			//基胡;
			if ((bLianCard == true) && (bPengCard == true))
				wChiHuKind |= CHK_JI_HU;
			if ((bLianCard == true) && (bPengCard == false))
				wChiHuKind |= CHK_JI_HU;
			if ((bLianCard == false) && (bPengCard == true))
				wChiHuKind |= CHK_PENG_PENG;
		}
	}

	//字一色分析;
	if (IsZiYiSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard))
	{
		if (wChiHuKind == WIK_NULL)
		{	//没有组成胡牌的字一色胡权位;
			wChiHuRight |= CHR_INVALIDHU_ZIYISE;
		}

		wChiHuKind |= CHK_ZIYISE;
		wChiHuKind &= (~CHK_JI_HU);

		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}

	//清一色分析;
	if ((wChiHuKind != CHK_NULL) && IsQingYiSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard))
	{
		wChiHuKind |= CHK_QINYISE;
		wChiHuKind &= (~CHK_JI_HU);

		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}

	//混一色分析;
	if ((wChiHuKind != CHK_NULL) && IsHunYiSe(cbCardIndex, WeaveItem, cbWeaveCount, cbCurrentCard))
	{
		wChiHuKind |= CHK_HUNYISE;
		wChiHuKind &= (~CHK_JI_HU);

		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight |= wChiHuRight;

		return WIK_CHI_HU;
	}

	if (wChiHuKind == CHK_JI_HU)
	{	//只是基本胡,就不是一边倒胡;
		wChiHuKind = CHK_NULL;
	}

	//结果判断;
	if (wChiHuKind != CHK_NULL)
	{
		//设置结果
		ChiHuResult.wChiHuKind = wChiHuKind;
		ChiHuResult.wChiHuRight = wChiHuRight;
		return WIK_CHI_HU;
	}

	return WIK_NULL;
}

bool CGameLogic::IsCheckZhongSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount, const BYTE cbCurrentCard, tagChiHuResult & ChiHuResult, BYTE cbRule, bool bTing)
{
	if (ChiHuResult.wChiHuKind & CHK_ZIYISE)
	{
		if (IsZiYiSe(cbCardIndex, WeaveItem, cbItemCount, cbCurrentCard))
		{
			ChiHuResult.wChiHuRight &= (~CHR_INVALIDHU_ZIYISE);
			ChiHuResult.wChiHuRight |= CHR_GANG_ZHONGSE;
		}
		else
		{
			if (ChiHuResult.wChiHuRight & CHR_INVALIDHU_ZIYISE)
			{	//没杠到色，并且字一色不是胡牌(只是特殊的字一色胡，没有组合成胡牌)的情况下;
				ChiHuResult.wChiHuKind = WIK_NULL;
			}
			else
			{
				if (!bTing)
				{
					ChiHuResult.wChiHuKind &= (~CHK_ZIYISE);
				}
				else
				{	
					if (ChiHuResult.wChiHuKind & (~CHK_ZIYISE))
					{	//如果有其他的大胡，去除字一色权位;
						ChiHuResult.wChiHuKind &= (~CHK_ZIYISE);
					}
				}

				//听牌后，如果是混一色，改变胡牌种类;
				if (IsHunYiSe(cbCardIndex, WeaveItem, cbItemCount, cbCurrentCard))
				{
					ChiHuResult.wChiHuKind &= (~CHK_ZIYISE);
					ChiHuResult.wChiHuKind |= CHK_HUNYISE;
					ChiHuResult.wChiHuRight |= CHR_GANG_ZHONGSE;
				}
			}
		}
	}
	else if(ChiHuResult.wChiHuKind & CHK_QINYISE)
	{
		if (IsQingYiSe(cbCardIndex, WeaveItem, cbItemCount, cbCurrentCard))
		{
			ChiHuResult.wChiHuRight |= CHR_GANG_ZHONGSE;
		}
		else
		{
			if (!bTing)
			{
				ChiHuResult.wChiHuKind &= (~CHK_QINYISE);
			}
			else
			{	
				if (ChiHuResult.wChiHuKind & (~CHK_QINYISE))
				{	//如果有其他的大胡，去除清一色权位;
					ChiHuResult.wChiHuKind &= (~CHK_QINYISE);
				}
			}

			//如果是混一色，改变胡牌种类;
			if (IsHunYiSe(cbCardIndex, WeaveItem, cbItemCount, cbCurrentCard))
			{
				ChiHuResult.wChiHuKind &= (~CHK_QINYISE);
				ChiHuResult.wChiHuKind |= CHK_HUNYISE;
				ChiHuResult.wChiHuRight |= CHR_GANG_ZHONGSE;
			}
		}
	}
	else if (ChiHuResult.wChiHuKind & CHK_HUNYISE)
	{
		if (IsHunYiSe(cbCardIndex, WeaveItem, cbItemCount, cbCurrentCard))
		{
			ChiHuResult.wChiHuRight |= CHR_GANG_ZHONGSE;
		}
		else
		{
			if (!bTing)
			{
				ChiHuResult.wChiHuKind &= (~CHK_HUNYISE);
			}
			else
			{
				if (ChiHuResult.wChiHuKind & (~CHK_HUNYISE))
				{	//如果有其他的大胡，去除混一色权位;
					ChiHuResult.wChiHuKind &= (~CHK_HUNYISE);
				}
			}
		}
	}

	if (ChiHuResult.wChiHuKind == CHK_SERVEN)
	{
		//构造扑克;
		BYTE cbCardIndexTemp[MAX_INDEX];
		CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

		//插入扑克;
		if (cbCurrentCard != 0)
			cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

		//再次判断时,七星时是可以重复风牌,能走到这里一般都是有宝牌替换的;

		BYTE bGerman = 0;
		bool bZimo = false;
		bool bReal = ServenStar(cbCardIndexTemp, bGerman, cbCurrentCard, bZimo, true);
		if (!bReal)
		{	//假七星;
			if (cbRule == eWNMJHURuleEnum_YiBianDaoHU)
			{	//胡不了;
				ChiHuResult.wChiHuKind = CHK_NULL;
			}
			else
			{	//降成十三烂;
				ChiHuResult.wChiHuKind = CHK_THIRTEEN;
			}
		}
	}

	if ( ChiHuResult.wChiHuKind == CHK_NULL )
	{
		ChiHuResult.wChiHuRight = 0;
		return false;
	}

	return true;
}

void CGameLogic::CompareChiHuResult(tagChiHuResult& destChiHuResult, tagChiHuResult& tempChiHuResult)
{
	if (destChiHuResult.wChiHuKind == CHK_NULL)
	{
		destChiHuResult = tempChiHuResult;
	}
	else
	{
		if (destChiHuResult.wChiHuKind < tempChiHuResult.wChiHuKind)
		{
			if (tempChiHuResult.wChiHuKind >= CHK_HUNYISE)
			{
				if (tempChiHuResult.wChiHuRight & CHR_GANG_ZHONGSE)
				{
					destChiHuResult = tempChiHuResult;
				}
			}
			else
			{
				destChiHuResult = tempChiHuResult;
			}
		}
		else 
		{
			if (destChiHuResult.wChiHuKind >= CHK_HUNYISE)
			{
				if (!(destChiHuResult.wChiHuRight & CHR_GANG_ZHONGSE))
				{
					destChiHuResult = tempChiHuResult;
				}
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////