#include "StdAfx.h"
#include "GameLogicZhiPai.h"
#include "math.h"
#include "TableFrameSinkZhiPai.h"
#include "fstream"
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
//静态变量
//麻将数据
BYTE const CGameLogicZhiPai::m_cbCardDataArray_HUA[MAX_REPERTORY_HUA] =
{
	0x01, 0x01, 0x01, 0x11, 0x11,               //一
	0x02, 0x02, 0x02, 0x02, 0x02,               //二
	0x03, 0x03, 0x03, 0x13, 0x13,               //三
	0x04, 0x04, 0x04, 0x04, 0x04,               //四
	0x05, 0x05, 0x05, 0x15, 0x15,               //五
	0x06, 0x06, 0x06, 0x06, 0x06,               //六
	0x07, 0x07, 0x07, 0x17, 0x17,               //七
	0x08, 0x08, 0x08, 0x08, 0x08,               //八
	0x09, 0x09, 0x09, 0x19, 0x19,				//九
	0x0A, 0x0A, 0x0A, 0x0A, 0x0A,               //十

	0x21, 0x21, 0x21, 0x21, 0x21,               //孔
	0x22, 0x22, 0x22, 0x22, 0x22,               //己

	0x23, 0x23, 0x23, 0x23, 0x23,               //上
	0x24, 0x24, 0x24, 0x24, 0x24,               //大
	0x25, 0x25, 0x25, 0x25, 0x25,               //人

	0x26, 0x26, 0x26, 0x26, 0x26,               //土
	0x27, 0x27, 0x27, 0x27, 0x27,               //化
	0x28, 0x28, 0x28, 0x28, 0x28,               //千

	0x29, 0x29, 0x29, 0x29, 0x29,               //可
	0x2A, 0x2A, 0x2A, 0x2A, 0x2A,               //知
	0x2B, 0x2B, 0x2B, 0x2B, 0x2B,               //礼

	0x2C, 0x2C, 0x2C, 0x2C, 0x2C,               //子
};
BYTE const CGameLogicZhiPai::m_cbCardDataArray_HUA_One[MAX_REPERTORY_HUA_ONE] =
{
	0x01, 0x01, 0x01, 0x11, 0x11,               //一
	0x02, 0x02, 0x02, 0x02, 0x02,               //二
	0x03, 0x03, 0x03, 0x13, 0x13,               //三
	0x04, 0x04, 0x04, 0x04, 0x04,               //四
	0x05, 0x05, 0x05, 0x15, 0x15,               //五
	0x06, 0x06, 0x06, 0x06, 0x06,               //六
	0x07, 0x07, 0x07, 0x17, 0x17,               //七
	0x08, 0x08, 0x08, 0x08, 0x08,               //八
	0x09, 0x09, 0x09, 0x19, 0x19,				//九
	0x0A, 0x0A, 0x0A, 0x0A, 0x0A,               //十

	0x21, 0x21, 0x21, 0x21, 0x21,               //孔
	0x22, 0x22, 0x22, 0x22, 0x22,               //己

	0x23, 0x23, 0x23, 0x23, 0x23,               //上
	0x24, 0x24, 0x24, 0x24, 0x24,               //大
	0x25, 0x25, 0x25, 0x25, 0x25,               //人

	0x26, 0x26, 0x26, 0x26, 0x26,               //土
	0x27, 0x27, 0x27, 0x27, 0x27,               //化
	0x28, 0x28, 0x28, 0x28, 0x28,               //千

	0x29, 0x29, 0x29, 0x29, 0x29,               //可
	0x2A, 0x2A, 0x2A, 0x2A, 0x2A,               //知
	0x2B, 0x2B, 0x2B, 0x2B, 0x2B,               //礼

	0x2C, 0x2C, 0x2C, 0x2C, 0x2C,               //子
	0x2D,										//别杠
};
BYTE const CGameLogicZhiPai::m_cbCardDataArray_HUA_Two[MAX_REPERTORY_HUA_TWO] =
{
	0x01, 0x01, 0x01, 0x11, 0x11,               //一
	0x02, 0x02, 0x02, 0x02, 0x02,               //二
	0x03, 0x03, 0x03, 0x13, 0x13,               //三
	0x04, 0x04, 0x04, 0x04, 0x04,               //四
	0x05, 0x05, 0x05, 0x15, 0x15,               //五
	0x06, 0x06, 0x06, 0x06, 0x06,               //六
	0x07, 0x07, 0x07, 0x17, 0x17,               //七
	0x08, 0x08, 0x08, 0x08, 0x08,               //八
	0x09, 0x09, 0x09, 0x19, 0x19,				//九
	0x0A, 0x0A, 0x0A, 0x0A, 0x0A,               //十

	0x21, 0x21, 0x21, 0x21, 0x21,               //孔
	0x22, 0x22, 0x22, 0x22, 0x22,               //己

	0x23, 0x23, 0x23, 0x23, 0x23,               //上
	0x24, 0x24, 0x24, 0x24, 0x24,               //大
	0x25, 0x25, 0x25, 0x25, 0x25,               //人

	0x26, 0x26, 0x26, 0x26, 0x26,               //土
	0x27, 0x27, 0x27, 0x27, 0x27,               //化
	0x28, 0x28, 0x28, 0x28, 0x28,               //千

	0x29, 0x29, 0x29, 0x29, 0x29,               //可
	0x2A, 0x2A, 0x2A, 0x2A, 0x2A,               //知
	0x2B, 0x2B, 0x2B, 0x2B, 0x2B,               //礼

	0x2C, 0x2C, 0x2C, 0x2C, 0x2C,               //子
	0x2D, 0x2D,									//别杠
};
//////////////////////////////////////////////////////////////////////////

//构造函数
CGameLogicZhiPai::CGameLogicZhiPai(TableFrameSinkZhiPai* pTableFramSink)
{
	m_pTableFramSink = pTableFramSink;
	m_cbMagicIndex = MAX_INDEX_HUA;
}

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

//混乱扑克
BYTE CGameLogicZhiPai::RandCardData(BYTE cbCardData[],BYTE bGameType)
{
	if (bGameType == 14)
	{
		BYTE cbCardDataTemp[MAX_REPERTORY_HUA_TWO];
		BYTE cbMaxCount = 0;
		CopyMemory(cbCardDataTemp, m_cbCardDataArray_HUA_Two, sizeof(m_cbCardDataArray_HUA_Two));
		cbMaxCount = MAX_REPERTORY_HUA_TWO;
		//}
		//混乱扑克
		BYTE cbRandCount = 0, cbPosition = 0;
		do
		{
			cbPosition = rand() % (cbMaxCount - cbRandCount);
			cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
			cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
		} while (cbRandCount < cbMaxCount);
		cbRandCount = 0, cbPosition = 0;
		ZeroMemory(cbCardDataTemp, sizeof(cbCardDataTemp));
		CopyMemory(cbCardDataTemp, cbCardData, sizeof(cbCardDataTemp));
		ZeroMemory(cbCardData, sizeof(cbCardData));
		do
		{
			cbPosition = rand() % (cbMaxCount - cbRandCount);
			cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
			cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
		} while (cbRandCount < cbMaxCount);
		return cbMaxCount;
	}
	else if (bGameType == 15)
	{
		BYTE cbCardDataTemp[MAX_REPERTORY_HUA_ONE];
		BYTE cbMaxCount = 0;
		CopyMemory(cbCardDataTemp, m_cbCardDataArray_HUA_One, sizeof(m_cbCardDataArray_HUA_One));
		cbMaxCount = MAX_REPERTORY_HUA_ONE;
		//}
		//混乱扑克
		BYTE cbRandCount = 0, cbPosition = 0;
		do
		{
			cbPosition = rand() % (cbMaxCount - cbRandCount);
			cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
			cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
		} while (cbRandCount < cbMaxCount);
		cbRandCount = 0, cbPosition = 0;
		ZeroMemory(cbCardDataTemp, sizeof(cbCardDataTemp));
		CopyMemory(cbCardDataTemp, cbCardData, sizeof(cbCardDataTemp));
		ZeroMemory(cbCardData, sizeof(cbCardData));
		do
		{
			cbPosition = rand() % (cbMaxCount - cbRandCount);
			cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
			cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
		} while (cbRandCount < cbMaxCount);
		return cbMaxCount;
	}
	else
	{
		BYTE cbCardDataTemp[MAX_REPERTORY_HUA];
		BYTE cbMaxCount = 0;
		CopyMemory(cbCardDataTemp, m_cbCardDataArray_HUA, sizeof(m_cbCardDataArray_HUA));
		cbMaxCount = MAX_REPERTORY_HUA;
		//}
		//混乱扑克
		BYTE cbRandCount = 0, cbPosition = 0;
		do
		{
			cbPosition = rand() % (cbMaxCount - cbRandCount);
			cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
			cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
		} while (cbRandCount < cbMaxCount);
		cbRandCount = 0, cbPosition = 0;
		ZeroMemory(cbCardDataTemp, sizeof(cbCardDataTemp));
		CopyMemory(cbCardDataTemp, cbCardData, sizeof(cbCardDataTemp));
		ZeroMemory(cbCardData, sizeof(cbCardData));
		do
		{
			cbPosition = rand() % (cbMaxCount - cbRandCount);
			cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
			cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
		} while (cbRandCount < cbMaxCount);
		return cbMaxCount;
	}
}

//删除扑克
bool CGameLogicZhiPai::RemoveCard(BYTE cbCardIndex[MAX_INDEX_HUA], 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 CGameLogicZhiPai::RemoveCard(BYTE cbCardIndex[MAX_INDEX], const 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 CGameLogicZhiPai::RemoveCard(BYTE cbCardData[], BYTE cbCardCount, const BYTE cbRemoveCard[], BYTE cbRemoveCount)
{
	//检验数据
	ASSERT(cbCardCount<=14);
	ASSERT(cbRemoveCount<=cbCardCount);

	//定义变量
	BYTE cbDeleteCount=0,cbTempCardData[14];
	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 CGameLogicZhiPai::IsValidCard(BYTE cbCardData)
{
	BYTE cbValue = (cbCardData&MASK_VALUE);
	BYTE cbColor = (cbCardData&MASK_COLOR) >> 4;

	//如果颜色是0||1，牌值必须是0--A(10)
	//如果颜色是2，牌值必须是0--C(12)
	return (((cbColor == 0 || cbColor == 1) && (cbValue>0 && cbValue <= 10)) || ((cbColor == 2) && (cbValue >= 1 && cbValue <= 13)));
}

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

	return cbCardCount;
}

//获取组合
//BYTE CGameLogicZhiPai::GetWeaveCard(int cbWeaveKind, BYTE cbCenterCard, BYTE cbCardBuffer[4])
//{
//	//组合扑克
//	switch (cbWeaveKind)
//	{
//	case WIK_LEFT:		//上牌操作
//	{
//		//设置变量
//		cbCardBuffer[0] = cbCenterCard;
//		cbCardBuffer[1] = cbCenterCard + 1;
//		cbCardBuffer[2] = cbCenterCard + 2;
//
//		return 3;
//	}
//	case WIK_RIGHT:		//上牌操作
//	{
//		//设置变量
//		cbCardBuffer[0] = cbCenterCard;
//		cbCardBuffer[1] = cbCenterCard - 1;
//		cbCardBuffer[2] = cbCenterCard - 2;
//
//		return 3;
//	}
//	case WIK_CENTER:	//上牌操作
//	{
//		//设置变量
//		cbCardBuffer[0] = cbCenterCard;
//		cbCardBuffer[1] = cbCenterCard - 1;
//		cbCardBuffer[2] = cbCenterCard + 1;
//
//		return 3;
//	}
//	case WIK_PENG:		//碰牌操作
//	{
//		//设置变量
//		cbCardBuffer[0] = cbCenterCard;
//		cbCardBuffer[1] = cbCenterCard;
//		cbCardBuffer[2] = cbCenterCard;
//
//		return 3;
//	}
//	case WIK_MING_GANG:
//	case WIK_AN_GANG:
//	case WIK_BU_GANG:
//	{
//		//设置变量
//		cbCardBuffer[0] = cbCenterCard;
//		cbCardBuffer[1] = cbCenterCard;
//		cbCardBuffer[2] = cbCenterCard;
//		cbCardBuffer[3] = cbCenterCard;
//
//		return 4;
//	}
//	default:
//	{
//		ASSERT(FALSE);
//	}
//	}
//	return 0;
//}

//动作等级,只有碰，杠
BYTE CGameLogicZhiPai::GetUserActionRank(int cbUserAction)
{
	//胡牌等级
	if (cbUserAction&WIK_CHI_HU) { return 5; }

	//招等级
	if (cbUserAction&WIK_SAN_ZHAO) { return 3; }

	//对等级
	if (cbUserAction&WIK_DUI) { return 2; }

	return 0;
}

//吃牌判断 
//int CGameLogicZhiPai::EstimateEatCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
//{
//	//参数效验
//	ASSERT(IsValidCard(cbCurrentCard));
//
//	//变量定义
//	BYTE cbExcursion[3] = { 0, 1, 2 };
//	BYTE cbItemKind[3] = { WIK_LEFT, WIK_CENTER, WIK_RIGHT };
//
//	//吃牌判断
//	BYTE cbEatKind = 0, cbFirstIndex = 0;
//	BYTE cbCurrentIndex = SwitchToCardIndex(cbCurrentCard);
//	for (BYTE i = 0; i < CountArray(cbItemKind); i++)
//	{
//		BYTE cbValueIndex = cbCurrentIndex % 9;
//		if ((cbValueIndex >= cbExcursion[i]) && ((cbValueIndex - cbExcursion[i]) <= 6))
//		{
//			//吃牌判断
//			cbFirstIndex = cbCurrentIndex - cbExcursion[i];
//
//			//吃牌不能包含有王霸
//			if (m_cbMagicIndex != MAX_INDEX &&
//				m_cbMagicIndex >= cbFirstIndex && m_cbMagicIndex <= cbFirstIndex + 2) 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;
//
//			//设置类型
//			cbEatKind |= cbItemKind[i];
//		}
//	}
//	return cbEatKind;
//}

//碰牌判断
int CGameLogicZhiPai::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX_HUA], BYTE cbCurrentCard)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));
	//碰牌判断
	BYTE TempIndex = SwitchToCardIndex(cbCurrentCard);
	return (cbCardIndex[TempIndex] >= 2) ? WIK_DUI : WIK_NULL;
}

//杠牌判断
int CGameLogicZhiPai::EstimateGangCard(const BYTE cbCardIndex[MAX_INDEX_HUA], BYTE cbCurrentCard, const tagWeaveItem_Hua WeaveItem[], BYTE cbWeaveCount)
{
	ASSERT(IsValidCard(cbCurrentCard));
	int actionMask = WIK_NULL;
	BYTE index = SwitchToCardIndex(cbCurrentCard);
	BYTE zhi = cbCardIndex[index];

	//杠牌判断
	if (zhi >= 3)
	{
		actionMask |= WIK_SAN_ZHAO;
	}
	if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
	{
		for (BYTE i = 0; i < cbWeaveCount; i++)
		{
			if (WeaveItem[i].cbWeaveKind == WIK_SI_TONG && (SwitchToCardIndex(WeaveItem[i].cbCenterCard) == index) && WeaveItem[i].cbMargicOffset[2] == 0)
			{
				actionMask |= WIK_SI_ZHAO;
			}
		}
	}
	else
	{
		for (BYTE i = 0; i < cbWeaveCount; i++)
		{
			if (WeaveItem[i].cbWeaveKind == WIK_SI_TONG && WeaveItem[i].cbCenterCard == cbCurrentCard && WeaveItem[i].cbMargicOffset[2] == 0)
			{
				actionMask |= WIK_SI_ZHAO;
			}
		}
	}
	return actionMask;
}

//是否胡牌
//bool CGameLogicZhiPai::IsHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard)
//{
//	ASSERT(IsValidCard(cbCurrentCard));
//
//	BYTE cbCardIndexTemp[MAX_INDEX];
//	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
//	cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
//
//	//不符合硬胡规则的牌型
//	if (IsQiXiaoDui(cbCardIndexTemp, WeaveItem, cbWeaveCount))
//	{
//		return true;
//	}
//	if (IsJiangJiang(cbCardIndexTemp, WeaveItem, cbWeaveCount))
//	{
//		return true;
//	}
//
//	CAnalyseItemArray AnalyseItemArray;
//	if (1)//(AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray))
//	{
//		//符合硬胡规则牌型,将可以不是 2，5，8
//		if (IsQingYiSe(cbCardIndexTemp, WeaveItem, cbWeaveCount))
//			return true;
//		if (IsPengPeng(cbCardIndexTemp, WeaveItem, cbWeaveCount))
//			return true;
//		if (IsQuanQiuRen(cbCardIndexTemp, WeaveItem, cbWeaveCount))
//			return true;
//		//符合硬胡规则牌型，将必须是 2，5，8
//		for (BYTE i = 0; i < AnalyseItemArray.GetCount(); i++)
//		{
//			tagAnalyseItem& tagItem = AnalyseItemArray.GetAt(i);
//			BYTE cbCardData = tagItem.cbCardEye&MASK_VALUE;
//			if (cbCardData == 0x02 || cbCardData == 0x05 || cbCardData == 0x08)
//				return true;
//		}
//	}
//	return false;
//}

//分析胡牌
int CGameLogicZhiPai::AnalyseHuCard(const BYTE cbCardIndex[MAX_INDEX_HUA], const BYTE HuaCardInex[5], BYTE cbCurrentCard, const tagWeaveItem_Hua WeaveItem[], BYTE cbItemCount, const BYTE WeavHuaIndex[5], BYTE TongCount, tagHuCardResult & ChiHuResult)
{
	CAnalyseItemArray_hua AnalyseItemArray;
	//设置变量
	AnalyseItemArray.RemoveAll();
	ZeroMemory(&ChiHuResult, sizeof(ChiHuResult));

	//定义临时数组保存手中牌索引
	BYTE cbCardIndexTemp[MAX_INDEX_HUA];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
		
	//定义变量保存手中花牌的个数
	BYTE cbTempHuaCardIndex[5];
	BYTE cbTempWeaveHuaIndex[5];
	//tagWeaveItem_Hua WeaveItem[8];//保存组合牌（自摸没有统，统会变成手牌，点炮有统）
	//BYTE cbItemCount = 0;
	CopyMemory(cbTempHuaCardIndex, HuaCardInex, sizeof(cbTempHuaCardIndex));
	CopyMemory(cbTempWeaveHuaIndex, WeavHuaIndex, sizeof(cbTempWeaveHuaIndex));//组合中含有的花牌（自摸没有统，统会变成手牌，点炮有统）
	//if (cbCurrentCard == 0)//表示这是自摸
	//{
	//	HeBingCardIndex(cbCardIndexTemp, cbCardIndex_Tong, cbTempHuaCardIndex, HuaCardInex_Tong);
	//	cbItemCount = cbItemCount_HuPai;
	//	if (cbItemCount > 0)
	//	{
	//		CopyMemory(WeaveItem, WeaveItem_HuPai, sizeof(WeaveItem));
	//	}
	//	else
	//	{
	//		ZeroMemory(WeaveItem, sizeof(WeaveItem));
	//	}
	//}
	//else//放炮
	//{
	//	cbItemCount = cbItemCount_ChiHu;
	//	if (cbItemCount > 0)
	//	{
	//		CopyMemory(WeaveItem, WeaveItem_ChiHu, sizeof(WeaveItem));
	//	}
	//	else
	//	{
	//		ZeroMemory(WeaveItem, sizeof(WeaveItem));
	//	}
	//}

	//将当前牌加入手中牌索引数组中,0表示自摸，非零表示点炮
	if (cbCurrentCard != 0)
	{
		BYTE CardIndex = SwitchToCardIndex(cbCurrentCard);
		cbCardIndexTemp[CardIndex]++;
		//如果当前牌是花牌，保存到手中花牌索引数组中
		if ((cbCurrentCard & 0xF0) == 0x10)	cbTempHuaCardIndex[CardIndex / 2]++;
		
	}

	//得到手中各经牌的个数
	BYTE cbHandGoldCard[3];
	for (BYTE i = 0; i<3; i++)
	{
		cbHandGoldCard[i] = cbCardIndexTemp[(i * 2) + 2];
	}
	BYTE LaiZi[3] = { 0 };//用来存别杠那个牌变成啥经了
	if (cbCardIndexTemp[22] == 0)
	{	
		AnalyseItemArray.RemoveAll();		
		AnalyseCard(cbCardIndexTemp, WeaveItem, cbItemCount, AnalyseItemArray);				
		//对胡牌组合进行分析，得出最佳的胡牌组合
		if (AnalyseItemArray.GetCount()>0)
		{
			tagAnalyseItem_hua BestAnalyseItem;
			if (AnalyseCardHuNum(cbCardIndexTemp, cbCurrentCard, cbHandGoldCard, LaiZi, cbTempHuaCardIndex, cbTempWeaveHuaIndex, WeaveItem, cbItemCount, TongCount, AnalyseItemArray, BestAnalyseItem) >= 17)
			{
				ChiHuResult.IsHu = true;
				ChiHuResult.bHuPoint = BestAnalyseItem.cbPoint;
				ChiHuResult.bRealGold = BestAnalyseItem.cbGoldCard;
				CopyMemory(&ChiHuResult.AnalyseItem, &BestAnalyseItem, sizeof(tagAnalyseItem_hua));
				return WIK_ZI_MO;
			}
		}
	}
	else if (cbCardIndexTemp[22] == 1)
	{
		cbCardIndexTemp[22] = 0;
		tagAnalyseItem_hua MaxBestAnalyseItem;
		for (BYTE i = 0; i<3; i++)
		{
			cbHandGoldCard[i]++;
			cbCardIndexTemp[(i * 2) + 2]++;
			cbTempHuaCardIndex[i + 1]++;
			LaiZi[i] = 1;
			AnalyseItemArray.RemoveAll();
			AnalyseCard(cbCardIndexTemp, WeaveItem, cbItemCount, AnalyseItemArray);			
			if (AnalyseItemArray.GetCount()>0)
			{
				tagAnalyseItem_hua BestAnalyseItem;
				if (AnalyseCardHuNum(cbCardIndexTemp, cbCurrentCard, cbHandGoldCard, LaiZi, cbTempHuaCardIndex, cbTempWeaveHuaIndex, WeaveItem, cbItemCount, TongCount, AnalyseItemArray, BestAnalyseItem) >= 17)
				{
					if (BestAnalyseItem.cbPoint > ChiHuResult.bHuPoint)
					{
						ChiHuResult.IsHu = true;
						ChiHuResult.bHuPoint = BestAnalyseItem.cbPoint;
						ChiHuResult.bRealGold = BestAnalyseItem.cbGoldCard;
						CopyMemory(&ChiHuResult.AnalyseItem, &BestAnalyseItem, sizeof(tagAnalyseItem_hua));
					}					
				}
			}
			cbHandGoldCard[i]--;
			cbCardIndexTemp[(i * 2) + 2]--;
			cbTempHuaCardIndex[i + 1]--;
			LaiZi[i] = 0;
		}
		if (ChiHuResult.IsHu)
		{
			return WIK_ZI_MO;
		}
	}
	else
	{
		cbCardIndexTemp[22] = 0;
		for (BYTE i = 0; i<3; i++)
		{
			cbHandGoldCard[i]++;
			cbCardIndexTemp[(i * 2) + 2]++;
			cbTempHuaCardIndex[i + 1]++;
			LaiZi[i]++;
			for (BYTE j = 0; j < 3; j++)
			{
				cbHandGoldCard[j]++;
				cbCardIndexTemp[(j * 2) + 2]++;
				cbTempHuaCardIndex[j + 1]++;
				LaiZi[j]++;
				AnalyseItemArray.RemoveAll();				
				AnalyseCard(cbCardIndexTemp, WeaveItem, cbItemCount, AnalyseItemArray);				
				if (AnalyseItemArray.GetCount()>0)
				{
					tagAnalyseItem_hua BestAnalyseItem;
					if (AnalyseCardHuNum(cbCardIndexTemp, cbCurrentCard, cbHandGoldCard, LaiZi, cbTempHuaCardIndex, cbTempWeaveHuaIndex, WeaveItem, cbItemCount, TongCount, AnalyseItemArray, BestAnalyseItem) >= 17)
					{
						if (BestAnalyseItem.cbPoint > ChiHuResult.bHuPoint)
						{
							ChiHuResult.IsHu = true;
							ChiHuResult.bHuPoint = BestAnalyseItem.cbPoint;
							ChiHuResult.bRealGold = BestAnalyseItem.cbGoldCard;
							CopyMemory(&ChiHuResult.AnalyseItem, &BestAnalyseItem, sizeof(tagAnalyseItem_hua));
						}						
					}
				}
				cbHandGoldCard[j]--;
				cbCardIndexTemp[(j * 2) + 2]--;
				cbTempHuaCardIndex[j + 1]--;
				LaiZi[j]--;
			}
			cbHandGoldCard[i]--;
			cbCardIndexTemp[(i * 2) + 2]--;
			cbTempHuaCardIndex[i + 1]--;
			LaiZi[i]--;
		}
		if (ChiHuResult.IsHu)
		{
			return WIK_ZI_MO;
		}
	}
	return WIK_NULL;
}
//
//给定一个操作类型和操作中心牌索引，得到三张牌的索引,返回操作索引的个数
BYTE CGameLogicZhiPai::GetWeaveIndex(BYTE cbWeaveKind, BYTE cbCenterCardIndex, BYTE cbCardIndex[])
{
	//组合扑克
	switch (cbWeaveKind)
	{
	case WIK_DUI:		//对牌操作
	{
		//设置变量
		cbCardIndex[0] = cbCenterCardIndex;
		cbCardIndex[1] = cbCenterCardIndex;
		cbCardIndex[2] = cbCenterCardIndex;

		return 3;
	}
	case WIK_QI_TA:   //三连情况
	{
		//0--9之间的数字牌组合
		if (cbCenterCardIndex<(10 - 2))
		{
			cbCardIndex[0] = cbCenterCardIndex;
			cbCardIndex[1] = cbCenterCardIndex + 1;
			cbCardIndex[2] = cbCenterCardIndex + 2;
		}
		//孔乙已:孔
		if (cbCenterCardIndex == 10)
		{
			cbCardIndex[0] = cbCenterCardIndex;
			cbCardIndex[1] = 0;
			cbCardIndex[2] = cbCenterCardIndex + 1;
		}
		//上大人:上
		if (cbCenterCardIndex == 12)
		{
			cbCardIndex[0] = cbCenterCardIndex;
			cbCardIndex[1] = cbCenterCardIndex + 1;
			cbCardIndex[2] = cbCenterCardIndex + 2;
		}
		//七十土:土
		if (cbCenterCardIndex == 15)
		{
			cbCardIndex[0] = 6;
			cbCardIndex[1] = 9;
			cbCardIndex[2] = cbCenterCardIndex;
		}
		//化三千:化
		if (cbCenterCardIndex == 16)
		{
			cbCardIndex[0] = cbCenterCardIndex;
			cbCardIndex[1] = 2;
			cbCardIndex[2] = cbCenterCardIndex + 1;
		}
		//可知礼
		if (cbCenterCardIndex == 18)
		{
			cbCardIndex[0] = (cbCenterCardIndex);
			cbCardIndex[1] = (cbCenterCardIndex + 1);
			cbCardIndex[2] = (cbCenterCardIndex + 2);
		}
		//八九子
		if (cbCenterCardIndex == 21)
		{
			cbCardIndex[0] = (7);
			cbCardIndex[1] = (8);
			cbCardIndex[2] = (cbCenterCardIndex);
		}

		return 3;
	}
	case WIK_SI_ZHAO:		//四招操作
	{
		//设置变量
		cbCardIndex[0] = cbCenterCardIndex;
		cbCardIndex[1] = cbCenterCardIndex;
		cbCardIndex[2] = cbCenterCardIndex;
		cbCardIndex[3] = cbCenterCardIndex;
		cbCardIndex[4] = cbCenterCardIndex;

		return 5;
	}
	case WIK_SAN_ZHAO:		//三招操作
	{
		//设置变量
		cbCardIndex[0] = cbCenterCardIndex;
		cbCardIndex[1] = cbCenterCardIndex;
		cbCardIndex[2] = cbCenterCardIndex;
		cbCardIndex[3] = cbCenterCardIndex;

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

	return 0;
}
//合并手牌
bool CGameLogicZhiPai::HeBingCardIndex(BYTE cbCardIndexTemp[MAX_INDEX_HUA], const BYTE cbCardIndex_Tong[MAX_INDEX_HUA], BYTE cbTempHuaCardIndex[5], const BYTE HuaCardInex_Tong[5])
{
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		cbCardIndexTemp[i] += cbCardIndex_Tong[i];
		ASSERT(cbCardIndexTemp[i] <= 5);
	}
	for (BYTE i = 0; i < 5; i++)
	{
		cbTempHuaCardIndex[i] += HuaCardInex_Tong[i];
		ASSERT(cbTempHuaCardIndex[i] <= 2);
	}
	return true;
}


//bool CGameLogicZhiPai::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *cbTingPaiData, BYTE subMit)
//{
//	//复制数据
//	BYTE cbCardIndexTemp[MAX_INDEX];
//	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
//	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);
//	if (cbCardCount > 1 && (cbCardCount - 1) % 3 != 0)
//	{
//		ASSERT(false);
//		return false;
//	}
//	bool IsHu = false;
//	CChiHuRight chr;
//	for (BYTE i = 0; i < MAX_INDEX; i++)
//	{
//		BYTE cbCurrentCard = SwitchToCardData(i);
//		if (AnalyseHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, chr, cbCurrentCard, subMit))
//		{
//			cbTingPaiData[i] = 1;//保存番数
//			IsHu = true;
//		}
//		else
//		{
//			cbTingPaiData[i] = 0;
//		}
//	}
//	return IsHu;
//}

//是否听牌
//bool CGameLogicZhiPai::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE subMit)
//{
//	//复制数据
//	BYTE cbCardIndexTemp[MAX_INDEX];
//	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
//
//	for (BYTE i = 0; i < MAX_INDEX; i++)
//	{
//		BYTE cbCurrentCard = SwitchToCardData(i);		
//		if (IsHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard))
//			return true;
//	}
//	return false;
//}

//花牌索引转换成数据
BYTE CGameLogicZhiPai::SwitchToCardData(BYTE cbCardIndex)
{
	ASSERT((cbCardIndex >= 0) && (cbCardIndex<23));
	if ((cbCardIndex >= 0) && (cbCardIndex<10))
	{
		return 0x00 | (cbCardIndex + 1);
	}
	else
	{
		return 0x20 | (cbCardIndex - 9);
	}
}

//花牌数据转换成索引
BYTE CGameLogicZhiPai::SwitchToCardIndex(BYTE cbCardData)
{
	ASSERT(IsValidCard(cbCardData));
	BYTE cbValue = (cbCardData&MASK_VALUE);
	BYTE cbColor = (cbCardData&MASK_COLOR) >> 4;
	//如果是数字，直接得到最后一位值
	if (cbColor == 0 || cbColor == 1) return cbValue - 1;
	else return  cbValue + 9;
}

//扑克转换
BYTE CGameLogicZhiPai::SwitchToCardData(BYTE cbCardIndex[MAX_INDEX_HUA], BYTE cbCardData[MAX_COUNT_HUA], BYTE cbHuaCardIndex[])
{
	//转换扑克
	BYTE cbPosition = 0;
	for (BYTE i = 0; i<MAX_INDEX_HUA; i++)
	{
		if (cbCardIndex[i] != 0)
		{
			ASSERT(cbPosition<=MAX_COUNT_HUA);
			//如果是经牌，特殊处理
			if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
			{
				//将花牌数组中花牌个数保存到牌数据中
				for (BYTE k = 0; k<cbHuaCardIndex[i / 2]; k++)
				{
					cbCardData[cbPosition++] = 0x10 | (i + 1);
				}
				//将剩下的画白皮的
				for (BYTE j = 0; j<(cbCardIndex[i] - cbHuaCardIndex[i / 2]); j++)
				{
					cbCardData[cbPosition++] = 0x00 | (i + 1);
				}
			}
			//普通牌处理
			else
			{
				for (BYTE j = 0; j<cbCardIndex[i]; j++)
				{
					cbCardData[cbPosition++] = SwitchToCardData(i);
				}
			}
		}
	}

	return cbPosition;
}

//花牌数据转换
BYTE CGameLogicZhiPai::SwitchToCardIndex(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX_HUA])
{
	//设置变量
	ZeroMemory(cbCardIndex, sizeof(BYTE)*MAX_INDEX_HUA);

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

	return cbCardCount;
}

//根据扑克牌数据得到花牌保存到索引中,返回花牌的个数
BYTE CGameLogicZhiPai::GetHuaCard(BYTE cbCardData[], BYTE bCardCount, BYTE cbHuaCardIndex[])
{
	BYTE bHuaCardCount = 0;
	//循环从牌数据数组中得到花牌
	for (BYTE i = 0; i<bCardCount; i++)
	{
		//参数效验
		ASSERT(IsValidCard(cbCardData[i]));

		//如果是花牌，将花牌转换成索引存放到花牌索引数组中
		if ((cbCardData[i] & MASK_COLOR) == 0x10)
		{
			BYTE TempIndex = SwitchToCardIndex(cbCardData[i]);
			cbHuaCardIndex[TempIndex / 2]++;

			ASSERT(cbHuaCardIndex[TempIndex / 2] <= 2);
			bHuaCardCount++;
		}
	}
	return bHuaCardCount;
}

int CGameLogicZhiPai::AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX_HUA], const BYTE HuaCardInex[5], const tagWeaveItem_Hua WeaveItem[], BYTE cbWeaveCount,
	tagGangCardResult_Hua & GangCardResult, bool bFlag)
{
	//设置变量
	int cbActionMask = WIK_NULL;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));

	BYTE cbCardIndexTemp[MAX_INDEX_HUA];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
	BYTE cbHuaCardIndexTemp[5];
	CopyMemory(cbHuaCardIndexTemp, HuaCardInex, sizeof(cbHuaCardIndexTemp));

	tagWeaveItem_Hua WeaveItemTemp[8];
	if (cbWeaveCount > 0)
		CopyMemory(WeaveItemTemp, WeaveItem, sizeof(WeaveItemTemp));
	else
	{
		ZeroMemory(&WeaveItemTemp, sizeof(WeaveItemTemp));
	}
	//手上杠牌
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		if (i == 2 || i == 4 || i == 6)
		{
			if (cbCardIndex[i] + cbCardIndex[22] >= 4)
			{
				BYTE cbCardData = SwitchToCardData(i);
				if ((cbHuaCardIndexTemp[i / 2] + cbCardIndexTemp[22]) == 4 && cbCardIndex[i] == 0)
				{
					cbActionMask |= WIK_SI_TONG;
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = (cbCardData | 0x10);
				}
				else
				{
					cbActionMask |= WIK_SI_TONG;
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardData;
				}
			}
		}
		else if (cbCardIndex[i] >= 4)
		{
			BYTE cbCardData = SwitchToCardData(i);
			cbActionMask |= WIK_SI_TONG;
			GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardData;
		}
	}

	//组合杠牌
	for (BYTE i = 0; i < cbWeaveCount; i++)
	{
		if (WeaveItem[i].cbWeaveKind == WIK_SAN_ZHAO)
		{
			BYTE TempIndex = SwitchToCardIndex(WeaveItem[i].cbCenterCard);
			if (cbCardIndex[TempIndex] == 1)
			{
				if (TempIndex == 0 || TempIndex == 2 || TempIndex == 4 || TempIndex == 6 || TempIndex == 8)
				{
					if (HuaCardInex[TempIndex / 2] == 1)
					{
						cbActionMask |= WIK_SI_ZHAO;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = (WeaveItemTemp[i].cbCenterCard | 0x80 | 0x10);
					}
					else
					{
						cbActionMask |= WIK_SI_ZHAO;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = ((WeaveItemTemp[i].cbCenterCard & 0xEF) | 0x80);
					}
				}
				else
				{
					cbActionMask |= WIK_SI_ZHAO;
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = (WeaveItemTemp[i].cbCenterCard | 0x80);
				}
			}
		}
		if (WeaveItem[i].cbWeaveKind == WIK_SI_TONG)
		{
			BYTE TempIndex = SwitchToCardIndex(WeaveItem[i].cbCenterCard);
			if (TempIndex == 2 || TempIndex == 4 || TempIndex == 6)
			{
				if (cbCardIndex[TempIndex] >= 1 || cbCardIndex[22] >= 1)
				{
					if (cbCardIndex[TempIndex] - HuaCardInex[TempIndex / 2] >= 1)
					{
						cbActionMask |= WIK_WU_TONG;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = ((WeaveItemTemp[i].cbCenterCard & 0xEF) | 0x40);
					}
					else if (HuaCardInex[TempIndex / 2] >= 1)
					{
						cbActionMask |= WIK_WU_TONG;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = (WeaveItemTemp[i].cbCenterCard | 0x10 | 0x40);
					}
					else
					{
						cbActionMask |= WIK_WU_TONG;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = ((WeaveItemTemp[i].cbCenterCard & 0xEF) | 0x40);
					}
				}
			}
			else if (cbCardIndex[TempIndex] == 1)
			{
				if (TempIndex == 0 || TempIndex == 8)
				{
					if (HuaCardInex[TempIndex / 2] == 1)
					{
						cbActionMask |= WIK_WU_TONG;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = (WeaveItemTemp[i].cbCenterCard | 0x40 | 0x10);
					}
					else
					{
						cbActionMask |= WIK_WU_TONG;
						GangCardResult.cbCardData[GangCardResult.cbCardCount++] = ((WeaveItemTemp[i].cbCenterCard & 0xEF) | 0x40);
					}
				}
				else
				{
					cbActionMask |= WIK_WU_TONG;
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = (WeaveItemTemp[i].cbCenterCard | 0x40);
				}
			}
		}
	}
	return cbActionMask;
}

//分析用户手中的牌，得到可能胡牌的组合信息//用户手中牌的索引数组 //组合牌的数组                 //组合个数             //胡牌组合数组
bool CGameLogicZhiPai::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX_HUA], const tagWeaveItem_Hua WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray_hua & AnalyseItemArray)
{
	//统计索引数组中的所有牌数
	BYTE cbCardCount = 0;
	for (BYTE i = 0; i<MAX_INDEX_HUA; i++) cbCardCount += cbCardIndex[i];

	//效验数目，索引数组中牌的总数在最特殊的情况下，都会有一对丫口
	ASSERT(cbCardCount >= 2);
	if (cbCardCount<2) return false;

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

	//需求判断--用户手中胡牌的正确组合数
	BYTE cbLessKindItem = 8 - cbWeaveCount;

	//单吊判断，cbCardCount=2的情况：原来手中牌只有一张牌，加入要分析的牌后正好构成两张，其他的牌都在组合牌中
	if (cbCardCount == 2)
	{
		BYTE FirstIndex = -1, SecondeIndex = -1;
		//如果剩下的两张是丫口，保存所有组合牌
		if (IsYaKou(cbCardIndex, FirstIndex, SecondeIndex) == true)
		{
			tagAnalyseItem_hua AnalyseItem;
			ZeroMemory(&AnalyseItem, sizeof(AnalyseItem));

			//分析每一组组合牌，得到组合牌的组合牌型和中间牌索引,保存到分析子项中
			for (BYTE j = 0; j<cbWeaveCount; j++)
			{
				AnalyseItem.cbWeaveKind[j] = WeaveItem[j].cbWeaveKind;
				AnalyseItem.cbCenterCard[j] = SwitchToCardIndex(WeaveItem[j].cbCenterCard);
			}
			//保存丫口
			AnalyseItem.cbCardEye[0] = FirstIndex;
			AnalyseItem.cbCardEye[1] = SecondeIndex;
			//将分析结果插入到分析数组中
			AnalyseItemArray.Add(AnalyseItem);

			return true;
		}
		return false;
	}

	//加入待分析的牌后，手中牌>=3的情况，对手中牌索引数组进行分析
	if (cbCardCount >= 3)
	{
		for (BYTE i = 0; i<MAX_INDEX_HUA; i++)
		{
			//三个一样的牌
			if (cbCardIndex[i] >= 3)
			{
				KindItem[cbKindItemCount].cbCenterCard = i;
				KindItem[cbKindItemCount].cbCardIndex[0] = i;
				KindItem[cbKindItemCount].cbCardIndex[1] = i;
				KindItem[cbKindItemCount].cbCardIndex[2] = i;
				KindItem[cbKindItemCount].cbCardCount = 3;

				KindItem[cbKindItemCount++].cbWeaveKind = WIK_DUI;
			}
			//四个一样
			if (cbCardIndex[i] >= 4)
			{
				KindItem[cbKindItemCount].cbCenterCard = i;
				KindItem[cbKindItemCount].cbCardIndex[0] = i;
				KindItem[cbKindItemCount].cbCardIndex[1] = i;
				KindItem[cbKindItemCount].cbCardIndex[2] = i;
				KindItem[cbKindItemCount].cbCardIndex[3] = i;
				KindItem[cbKindItemCount].cbCardCount = 4;

				KindItem[cbKindItemCount++].cbWeaveKind = WIK_SI_TONG;
			}
			//五个一样
			if (cbCardIndex[i] >= 5)
			{
				KindItem[cbKindItemCount].cbCenterCard = i;
				KindItem[cbKindItemCount].cbCardIndex[0] = i;
				KindItem[cbKindItemCount].cbCardIndex[1] = i;
				KindItem[cbKindItemCount].cbCardIndex[2] = i;
				KindItem[cbKindItemCount].cbCardIndex[3] = i;
				KindItem[cbKindItemCount].cbCardIndex[4] = i;
				KindItem[cbKindItemCount].cbCardCount = 5;

				KindItem[cbKindItemCount++].cbWeaveKind = WIK_WU_TONG;
			}

			//2.连牌判断
			//0--9之间的排序
			if ((i<(10 - 2)) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if ((cbCardIndex[i + 1] >= j) && (cbCardIndex[i + 2] >= j))
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = i;
						KindItem[cbKindItemCount].cbCardIndex[1] = i + 1;
						KindItem[cbKindItemCount].cbCardIndex[2] = i + 2;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}
			}
			//11-21
			//孔乙已
			else if ((i == 10) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if (cbCardIndex[0] >= j && cbCardIndex[11] >= j)
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = i;
						KindItem[cbKindItemCount].cbCardIndex[1] = 0;
						KindItem[cbKindItemCount].cbCardIndex[2] = 11;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}
			}
			//上大人
			else if ((i == 12) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if (cbCardIndex[13] >= j && cbCardIndex[14] >= j)
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = i;
						KindItem[cbKindItemCount].cbCardIndex[1] = i + 1;
						KindItem[cbKindItemCount].cbCardIndex[2] = i + 2;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}
			}
			//七十土
			else if ((i == 15) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if (cbCardIndex[6] >= j && cbCardIndex[9] >= j)
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = 6;
						KindItem[cbKindItemCount].cbCardIndex[1] = 9;
						KindItem[cbKindItemCount].cbCardIndex[2] = i;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}
			}
			//化三千
			else if ((i == 16) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if (cbCardIndex[2] >= j && cbCardIndex[17] >= j)
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = i;
						KindItem[cbKindItemCount].cbCardIndex[1] = 2;
						KindItem[cbKindItemCount].cbCardIndex[2] = 17;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}

			}
			//可知礼
			else if ((i == 18) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if (cbCardIndex[19] >= j && cbCardIndex[20] >= j)
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = i;
						KindItem[cbKindItemCount].cbCardIndex[1] = i + 1;
						KindItem[cbKindItemCount].cbCardIndex[2] = i + 2;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}
			}
			//八九子
			else if ((i == 21) && (cbCardIndex[i]>0))
			{
				for (BYTE j = 1; j <= cbCardIndex[i]; j++)
				{
					if (cbCardIndex[7] >= j && cbCardIndex[8] >= j)
					{
						KindItem[cbKindItemCount].cbCenterCard = i;
						KindItem[cbKindItemCount].cbCardIndex[0] = 7;
						KindItem[cbKindItemCount].cbCardIndex[1] = 8;
						KindItem[cbKindItemCount].cbCardIndex[2] = i;
						KindItem[cbKindItemCount].cbCardCount = 3;

						KindItem[cbKindItemCount++].cbWeaveKind = WIK_QI_TA;
					}
				}

			}
		}
	}

	//打印用户手中牌的所有组合信息
#ifdef _DEBUG
	//CString csTemp;
	//csTemp.Format(L"时间:%d \r\n", KindItem[cbKindItemCount]);
	//OutputDebugString(csTemp);
	//m_Debug.PrintKindItemsMessage(KindItem, cbKindItemCount);
#endif 

	//分析所有的组合，从而得到可能胡牌的情况
	if (cbKindItemCount >= cbLessKindItem)
	{
		//变量定义
		BYTE cbCardIndexTemp[MAX_INDEX_HUA];
		ZeroMemory(cbCardIndexTemp, sizeof(cbCardIndexTemp));

		//变量定义
		BYTE cbIndex[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
		tagKindItem_hua * pKindItem[8];
		ZeroMemory(&pKindItem, sizeof(pKindItem));
		do
		{
			//每次循环将传进来的牌索引数组拷贝到临时数组中，进行分析
			CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

			//每次从上面分析得出的分析子项中取cbLessKindItem个分析子项进行分析，
			//注意：索引数组cbIndex[]在每次循环结束时都重新设置了
			for (BYTE i = 0; i<cbLessKindItem; i++)
			{
				pKindItem[i] = &KindItem[cbIndex[i]];
			}

			//数量判断
			bool bEnoughCard = true;
			//修改临时数组的值，把临时数组中构成cbLessKindItem个分析子项里的每一张牌，牌数减1，
			//以下是都是三个一组的
			for (BYTE k = 0; k<cbLessKindItem; k++)
			{
				//对组合里的每一个牌索引进行分析
				for (BYTE i = 0; i<pKindItem[k]->cbCardCount; i++)
				{
					//存在判断
					BYTE cbCardIndex = pKindItem[k]->cbCardIndex[i];

					if (cbCardIndexTemp[cbCardIndex] == 0)
					{
						bEnoughCard = false;
						break;
					}
					else cbCardIndexTemp[cbCardIndex]--;
				}
			}
			//胡牌判断，注意下面使用到的cbCardIndexTemp[]数组是经前面修改过后的
			if (bEnoughCard == true)
			{
				//统计数组中的个数要为2
				WORD cbCardCount = 0;
				for (BYTE i = 0; i<MAX_INDEX_HUA; i++) cbCardCount += cbCardIndexTemp[i];

				//丫口值
				BYTE cbFirstIndex = -1, cbSecondIndex = -1;
				//对剩下的牌进行分析，判断是否是丫口，
				if (IsYaKou(cbCardIndexTemp, cbFirstIndex, cbSecondIndex) == true)
				{
					ASSERT((cbFirstIndex != -1) && (cbSecondIndex != -1));

					tagAnalyseItem_hua AnalyseItem;
					ZeroMemory(&AnalyseItem, sizeof(AnalyseItem));

					//得到组合牌中的牌型，保存到分析子项中
					for (BYTE i = 0; i<cbWeaveCount; i++)
					{
						AnalyseItem.cbWeaveKind[i] = WeaveItem[i].cbWeaveKind;
						AnalyseItem.cbCenterCard[i] = SwitchToCardIndex(WeaveItem[i].cbCenterCard);
					}

					//得到手中牌的牌型，保存到分析子项中
					for (BYTE i = 0; i<cbLessKindItem; i++)
					{
						AnalyseItem.cbWeaveKind[i + cbWeaveCount] = pKindItem[i]->cbWeaveKind;
						AnalyseItem.cbCenterCard[i + cbWeaveCount] = pKindItem[i]->cbCenterCard;
					}
					//设置牌眼
					AnalyseItem.cbCardEye[0] = cbFirstIndex;
					AnalyseItem.cbCardEye[1] = cbSecondIndex;

					//将分析子项插入到分析数组中
					AnalyseItemArray.Add(AnalyseItem);
				}
			}

			//设置索引，索引数组中存放的是分析子项数组的下标，每次取分析子项进行分析时，都是按照索引数组
			//里面存放的下标值进行存取，当cbIndex[cbLessKindItem-1]的最后一位存放的值与得出的分析子项下标相同，
			//重新调整索引数组，下一次取值就会取新的组合
			if (cbIndex[cbLessKindItem - 1] == (cbKindItemCount - 1))
			{
				BYTE i = cbLessKindItem - 1;
				for (; 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;
					}
				}
				//跳出整个while循环
				if (i == 0) break;
			}
			else cbIndex[cbLessKindItem - 1]++;

		} while (true);
	}

	//打印用户手中牌合法的组合信息
#ifdef _DEBUG
	//CString csTemp;
	//csTemp.Format(L"时间:%d \r\n", AnalyseItemArray);
	//OutputDebugString(csTemp);
	//m_Debug.PrintValidKindItemsMessage(AnalyseItemArray);
#endif 

	return (AnalyseItemArray.GetCount()>0);
}

BYTE CGameLogicZhiPai::AnalyseCardHuNum(const BYTE cbCardIndexTemp[MAX_INDEX_HUA], BYTE cbCurrentCard, BYTE cbHandGoldCard[3], BYTE LaiZi[3], BYTE cbTempHuaCardIndex[5], BYTE cbTempWeaveHuaIndex[5], const tagWeaveItem_Hua WeaveItem[], BYTE cbItemCount, BYTE TongCount, CAnalyseItemArray_hua & AnalyseItemArray, tagAnalyseItem_hua & BestAnalyseItem)
{	
		//用动态数组		
		ZeroMemory(&BestAnalyseItem, sizeof(BestAnalyseItem));

		//逐一分析每一合法胡牌的组合
		for (INT_PTR i = 0; i<AnalyseItemArray.GetCount(); i++)
		{
			//对某一种组合进行分析
			tagAnalyseItem_hua *pAnalyseItem = &AnalyseItemArray[i];
			BYTE pTempTongCount = 0;
			for (BYTE j = 0; j < 8; j++)
			{
				if (pAnalyseItem->cbWeaveKind[j] == WIK_SI_TONG)
				{
					pTempTongCount++;
				}
				if (pAnalyseItem->cbWeaveKind[j] == WIK_WU_TONG)
				{
					pTempTongCount += 2;
				}
			}
			if (pTempTongCount < TongCount)continue;
			BYTE cbMaxPoint = 0;
			BYTE cbMaxPointGoldCard = 255;
			//对每一种组合分别讨论以1,3,5,7,9作为主金得出胡数最大的情况
			for (BYTE j = 0; j<3; j++)
			{
				//得到主经的索引值 
				BYTE RealGold = (j * 2) + 2;   //当前的假设主精
				WORD WeavePoint = 0;     //用户组合牌的总点数
				WORD HandPoint = 0;      //用户手中的总点数

				//每次重新保存手中经牌和花牌的个数，
				BYTE cbGoldCard[3];      //用户手中牌的各精牌个数
				BYTE cbHuaCardIndex[5];  //用户手中牌的各花牌个数
				CopyMemory(cbGoldCard, cbHandGoldCard, sizeof(cbGoldCard));
				CopyMemory(cbHuaCardIndex, cbTempHuaCardIndex, sizeof(cbHuaCardIndex));

				//1 分析用户组合牌中的分数
				//////////////////////下面用到的花牌索引应该是组合牌中的花牌///////////////////
				BYTE cbItemPoint;   //测试时用，用于记录每一组成的点数
				ZeroMemory(pAnalyseItem->cbKindPoint, sizeof(pAnalyseItem->cbKindPoint));
				for (BYTE m = 0; m<cbItemCount; m++)
				{
					//得到组合牌的中心牌索引
					cbItemPoint = 0;
					BYTE index = pAnalyseItem->cbCenterCard[m];
					if (pAnalyseItem->cbWeaveKind[m] == WIK_WU_TONG)
					{
						if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
						{
							if (index == 0 || index == 8)
							{
								HandPoint += 6;
								cbItemPoint = 6;
							}
							else
							{
								//1.是主金牌+56
								if (index == RealGold)
								{
									if (cbTempWeaveHuaIndex[index / 2] == 4)
									{
										//对应位置的花牌数减为0
										HandPoint += 96;
										cbItemPoint = 96;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 3)
									{
										//对应位置的花牌数减为0
										HandPoint += 72;
										cbItemPoint = 72;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 2)
									{
										//对应位置的花牌数减为0
										HandPoint += 56;
										cbItemPoint = 56;
									}
									else
									{
										ASSERT(false);
										cbItemPoint = 0;
										WeavePoint += 0;
									}
								}
								//不是主金+28
								else
								{
									if (cbTempWeaveHuaIndex[index / 2] == 4)
									{
										//对应位置的花牌数减为0
										HandPoint += 48;
										cbItemPoint = 48;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 3)
									{
										//对应位置的花牌数减为0
										HandPoint += 36;
										cbItemPoint = 36;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 2)
									{
										//对应位置的花牌数减为0
										HandPoint += 28;
										cbItemPoint = 28;
									}
									else
									{
										ASSERT(false);
										cbItemPoint = 0;
										WeavePoint += 0;
									}									
								}
							}
						}
						//2.普通牌(手中牌):红牌算8胡，黑牌算4胡
						else
						{
							//2.1红牌,只有上,大,人,可,知,礼六种情况+8
							if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
							{
								HandPoint += 8;
								cbItemPoint = 8;
							}
							//2.2黑牌+4
							else
							{
								HandPoint += 4;
								cbItemPoint = 4;
							}
						}
					}
					else if (pAnalyseItem->cbWeaveKind[m] == WIK_SI_TONG)
					{
						if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
						{
							if (index == 0 || index == 8)
							{
								switch (cbTempWeaveHuaIndex[index / 2])
								{
								case 1:   //一张花牌的情况
								{
									cbItemPoint = 3;
									WeavePoint += 3;
									break;
								}
								case 2:		//二张花牌的情况
								{
									cbItemPoint = 4;
									WeavePoint += 4;
									break;
								}
								}
							}
							else
							{
								//1.是主金牌根据花牌个数进行算分
								if (index == RealGold)
								{						
									//根据花牌个数进行计算
									switch (cbTempWeaveHuaIndex[index / 2])
									{
									case 1:    //一张花牌的情况
									{
										cbItemPoint = 24;
										WeavePoint += 24;
										break;
									}
									case 2:      //两张花牌情况
									{
										cbItemPoint = 28;
										WeavePoint += 28;
										break;
									}
									case 3:    //一张花牌的情况
									{
										cbItemPoint = 36;
										WeavePoint += 36;
										break;
									}
									case 4:    //一张花牌的情况
									{
										cbItemPoint = 48;
										WeavePoint += 48;
										break;
									}
									default:
									{
										ASSERT(false);
										break;
									}
									}
								}

								//非主金的牌,根据花牌的个数进行算分
								else
								{
									//根据花牌个数进行计算
									switch (cbTempWeaveHuaIndex[index / 2])
									{
									case 1:    //一张花牌的情况
									{
										cbItemPoint = 12;
										WeavePoint += 12;
										break;
									}
									case 2:      //两张花牌情况
									{
										cbItemPoint = 14;
										WeavePoint += 14;
										break;
									}
									case 3:    //一张花牌的情况
									{
										cbItemPoint = 18;
										WeavePoint += 18;
										break;
									}
									case 4:    //一张花牌的情况
									{
										cbItemPoint = 24;
										WeavePoint += 24;
										break;
									}
									}
								}
							}
						}
						//普通牌2.1红牌算4胡,2.2黑牌算2胡
						else
						{
							//2.1红牌,只有上,大,人,可,知,礼六种情况+4
							if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
							{
								WeavePoint += 4;
								cbItemPoint = 4;
							}
							//2.2黑牌+2
							else
							{
								WeavePoint += 2;
								cbItemPoint = 2;
							}
						}
					}
					//四招情况:1.是金牌,2.普通牌
					else if (pAnalyseItem->cbWeaveKind[m] == WIK_SI_ZHAO)
					{
						//1.是经牌1,3,5,7,9,分为:1.1主经,1.2非主经
						if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
						{
							if (index == 0 || index == 8)
							{
								cbItemPoint = 6;
								WeavePoint += 6;
							}
							else
							{
								//1.是主金牌+56
								if (index == RealGold)
								{
									if (cbTempWeaveHuaIndex[index  / 2] == 4)
									{
										cbItemPoint = 96;
										WeavePoint += 96;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 3)
									{
										cbItemPoint = 72;
										WeavePoint += 72;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 2)
									{
										cbItemPoint = 56;
										WeavePoint += 56;
									}
									else
									{
										ASSERT(false);
										cbItemPoint = 0;
										WeavePoint += 0;
									}
								}
								//不是主金+28
								else
								{
									if (cbTempWeaveHuaIndex[index / 2] == 4)
									{
										cbItemPoint = 48;
										WeavePoint += 48;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 3)
									{
										cbItemPoint = 36;
										WeavePoint += 36;
									}
									else if (cbTempWeaveHuaIndex[index / 2] == 2)
									{
										cbItemPoint = 28;
										WeavePoint += 28;
									}
									else
									{
										ASSERT(false);
										cbItemPoint = 0;
										WeavePoint += 0;
									}
								}
							}
						}
						//2.不是经牌的普通牌分:2.1红牌,2.2黑牌
						else
						{
							//2.1红牌,只有上,大,人,可,知,礼六种情况+8
							if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
							{
								WeavePoint += 8;
								cbItemPoint = 8;
							}
							//2.2黑牌+4
							else
							{
								WeavePoint += 4;
								cbItemPoint = 4;
							}
						}
					}
				//三招情况:1.是金牌,2.普通牌
				else if (pAnalyseItem->cbWeaveKind[m] == WIK_SAN_ZHAO)
				{
					//1,3,5,7,9的情况
					if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
					{
						if (index == 0 || index == 8)
						{
							switch (cbTempWeaveHuaIndex[index / 2])
							{
							case 1:   //一张花牌的情况
							{
								cbItemPoint = 3;
								WeavePoint += 3;
								break;
							}
							case 2:		//二张花牌的情况
							{
								cbItemPoint = 4;
								WeavePoint += 4;
								break;
							}
							}
						}
						else
						{
							//1.是主金牌根据花牌个数进行算分
							if (index == RealGold)
							{
								//根据花牌个数进行计算
								switch (cbTempWeaveHuaIndex[index / 2])
								{
								case 1:    //一张花牌的情况
								{
									cbItemPoint = 24;
									WeavePoint += 24;
									break;
								}
								case 2:      //两张花牌情况
								{
									cbItemPoint = 28;
									WeavePoint += 28;
									break;
								}
								case 3:    //一张花牌的情况
								{
									cbItemPoint = 36;
									WeavePoint += 36;
									break;
								}
								case 4:    //一张花牌的情况
								{
									cbItemPoint = 48;
									WeavePoint += 48;
									break;
								}
								}
							}

							//非主金的牌,根据花牌的个数进行算分
							else
							{
								//根据花牌个数进行计算
								switch (cbTempWeaveHuaIndex[index / 2])
								{
								case 1:    //一张花牌的情况
								{
									cbItemPoint = 12;
									WeavePoint += 12;
									break;
								}
								case 2:      //两张花牌情况
								{
									cbItemPoint = 14;
									WeavePoint += 14;
									break;
								}
								case 3:    //一张花牌的情况
								{
									cbItemPoint = 18;
									WeavePoint += 18;
									break;
								}
								case 4:    //一张花牌的情况
								{
									cbItemPoint = 24;
									WeavePoint += 24;
									break;
								}
								}
							}
						}
					}
					//普通牌2.1红牌算4胡,2.2黑牌算2胡
					else
					{
						//2.1红牌,只有上,大,人,可,知,礼六种情况+4
						if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
						{
							WeavePoint += 4;
							cbItemPoint = 4;
						}
						//2.2黑牌+2
						else
						{
							WeavePoint += 2;
							cbItemPoint = 2;
						}
					}
				}
				//对牌情况:1.是金牌,2.普通牌
				else if (pAnalyseItem->cbWeaveKind[m] == WIK_DUI)
				{
					//1,3,5,7,9的情况
					if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
					{
						if (index == 0 || index == 8)
						{
							//根据花牌个数进行计算
							switch (cbTempWeaveHuaIndex[index / 2])
							{
							case 0:    //0张花牌的情况
							{
								cbItemPoint = 0;
								WeavePoint += 0;

								break;
							}
							case 1:      //1张花牌情况
							{
								cbItemPoint = 1;
								WeavePoint += 1;
								break;
							}
							case 2:      //2张花牌情况
							{
								cbItemPoint = 2;
								WeavePoint += 2;
								break;
							}
							}

						}
						else
						{
							//1.是主金牌根据花牌个数进行算分
							if (index == RealGold)
							{
								//根据花牌个数进行计算
								switch (cbTempWeaveHuaIndex[index / 2])
								{
								case 0:    //0张花牌的情况
								{
									cbItemPoint = 6;
									WeavePoint += 6;
									break;
								}
								case 1:      //1张花牌情况
								{
									cbItemPoint = 8;
									WeavePoint += 8;
									break;
								}
								case 2:      //2张花牌情况
								{
									cbItemPoint = 10;
									WeavePoint += 10;
									break;
								}
								default:
								{
									ASSERT(false);
									cbItemPoint = 0;
									WeavePoint += 0;
									break;
								}
								}
							}
							//////////////非主金的情况下算胡///////////////////
							//2.非主金的牌
							else
							{
								//根据花牌个数进行计算
								switch (cbTempWeaveHuaIndex[index / 2])
								{
								case 0:    //0张花牌的情况
								{
									cbItemPoint = 3;
									WeavePoint += 3;
									break;
								}
								case 1:      //1张花牌情况
								{
									cbItemPoint = 4;
									WeavePoint += 4;
									break;
								}
								case 2:      //2张花牌情况
								{
									cbItemPoint = 5;
									WeavePoint += 5;
									break;
								}
								default:
								{
									ASSERT(false);
									cbItemPoint = 0;
									WeavePoint += 0;
									break;
								}
								}
							}
						}
					}
					//普通牌2.1红牌算1胡,2.2黑牌不算胡
					else
					{
						//2.1红牌,只有上,大,人,可,知,礼六种情况+1
						if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
						{
							WeavePoint += 1;
							cbItemPoint = 1;
						}
						//2.2黑牌+0
						else
						{
							WeavePoint += 0;
							cbItemPoint = 0;
						}
					}
				}

				pAnalyseItem->cbKindPoint[m] = cbItemPoint;
			}

			//2 计算用户手中坎牌的所有点数
			for (BYTE k = cbItemCount; k < 8; k++)
			{
				cbItemPoint = 0;
				//取每种组合里面的每小组的中心牌索引
				BYTE index = pAnalyseItem->cbCenterCard[k];

				//五藏情况:1.1是金牌,1.2.普通牌
				if (pAnalyseItem->cbWeaveKind[k] == WIK_WU_TONG)
				{
					//1.是金牌1,3,5,7,9,分为:1.1主金,1.2非主金
					if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
					{						
						if (index == 0 || index == 8)
						{
							HandPoint += 6;
							cbItemPoint = 6;
						}
						else
						{
							ASSERT(cbGoldCard[(index - 2) / 2] >= 5);
							cbGoldCard[(index - 2) / 2] -= 5;     //手中此精牌个数为0
							//1.1主金
							if (index == RealGold)
							{
								if (cbHuaCardIndex[index / 2] == 4)
								{
									//对应位置的花牌数减为0
									HandPoint += 96;
									cbItemPoint = 96;
									cbHuaCardIndex[index / 2] -= 4;
								}
								else if (cbHuaCardIndex[index / 2] == 3)
								{
									//对应位置的花牌数减为0
									HandPoint += 72;
									cbItemPoint = 72;
									cbHuaCardIndex[index / 2] -= 3;
								}
								else
								{
									//对应位置的花牌数减为0
									HandPoint += 56;
									cbItemPoint = 56;
									cbHuaCardIndex[index / 2] -= 2;
								}								
							}
							//1.2非主金的金牌
							else
							{
								if (cbHuaCardIndex[index / 2] == 4)
								{
									//对应位置的花牌数减为0
									HandPoint += 48;
									cbItemPoint = 48;
									cbHuaCardIndex[index / 2] -= 4;
								}
								else if (cbHuaCardIndex[index / 2] == 3)
								{
									//对应位置的花牌数减为0
									HandPoint += 36;
									cbItemPoint = 36;
									cbHuaCardIndex[index / 2] -= 3;
								}
								else
								{
									//对应位置的花牌数减为0
									HandPoint += 28;
									cbItemPoint = 28;
									cbHuaCardIndex[index / 2] -= 2;
								}
							}
						}
					}
					//2.普通牌(手中牌):红牌算8胡，黑牌算4胡
					else
					{
						//2.1红牌,只有上,大,人,可,知,礼六种情况+8
						if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
						{
							HandPoint += 8;
							cbItemPoint = 8;
						}
						//2.2黑牌+4
						else
						{
							HandPoint += 4;
							cbItemPoint = 4;
						}
					}
				}
				//四藏情况:1.是金牌,2.普通牌
				else if (pAnalyseItem->cbWeaveKind[k] == WIK_SI_TONG)
				{
					//1.是金牌1,3,5,7,9的情况
					if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
					{
						if (index == 0 || index == 8)
						{
							//根据花牌个数进行计算
							switch (cbHuaCardIndex[index / 2])
							{
							case 1:    //一张花牌的情况
							{
								cbItemPoint = 3;
								HandPoint += 3;
								cbHuaCardIndex[index / 2] -= 1;

								break;
							}
							case 2:      //两张花牌情况
							{
								cbItemPoint = 4;
								HandPoint += 4;
								cbHuaCardIndex[index / 2] -= 2;
								break;
							}
							}
						}
						else
						{
							cbGoldCard[(index - 2) / 2] -= 4;
							//1.是主金牌,根据花牌个数进行算分
							if (index == RealGold)
							{
								//根据花牌个数进行计算
								switch (cbHuaCardIndex[index / 2])
								{
								case 1:    //一张花牌的情况
								{
									cbItemPoint = 24;
									HandPoint += 24;
									cbHuaCardIndex[index / 2] -= 1;

									break;
								}
								case 2:      //两张花牌情况
								{
									cbItemPoint = 28;
									HandPoint += 28;
									cbHuaCardIndex[index / 2] -= 2;
									break;
								}
								case 3:      //两张花牌情况
								{
									cbItemPoint = 36;
									HandPoint += 36;
									cbHuaCardIndex[index / 2] -= 3;
									break;
								}
								case 4:      //两张花牌情况
								{
									cbItemPoint = 48;
									HandPoint += 48;
									cbHuaCardIndex[index / 2] -= 4;
									break;
								}
								}
							}
							//非主金的牌
							else
							{
								//根据花牌个数进行计算
								switch (cbHuaCardIndex[index / 2])
								{
								case 1:    //一张花牌的情况
								{
									cbItemPoint = 12;
									HandPoint += 12;
									cbHuaCardIndex[index / 2] -= 1;

									break;
								}
								case 2:      //两张花牌情况
								{
									cbItemPoint = 14;
									HandPoint += 14;
									cbHuaCardIndex[index / 2] -= 2;
									break;
								}
								case 3:      //两张花牌情况
								{
									cbItemPoint = 18;
									HandPoint += 18;
									cbHuaCardIndex[index / 2] -= 3;
									break;
								}
								case 4:      //两张花牌情况
								{
									cbItemPoint = 24;
									HandPoint += 24;
									cbHuaCardIndex[index / 2] -= 4;
									break;
								}
								}
							}
						}
					}
					//普通牌2.1红牌算4胡,2.2黑牌算2胡
					else
					{
						//2.1红牌,只有上,大,人,可,知,礼六种情况+4
						if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
						{
							cbItemPoint = 4;
							HandPoint += 4;
						}
						//2.2黑牌+2
						else
						{
							cbItemPoint = 2;
							HandPoint += 2;
						}
					}
				}
				//三张相同的：1.是金牌,2.普通牌
				else if (pAnalyseItem->cbWeaveKind[k] == WIK_DUI)
				{
					//是金牌:1,3,5,7,9的情况
					if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
					{
						if (index == 0 || index == 8)
						{
							//根据花牌个数进行计算
							switch (cbHuaCardIndex[index / 2])
							{
							case 0:    //0张花牌的情况
							{
								cbItemPoint = 1;
								HandPoint += 1;
								cbHuaCardIndex[index / 2] -= 0;

								break;
							}
							case 1:      //1张花牌情况
							{
								cbItemPoint = 2;
								HandPoint += 2;
								cbHuaCardIndex[index / 2] -= 1;
								break;
							}
							case 2:      //2张花牌情况
							{
								cbItemPoint = 3;
								HandPoint += 3;
								cbHuaCardIndex[index / 2] -= 2;
								break;
							}
							}
						}
						else
						{
							cbGoldCard[(index - 2) / 2] -= 3;
							//1.是主金牌,根据花牌个数进行算分
							if (index == RealGold)
							{
								//根据花牌个数进行计算
								switch (cbHuaCardIndex[index / 2])
								{
								case 0:    //0张花牌的情况
								{
									cbItemPoint = 10;
									HandPoint += 10;
									cbHuaCardIndex[index / 2] -= 0;

									break;
								}
								case 1:      //1张花牌情况
								{
									cbItemPoint = 12;
									HandPoint += 12;
									cbHuaCardIndex[index / 2] -= 1;
									break;
								}
								case 2:      //2张花牌情况
								{
									cbItemPoint = 14;
									HandPoint += 14;
									cbHuaCardIndex[index / 2] -= 2;
									break;
								}
								case 3:      //2张花牌情况
								{
									if (LaiZi[(index - 2) / 2] == 2)
									{
										cbItemPoint = 24;
										HandPoint += 24;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
									else
									{
										cbItemPoint = 18;
										HandPoint += 18;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}									
								}
								case 4:      //2张花牌情况
								{
									if (LaiZi[(index - 2) / 2] == 2)
									{
										cbItemPoint = 24;
										HandPoint += 24;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
									else
									{
										cbItemPoint = 18;
										HandPoint += 18;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
								}
								default:
								{
									ASSERT(false); 
									break;
								}
								}
							}
							//1.2非主金的花牌
							else
							{
								//根据花牌个数进行计算
								switch (cbHuaCardIndex[index / 2])
								{
								case 0:    //0张花牌的情况
								{
									cbItemPoint = 5;
									HandPoint += 5;
									cbHuaCardIndex[index / 2] -= 0;

									break;
								}
								case 1:      //1张花牌情况
								{
									cbItemPoint = 6;
									HandPoint += 6;
									cbHuaCardIndex[index / 2] -= 1;
									break;
								}
								case 2:      //2张花牌情况
								{
									cbItemPoint = 7;
									HandPoint += 7;
									cbHuaCardIndex[index / 2] -= 2;
									break;
								}
								case 3:      //2张花牌情况
								{
									if (LaiZi[(index - 2) / 2] == 2)
									{
										cbItemPoint = 12;
										HandPoint += 12;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
									else
									{
										cbItemPoint = 9;
										HandPoint += 9;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
								}
								case 4:      //2张花牌情况
								{
									if (LaiZi[(index - 2) / 2] == 2)
									{
										cbItemPoint = 12;
										HandPoint += 12;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
									else
									{
										cbItemPoint = 9;
										HandPoint += 9;
										cbHuaCardIndex[index / 2] -= 3;
										break;
									}
								}
								}
							}
						}
					}
					//2.普通牌
					else
					{
						//2.1红牌,只有上,大,人,可,知,礼六种情况+2
						if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20)
						{
							HandPoint += 2;
							cbItemPoint = 2;
						}
						//2.2黑牌+1
						else
						{
							HandPoint += 1;
							cbItemPoint = 1;
						}
					}
				}

				//句子判断,只统计上大人，可知礼的个数和剩下的经牌个数
				else if (pAnalyseItem->cbWeaveKind[k] == WIK_QI_TA)
				{
					//上大人/可知礼组合 +1
					if (index == 12 || index == 18)
					{
						HandPoint += 1;
						cbItemPoint = 1;
					}
				}
				pAnalyseItem->cbKindPoint[k] = cbItemPoint;
			}

			//3 数剩下的金牌的个数
			for (BYTE t = 0; t < 3; t++)
			{
				//计算花牌的点数
				if (cbHuaCardIndex[t + 1] > 0)
				{
					//除去经牌中花牌的个数
					cbGoldCard[t] -= cbHuaCardIndex[t + 1];
					//主金情况
					if (((t * 2) + 2) == RealGold)
					{
						HandPoint += cbHuaCardIndex[t + 1] * 4;
					}
					else
					{
						HandPoint += cbHuaCardIndex[t + 1] * 2;
					}
				}
				//计算白皮经牌的点数
				if (cbGoldCard[t] > 0)
				{
					//主金情况白皮的*2
					if (((t * 2) + 2) == RealGold)
					{
						HandPoint += cbGoldCard[t] * 2;
					}
					//非主金,白皮的*1
					else
					{
						HandPoint += cbGoldCard[t] * 1;
					}
				}
			}

			//4 数剩下的花牌的个数
			for (BYTE t = 0; t < 2; t++)
			{
				if (cbHuaCardIndex[t * 4] > 0)
				{
					HandPoint += cbHuaCardIndex[t * 4] * 1;
				}
			}

			//#ifdef _DEBUG
			//				m_Debug.PrintValidKindItemPointBeforeMessage(pAnalyseItem,WeavePoint,HandPoint);
			//#endif

			//校正手中牌的胡点:如果胡牌组合中，别人打出的一张牌与自己手中牌形成三张一样的，只能将其当作倒下的牌算点数
			//将手中牌每一种组合进行转换，判断所供牌是否在其中
			bool bFalgContinue = false;//表示这个打出牌是否会换统，当换统不影响统的个数，还是可以胡的，否则不可以胡
			if (cbCurrentCard != 0)
			{
				//得到所供的牌
				BYTE cbCurrentCardIndex = SwitchToCardIndex(cbCurrentCard);
				//首先是丫口判断,如果所供的牌在丫口中，不进行校正
				if ((cbCurrentCardIndex != pAnalyseItem->cbCardEye[0]) && (cbCurrentCardIndex != pAnalyseItem->cbCardEye[1]))
				{
					bool Qi_Ta = false;
					//分析别人出的牌是否在句牌中
					for (BYTE l = cbItemCount; l < 8; l++)
					{
						//得到WIK_QI_TA组合类型的所有索引，判断是否有所供的牌
						if (pAnalyseItem->cbWeaveKind[l] == WIK_QI_TA)
						{
							BYTE cbWeaveIndex[5] = { -1, -1, -1, -1, -1 };
							BYTE cbWeaveCount = GetWeaveIndex(pAnalyseItem->cbWeaveKind[l], pAnalyseItem->cbCenterCard[l], cbWeaveIndex);
							//判断所供的牌是否在WIK_QI_TA类型中，如果在，直接跳出不用校正
							for (BYTE n = 0; n < cbWeaveCount; n++)
							{
								if (cbCurrentCardIndex == cbWeaveIndex[n])
								{
									Qi_Ta = true;
									break;
								}
							}

							//如果在句牌中找到了别人所打的牌跳出循环
							if (Qi_Ta == true) break;
						}
						//得到WIK_SI_TONG组合类型中的所有索引，判断所供的牌是否是在其中，如果是，不能胡牌
						else if (pAnalyseItem->cbWeaveKind[l] == WIK_SI_TONG || pAnalyseItem->cbWeaveKind[l] == WIK_WU_TONG)
						{
							if (pAnalyseItem->cbWeaveKind[l] == WIK_WU_TONG && cbCurrentCardIndex == pAnalyseItem->cbCenterCard[l])
							{
								//AfxMessageBox("对不起！最佳胡牌组合分析得出，别人打出的牌形成四张的不能胡牌!");						
								bFalgContinue = true;
								//return WIK_NULL;
							}
							if (pAnalyseItem->cbWeaveKind[l] == WIK_SI_TONG && cbCurrentCardIndex == pAnalyseItem->cbCenterCard[l] && cbCardIndexTemp[cbCurrentCardIndex] == 4)
							{
								bFalgContinue = true;
							}
						}

					}

					//如果在句牌中没有找到别人打的牌，再到对牌中找
					if (Qi_Ta == false)
					{
						for (BYTE i = cbItemCount; i < 8; i++)
						{
							//WIK_DUI
							if (pAnalyseItem->cbWeaveKind[i] == WIK_DUI)
							{
								//如果手中对牌与所供牌相同，进行胡点校正
								if (cbCurrentCardIndex == pAnalyseItem->cbCenterCard[i])
								{
									//如果所供牌是金牌分：1.主金，2.普通金牌
									if (cbCurrentCardIndex == 2 || cbCurrentCardIndex == 4 || cbCurrentCardIndex == 6)
									{
										//1.主金减4胡
										if (cbCurrentCardIndex == RealGold)
										{
											HandPoint -= 4;  //HuPoint-=4;
											pAnalyseItem->cbKindPoint[i] -= 4;
										}
										//2.普通金牌减2胡
										else
										{
											HandPoint -= 2;  //HuPoint -=2;
											pAnalyseItem->cbKindPoint[i] -= 2;
										}
									}
									//普通牌分,总胡数减1
									else
									{
										HandPoint -= 1;
										pAnalyseItem->cbKindPoint[i] -= 1;
										//HuPoint -=1;
									}
									//处理完成后，结束循环
									break;
								}
							}

						}
					}
				}
			}
			if (bFalgContinue)
			{
				continue;
			}
			//以该经牌做为主经是否大于前面的点数
			//保存本组合中最大的点数及其对应的主精牌
			if ((WeavePoint + HandPoint) > cbMaxPoint)
			{
				cbMaxPoint = WeavePoint + HandPoint;
				cbMaxPointGoldCard = RealGold;
			}
			//先设置本循环中计算的点数及主精
			pAnalyseItem->cbPoint = WeavePoint + HandPoint;
			pAnalyseItem->cbGoldCard = RealGold;			
		}
		//修正：设置本组合中真正最大的点数及其对应的主精牌
		pAnalyseItem->cbPoint = cbMaxPoint;
		pAnalyseItem->cbGoldCard = cbMaxPointGoldCard;
	}
	//在此加上一项特殊的胡牌判断--7点胡牌
	//分析胡牌是否是7点特殊胡牌
	//1、就是用户手中所有的牌里,没有357的金,没有花乙和花九;
	//2、就是用户桌面上的组合牌里，要对上三对黑色字的牌，这三对黑色字的牌算一个胡
	//3、用户手中有三张及以上的组合牌,或桌面的组合牌中有四张及以上的招牌,要有一个红色字牌的一坎,比如三个上
	//4、并且最后胡牌是手里刚好是7个胡.
	//for (INT_PTR t = 0; t < AnalyseItemArray.GetCount(); t++)
	//{
	//	tagAnalyseItem_hua *pAnalyseItem = &AnalyseItemArray[t];
	//	//if(pAnalyseItem->cbPoint<10)
	//	//{
	//	//	CString str;
	//	//	str.Format("现在的点数为:%d",pAnalyseItem->cbPoint);
	//	//	AfxMessageBox(str);
	//	//}
	//	if (pAnalyseItem->cbPoint + 1 == 7)
	//	{
	//		bool bHaveHuGold = true;    //用户整个牌中，是否没有357的金,没有花乙和花九,默认是有
	//		BYTE cbBlackDuiCount = 0;   //用户桌面的组合牌中,是否有三对以上的黑对牌，默认为0
	//		BYTE cbReadDuiCount = 0;     //用户手中三张相同的红牌或桌面上招的红牌
	//		//1、就是手里没有357的金，没有花乙和花九
	//		BYTE cbUserHuaCardIndex[5];          //保存用户牌中花精的个数
	//		BYTE cbUserGoldCardIndex[5];         //保存用户牌中精牌的个数
	//		ZeroMemory(cbUserHuaCardIndex, sizeof(cbUserHuaCardIndex));
	//		ZeroMemory(cbUserGoldCardIndex, sizeof(cbUserGoldCardIndex));
	//		//将用户手中牌中的数据统计到数组中
	//		for (BYTE i = 0; i < 5; i++)
	//		{
	//			cbUserGoldCardIndex[i] = cbCardIndexTemp[i * 2];
	//			cbUserHuaCardIndex[i] = cbTempHuaCardIndex[i];
	//		}
	//		//将用户组合牌中的数据统计到数组中
	//		for (BYTE i = 0; i < cbItemCount; i++)
	//		{
	//			BYTE index = pAnalyseItem->cbCenterCard[i];
	//			if (index == 0 || index == 2 || index == 4 || index == 6 || index == 8)
	//			{
	//				if (pAnalyseItem->cbWeaveKind[i] == WIK_SI_ZHAO)
	//				{
	//					cbUserGoldCardIndex[i] += 4;
	//					cbUserHuaCardIndex[i] += cbTempWeaveHuaIndex[i];
	//				}
	//				else if (pAnalyseItem->cbWeaveKind[i] == WIK_SAN_ZHAO)
	//				{
	//					cbUserGoldCardIndex[i] += 5;
	//					cbUserHuaCardIndex[i] += cbTempWeaveHuaIndex[i];
	//				}
	//				else if (pAnalyseItem->cbWeaveKind[i] == WIK_DUI)
	//				{
	//					cbUserGoldCardIndex[i] += 3;
	//					cbUserHuaCardIndex[i] += cbTempWeaveHuaIndex[i];
	//				}
	//			}
	//		}
	//		//用户没有357牌
	//		if (cbUserGoldCardIndex[1] == 0 && cbUserGoldCardIndex[2] == 0 && cbUserGoldCardIndex[3] == 0)
	//		{
	//			//用户没有花1和花9
	//			if (cbUserHuaCardIndex[0] == 0 && cbUserHuaCardIndex[4] == 0)
	//			{
	//				bHaveHuGold = false;   //满足第一项:没有357的金,没有花乙和花九
	//			}
	//		}
	//		//统计用户组合牌中黑色的对牌数--用户桌面上的对牌中,黑对牌的数目
	//		for (BYTE i = 0; i < cbItemCount; i++)
	//		{
	//			if (pAnalyseItem->cbWeaveKind[i] == WIK_DUI)
	//			{
	//				BYTE index = pAnalyseItem->cbCenterCard[i];
	//				//红色的只有上大人[12,13,14]，可知礼[18,19,20]，三五七[2,4,6]
	//				if (index != 12 && index != 13 && index != 14 && index != 18 && index != 19 && index != 20 && index != 2 && index != 4 && index != 6)
	//				{
	//					cbBlackDuiCount++;  //满足第二项：用户桌面的对牌中,黑队牌的数目
	//				}
	//			}
	//		}
	//		//统计用户手中的对、统型中的红组合数目,及桌面上红招组合的数目
	//		//用户桌面中的红三招或红四招数目
	//		for (BYTE i = 0; i < cbItemCount; i++)
	//		{
	//			BYTE cbWeaveKind = pAnalyseItem->cbWeaveKind[i];
	//			if (cbWeaveKind == WIK_SAN_ZHAO || cbWeaveKind == WIK_SI_ZHAO)
	//			{
	//				BYTE index = pAnalyseItem->cbCenterCard[i];
	//				//红色的只有上大人[12,13,14]，可知礼[18,19,20]，三五七[2,4,6]
	//				if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20 || index == 2 || index == 4 || index == 6)
	//				{
	//					cbReadDuiCount++;
	//				}
	//			}
	//		}
	//		//用户手中红对、红四统、红五统的数目
	//		for (BYTE i = cbItemCount; i < 9; i++)
	//		{
	//			BYTE cbWeaveKind = pAnalyseItem->cbWeaveKind[i];
	//			if (cbWeaveKind == WIK_DUI || cbWeaveKind == WIK_SI_TONG || cbWeaveKind == WIK_WU_TONG)
	//			{
	//				BYTE index = pAnalyseItem->cbCenterCard[i];
	//				//红色的只有上大人[12,13,14]，可知礼[18,19,20]，三五七[2,4,6]
	//				if (index == 12 || index == 13 || index == 14 || index == 18 || index == 19 || index == 20 || index == 2 || index == 4 || index == 6)
	//				{
	//					cbReadDuiCount++;
	//				}
	//			}
	//		}
	//		//当满足四条规则时，应该将其6点数修改为32点
	//		if (bHaveHuGold == false && cbBlackDuiCount >= 3 && cbReadDuiCount >= 1)
	//		{
	//			pAnalyseItem->cbPoint = 32;
	//		}
	//	}
	//}
	//从所有的胡牌组合中找出胡点最大的组合
	INT_PTR BestIndex = 0;
	//对每一个胡牌组合进行比较，找出最佳胡牌组合
	for (INT_PTR i = 0; i < AnalyseItemArray.GetCount(); i++)
	{
		if (AnalyseItemArray[i].cbPoint > AnalyseItemArray[BestIndex].cbPoint)
		{
			BestIndex = i;
		}
	}

	BestAnalyseItem.cbPoint = AnalyseItemArray[BestIndex].cbPoint;
	BestAnalyseItem.cbGoldCard = AnalyseItemArray[BestIndex].cbGoldCard;
	//最好保存该种情况下的胡牌组合,以便别人算分
	CopyMemory(&BestAnalyseItem, &AnalyseItemArray[BestIndex], sizeof(tagAnalyseItem_hua));

	return BestAnalyseItem.cbPoint;
	//		if (BestAnalyseItem.cbPoint < 17)
	//		{
	//			return WIK_NULL;
	//		}
	//
	//		ChiHuResult.IsHu = true;
	//		ChiHuResult.HuScore = 2 + ((BestAnalyseItem.cbPoint - 17) / 5) * 2;
	//		ChiHuResult.bHuPoint = BestAnalyseItem.cbPoint;  //胡牌点数
	//		ChiHuResult.bRealGold = BestAnalyseItem.cbGoldCard;
	//		CopyMemory(&ChiHuResult.AnalyseItem, &BestAnalyseItem, sizeof(tagAnalyseItem_hua));
	//
	//#ifdef _DEBUG
	//		//m_Debug.PrintHuCardMessage(&BestAnalyseItem);
	//		//CString csTemp;
	//		//csTemp.Format(L"分析:%s \r\n", BestAnalyseItem);
	//		//OutputDebugString(csTemp);
	//#endif
	//		return WIK_CHI_HU;
}
//
bool CGameLogicZhiPai::IsYaKou(const BYTE cbCardIndex[], BYTE &FirstIndex, BYTE &SecondeIndex)
{
	BYTE cbCardIndexTemp[MAX_INDEX_HUA];
	ZeroMemory(cbCardIndexTemp, sizeof(cbCardIndexTemp));

	for (BYTE i = 0; i<MAX_INDEX_HUA; i++)
	{
		cbCardIndexTemp[i] = cbCardIndex[i];
	}
	//CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));


	//统计数组中的个数要为2
	WORD cbCardCount = 0;
	for (BYTE i = 0; i<MAX_INDEX_HUA; i++) cbCardCount += cbCardIndexTemp[i];

	//CString sz;
	//sz.Format("剩下的牌个数为:%d", cbCardCount);
	//AfxMessageBox(sz);

	if (cbCardCount != 2)	return false;


	//ASSERT(cbCardCount == 2);
	//if (cbCardCount != 2) return false;

	//	BYTE FirstIndex = -1,SecondeIndex = -1;

	//丫口为半句话
	for (BYTE i = 0; i<MAX_INDEX_HUA; i++)
	{
		if (cbCardIndexTemp[i] != 0)
		{
			FirstIndex = i;
			cbCardIndexTemp[i]--;
			break;
		}
	}
	//找下一张牌
	for (BYTE i = 0; i<MAX_INDEX_HUA; i++)
	{
		if (cbCardIndexTemp[i] != 0)
		{
			SecondeIndex = i;
			cbCardIndexTemp[i]--;
			break;
		}
	}

	//CString sz;
	//sz.Format("第一个索引为：%d,第二个索引为:%d", FirstIndex, SecondeIndex);
	//AfxMessageBox(sz);

	//判断是不是丫口
	//1.如果两张牌都是数字的情况下，相减绝对值必须<=2  单独考虑七，十，
	if (FirstIndex < 10 && SecondeIndex <10)
	{
		//特例:七，十
		if ((FirstIndex == 6 && SecondeIndex == 9) || (FirstIndex == 9 && SecondeIndex == 6)) return true;

		//其他情况按数字组合算,相减绝对值必须<=2          
		if (Abs(FirstIndex, SecondeIndex) <= 2) return true;
	}
	else
	{
		//2.有数字和字的情况下
		//孔,乙，己
		if ((FirstIndex == 10) && (SecondeIndex == 10 || SecondeIndex == 0 || SecondeIndex == 11)) return true;
		if ((FirstIndex == 0) && (SecondeIndex == 10 || SecondeIndex == 0 || SecondeIndex == 11)) return true;
		if ((FirstIndex == 11) && (SecondeIndex == 10 || SecondeIndex == 0 || SecondeIndex == 11)) return true;

		//上大人
		if ((FirstIndex == 12) && (SecondeIndex == 12 || SecondeIndex == 13 || SecondeIndex == 14)) return true;
		if ((FirstIndex == 13) && (SecondeIndex == 12 || SecondeIndex == 13 || SecondeIndex == 14)) return true;
		if ((FirstIndex == 14) && (SecondeIndex == 12 || SecondeIndex == 13 || SecondeIndex == 14)) return true;


		//化,三,千
		if ((FirstIndex == 16) && (SecondeIndex == 16 || SecondeIndex == 2 || SecondeIndex == 17)) return true;
		if ((FirstIndex == 2) && (SecondeIndex == 16 || SecondeIndex == 2 || SecondeIndex == 17)) return true;
		if ((FirstIndex == 17) && (SecondeIndex == 16 || SecondeIndex == 2 || SecondeIndex == 17)) return true;

		//七十土
		if ((FirstIndex == 6) && (SecondeIndex == 6 || SecondeIndex == 9 || SecondeIndex == 15)) return true;
		if ((FirstIndex == 9) && (SecondeIndex == 6 || SecondeIndex == 9 || SecondeIndex == 15)) return true;
		if ((FirstIndex == 15) && (SecondeIndex == 6 || SecondeIndex == 9 || SecondeIndex == 15)) return true;

		//八九子
		if ((FirstIndex == 7) && (SecondeIndex == 7 || SecondeIndex == 8 || SecondeIndex == 21)) return true;
		if ((FirstIndex == 8) && (SecondeIndex == 7 || SecondeIndex == 8 || SecondeIndex == 21)) return true;
		if ((FirstIndex == 21) && (SecondeIndex == 7 || SecondeIndex == 8 || SecondeIndex == 21)) return true;

		//可知礼
		if ((FirstIndex == 18) && (SecondeIndex == 18 || SecondeIndex == 19 || SecondeIndex == 20)) return true;
		if ((FirstIndex == 19) && (SecondeIndex == 18 || SecondeIndex == 19 || SecondeIndex == 20)) return true;
		if ((FirstIndex == 20) && (SecondeIndex == 18 || SecondeIndex == 19 || SecondeIndex == 20)) return true;
	}

	return false;
}
BYTE CGameLogicZhiPai::Abs(BYTE cbFirst, BYTE cbSecond)
{
	return (cbFirst > cbSecond) ? (cbFirst - cbSecond) : (cbSecond - cbFirst);

}
//编码
WORD CGameLogicZhiPai::GetValue(BYTE uNum, BYTE uFangShu, WORD PaiZhi)
{
	WORD mcd = PaiZhi | (uFangShu << 6) | (uNum << 13);
	return mcd;
}
//解码
BYTE CGameLogicZhiPai::DeCodeCard(const WORD cbCardData)
{
	BYTE TempCardData = cbCardData & 0x003F;
	return TempCardData;
}
//解码番薯
BYTE CGameLogicZhiPai::DeCodeFanshu(const WORD cbCardData)
{
	BYTE fanshu = (cbCardData & 0x1FC0) >> 6;
	return fanshu;
}

bool CGameLogicZhiPai::PeiPai(BYTE ParZhi[],BYTE nCount)
{
	std::ifstream in;
	std::string filename = "zuopai.dat";
	in.open(filename);
	if (!in.is_open())
	{
		return false;
	}
	switch (nCount)
	{
	case MAX_REPERTORY_HUA:
	{
		static BYTE TempCardData[MAX_REPERTORY_HUA];
		ZeroMemory(TempCardData, sizeof(TempCardData));
		BYTE tempCount = 0;
		char ch[1];
		while (!in.eof())
		{
			in.read(ch, 1);
			TempCardData[tempCount++] = ch[0];
		}
		in.close();
		if (tempCount < MAX_REPERTORY_HUA)
		{
			return false;
		}
		for (BYTE i = 0; i < MAX_REPERTORY_HUA; i++)
		{
			ASSERT(i < MAX_REPERTORY_HUA);
			ParZhi[i] = TempCardData[MAX_REPERTORY_HUA - i - 1];
		}
		return true;
	}
	case MAX_REPERTORY_HUA_ONE:
	{
		static BYTE TempCardData[MAX_REPERTORY_HUA_ONE];
		ZeroMemory(TempCardData, sizeof(TempCardData));
		BYTE tempCount = 0;
		char ch[1];
		while (!in.eof())
		{
			in.read(ch, 1);
			TempCardData[tempCount++] = ch[0];
		}
		in.close();
		if (tempCount < MAX_REPERTORY_HUA_ONE)
		{
			return false;
		}
		for (BYTE i = 0; i < MAX_REPERTORY_HUA_ONE; i++)
		{
			ASSERT(i < MAX_REPERTORY_HUA_ONE);
			ParZhi[i] = TempCardData[MAX_REPERTORY_HUA_ONE - i - 1];
		}
		return true;
	}
	case MAX_REPERTORY_HUA_TWO:
	{
		static BYTE TempCardData[MAX_REPERTORY_HUA_TWO];
		ZeroMemory(TempCardData, sizeof(TempCardData));
		BYTE tempCount = 0;
		char ch[1];
		while (!in.eof())
		{
			in.read(ch, 1);
			TempCardData[tempCount++] = ch[0];
		}
		in.close();
		if (tempCount < MAX_REPERTORY_HUA_TWO)
		{
			return false;
		}
		for (BYTE i = 0; i < MAX_REPERTORY_HUA_TWO; i++)
		{
			ASSERT(i < MAX_REPERTORY_HUA_TWO);
			ParZhi[i] = TempCardData[MAX_REPERTORY_HUA_TWO - i - 1];
		}
		return true;
	}
	default:
		break;
	}
	return false;
}
BYTE CGameLogicZhiPai::GetEndCard(BYTE cbCardIndex[MAX_INDEX_HUA])
{
	for (BYTE i = MAX_INDEX_HUA - 1; i >= 0; i--)
	{
		if (cbCardIndex[i] > 0)
		{
			return SwitchToCardData(i);
		}
	}	
	ASSERT(false);
	return 1;
}
/*
// 胡法分析函数
*/
//将将胡
//bool CGameLogicZhiPai::IsJiangJiang(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount)
//{
//	BYTE cbCardIndexTemp[MAX_INDEX];
//	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
//	BYTE cbCardData[MAX_COUNT] = { 0 };
//	BYTE Count = SwitchToCardData(cbCardIndexTemp, cbCardData);
//	for (int i = Count - 1; i >= 0; i--)
//	{
//		if ((cbCardData[i] & MASK_VALUE) == 2)continue;
//		else if ((cbCardData[i] & MASK_VALUE) == 5)continue;
//		else if ((cbCardData[i] & MASK_VALUE) == 8)continue;
//		else return false;
//	}
//	for (BYTE i = 0; i < cbWeaveCount; i++)
//	{
//		if (WeaveItem[i].cbWeaveKind == WIK_LIANG_PAI)continue;
//		if (WeaveItem[i].cbWeaveKind&(WIK_LEFT | WIK_RIGHT | WIK_CENTER))
//			return false;
//		if ((WeaveItem[i].cbCenterCard&MASK_VALUE) == 2)continue;
//		else if ((WeaveItem[i].cbCenterCard&MASK_VALUE) == 5)continue;
//		else if ((WeaveItem[i].cbCenterCard&MASK_VALUE) == 8)continue;
//		else return false;
//	}
//	return true;
//}
//全求人
//bool CGameLogicZhiPai::IsQuanQiuRen(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount)
//{
//	BYTE cbCardCount = 0;
//	BYTE cbCardData = 0;
//	for (BYTE i = 0; i < MAX_INDEX; i++)
//	{
//		if (cbCardIndex[i] != 0)
//		{
//			cbCardCount += cbCardIndex[i];
//			++cbCardData;
//		}
//	}
//	return (cbCardCount == 2 && cbCardData == 1);
//}
//七小对类型
//int CGameLogicZhiPai::TypeQiXiaoDui(const BYTE cbCardIndex[MAX_INDEX])
//{
//	int cbCount = 0;
//	for (int i = 0; i < MAX_INDEX;i++)
//	{
//		if (cbCardIndex[i] == 4)
//			++cbCount;
//	}
//	int nHuType = CHR_QI_XIAO_DUI;
//	return nHuType << cbCount;
//}
//大对子
//bool CGameLogicZhiPai::IsPengPeng(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount)
//{
//	for (BYTE i = 0; i < cbItemCount; i++)
//	{
//		if (WeaveItem[i].cbWeaveKind&(WIK_LEFT | WIK_RIGHT | WIK_CENTER))
//			return false;
//	}
//	BYTE cbCardCount = GetCardCount(cbCardIndex);
//	BYTE DanCount = 0;
//	BYTE DuiZiCount = 0;
//	for (BYTE i = 0; i<MAX_INDEX; i++)
//	{
//		if (cbCardIndex[i] == 3)
//		{
//			DuiZiCount++;
//		}
//		if (cbCardIndex[i] == 2)
//		{
//			DanCount++;
//		}
//	}
//	switch (cbCardCount)
//	{
//	case 2:
//		if (DanCount == 1)
//			return true;
//	case 5:
//		if (DuiZiCount == 1 && DanCount == 1)
//			return true;
//	case 8:
//		if (DuiZiCount == 2 && DanCount == 1)
//			return true;
//	case 11:
//		if (DuiZiCount == 3 && DanCount == 1)
//			return true;
//	case 14:
//		if (DuiZiCount == 4 && DanCount == 1)
//			return true;
//	default:
//		return false;
//	}
//	return false;
//}
//清一色牌
//bool CGameLogicZhiPai::IsQingYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount)
//{
//	//胡牌判断
//	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);
//			//设置索引
//			i = (i / 9 + 1) * 9 - 1;
//		}
//	}
//	//组合判断
//	for (BYTE i = 0; i<cbItemCount; i++)
//	{
//		if (WeaveItem[i].cbWeaveKind == WIK_LIANG_PAI) continue;
//		BYTE cbCenterCard = WeaveItem[i].cbCenterCard;
//		if ((cbCenterCard&MASK_COLOR) != cbCardColor)	return false;
//	}
//	return true;
//}
////七小对牌
//bool CGameLogicZhiPai::IsQiXiaoDui(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount)
//{
//	//组合判断
//	for (BYTE i = 0; i < cbWeaveCount; i++)
//	{		
//		return false;
//	}
//	//单牌数目
//	BYTE cbReplaceCount = 0;
//	//临时数据
//	BYTE cbCardIndexTemp[MAX_INDEX];
//	CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
//	//计算单牌
//	for (BYTE i=0;i<MAX_INDEX;i++)
//	{
//		//单牌统计
//		if (cbCardIndexTemp[i] == 1 || cbCardIndexTemp[i] == 3) 	cbReplaceCount++;
//	}
//	if(cbReplaceCount > 0 )
//		return false;
//	return true;
//}

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