zhujimajiang_redis/游戏服务器/GameLogic.cpp

#include "StdAfx.h"
#include "GameLogic.h"
#include "math.h"
#include "TableFrameSink.h"
#include "fstream"
//////////////////////////////////////////////////////////////////////////

//静态变量
bool		CChiHuRight::m_bInit = false;
DWORD		CChiHuRight::m_dwRightMask[MAX_RIGHT_COUNT];

//构造函数
CChiHuRight::CChiHuRight()
{
	ZeroMemory( m_dwRight,sizeof(m_dwRight) );

	if( !m_bInit )
	{
		m_bInit = true;
		for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )
		{
			if( 0 == i )
				m_dwRightMask[i] = 0;
			else
				m_dwRightMask[i] = (DWORD(pow(2.0,i-1)))<<28;
		}
	}
}

//赋值符重载
CChiHuRight & CChiHuRight::operator = ( DWORD dwRight )
{
	DWORD dwOtherRight = 0;
	//验证权位
	if( !IsValidRight( dwRight ) )
	{
		//验证取反权位
		ASSERT( IsValidRight( ~dwRight ) );
		if( !IsValidRight( ~dwRight ) ) return *this;
		dwRight = ~dwRight;
		dwOtherRight = MASK_CHI_HU_RIGHT;
	}

	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )
	{
		if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) )
			m_dwRight[i] = dwRight&MASK_CHI_HU_RIGHT;
		else m_dwRight[i] = dwOtherRight;
	}

	return *this;
}

//与等于
CChiHuRight & CChiHuRight::operator &= ( DWORD dwRight )
{
	bool bNavigate = false;
	//验证权位
	if( !IsValidRight( dwRight ) )
	{
		//验证取反权位
		ASSERT( IsValidRight( ~dwRight ) );
		if( !IsValidRight( ~dwRight ) ) return *this;
		//调整权位
		DWORD dwHeadRight = (~dwRight)&0xF0000000;
		DWORD dwTailRight = dwRight&MASK_CHI_HU_RIGHT;
		dwRight = dwHeadRight|dwTailRight;
		bNavigate = true;
	}

	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )
	{
		if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) )
		{
			m_dwRight[i] &= (dwRight&MASK_CHI_HU_RIGHT);
		}
		else if( !bNavigate )
			m_dwRight[i] = 0;
	}

	return *this;
}

//或等于
CChiHuRight & CChiHuRight::operator |= ( DWORD dwRight )
{
	//验证权位
	if( !IsValidRight( dwRight ) ) return *this;

	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )
	{
		if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) )
			m_dwRight[i] |= (dwRight&MASK_CHI_HU_RIGHT);
	}

	return *this;
}
//异或等于
CChiHuRight & CChiHuRight::operator -= (DWORD dwRight)
{
	//验证权位
	if (!IsValidRight(dwRight)) return *this;

	for (BYTE i = 0; i < CountArray(m_dwRightMask); i++)
	{
		if ((dwRight&m_dwRightMask[i]) || (i == 0 && dwRight < 0x10000000))
			if (m_dwRight[i]&dwRight)
			{
				m_dwRight[i] ^= dwRight;
			}
			
	}

	return *this;
}

//与
CChiHuRight CChiHuRight::operator & ( DWORD dwRight )
{
	CChiHuRight chr = *this;
	return (chr &= dwRight);
}

//与
CChiHuRight CChiHuRight::operator & ( DWORD dwRight ) const
{
	CChiHuRight chr = *this;
	return (chr &= dwRight);
}

//或
CChiHuRight CChiHuRight::operator | ( DWORD dwRight )
{
	CChiHuRight chr = *this;
	return chr |= dwRight;
}

//或
CChiHuRight CChiHuRight::operator | ( DWORD dwRight ) const
{
	CChiHuRight chr = *this;
	return chr |= dwRight;
}

//是否权位为空
bool CChiHuRight::IsEmpty()
{
	for( BYTE i = 0; i < CountArray(m_dwRight); i++ )
		if( m_dwRight[i] ) return false;
	return true;
}

//设置权位为空
void CChiHuRight::SetEmpty()
{
	ZeroMemory( m_dwRight,sizeof(m_dwRight) );
	return;
}

//获取权位数值
BYTE CChiHuRight::GetRightData( DWORD dwRight[], BYTE cbMaxCount )
{
	ASSERT( cbMaxCount >= CountArray(m_dwRight) );
	if( cbMaxCount < CountArray(m_dwRight) ) return 0;

	CopyMemory( dwRight,m_dwRight,sizeof(DWORD)*CountArray(m_dwRight) );
	return CountArray(m_dwRight);
}

//设置权位数值
bool CChiHuRight::SetRightData( const DWORD dwRight[], BYTE cbRightCount )
{
	ASSERT( cbRightCount <= CountArray(m_dwRight) );
	if( cbRightCount > CountArray(m_dwRight) ) return false;

	ZeroMemory( m_dwRight,sizeof(m_dwRight) );
	CopyMemory( m_dwRight,dwRight,sizeof(DWORD)*cbRightCount );
	
	return true;
}

//检查仅位是否正确
bool CChiHuRight::IsValidRight( DWORD dwRight )
{
	DWORD dwRightHead = dwRight & 0xF0000000;
	for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ )
		if( m_dwRightMask[i] == dwRightHead ) return true;
	return false;
}

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



//////////////////////////////////////////////////////////////////////////
//静态变量
//麻将数据
BYTE const CGameLogic::m_cbCardDataArray_ZJ[MAX_REPERTORY_ZJ] =
{
	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,									//风东南西北 中发白
};
BYTE const CGameLogic::m_cbCardDataArray_ZJ_Two[MAX_REPERTORY_ZJ_Two] =
{
	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(CTableFrameSink* pTableFramSink)
{
	m_cbMagicIndexFirst = MAX_INDEX;
	m_cbMagicIndexSecond = MAX_INDEX;
	m_pTableFramSink = pTableFramSink;
	mIsBaoMjType = 0;

}

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

//混乱扑克
BYTE CGameLogic::RandCardData(BYTE cbCardData[])
{
	BYTE cbCardDataTemp[MAX_REPERTORY_ZJ];
	BYTE cbMaxCount = 0;
	CopyMemory(cbCardDataTemp, m_cbCardDataArray_ZJ, sizeof(m_cbCardDataArray_ZJ));
	cbMaxCount = MAX_REPERTORY_ZJ;
	//}
	//混乱扑克
	BYTE cbRandCount = 0, cbPosition = 0;
	srand((unsigned)time(NULL));
	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));
	srand((unsigned)time(NULL));
	do
	{
		cbPosition = rand() % (cbMaxCount - cbRandCount);
		cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
		cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
	} while (cbRandCount < cbMaxCount);
	return cbMaxCount;
}

BYTE CGameLogic::RandCardData_Two(BYTE cbCardData[])
{
	BYTE cbCardDataTemp[MAX_REPERTORY_ZJ_Two];
	BYTE cbMaxCount = 0;
	CopyMemory(cbCardDataTemp, m_cbCardDataArray_ZJ_Two, sizeof(m_cbCardDataArray_ZJ_Two));
	cbMaxCount = MAX_REPERTORY_ZJ_Two;
	//}
	//混乱扑克
	BYTE cbRandCount = 0, cbPosition = 0;
	srand((unsigned)time(NULL));
	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));
	srand((unsigned)time(NULL));
	do
	{
		cbPosition = rand() % (cbMaxCount - cbRandCount);
		cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition];
		cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount];
	} while (cbRandCount < cbMaxCount);
	return cbMaxCount;
}

//删除扑克
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], 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 CGameLogic::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;
}

void CGameLogic::SetMagicIndex(BYTE CaiFirstIndex, BYTE CaiSecondIndex){

	if (CaiFirstIndex==MAX_INDEX&&CaiSecondIndex==MAX_INDEX)
	{
		m_BaoMj_MagicType = MagicType_NoMagic;
		return;
	}
	if (CaiSecondIndex==MAX_INDEX)
	{
		m_BaoMj_MagicType = MagicType_OneMagic;
		m_cbMagicIndexFirst = CaiFirstIndex;
		m_cbMagicIndexSecond = CaiSecondIndex;
	}
	else
	{
		m_BaoMj_MagicType = MagicType_TwoMagic;
		m_cbMagicIndexFirst = CaiFirstIndex;
		m_cbMagicIndexSecond = CaiSecondIndex;
	}
}
//有效判断
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(const BYTE cbCardIndex[MAX_INDEX])
{
	//数目统计
	BYTE cbCardCount=0;
	for (BYTE i=0;i<MAX_INDEX;i++) 
		cbCardCount+=cbCardIndex[i];

	return cbCardCount;
}

//获取组合
BYTE CGameLogic::GetWeaveCard(int cbWeaveKind, BYTE cbCenterCard, const BYTE cbMargicOffset[4], 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_AN_GANG:		//杠牌操作
		{
			//设置变量
			cbCardBuffer[0]=cbCenterCard;
			cbCardBuffer[1]=cbCenterCard;
			cbCardBuffer[2]=cbCenterCard;
			cbCardBuffer[3]=cbCenterCard;

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

		return 4;
	}	
	case WIK_BU_GANG:
	{
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbCenterCard;
		cbCardBuffer[2] = cbCenterCard;
		cbCardBuffer[3] = cbCenterCard;
		return 4;
	}
	case WIK_DAN_AN_GANG:		//暗杠牌操作
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbCenterCard;
		cbCardBuffer[3] = cbCenterCard;
		return 4;
	}
	case WIK_DAN_MING_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbCenterCard;
		cbCardBuffer[3] = cbCenterCard;
		return 4;
	}
	case WIK_DAN_BU_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbCenterCard;
		cbCardBuffer[3] = cbCenterCard;

		return 4;
	}
	case WIK_DAN_PENG:
	{
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbCenterCard;
		return 3;
	}
	case WIK_DAN_CHI:
	{
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		return 3;
	}
	case WIK_SHUANG_MING_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		cbCardBuffer[3] = cbCenterCard;

		return 4;
	}
	case WIK_SHUANG_AN_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		cbCardBuffer[3] = cbCenterCard;

		return 4;
	}
	case WIK_SHUANG_PENG:
	{
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		return 3;
	}
	case WIK_SHUANG_CAICHI:
	{
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		return 3;
	}
	case WIK_SAN_MING_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		cbCardBuffer[3] = cbMargicOffset[2];

		return 4;
	}
	case WIK_SAN_AN_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbMargicOffset[0];
		cbCardBuffer[2] = cbMargicOffset[1];
		cbCardBuffer[3] = cbMargicOffset[2];

		return 4;
	}
	case WIK_QUANG_AN_GANG:
	{
		//设置变量
		cbCardBuffer[0] = cbMargicOffset[0];
		cbCardBuffer[1] = cbMargicOffset[1];
		cbCardBuffer[2] = cbMargicOffset[2];
		cbCardBuffer[3] = cbMargicOffset[3];

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

//动作等级,操作特别多
BYTE CGameLogic::GetUserActionRank(int cbUserAction)
{
	//抢杠胡
	if (cbUserAction&WIK_ZI_MO) { return 13; }
	//胡牌等级
	if (cbUserAction&(WIK_CHI_HU | WIK_DI_CHIHU) ) { return 12; }
	//杠牌等级
	if (cbUserAction&WIK_MING_GANG) { return 11; }
	//碰牌等级
	if (cbUserAction&WIK_PENG) { return 10; }
	//上牌等级
	if (cbUserAction&(WIK_RIGHT | WIK_CENTER | WIK_LEFT)) { return 9; }
	//单财明杠
	if (cbUserAction&WIK_DAN_MING_GANG)
	{
		return 8;
	}
	//单财神碰
	if (cbUserAction&WIK_DAN_PENG) { return 7; }
	//单财神上牌等级
	if (cbUserAction&WIK_DAN_CHI) { return 6; }
	//双财明杠
	if (cbUserAction&WIK_SHUANG_MING_GANG){ return 5; }
	//双财神碰
	if (cbUserAction&WIK_SHUANG_PENG)return 4;
	//双财吃
	if (cbUserAction&WIK_SHUANG_CAICHI)return 3;
	//三财明杠
	if (cbUserAction&WIK_SAN_MING_GANG)return 2;

	if (cbUserAction&WIK_ZAHU)return 1;

	if (cbUserAction == WIK_NULL )
	{
		return 0;
	}
	ASSERT(FALSE);
	return 0;
}

//吃牌判断 
int CGameLogic::EstimateEatCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));
	//过滤判断
	if ( cbCurrentCard>=0x31 || IsMagicCard(cbCurrentCard) ) 
		return WIK_NULL;
	//吃牌判断
	int cbEatKind = 0;
	BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard);
	//获取手牌财神牌数目
	BYTE CaiShenCount = GetMaigcCardCount(cbCardIndex);
	if (CaiShenCount > 1)
	{
		cbEatKind = WIK_SHUANG_CAICHI;
	}
	if (CaiShenCount > 0)
	{
		BYTE TempCardIndex[MAX_INDEX] = { 0 };
		CopyMemory(TempCardIndex, cbCardIndex, sizeof(TempCardIndex));
// 		TempCardIndex[m_cbMagicIndexFirst] = 0;
// 		TempCardIndex[m_cbMagicIndexSecond] = 0;
		DeleteMagicCards(TempCardIndex);
		BYTE cbFirstIndex = 0;
		BYTE cbExcursion[3] = { 0, 1, 2 };
		BYTE cbItemKind[3] = { WIK_DAN_CHI, WIK_DAN_CHI, WIK_DAN_CHI };
		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 ((TempCardIndex[cbFirstIndex ] >= 1 && (cbFirstIndex != cbCurrentIndex)) 
					||(TempCardIndex[cbFirstIndex + 1] >= 1 && (cbFirstIndex + 1 != cbCurrentIndex)) 
					|| ((cbFirstIndex + 2 != cbCurrentIndex) && TempCardIndex[cbFirstIndex + 2] >= 1))
				{

					cbEatKind |= cbItemKind[i];
				}
			}
		}
	}
	BYTE cbExcursion[3] = { 0, 1, 2 };
	BYTE cbItemKind[3] = { WIK_LEFT, WIK_CENTER, WIK_RIGHT };
	//吃牌判断
	BYTE cbFirstIndex = 0;
	BYTE szTmpIndex[MAX_INDEX] = { 0 };
	CopyMemory(szTmpIndex, cbCardIndex, MAX_INDEX);
	DeleteMagicCards(szTmpIndex);//删除财神牌，再来判断是否吃
	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 ((cbCurrentIndex != cbFirstIndex) && (szTmpIndex[cbFirstIndex] == 0))
				continue;
			if ((cbCurrentIndex != (cbFirstIndex + 1)) && (szTmpIndex[cbFirstIndex + 1] == 0))
				continue;
			if ((cbCurrentIndex != (cbFirstIndex + 2)) && (szTmpIndex[cbFirstIndex + 2] == 0))
				continue;

			//设置类型
			cbEatKind |= cbItemKind[i];
		}
	}
	return cbEatKind;	
}

//碰牌判断
int CGameLogic::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
{
	int Operator = 0;
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));
	//过滤判断
	if (IsMagicCard(cbCurrentCard))
		return WIK_NULL;
	BYTE CaiShenCount = GetMaigcCardCount(cbCardIndex);
	if (CaiShenCount>1)
	{
		Operator = WIK_SHUANG_PENG;
	}
	if (CaiShenCount>0)
	{
		if (cbCardIndex[SwitchToCardIndex(cbCurrentCard)]>0)
		{
			Operator |= WIK_DAN_PENG;
		}
	}
	Operator |= ((cbCardIndex[SwitchToCardIndex(cbCurrentCard)] >= 2) ? WIK_PENG : WIK_NULL);
	//碰牌判断
	return Operator;
}

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

	//过滤判断
	if ( IsMagicCard(cbCurrentCard) ) 
		return WIK_NULL;
	BYTE index = SwitchToCardIndex(cbCurrentCard);
	BYTE CaiShenCount = GetMaigcCardCount(cbCardIndex);
	if (CaiShenCount > 2)
	{
		Operator = WIK_SAN_MING_GANG;
	}
	if (CaiShenCount > 1)
	{
		if (cbCardIndex[index] > 0)
			Operator |= WIK_SHUANG_MING_GANG;
	}
	if (CaiShenCount > 0)
	{
		if (cbCardIndex[index] > 1)
		{
			Operator |= WIK_DAN_MING_GANG;
		}
	}
	Operator |= (cbCardIndex[index] == 3) ? WIK_MING_GANG : WIK_NULL;
	//杠牌判断
	return Operator;
}

//杠牌分析
// 修改杠牌提供的顺序 [9/4/2017 Zoro]
int CGameLogic::AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult)
{
	//设置变量
	int cbActionMask = WIK_NULL;
	BYTE TempCardIndex[MAX_INDEX];
	ZeroMemory(TempCardIndex, sizeof(TempCardIndex));
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	CopyMemory(TempCardIndex, cbCardIndex, sizeof(TempCardIndex));
	BYTE nMagicCount = GetMaigcCardCount(cbCardIndex);

	//手上杠牌
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{

		if (IsMagicCard(SwitchToCardData(i)))
		{
			continue;
		}

		if (cbCardIndex[i] == 4)
		{
			BYTE cbCardData = SwitchToCardData(i);
			cbActionMask |= WIK_AN_GANG;
			if (GangCardResult.cbCardCount < 6){
				GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardData;
			}
			
		}
	}

	if (nMagicCount > 0)//单财杠
	{
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			
			if (IsMagicCard(SwitchToCardData(i)))
			{
				continue;
			}

			if (TempCardIndex[i] >= 3)
			{
				cbActionMask |= WIK_DAN_AN_GANG;
				if (GangCardResult.cbCardCount < 6){
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = SwitchToCardData(i) | 0x0200;
				}
			
			}
		}
	}


//  [9/4/2017 Zoro]
//先计算组合正杠

	//组合杠牌
	for (BYTE i = 0; i < cbWeaveCount; i++)
	{
		if (WeaveItem[i].cbWeaveKind & (WIK_PENG | WIK_DAN_PENG | WIK_SHUANG_PENG))
		{
			if (cbCardIndex[SwitchToCardIndex(WeaveItem[i].cbCenterCard)] >= 1)
			{
				cbActionMask |= WIK_BU_GANG;
				if (GangCardResult.cbCardCount < 6){
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = WeaveItem[i].cbCenterCard | 0x0100;
				}
				
	
			}
		}
	}
//在计算组合单财杠


	for (BYTE i = 0; i < cbWeaveCount; i++)
	{
		if (WeaveItem[i].cbWeaveKind & (WIK_PENG | WIK_DAN_PENG | WIK_SHUANG_PENG))
		{
			if (nMagicCount> 0)
			{
				cbActionMask |= WIK_DAN_BU_GANG;
				if (GangCardResult.cbCardCount<6)
				{
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = WeaveItem[i].cbCenterCard | 0x0800;
				}
			
			}
		}
	}

	if (nMagicCount > 1)//双财杠
	{
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			if (IsMagicCard(SwitchToCardData(i)))
			{
				continue;
			}

			if (TempCardIndex[i] >= 2)
			{
				cbActionMask |= WIK_SHUANG_AN_GANG;
				if (GangCardResult.cbCardCount<6)
				{
					GangCardResult.cbCardData[GangCardResult.cbCardCount++] = SwitchToCardData(i) | 0x0400;
				}

			}
		}
	}

	if (nMagicCount>3)
	{
		cbActionMask |= WIK_QUANG_AN_GANG;
		//GangCardResult.cbCardData[GangCardResult.cbCardCount++] = m_cbLaiZiData;
	}
	if (nMagicCount > 2)
	{
		cbActionMask |= WIK_SAN_AN_GANG;
	}

	if (GangCardResult.cbCardCount>6)
	{
		GangCardResult.cbCardCount = 6;

	}

	return cbActionMask;
}

//胡牌分析，bFlag默认false表示正常胡牌，true标示杠上花
int CGameLogic::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, 
	CChiHuRight &ChiHuRight, BYTE& nHuTai, bool bFlag, bool bQiangGangFlag)
{
	nHuTai = 0;
	BYTE cbTmpCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(cbTmpCardIndex, cbCardIndex, MAX_INDEX);
	cbTmpCardIndex[SwitchToCardIndex(cbCurrentCard)]++;
	BYTE CaiShenCount = GetMaigcCardCount(cbTmpCardIndex);
	switch (CaiShenCount)
	{
	//case 0:
	//{
	//	CAnalyseItemArray AnalyseItemArray;
	//	//设置变量
	//	AnalyseItemArray.RemoveAll();
	//	ChiHuRight.SetEmpty();
	//	AnalyseCard(cbTmpCardIndex, WeaveItem, cbWeaveCount, AnalyseItemArray);
	//	if (AnalyseItemArray.GetCount() > 0)
	//	{
	//		mSunTaiJiangInColor = GetCardColor(AnalyseItemArray[0].cbCardEye);
	//		nHuTai = AnalyseCardTaiNum(cbTmpCardIndex, WeaveItem, cbWeaveCount);
	//		if (nHuTai > 0 || bFlag)
	//		{
	//			if (bFlag)
	//				nHuTai++;
	//			ChiHuRight = mChiHuRight;
	//			return WIK_ZI_MO;
	//		}
	//	}
	//	return WIK_NULL;
	//}
	//case 1:
	//{
	//	CAnalyseItemArray AnalyseItemArray;
	//	//设置变量
	//	AnalyseItemArray.RemoveAll();
	//	ChiHuRight.SetEmpty();
	//	BYTE LaiZiIndex = 0;
	//	if (cbTmpCardIndex[m_cbMagicIndex] == 0)
	//	{
	//		cbTmpCardIndex[m_cbCaiShenIndex]--;
	//		LaiZiIndex = m_cbCaiShenIndex;
	//	}
	//	else
	//	{
	//		cbTmpCardIndex[m_cbMagicIndex]--;
	//		LaiZiIndex = m_cbMagicIndex;			
	//	}
	//	BYTE MaxTaiShu = 0;
	//	bool bHu = false;
	//	BYTE Fanhui[MAX_INDEX];
	//	IsCanChangCardAndCount(cbTmpCardIndex, Fanhui);
	//	for (BYTE i = 0; i < MAX_INDEX;i++)
	//	{
	//		if (i == LaiZiIndex || Fanhui[i] == 0)continue;
	//		cbTmpCardIndex[i]++;
	//		AnalyseCard(cbTmpCardIndex, WeaveItem, cbWeaveCount, AnalyseItemArray);
	//		if (AnalyseItemArray.GetCount() > 0)
	//		{
	//			bHu = true;
	//			cbTmpCardIndex[i]--;
	//			break;
	//		}
	//		cbTmpCardIndex[i]--;
	//		AnalyseItemArray.RemoveAll();	
	//	}
	//	cbTmpCardIndex[LaiZiIndex]++;
	//	if (bHu)
	//	{
	//		nHuTai = AnalyseCardTaiNum(cbTmpCardIndex, WeaveItem, cbWeaveCount);
	//		if (bFlag || nHuTai > 0)
	//		{
	//			if (bFlag)nHuTai++;
	//			ChiHuRight = mChiHuRight;
	//			return WIK_ZI_MO;
	//		}
	//	}
	//	return WIK_NULL;
	//}
	default:
	{
		if (AnalyseCardNew(cbTmpCardIndex, WeaveItem, cbWeaveCount))
		{
			m_cbHuCard = cbCurrentCard;
			int TmpJiangInColor = mJiangInColor;
			mSunTaiJiangInColor = mJiangInColor;
			int nTai = AnalyseCardTaiNum(cbTmpCardIndex, WeaveItem, cbWeaveCount);
			//如果胡了 而且将是在风牌中，且东中发白有一个为1且没有风牌刻字 且全顺 则不能胡	

			//DebugLog(_T("胡了 %02x 台数=%d\r\n"), cbCurrentCard, nTai);
			if (nTai>0||bFlag || bQiangGangFlag)
			{
				ChiHuRight = mChiHuRight;
				if (bFlag)
				{
					nTai++;
				}
				if (bQiangGangFlag)
				{
					nTai++;
				}
				nHuTai = nTai;
				return WIK_ZI_MO;
			}
		}
		return WIK_NULL;
	}
	}
}
//
bool CGameLogic::AnalyseCardNew(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	BYTE TmpcbCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);
	int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex);
	int nHaveGangCount = 0;
	for (int i = 0; i < MAX_INDEX; i++)
	{
		if (TmpcbCardIndex[i] == 4)
		{
		//	TmpcbCardIndex[i] = 0;
			nHaveGangCount++;
		}
	}
	if (nCurrentMagicCount==2&& GetCardCount(TmpcbCardIndex)==0)
	{
		return true;

	}
 	bool bHu = TestHu(TmpcbCardIndex, nCurrentMagicCount, WeaveItem, cbWeaveCount);
	if (bHu)
	{
		return true;
	}
	else
	{
		if (nHaveGangCount > 0)
		{
			CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);
			int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex);
			if (TestHu(TmpcbCardIndex, nCurrentMagicCount, WeaveItem, cbWeaveCount))
			{
				return true;
			}

			for (int i = 0; i < MAX_INDEX; i++)
			{
				if (TmpcbCardIndex[i] == 4)
				{
					TmpcbCardIndex[i] = 1;
				}
			}
			return TestHu(TmpcbCardIndex, nCurrentMagicCount, WeaveItem, cbWeaveCount);

		}

	}
	return bHu;
}
//
bool CGameLogic::TestHu(const BYTE cbCardIndex[MAX_INDEX], int nCurrentMagicCount, const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	//////////////////////////////////////////////////////////////////////////
	mJiangInColor = -1;
	mNeedMinMagicNum = 8;
	BYTE cbCardDataWan[MAX_COUNT] = { 0 };
	int nCount;

	int WanNeedMagicCount, TiaoNeedMagicCount, BingNeedMagicCount, FengNeedMagicCount;//变量分别表示‘万’型需要财神牌数、。。。
	int nWanCount, nTiaoCount, nBingCount, nFengCount;
	//万
	mMagicDataCount = 0;
	ZeroMemory(mMagicData, 7);
	ZeroMemory(mMagicReplaceCard, MAX_INDEX);

	mNeedMinMagicNum = 8;
	GetOneColorCards(cbCardIndex, Color_Wan, cbCardDataWan, nCount);
	nWanCount = nCount;
	GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0);
	WanNeedMagicCount = mNeedMinMagicNum;
	ShowMagicData();
	//////////////////////////////////////////////////////////////////////////
	//DebugLog(_T("*********************************************\r\n"));
	//条
	mMagicDataCount = 0;
	ZeroMemory(mMagicData, 7);
	mNeedMinMagicNum = 8;
	GetOneColorCards(cbCardIndex, Color_Tiao, cbCardDataWan, nCount);
	nTiaoCount = nCount;
	GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0);
	TiaoNeedMagicCount = mNeedMinMagicNum;
	ShowMagicData();
	//DebugLog(_T("*********************************************\r\n"));
	//饼
	mMagicDataCount = 0;
	ZeroMemory(mMagicData, 7);
	mNeedMinMagicNum = 8;
	GetOneColorCards(cbCardIndex, Color_Bing, cbCardDataWan, nCount);
	nBingCount = nCount;
	GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0);
	BingNeedMagicCount = mNeedMinMagicNum;
	ShowMagicData();
	//DebugLog(_T("*********************************************\r\n"));
	//风
	mMagicDataCount = 0;
	ZeroMemory(mMagicData, 7);
	mNeedMinMagicNum = 8;
	GetOneColorCards(cbCardIndex, Color_Feng, cbCardDataWan, nCount);
	nFengCount = nCount;
	GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0);
	FengNeedMagicCount = mNeedMinMagicNum;
	ShowMagicData();
	//DebugLog(_T("*********************************************\r\n"));
	//将在万中
	ShowMagicReplaceData();

	//手牌全是财神 且满足3N+2
	if (GetCardCount(cbCardIndex) == 0 && nCurrentMagicCount % 3 == 2)
	{
		mJiangInColor = Color_Wan;

		return true;
	}

	//这个 考虑好了在加 主要用于解决2个杠的问题
// 	if (WanNeedMagicCount+TiaoNeedMagicCount+BingNeedMagicCount+FengNeedMagicCount== nCurrentMagicCount)
// 	{
// 		return true;
// 
// 	}
	//判断是否是2杠的牌

    int nNeedMagicNum = BingNeedMagicCount + TiaoNeedMagicCount + FengNeedMagicCount;
	if (nNeedMagicNum <= nCurrentMagicCount)
	{
		//DebugLog(_T("jiang in W Need %d Have %d"),nNeedMagicNum,nCurrentMagicCount);
		//剩余几个财神 供给单颜色牌手牌
		int nHasMagicNum = nCurrentMagicCount - nNeedMagicNum;

		BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 };
		int nTmpCount;
		GetOneColorCards(cbCardIndex, Color_Wan, cbTmpCardDataWan, nTmpCount);
		if (nTmpCount>0)
		{
			if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasMagicNum))
			{
				mJiangInColor = Color_Wan;

				return true;
			}
		}
		

	}
	//DebugLog(_T("*********************************************\r\n"));
	//tiao
	nNeedMagicNum = WanNeedMagicCount + BingNeedMagicCount + FengNeedMagicCount;
	if (nNeedMagicNum <= nCurrentMagicCount)
	{
		int nHasNum = nCurrentMagicCount - nNeedMagicNum;

		BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 };
		int nTmpCount;
		GetOneColorCards(cbCardIndex, Color_Tiao, cbTmpCardDataWan, nTmpCount);
		if (nTmpCount > 0){
			if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasNum))
			{
				mJiangInColor = Color_Tiao;
				return true;
			}
		}

	}
	//DebugLog(_T("*********************************************\r\n"));
	//bing
	nNeedMagicNum = WanNeedMagicCount + TiaoNeedMagicCount + FengNeedMagicCount;
	if (nNeedMagicNum <= nCurrentMagicCount)
	{
		int nHasNum = nCurrentMagicCount - nNeedMagicNum;

		BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 };
		int nTmpCount;
		GetOneColorCards(cbCardIndex, Color_Bing, cbTmpCardDataWan, nTmpCount);
		if (nTmpCount > 0){
			if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasNum))
			{
				mJiangInColor = Color_Bing;
				return true;
			}
		}

	}
	//DebugLog(_T("*********************************************\r\n"));
	//feng
	nNeedMagicNum = WanNeedMagicCount + BingNeedMagicCount + TiaoNeedMagicCount;
	if (nNeedMagicNum <= nCurrentMagicCount)
	{
		int nHasNum = nCurrentMagicCount - nNeedMagicNum;

		BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 };
		int nTmpCount;
		GetOneColorCards(cbCardIndex, Color_Feng, cbTmpCardDataWan, nTmpCount);
		if (nTmpCount > 0){
			if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasNum))
			{
				mJiangInColor = Color_Feng;
				//如果将在凤牌中 如果东风做将
				//if ((cbCardIndex[27] == 1)
				//	|| (cbCardIndex[31] == 1)
				//	|| (cbCardIndex[32] == 1)
				//	|| (cbCardIndex[33] == 1)
				//	)
				//{
				//	/*	BYTE cbTmpCardIndex[MAX_INDEX] = { 0 };
				//		CopyMemory(cbTmpCardIndex, cbCardIndex,MAX_INDEX);
				//		BYTE cbCard[2] = { 0 };
				//		cbTmpCardIndex[m_cbCaiShenIndex] = nCurrentMagicCount;
				//		if (IsQuanShun(cbTmpCardIndex,WeaveItem,cbWeaveCount))
				//		{
				//		return false;
				//		}*/
				//	//if (IsCardsIsHunYiSe(cbTmpCardIndex, WeaveItem, cbWeaveCount) || IsPengPengHu(cbTmpCardIndex,WeaveItem,cbWeaveCount))
				//	//{
				//	//	return true;
				//	//}
				//	//else{
				//	//	////OutputDebugString(_T("东 中发白  做将，不是混一色 也不是碰碰胡"));
				//	//	return false;
				//	//}

				//}
				return true;
			}
		}
	}
	//DebugLog(_T("*********************************************\r\n"));
	return false;
}
//从cbCardIndex 获取 同一花色nColor的手牌牌值cbCardData与数量CardCount
bool CGameLogic::GetOneColorCards(const BYTE cbCardIndex[MAX_INDEX], BYTE nColor, BYTE cbCardData[MAX_COUNT], int&CardCount)
{
	CardCount = 0;
	ZeroMemory(cbCardData, MAX_COUNT);

	int nBegin = 0;
	int nEnd = 0;
	if (nColor == 0)
	{
		nBegin = 0;
		nEnd = 9;

	}
	if (nColor == 1 || nColor == 2){
		nBegin = 9 * nColor;
		nEnd = nBegin + 9;
	}
	if (nColor == 3)
	{
		nBegin = 9 * nColor;
		nEnd = nBegin + 7;
	}
	for (int i = nBegin; i < nEnd; i++)
	{
		if (cbCardIndex[i]>0)
		{
			for (int j = 0; j < cbCardIndex[i]; j++){
				cbCardData[CardCount++] = SwitchToCardData(i);//记录该玩家手牌
			}
		}
	}
	return true;
}
//cbCardData:手牌中希望作将的同色牌，nCardCount:手牌数量，nMagicCount:剩余可用癞子数量
bool CGameLogic::OneCardsCanHu(const BYTE cbCardData[MAX_COUNT], int nCardCount, int nMagicCount, bool isQuanShun)
{
	if (nCardCount <= 0)
	{
		//如果没有其他牌做将，那就两个癞子做将（黄石麻将不能2癞子做将）
		if (nMagicCount >= 2)
		{
			return true;
		}
		return false;
	}

	BYTE cbCard = cbCardData[0];
	for (int i = 0; i < nCardCount; i++)
	{
		if (i == nCardCount - 1)//如果只有一张牌
		{

			if (nMagicCount > 0)
			{

				nMagicCount = nMagicCount - 1;
				mNeedMinMagicNum = 8;
				GetOneColorNeedMagicCards(cbCardData, nCardCount - 1, 0, isQuanShun);//该单花色牌型不需要组成整扑，只需要和一个财神牌组成将
				if (mNeedMinMagicNum <= nMagicCount)
				{
					PrintCards(cbCardData, nCardCount );
					return true;
				}
				nMagicCount += 1;

			}
		}
		else
		{
			if (i + 2 == nCardCount || cbCardData[i] != cbCardData[i + 2])//如果不止两张牌，那可能需要整扑一将（该花色牌）
			{
				//DebugLog(_T("Other Pai %d"),i);
				if (test2Combine(cbCardData[i], cbCardData[i + 1]))
				{
					//DebugLog(_T("i=%d card=%02x card=%02x"), i, cbCardData[i], cbCardData[i + 1]);
					mNeedMinMagicNum = 8;
					BYTE tmpCbCardDatas[MAX_COUNT] = { 0 };
					int TmpCardCount = nCardCount;

					BYTE deleteIndex[2];
					deleteIndex[0] = i;
					deleteIndex[1] = i + 1;//有原始的一对将
					DeleteCardDataFromCardDatas(deleteIndex, 2, cbCardData, TmpCardCount, tmpCbCardDatas);
					TmpCardCount = TmpCardCount - 2;//删除一对将
					//再获取(其他牌和财神牌)能否组成整扑
					GetOneColorNeedMagicCards(tmpCbCardDatas, TmpCardCount, 0, isQuanShun);
					if (mNeedMinMagicNum <= nMagicCount)
					{
						//能胡牌
						PrintCards(tmpCbCardDatas, TmpCardCount);
						return true;
					}

				}
			}

			if (nMagicCount > 0 && cbCardData[i] != cbCardData[i + 1])
			{
				nMagicCount -= 1;

				BYTE tmpCbCardDatas[MAX_COUNT] = { 0 };
				int TmpCardCount = nCardCount;

				BYTE DeleteIndex[1];
				DeleteIndex[0] = i;//做将中的一个，另一个为癞子

				DeleteCardDataFromCardDatas(DeleteIndex, 1, cbCardData, TmpCardCount, tmpCbCardDatas);
				TmpCardCount--;

				mNeedMinMagicNum = 8;
				GetOneColorNeedMagicCards(tmpCbCardDatas, TmpCardCount, 0, isQuanShun);
				if (mNeedMinMagicNum <= nMagicCount)
				{
					PrintCards(tmpCbCardDatas, TmpCardCount);
					return true;
				}
				nMagicCount += 1;
			}
		}

	}
	return false;
}
//在数组cbCardData中删除DeleteCount个和数组vDeletIndex元素相同的元素，结果重新组合新的数组cbOutCardDatas
int CGameLogic::DeleteCardDataFromCardDatas(const BYTE vDeletIndex[MAX_COUNT], int DeleteCount, const BYTE cbCardData[MAX_COUNT], BYTE nCount, BYTE cbOutCardDatas[MAX_COUNT])
{
	ZeroMemory(cbOutCardDatas, MAX_COUNT);
	int nPaiCount = 0;

	BYTE tmpData[MAX_COUNT] = { 0 };
	CopyMemory(tmpData, cbCardData, nCount);

	for (int i = 0; i < DeleteCount; i++)
	{
		tmpData[vDeletIndex[i]] = 0;
	}

	for (int i = 0; i < nCount; i++)
	{
		if (tmpData[i] != 0)
		{
			cbOutCardDatas[nPaiCount++] = tmpData[i];
		}
	}
	return true;
}
//
int CGameLogic::PrintCards(const BYTE cbCardData[MAX_COUNT], int nCout)
{
	std::wstring StrItems;
	StrItems = _T("PrintCards  ");
	for (int i = 0; i < nCout; i++)
	{
		std::wstring item;
		TCHAR szBuffer[MAX_COUNT] = { 0 };
		switch (GetCardColor(cbCardData[i]))
		{
		case Color_Wan:{
			wsprintf(szBuffer, _T("%dW"), GetCardValue(cbCardData[i]));
			break;
		}
		case Color_Tiao:{
			wsprintf(szBuffer, _T("%dT"), GetCardValue(cbCardData[i]));
			break;
		}
		case Color_Bing:{
			wsprintf(szBuffer, _T("%dB"), GetCardValue(cbCardData[i]));
			break;
		}
		case Color_Feng:{

			switch (GetCardValue(cbCardData[i]))
			{
			case 1: _tcscpy_s(szBuffer, _tclen(_T("东")) + 1, _T("东")); break;
			case 2:_tcscpy_s(szBuffer, _tclen(_T("南")) + 1, _T("南")); break;
			case 3: _tcscpy_s(szBuffer, _tclen(_T("西")) + 1, _T("西")); break;
			case 4:_tcscpy_s(szBuffer, _tclen(_T("北")) + 1, _T("北")); break;
			case 5:_tcscpy_s(szBuffer, _tclen(_T("中")) + 1, _T("中")); break;
			case 6: _tcscpy_s(szBuffer, _tclen(_T("发")) + 1, _T("发")); break;
			case 7:_tcscpy_s(szBuffer, _tclen(_T("白")) + 1, _T("白")); break;
			}

			break;
		}
		}
		item.append(_T("\t"));
		item.append(szBuffer);
		item.append(_T("\t"));
		StrItems += item;
	}
	StrItems.append(_T("\r\n"));
	//DebugLog(StrItems.c_str());
	return true;
}
//
int CGameLogic::AnalyseCardTaiNum(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	mChiHuRight.SetEmpty();
	//首先算是不是 辣子胡 如果是 其他的就不用算了。封顶
	bool WeavieIsLaZi = true;
	mTaiRight = 0;
	int nTai=0;
	tagWeaveItem AnalyseWeaveItem[5];
	BYTE		 AnalyseCbWeaveCount;
	CopyMemory(AnalyseWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbWeaveCount);
	AnalyseCbWeaveCount = cbWeaveCount;
	

	/*
	检测是否有全财暗杠，有则先去掉在计算。
	*/
	int nQuanMagicAnGangCount = 0;
	for (int i = 0; i < AnalyseCbWeaveCount;i++)
	{
		if  (WeaveItem[i].cbWeaveKind == WIK_QUANG_AN_GANG)
		{
			nQuanMagicAnGangCount++;
		}
	}
	if (nQuanMagicAnGangCount>0)
	{
		int nTmpCount = 0;
		for (int i = 0; i < AnalyseCbWeaveCount;i++)
		{
			if (WeaveItem[i].cbWeaveKind == WIK_QUANG_AN_GANG)
			{
				continue;
			}
			CopyMemory(&AnalyseWeaveItem[nTmpCount++], &WeaveItem[i], sizeof(tagWeaveItem));
		}
		AnalyseCbWeaveCount = nTmpCount;
	}



	//落地牌是否全是碰/顺
	int luodiKind = 0; //1 顺  2 碰 3非全顺/全碰

	for (int i = 0; i < AnalyseCbWeaveCount; i++)
	{
		if (((AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_PENG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_PENG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_PENG) || 
			(AnalyseWeaveItem[i].cbWeaveKind == WIK_MING_GANG)  || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SAN_AN_GANG)||
			(AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_AN_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_AN_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_AN_GANG)||
			(AnalyseWeaveItem[i].cbWeaveKind == WIK_SAN_MING_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_MING_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_MING_GANG)||
			(AnalyseWeaveItem[i].cbWeaveKind == WIK_BU_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_BU_GANG)
			))
		{
			//计算是否有各种加台刻字
			if (AnalyseWeaveItem[i].cbCenterCard < 0x31)
			{
				WeavieIsLaZi = false;
			}
			if (AnalyseWeaveItem[i].cbCenterCard == 0x31)
			{
				//DebugLog(_T("落地派中	发现东风刻字 %02x +2台"), WeaveItem[i].cbCenterCard);
				mChiHuRight |= ZJ_TAI_DongFeng;
				mTaiRight |= ZJ_TAI_DongFeng;
				nTai += 2;
			}
			if ((AnalyseWeaveItem[i].cbCenterCard == 0x35))
			{
				//DebugLog(_T("落地派中	发现中发白刻字 %02x +1台"), WeaveItem[i].cbCenterCard);
				mChiHuRight |= ZJ_TAI_ZFB;
				mTaiRight |= ZJ_TAI_ZFB;
				nTai += 1;
			}
			if ( AnalyseWeaveItem[i].cbCenterCard == 0x36 )
			{
				//DebugLog(_T("落地派中	发现中发白刻字 %02x +1台"), WeaveItem[i].cbCenterCard);
				mChiHuRight |= ZJ_TAI_ZFB;
				mTaiRight |= ZJ_TAI_ZFB;
				nTai += 1;
			}
			if ((AnalyseWeaveItem[i].cbCenterCard == 0x37))
			{
				//DebugLog(_T("落地派中	发现中发白刻字 %02x +1台"), WeaveItem[i].cbCenterCard);
				mChiHuRight |= ZJ_TAI_ZFB;
				mTaiRight |= ZJ_TAI_ZFB;
				nTai += 1;
			}
			if (luodiKind == 1)
			{
				luodiKind = 3;
			}
			if (luodiKind == 0)
			{
				luodiKind = 2;
			}
			continue;
		}
		if ((
			(AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_CHI)
			|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_CAICHI)
			|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_LEFT)
			|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_CENTER)
			|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_RIGHT)
			))
		{
			WeavieIsLaZi = false;
			if (luodiKind == 2)
			{
				luodiKind = 3;
			}
			if (luodiKind == 0)
			{
				luodiKind = 1;
			}
			continue;
		}
	}

	//落地牌分析完毕
	//////////////////////////////////////////////////////////////////////////
	//全字 分析
	if (WeavieIsLaZi == true)
	{
		for (int i = 0; i < 27; i++)
		{
			if (cbCardIndex[i]>0&&!IsMagicCard(SwitchToCardData(i)))//手牌中存在不是字牌，并且该牌不是财神牌（癞子与癞子皮）
			{
				WeavieIsLaZi = false;
				break;
			}
		}
	}
	if (WeavieIsLaZi == true)
	{
		mChiHuRight |= ZJ_TAI_QuanZi;
		mTaiRight |= ZJ_TAI_QuanZi;
		return 7;
	}
	//////////////////////////////////////////////////////////////////////////




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

	//更新算法 计算手牌包含刻字情况
	//财东东 123 123 11 123  
	BYTE cbCardIndexTmp[MAX_INDEX];
	tagWeaveItem WeaveItemTmp[5];
	BYTE cbWeaveCountTmp;

	ZeroMemory(cbCardIndexTmp, MAX_INDEX);
	ZeroMemory(WeaveItemTmp, sizeof(WeaveItemTmp));
	cbWeaveCountTmp = 0;
	CopyMemory(cbCardIndexTmp, cbCardIndex, MAX_INDEX);
	CopyMemory(WeaveItemTmp, AnalyseWeaveItem, sizeof(tagWeaveItem)*AnalyseCbWeaveCount);
	cbWeaveCountTmp = AnalyseCbWeaveCount;


	int nFengTai=0;
	BOOL haveFengKe=FALSE;
	
	for (int i = 0; i < 4; i++)
	{
	
		if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 27))//东风刻字
		{
			nTai += 2;
			nFengTai += 2;
			mChiHuRight |= ZJ_TAI_DongFeng;
			mTaiRight |= ZJ_TAI_DongFeng;
			haveFengKe = TRUE;
			//DebugLog(_T("手牌中 发现[东风]刻字 +2台"));
			//如果 删掉东风+财神 依然可以胡牌 那么就删掉3张牌
		}
		else
		{
			break;
		}
	}

	for (int i = 0; i < 4; i++)
	{
	
		//计算中发白 刻字个数
		if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 31))
		{
			nTai++;
			nFengTai++;
			mChiHuRight |= ZJ_TAI_ZFB;
			mTaiRight |= ZJ_TAI_ZFB;
			haveFengKe = TRUE;
			//DebugLog(_T("手牌中 发现[中发白]有2张 可能有刻字   +1台"));
		}
		else
		{
			break;
		}
	}




	for (int i = 0; i < 4; i++)
	{
		
		//计算中发白 刻字个数
		if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 32))
		{
			nTai++;
			nFengTai++;
			mChiHuRight |= ZJ_TAI_ZFB;
			mTaiRight |= ZJ_TAI_ZFB;
			haveFengKe = TRUE;
			//DebugLog(_T("手牌中 发现[中发白]有2张 可能有刻字   +1台"));
		}
		else
		{
			break;
		}
	}

	for (int i = 0; i < 4; i++)
	{
	
		//计算中发白 刻字个数
		if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 33))
		{
			nTai++;
			nFengTai++;
			mChiHuRight |= ZJ_TAI_ZFB;
			mTaiRight |= ZJ_TAI_ZFB;
			haveFengKe = TRUE;
			//DebugLog(_T("手牌中 发现[中发白]有2张 可能有刻字   +1台"));
		}
		else
		{
			break;
		}
	}
	if (nFengTai<4)
	{
		if (IsQingYiSe(cbCardIndex, AnalyseWeaveItem, AnalyseCbWeaveCount))
		{
			nTai += 3;
			mChiHuRight |= ZJ_TAI_QingYiSe;
			mTaiRight |= ZJ_TAI_QingYiSe;
			//DebugLog(_T("清一色 +3台"));
		}
	}

	if (!HaveMagic(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp)&&nQuanMagicAnGangCount==0)
	{
		nTai += 1;
		mChiHuRight |= ZJ_TAI_WuMagic;
		mTaiRight |= ZJ_TAI_WuMagic;
		//DebugLog(_T("无财神 +1台"));
	}

	//是清一色 并且清一色的花色 不是风则 不走风刻的计算

	if (!(mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty() && nFengTai>0&&nFengTai<4)
	{
		BYTE color = 0;
		//得到清一色的花色
		for (int i = 0; i < MAX_INDEX;i++)
		{
			if (cbCardIndex[i]>0 && !IsMagicCard(SwitchToCardData(i)))
			{
				color = GetCardColor(SwitchToCardData(i));
				break;
			}
		}

		if (color!=Color_Feng)
		{
			nTai -= nFengTai;
			mChiHuRight -= ZJ_TAI_ZFB;
			mChiHuRight -= ZJ_TAI_DongFeng;

			if (mTaiRight&ZJ_TAI_ZFB)
			{
				mTaiRight ^= ZJ_TAI_ZFB;
			}
			if (mTaiRight&ZJ_TAI_DongFeng)
			{
				mTaiRight ^= ZJ_TAI_DongFeng;
			}
			haveFengKe = FALSE;
			cbWeaveCountTmp = 0;
			CopyMemory(cbCardIndexTmp, cbCardIndex, MAX_INDEX);
			CopyMemory(WeaveItemTmp, AnalyseWeaveItem, sizeof(tagWeaveItem)*AnalyseCbWeaveCount);
			cbWeaveCountTmp = AnalyseCbWeaveCount;
		}

	}
	if (!(mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty() && nFengTai > 3)
	{
	
		BYTE color = 0;
		//得到清一色的花色
		for (int i = 0; i < MAX_INDEX; i++)
		{
			if (cbCardIndex[i]>0 && !IsMagicCard(SwitchToCardData(i)))
			{
				color = GetCardColor(SwitchToCardData(i));
				break;
			}
		}
		if (color != Color_Feng)
		{
			nTai -= 3;
			mChiHuRight -= ZJ_TAI_QingYiSe;


			if (mTaiRight&ZJ_TAI_QingYiSe)
			{
				mTaiRight ^= ZJ_TAI_QingYiSe;
			}
			cbWeaveCountTmp = 0;
			CopyMemory(cbCardIndexTmp, cbCardIndex, MAX_INDEX);
			CopyMemory(WeaveItemTmp, AnalyseWeaveItem, sizeof(tagWeaveItem)*AnalyseCbWeaveCount);
			cbWeaveCountTmp = AnalyseCbWeaveCount;
		}

	}

	if (luodiKind != 3)
	{
		//碰碰胡 和全顺 只能算出一个来 剩下的一个不要算了。
		bool bOK = false;

		//全碰
		if (IsPengPengHu(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp))
		{
			nTai += 1;
			mChiHuRight |= ZJ_TAI_PengPeng;
			mTaiRight |= ZJ_TAI_PengPeng;
			//DebugLog(_T("碰碰胡 +1台"));
			bOK = true;
		}
		//

		if (bOK == false && haveFengKe==FALSE&&nQuanMagicAnGangCount==0)
		{


			if (IsQuanShun(cbCardIndex, AnalyseWeaveItem, AnalyseCbWeaveCount))
			{
				nTai += 1;
				mChiHuRight |= ZJ_TAI_QuanShun;
				mTaiRight |= ZJ_TAI_QuanShun;
				//	DebugLog(_T("全顺 +1台"));
			}
		}

	}

	//if (cbCardIndexTmp[31] >= 3 || cbCardIndexTmp[32] >= 3 || cbCardIndexTmp[33] >= 3)
	//{
	//	nTai++;
	//	mChiHuRight |= ZJ_TAI_ZFB;
	//	mTaiRight |= ZJ_TAI_ZFB;
	//	//DebugLog(_T("手牌中 发现[中发白]刻字 +1台"));
	//}




	if ((mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty())
	{
		BOOL HaveFengKe = FALSE;
		if (!(mChiHuRight&ZJ_TAI_DongFeng).IsEmpty() || !(mChiHuRight&ZJ_TAI_ZFB).IsEmpty())
		{
			HaveFengKe = TRUE;
		}
		if (IsCardsIsHunYiSe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, HaveFengKe))
		{
	
			nTai += 1;
			mChiHuRight |= ZJ_TAI_HunYiSe;
			mTaiRight |= ZJ_TAI_HunYiSe;
		}
	}
	
	
	if (!(mChiHuRight&ZJ_TAI_QuanShun).IsEmpty()&& mSunTaiJiangInColor ==Color_Feng)
	{
		int nMagic = DeleteMagicCards(cbCardIndexTmp);
		if (mSunTaiJiangInColor ==Color_Feng)
		{	
			if (nMagic>0)
			{
				if (cbCardIndexTmp[27] == 1
					|| cbCardIndexTmp[31] == 1
					|| cbCardIndexTmp[32] == 1
					|| cbCardIndexTmp[33] == 1
					)
				{
					//OutputDebugString(_T("财神+东 中发白做将 不让胡"));
					if (nTai>1)
					{
						mTaiRight ^= ZJ_TAI_QuanShun;
						mChiHuRight -= ZJ_TAI_QuanShun;
						nTai--;
						return nTai;
					}
					mTaiRight = WIK_NULL;
					mChiHuRight.SetEmpty();
					return 0;
				}
				if (cbCardIndexTmp[27] == 2
					|| cbCardIndexTmp[31] == 2
					|| cbCardIndexTmp[32] == 2
					|| cbCardIndexTmp[33] == 2
					)
				{
					////OutputDebugString(_T(" 中发白做将 不让胡"));
					if (nTai > 1)
					{
						mTaiRight ^= ZJ_TAI_QuanShun;
						mChiHuRight -= ZJ_TAI_QuanShun;
						nTai--;
						return nTai;
					}
					mTaiRight = WIK_NULL;
					mChiHuRight.SetEmpty();
					return 0;
				}
			}
			else
			{
				if (cbCardIndexTmp[27] == 2
					|| cbCardIndexTmp[31] == 2
					|| cbCardIndexTmp[32] == 2
					|| cbCardIndexTmp[33] == 2
					)
				{
					////OutputDebugString(_T(" 中发白做将 不让胡"));
					if (nTai > 1)
					{
						mTaiRight ^= ZJ_TAI_QuanShun;
						mChiHuRight -= ZJ_TAI_QuanShun;
						nTai--;
						return nTai;
					}
					mTaiRight = WIK_NULL;
					mChiHuRight.SetEmpty();
					return 0;
				}
			}
			
		}
		//仅有全顺时 如果东 中发白 做将 不让胡 
	}

	//如果包含全财暗杠，并且胡牌不是辣子和全顺 则在原始牌台数基础上增加2*全财神个数 
	if (nQuanMagicAnGangCount>0 && (mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty() && (mChiHuRight&ZJ_TAI_QuanZi).IsEmpty())
	{
		nTai += 2;
		nFengTai += 2;
		mChiHuRight |= ZJ_TAI_DongFeng;
		mTaiRight |= ZJ_TAI_DongFeng;
	}



	//if ((cbCardIndexTmp[27] == 1 || cbCardIndexTmp[27] ==2 && !IsMagicCard(SwitchToCardData(27)))
	//	|| (cbCardIndexTmp[31] == 1 && !IsMagicCard(SwitchToCardData(31)))
	//	|| (cbCardIndexTmp[32] == 1 && !IsMagicCard(SwitchToCardData(32)))
	//	|| (cbCardIndexTmp[33] == 1 && !IsMagicCard(SwitchToCardData(33)))
	//	)
	//{
	//	nTai = 0;
	//	QueryPerformanceCounter(&nEndTime);
	//	strAddString.Format(_T("财神+东 中发白作将 全顺不能胡 花费时间 %f 秒"), (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart);
	//	m_ResultList.AddString(strAddString);
	//	return;
	//}

	return nTai;
}
//
//bool CGameLogic::isHaveMaigc(const BYTE cardMagicIndex[4])
//{
//	for (int i = 0; i < 4; i++){
//		if (cardMagicIndex[i]>0)
//		{
//			return false;
//		}
//	}
//	return false;
//}
//
bool CGameLogic::HaveMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	BYTE TmpcbCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);
	int nMagicCount = DeleteMagicCards(TmpcbCardIndex);
	if (nMagicCount > 0)
	{
		return true;
	}
	for (int i = 0; i < cbWeaveCount; i++)
	{
		if (WeaveItem[i].cbWeaveKind&(
			WIK_DAN_CHI |
			WIK_SHUANG_CAICHI |
			WIK_DAN_PENG | WIK_SHUANG_PENG |
			WIK_DAN_MING_GANG | WIK_SHUANG_MING_GANG | WIK_SAN_MING_GANG | WIK_DAN_BU_GANG |
			WIK_DAN_AN_GANG | WIK_SHUANG_AN_GANG | WIK_SAN_AN_GANG | WIK_QUANG_AN_GANG
			))
		{
			return true;
		}
		if (WeaveItem[i].cbWeaveKind == WIK_BU_GANG && WeaveItem[i].cbMargicOffset[0] != 0)
		{
			return true;
		}
	}
	return false;
}
//
bool CGameLogic::IsPengPengHu(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{

	BYTE TmpcbCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);

	for (int i = 0; i < cbWeaveCount; i++)
	{
		if (WeaveItem[i].cbWeaveKind
			& (WIK_DAN_CHI |
			WIK_SHUANG_CAICHI |
			WIK_LEFT | WIK_CENTER | WIK_RIGHT
			))//单财吃、双财吃、左、中、右吃
		{
			return false;
		}
	}

	int nMagic = DeleteMagicCards(TmpcbCardIndex);
	//计算出剩余的牌 全部变成刻字需要多少张财神

	//碰碰胡 分2种 3杠一对  4刻字一对

	int nNeedMagic = 0;
	int nGangCount=0;
	for (int i = 0; i < MAX_INDEX; i++)
	{
		if (TmpcbCardIndex[i] == 1 || TmpcbCardIndex[i] == 2)
		{
			nNeedMagic += (3 - TmpcbCardIndex[i]);
		}
		if (TmpcbCardIndex[i]==4)
		{
			nNeedMagic += 2;
			nGangCount++;
		}
	}
	//if (nGangCount>1)
	//{
	//	return false;
	//}
	if (nNeedMagic == nMagic + 1 || nNeedMagic ==nMagic%3 +1||(nNeedMagic==0&& nMagic%3==2))
	{
		return true;
	}
	//计算有几个杠 如果杠需要的财神=手牌财神+2 则 是碰碰胡
	nNeedMagic = 0;
	for (int i = 0; i < MAX_INDEX; i++)
	{
		if (TmpcbCardIndex[i] == 1 || TmpcbCardIndex[i] == 2 || TmpcbCardIndex[i] == 3)
		{
			nNeedMagic += (4 - TmpcbCardIndex[i]);
		}
	}
	if (nNeedMagic == nMagic + 2 || nNeedMagic == nMagic % 3 + 2 )
	{
		return true;
	}
	return false;
}
//
bool CGameLogic::IsQuanShun(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	BYTE TmpcbCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);

	for (int i = 0; i < cbWeaveCount; i++)
	{
		if (!(WeaveItem[i].cbWeaveKind
			&(WIK_CENTER | WIK_DAN_CHI | WIK_SHUANG_CAICHI|WIK_RIGHT|WIK_LEFT)
			))
		{
			return false;
		}
	}
	//如果有风牌 不可能是全顺
	//将手牌 遍历一次 把能够组成顺子 且 剩下的还能胡的牌 扔到组合里面。如果最后 剩下2张一样的牌 就判定是全顺
	int nMagicCount = DeleteMagicCards(TmpcbCardIndex);

	int nFengCardCount=0;
	BYTE nFengCard[MAX_INDEX] = { 0 };
	for (int i = 0; i < 7; i++)
	{
		if (TmpcbCardIndex[27 + i] >= 3)
		{
			return false;
		}
		if (TmpcbCardIndex[27 + i] >= 1)
		{
			nFengCard[nFengCardCount] = 27 + i;
			nFengCardCount++;
		}
	}
	if (nFengCardCount>=2)
	{
		return false;
	}


	BYTE cbUserIndexCardTmp[MAX_INDEX] = { 0 };
	CopyMemory(cbUserIndexCardTmp, TmpcbCardIndex, MAX_INDEX);
//////////////////////////////////////////////////////////////////////////
	{
	
		BYTE cbJiangIndex[MAX_INDEX] = { 0 };
		for (int i = 0; i < MAX_INDEX; i++)
		{
			if (cbUserIndexCardTmp[i] == 0)
			{
				continue;
			}
			if (cbUserIndexCardTmp[i] >= 2)
			{
				cbJiangIndex[i] = 1;
			}
		}
		for (int i = 0; i < MAX_INDEX; i++)
		{
			BYTE cbTmpCardIndex[MAX_INDEX] = { 0 };
			CopyMemory(cbTmpCardIndex, cbUserIndexCardTmp, MAX_INDEX);
			if (cbJiangIndex[i] == 0)
			{
				continue;
			}
			if (cbJiangIndex[i] == 1)
			{
				cbTmpCardIndex[i] -= 2;
				//计算剩余的牌 全顺需要财神个数
				int nNeedMagicCount = 0;
				BYTE cbColorCards[4][MAX_INDEX] = { 0 };
				int cbColorCardCount[MAX_COUNT] = { 0 };
				for (int iColor = 0; iColor < 4; iColor++)
				{
					mNeedMinMagicNum = 8;
					GetOneColorCards(cbTmpCardIndex, iColor, cbColorCards[iColor], cbColorCardCount[iColor]);
					int nNeedMagic = 0;
					
						GetOneColorNeedMagicCards(cbColorCards[iColor], cbColorCardCount[iColor], 0, true);
						nNeedMagic = mNeedMinMagicNum;
						nNeedMagicCount += nNeedMagic;
					

					//CString str;
					//str.Format(_T("花色 %d 需要财神个数 %d 才能组成全顺"), iColor, nNeedMagic);
					
				}
				if (nNeedMagicCount == nMagicCount)
				{
					if (nFengCardCount==1)
					{
						if (nFengCard[0]!=i)
						{
							continue;
						}
					}
	/*				CString str;
					str.Format(_T("全顺 %02x 做将"), SwitchToCardData(i));*/
					////OutputDebugString(str);
					return true;
				}

			}

		}

	}
//////////////////////////////////////////////////////////////////////////
	//正将没有找到 尝试找找财将
	{
		if (nMagicCount >= 1)
		{
			BYTE cbJiangIndex[MAX_INDEX] = { 0 };
			for (int i = 0; i < MAX_INDEX; i++)
			{
				if (cbUserIndexCardTmp[i] == 0)
				{
					continue;
				}
				if (cbUserIndexCardTmp[i] >= 1)
				{
					cbJiangIndex[i] = 1;
				}
			}

			for (int i = 0; i < MAX_INDEX; i++)
			{
				BYTE cbTmpCardIndex[MAX_INDEX] = { 0 };
				CopyMemory(cbTmpCardIndex, cbUserIndexCardTmp, MAX_INDEX);
				if (cbJiangIndex[i] == 0)
				{
					continue;
				}
				if (cbJiangIndex[i] == 1)
				{
					cbTmpCardIndex[i] -= 1;
					int nTmpMagicCount=nMagicCount-1;
					//计算剩余的牌 全顺需要财神个数
					int nNeedMagicCount = 0;
					BYTE cbColorCards[4][MAX_INDEX] = { 0 };
					int cbColorCardCount[MAX_COUNT] = { 0 };
					for (int iColor = 0; iColor < 4; iColor++)
					{
						mNeedMinMagicNum = 8;
						GetOneColorCards(cbTmpCardIndex, iColor, cbColorCards[iColor], cbColorCardCount[iColor]);
						int nNeedMagic = 0;
					
						
							GetOneColorNeedMagicCards(cbColorCards[iColor], cbColorCardCount[iColor], 0, true);
							nNeedMagic = mNeedMinMagicNum;
							nNeedMagicCount += nNeedMagic;
						
						CString str;
						str.Format(_T("花色 %d 需要财神个数 %d 才能组成全顺"), iColor, nNeedMagic);
					
					}
					if (nNeedMagicCount == nTmpMagicCount||nNeedMagicCount==nTmpMagicCount%3)
					{
						if (nFengCardCount == 1)
						{
							if (nFengCard[0] != i)
							{
								continue;
								
							}
						}
						CString str;
						str.Format(_T("全顺 %02x 财神 做将"), SwitchToCardData(i));
					
						return true;
					}
					

				}

			}
		}
	}
	//////////////////////////////////////////////////////////////////////////
	//双财将
	{
		//财将 也没有 那就试试 财财将
		if (nMagicCount >= 2)
		{
			BYTE cbTmpCardIndex[MAX_INDEX] = { 0 };
			CopyMemory(cbTmpCardIndex, cbUserIndexCardTmp, MAX_INDEX);

			nMagicCount -= 2;
			//计算剩余的牌 全顺需要财神个数
			int nNeedMagicCount = 0;
			BYTE cbColorCards[4][MAX_INDEX] = { 0 };
			int cbColorCardCount[MAX_COUNT] = { 0 };
			for (int iColor = 0; iColor < 4; iColor++)
			{
				mNeedMinMagicNum = 8;
				GetOneColorCards(cbTmpCardIndex, iColor, cbColorCards[iColor], cbColorCardCount[iColor]);
				int nNeedMagic = 0;
				
					//nNeedMagicCount = nNeedMagicCount + cbColorCardCount[iColor] * 3 - cbColorCardCount[iColor];
					//nNeedMagic = cbColorCardCount[iColor] * 3 - cbColorCardCount[iColor];
				
					GetOneColorNeedMagicCards(cbColorCards[iColor], cbColorCardCount[iColor], 0, true);
					nNeedMagic = mNeedMinMagicNum;
					nNeedMagicCount += nNeedMagic;
				
					/*	CString str;
						str.Format(_T("花色 %d 需要财神个数 %d 才能组成全顺"), iColor, nNeedMagic);*/
			
			}
			if (nNeedMagicCount == nMagicCount||nNeedMagicCount==nMagicCount%3)
			{
	/*			CString str;
				str.Format(_T("全顺 财神 财神 做将"));*/
				
				return true;
			}


		}
	}

//////////////////////////////////////////////////////////////////////////
	return false;
}
//
bool CGameLogic::IsCardsIsHunYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BOOL HaveFengKe)
{

	BYTE TmpcbCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);

	//////////////////////////////////////////////////////////////////////////
	//无风牌 不是混一色
	int cbFengCount = 0;
	int cbItemColor = -1;
	bool bHasFeng2 = false;
	for (int i = 0; i < cbWeaveCount; i++)
	{
		BYTE cbColor = GetCardColor(WeaveItem[i].cbCenterCard);
		if (cbColor == Color_Feng)
		{
			bHasFeng2 = true;
			cbFengCount++;
			continue;
		}
		if (cbItemColor == -1)
		{
			cbItemColor = cbColor;
		}
		if (cbItemColor != cbColor)
		{
			return false;
		}
	}



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

	//删除风 删除财神 判断是否是一色

	int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex);


	//如果没有 东南西北中发白 不可能是混一色

	for (int i = 1; i < 8; i++)
	{
		if (TmpcbCardIndex[26 + i] != 0 )
		{
			bHasFeng2 = true;
			break;
		}
		else
		{
			continue;
		}
	}
	if (!bHasFeng2&&!cbFengCount&&!HaveFengKe)
	{
		return false;
	}

	if (cbItemColor != -1)
	{
		for (BYTE i = 0; i < 27; i++){
			if (TmpcbCardIndex[i] != 0)
			{
				if (GetCardColor(SwitchToCardData(i)) != cbItemColor)
				{
					return false;
				}
			}
		}
	}
	else
	{
		BYTE cbFirst = 0;
		//遍历前 27张0-26
		//得到第一张颜色 如果后面的颜色与第一个不一样，返回false
		for (BYTE i = 0; i < 27; i++){
			if (TmpcbCardIndex[i] != 0)
			{
				if (cbFirst == 0)
				{
					cbFirst = SwitchToCardData(i);
					continue;
				}
				if (GetCardColor(cbFirst) != GetCardColor(SwitchToCardData(i)))
				{
					return false;
				}
			}

		}
	}
	return true;
}
//听牌分析,
bool CGameLogic::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *m_cbTingPaiData, const BYTE FanHui[MAX_INDEX], BYTE wChairID, BYTE wBaoUserID, BYTE BaoTai)
{
	//复制数据
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
	//BYTE FanHui[MAX_INDEX] = { 0 };
	//IsCanChangCardAndCount(cbCardIndexTemp, FanHui);
	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);
	if (cbCardCount > 1 && (cbCardCount - 1) % 3 != 0)
	{
		ASSERT(false);
		return false;
	}
	CChiHuRight chr;
	BYTE TaiShu = 0;
	bool isHu = false;
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
			if (FanHui[i]==0
				&& !IsMagicCard(SwitchToCardData(i)))
			{
				continue;
			}
		BYTE CardTempData = SwitchToCardData(i);
		if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, CardTempData, chr, TaiShu))
		{
			if (mIsBaoMjType==0)
			{
					//翻财神
				m_cbTingPaiData[i] = TaiShu;
				isHu = true;
			}
			else{
				//包麻将
				if (wChairID == wBaoUserID)
				{
					if (TaiShu < BaoTai)
					{
						m_cbTingPaiData[i] = 0;
					}
					else
					{
						m_cbTingPaiData[i] = TaiShu;
						isHu = true;
					}
				}
				else
				{
					m_cbTingPaiData[i] = TaiShu;
					isHu = true;
				}

			}
	
		}
		else
		{
			m_cbTingPaiData[i] = 0;
		}
	}
	return isHu;
}

//是否听牌
//bool CGameLogic::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, const BYTE FanHui[MAX_INDEX])
//{
//	//复制数据
//	BYTE cbCardIndexTemp[MAX_INDEX];
//	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
//	//BYTE FanHui[MAX_INDEX] = { 0 };
//	//IsCanChangCardAndCount(cbCardIndexTemp, FanHui);
//	for (BYTE i = 0; i < MAX_INDEX; i++)
//	{
//		if (FanHui[i] == 0)continue;
//		BYTE cbTempCardData = SwitchToCardData(i);
//		CChiHuRight chr;
//		BYTE TaiShu = 0;
//		if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbTempCardData,chr,TaiShu))
//			return true;
//	}
//	return false;
//}

//扑克转换
BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex)
{
	//ASSERT(cbCardIndex<34);
	return ((cbCardIndex/9)<<4)|(cbCardIndex%9+1);
}

//扑克转换
BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData)
{
	ASSERT(IsValidCard(cbCardData));
	return ((cbCardData&MASK_COLOR)>>4)*9+(cbCardData&MASK_VALUE)-1;
}

//扑克转换
BYTE CGameLogic::SwitchToCardData(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT])
{
	//转换扑克
	BYTE cbPosition=0;
	for (BYTE i=0;i<MAX_INDEX;i++)
	{
		if (cbCardIndex[i]!=0)
		{
			for (BYTE j=0;j<cbCardIndex[i];j++)
			{
				ASSERT(cbPosition<=MAX_COUNT);
				cbCardData[cbPosition++]=SwitchToCardData(i);
			}
		}
	}
	return cbPosition;
}

//扑克转换
BYTE CGameLogic::SwitchToCardIndex(const BYTE cbCardData[], BYTE cbCardCount, BYTE cbCardIndex[MAX_INDEX])
{
	//设置变量
	ZeroMemory(cbCardIndex,sizeof(BYTE)*MAX_INDEX);
	//转换扑克
	for (BYTE i=0;i<cbCardCount;i++)
	{
		ASSERT(IsValidCard(cbCardData[i]));
		cbCardIndex[SwitchToCardIndex(cbCardData[i])]++;
	}
	return cbCardCount;
}

//分析扑克 无癞子情况下是否可以胡牌，标志AnalyseItemArray.GetCount()>0
bool CGameLogic::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)
{
	//计算数目
	BYTE cbCardCount = GetCardCount(cbCardIndex);
	//效验数目
	if ((cbCardCount<2) || (cbCardCount>MAX_COUNT) || ((cbCardCount - 2) % 3 != 0))
		return false;
	//变量定义
	BYTE cbKindItemCount = 0;//组合个数
	tagKindItem KindItem[27 * 2 + 7 + 14];
	ZeroMemory(KindItem, sizeof(KindItem));

	//需求判断
	BYTE cbLessKindItem = (cbCardCount - 2) / 3;//表示手牌需要几个组合才能胡牌
	ASSERT((cbLessKindItem + cbWeaveCount) == 4);

	//单吊判断
	if (cbLessKindItem == 0)
	{
		//牌眼判断
		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.cbWeaveKind[j] = WeaveItem[j].cbWeaveKind;
					AnalyseItem.cbCenterCard[j] = WeaveItem[j].cbCenterCard;				
					GetWeaveCard(WeaveItem[j].cbWeaveKind, WeaveItem[j].cbCenterCard, WeaveItem[j].cbMargicOffset, AnalyseItem.cbCardData[j]);
				}
				AnalyseItem.cbCardEye = SwitchToCardData(i);
				AnalyseItem.bMagicEye = false;
				//插入结果
				AnalyseItemArray.Add(AnalyseItem);
				return true;
			}
		}
		return false;
	}

	//拆分分析，用户手上的临时牌变量
	BYTE cbMagicCardIndex[MAX_INDEX];
	CopyMemory(cbMagicCardIndex, cbCardIndex, sizeof(cbMagicCardIndex));
	if (cbCardCount >= 3)
	{
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			//同牌判断
			if (cbMagicCardIndex[i] >= 3)
			{
				ASSERT(cbKindItemCount < CountArray(KindItem));
				KindItem[cbKindItemCount].cbCardIndex[0] = i;
				KindItem[cbKindItemCount].cbCardIndex[1] = i;
				KindItem[cbKindItemCount].cbCardIndex[2] = i;
				KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG;
				KindItem[cbKindItemCount].cbCenterCard = SwitchToCardData(i);
				KindItem[cbKindItemCount].cbValidIndex[0] = i;
				KindItem[cbKindItemCount].cbValidIndex[1] = i;
				KindItem[cbKindItemCount].cbValidIndex[2] = i;
				cbKindItemCount++;				
			}

			//连牌判断
			if ((i < (MAX_INDEX - 9)) && ((i % 9) < 7))
			{
				//只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合
				if (cbMagicCardIndex[i] + cbMagicCardIndex[i + 1] + cbMagicCardIndex[i + 2] >= 3)
				{
					BYTE cbIndex[3] = { cbMagicCardIndex[i], cbMagicCardIndex[i + 1], cbMagicCardIndex[i + 2] };
					int nMagicCountTemp = 0;
					BYTE cbValidIndex[3];
					while (cbIndex[0] + cbIndex[1] + cbIndex[2] >= 3)
					{
						for (BYTE j = 0; j < CountArray(cbIndex); j++)
						{
							if (cbIndex[j] > 0)
							{
								cbIndex[j]--;
								cbValidIndex[j] = i + j;
							}
							else
							{
								nMagicCountTemp--;
							}
						}
						if (nMagicCountTemp == 0)
						{
							ASSERT(cbKindItemCount < CountArray(KindItem));
							KindItem[cbKindItemCount].cbCardIndex[0] = i;
							KindItem[cbKindItemCount].cbCardIndex[1] = i + 1;
							KindItem[cbKindItemCount].cbCardIndex[2] = i + 2;
							KindItem[cbKindItemCount].cbWeaveKind = WIK_LEFT;
							KindItem[cbKindItemCount].cbCenterCard = SwitchToCardData(i);
							CopyMemory(KindItem[cbKindItemCount].cbValidIndex, cbValidIndex, sizeof(cbValidIndex));
							cbKindItemCount++;
						}
						else break;
					}
				}
			}
		}
	}

	//组合分析
	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]->cbValidIndex[i % 3];
				if (cbCardIndexTemp[cbCardIndex] == 0)
				{
					bEnoughCard = false;
					break;
				}
				else
					cbCardIndexTemp[cbCardIndex]--;
			}

			//胡牌判断
			if (bEnoughCard == true)
			{
				//牌眼判断
				BYTE cbCardEye = 0;
				bool bMagicEye = false;
				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.cbWeaveKind[i] = WeaveItem[i].cbWeaveKind;
						AnalyseItem.cbCenterCard[i] = WeaveItem[i].cbCenterCard;
						GetWeaveCard(WeaveItem[i].cbWeaveKind, WeaveItem[i].cbCenterCard, WeaveItem[i].cbMargicOffset,
							AnalyseItem.cbCardData[i]);
					}

					//设置牌型
					for (BYTE i = 0; i < cbLessKindItem; i++)
					{
						AnalyseItem.cbWeaveKind[i + cbWeaveCount] = pKindItem[i]->cbWeaveKind;
						AnalyseItem.cbCenterCard[i + cbWeaveCount] = pKindItem[i]->cbCenterCard;
						AnalyseItem.cbCardData[cbWeaveCount + i][0] = SwitchToCardData(pKindItem[i]->cbValidIndex[0]);
						AnalyseItem.cbCardData[cbWeaveCount + i][1] = SwitchToCardData(pKindItem[i]->cbValidIndex[1]);
						AnalyseItem.cbCardData[cbWeaveCount + i][2] = SwitchToCardData(pKindItem[i]->cbValidIndex[2]);
					}

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

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

			//设置索引
			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;
					}
				}
				if (i == 0)
					break;
			}
			else
				cbIndex[cbLessKindItem - 1]++;
		} while (true);

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

//删除癞子牌
BYTE CGameLogic::DeleteMagicCards(BYTE cbCardIndex[MAX_INDEX])
{
	if (m_BaoMj_MagicType==MagicType_NoMagic)
	{
		return 0;
	}
	if (m_BaoMj_MagicType==MagicType_OneMagic)
	{
		BYTE cbCount = cbCardIndex[m_cbMagicIndexFirst];
		cbCardIndex[m_cbMagicIndexFirst] = 0;
		return cbCount;
	}
	if (m_BaoMj_MagicType==MagicType_TwoMagic)
	{
		BYTE cbCardData[2] = { 0 };
		BYTE cbCount = cbCardIndex[m_cbMagicIndexFirst] + cbCardIndex[m_cbMagicIndexSecond];
		cbCardIndex[m_cbMagicIndexFirst] = 0;
		cbCardIndex[m_cbMagicIndexSecond] = 0;
		return cbCount;
	}

	return 0;
}

BYTE CGameLogic::DeleteMagicCards(BYTE cbCardIndex[MAX_INDEX], int nDeleteCount)
{
	int HaveMagicCount = GetMaigcCardCount(cbCardIndex);
	if (nDeleteCount>HaveMagicCount || HaveMagicCount>8)
	{
		CString strInfo;
		strInfo.Format(_T("DeleteMagicCards Have Magic=%d Delete=%d"), HaveMagicCount, nDeleteCount);
		//OutputDebugString(strInfo);
		return 0;
	}
	
	if (m_BaoMj_MagicType==MagicType_NoMagic)
	{
		return 0;
	}
	if (m_BaoMj_MagicType == MagicType_OneMagic)
	{
	
		if ((cbCardIndex[m_cbMagicIndexFirst] - nDeleteCount)>4 || (cbCardIndex[m_cbMagicIndexFirst] - nDeleteCount )<0)
		{
			return 0;
		}
		cbCardIndex[m_cbMagicIndexFirst] = cbCardIndex[m_cbMagicIndexFirst] - nDeleteCount;
		return nDeleteCount;
	}
	if (m_BaoMj_MagicType==MagicType_TwoMagic)
	{
		BYTE nConut = 0;

		int nFirstMagicCount = cbCardIndex[m_cbMagicIndexFirst];

		int nSecondMagicCount = cbCardIndex[m_cbMagicIndexSecond];

		if (nDeleteCount > (nFirstMagicCount + nSecondMagicCount))
		{

			return 0;
		}
		for (int i = 0; i < nDeleteCount; i++)
		{
			if (cbCardIndex[m_cbMagicIndexFirst] > 0) {
				cbCardIndex[m_cbMagicIndexFirst]--;
				nConut++;
			}
			else if (cbCardIndex[m_cbMagicIndexSecond] > 0)
			{
				cbCardIndex[m_cbMagicIndexSecond]--;
				nConut++;
			}
		}

		return nConut;
	}
	return 0;
	
}

//获取牌值需要财神牌个数nNeedNum，组成扑（扑指的是顺子或者三重牌（比如 一饼二饼三饼  或者东风东风东风））
int CGameLogic::GetOneColorNeedMagicCards(const BYTE cbCardData[MAX_COUNT], int DataCount, int nNeedNum, bool isShun)
{

	//CString strTmpPrint;
	//strTmpPrint = _T("GetOneColorNeedMagicCards 分析 ");

	//{
	//	for (int i = 0; i < DataCount; i++)
	//	{
	//		CString tmp;
	//		tmp.Format(_T(" %02x"), cbCardData[i]);
	//		strTmpPrint.Append(tmp);
	//	}
	//	strTmpPrint.Append(_T("\r\n"));
	//	//OutputDebugString(strTmpPrint);

	//}

	if (mNeedMinMagicNum == 0)
	{
		return -1;
	}
	if (nNeedNum >= mNeedMinMagicNum)
	{
		return -1;
	}

	switch (DataCount)
	{
	case 0:{//cbCardData内没有同一花色的牌不需要财神牌变 
			   mNeedMinMagicNum = min(nNeedNum, mNeedMinMagicNum);//0
			   break;

	}
	case  1:{
				mNeedMinMagicNum = min(nNeedNum + 2, mNeedMinMagicNum);
				CString strTmp;
				strTmp.Format(_T("财神充当碰牌 需要2财神 %02X\r\n "), cbCardData[0]);
				////OutputDebugString(strTmp);
				//mMagicData[mMagicDataCount++] = cbCardData[0];
				break;
	}
	case  2:{
				BYTE cbFirst = cbCardData[0];
				BYTE cbSecend = cbCardData[1];
				//花色是3 为 东南西北中发白 不可能出现顺子
				if (GetCardColor(cbSecend) == 3)
				{
					if (cbFirst == cbSecend&&!isShun)
					{
						//DebugLog(_T("GetOneColorNeedMagicCards 风牌只有刻字 %02x %02x %02x\r\n"),cbFirst,cbSecend,cbFirst);
						mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 1);
						////OutputDebugString(_T("财神是风牌的碰\r\n"));
						mMagicData[mMagicDataCount++] = cbFirst;
					}
					else
					{
						mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4);
					}


				}
				else if (cbSecend - cbFirst < 3)//判断相差两个顺序牌需要财神mMagicData变能“碰”、“吃”（左、中、右）
				{
					//DebugLog(_T("GetOneColorNeedMagicCards 顺子/刻字 %02x %02x magic\r\n"), cbFirst, cbSecend);
					if (cbSecend-cbFirst==0)
					{
						CString strTmp;
						strTmp.Format(_T("财神充当碰牌 %02X\r\n "), cbFirst);
						////OutputDebugString(strTmp);
						mMagicData[mMagicDataCount++] = cbFirst;
					}
					else if (cbSecend-cbFirst==1)
					{
						if (GetCardValue(cbFirst)==1)
						{
							CString strTmp;
							strTmp.Format(_T("财神充当 右吃 %02X\r\n "), cbSecend + 1);
							////OutputDebugString(strTmp);
							mMagicData[mMagicDataCount++] = cbSecend+1;
						}
						else
						{
							CString strTmp;
							strTmp.Format(_T("财神充当 左吃 %02X\r\n "), cbFirst - 1);
							////OutputDebugString(strTmp);
							mMagicData[mMagicDataCount++] = cbFirst - 1;
						}
						
					}
					else if (cbSecend-cbFirst==2)
					{
						CString strTmp;
						strTmp.Format(_T("财神充当 中吃 %02X\r\n "), cbFirst+1);
						////OutputDebugString(strTmp);
						mMagicData[mMagicDataCount++] = cbFirst+1;

					}
					if (isShun&&cbSecend - cbFirst == 0)
					{
						mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4);
					}
					else
					{
						mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 1);
					}
					
				}
				else
				{
					if (isShun)
					{
						mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4);
					}
					else{
						mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4);
					}
				
				}


			break;
		}

		default:
		{

			//取前三张
			BYTE cbFirst = cbCardData[0];
			BYTE cbSecend = cbCardData[1];
			BYTE cbThree = cbCardData[2];

			//第一个自己一扑
			if (nNeedNum + 2 < mNeedMinMagicNum)
			{
				GetOneColorNeedMagicCards(cbCardData + 1, DataCount - 1, nNeedNum + 2, isShun);//从cbCardData一个一个元素开始，所以DataCount - 1，需要两个财神才能成（扑）

			}
			//第一个跟其它的一个一扑
			if (nNeedNum + 1 < mNeedMinMagicNum){

				if (GetCardColor(cbFirst) == 3){//东南西北中发白牌型
					if (cbFirst == cbSecend)
					{
						GetOneColorNeedMagicCards(cbCardData + 2, DataCount - 2, nNeedNum + 1, isShun);//如果是刻字（两两相等），则需要+1财神牌变，才能碰（即成扑）
					}
				}
				else
				{
					for (int i = 1; i < DataCount; i++)
					{
						if (nNeedNum + 1 >= mNeedMinMagicNum)//财神数最多7个，还有一个是第一次摸牌显示在台桌上无效
						{
							break;
						}
						cbSecend = cbCardData[i];

						if (i + 1 != DataCount){
							cbThree = cbCardData[i + 1];
							if (cbThree == cbSecend){
								continue;
							}
						}

						if (GetCardValue(cbSecend) - GetCardValue(cbFirst) < 3)
						{
							//删除 此时的 p1 p2 
							/*BYTE *pTmpData = new BYTE[DataCount];
							ZeroMemory(pTmpData, DataCount);
							int nCount = 0;
							for (int j = 0; j < DataCount; j++)
							{
								if (j == i || j == 0)
								{
									continue;
								}
								pTmpData[nCount++] = cbCardData[j];
							}*/

							if (isShun&&GetCardValue(cbSecend) - GetCardValue(cbFirst)==0)
							{
								BYTE delCards[2] = { 0 };
								delCards[0] = cbFirst;
								delCards[1] = cbSecend;
								BYTE outCards[14] = { 0 };
								DeleteCards(cbCardData, 14, delCards, 2, outCards);
								GetOneColorNeedMagicCards(outCards, DataCount - 2, nNeedNum + 4, isShun);
							}
							else
							{
								BYTE delCards[2] = { 0 };
								delCards[0] = cbFirst;
								delCards[1] = cbSecend;
								BYTE outCards[14] = { 0 };
								DeleteCards(cbCardData, 14, delCards, 2, outCards);
								GetOneColorNeedMagicCards(outCards, DataCount - 2, nNeedNum + 1, isShun);

							}
							

						

						}
						else
						{
							break;
						}

					}
				}
			}

			//第一个和其它两个一扑
			//后面间隔两张张不跟前面一张相同222234 
			//可能性为222 234
			for (int i = 1; i < DataCount; i++){
				if (nNeedNum >= mNeedMinMagicNum){
					break;
				}
				cbSecend = cbCardData[i];
				if (i + 2 < DataCount)
				{
					if (cbCardData[i + 2] == cbSecend)
					{
						continue;
					}
				}
				for (unsigned int j = i + 1; j < DataCount; j++)
				{
					if (nNeedNum >= mNeedMinMagicNum)
					{
						break;
					}
					cbThree = cbCardData[j];
					if (cbFirst == cbThree)
					{
						//不处理
					}
					if (j + 1 < DataCount)
					{
						if (cbThree == cbCardData[j + 1])
						{
							continue;
						}
					}
					if (isShun)
					{
						if (test3combineToShun(cbFirst, cbSecend, cbThree))
						{
							//删除 1 2 3 

							BYTE delCards[3] = { 0 };
							delCards[0] = cbFirst;
							delCards[1] = cbSecend;
							delCards[2] = cbThree;
							BYTE outCards[14] = { 0 };
							DeleteCards(cbCardData, 14, delCards, 3, outCards);
							CString strDeletecards;
							CString strout = _T("删除 ");
							for (int i = 0; i < 3; i++)
							{
								strDeletecards.Format(_T("%02x "), delCards[i]);
								strout += strDeletecards;
							}
							////OutputDebugString(strout);
							GetOneColorNeedMagicCards(outCards, DataCount - 3, nNeedNum, isShun);


						}
					}
					else
					{
						if (test3Combine(cbFirst, cbSecend, cbThree))
						{
							//删除 1 2 3 

							BYTE delCards[3] = { 0 };
							delCards[0] = cbFirst;
							delCards[1] = cbSecend;
							delCards[2] = cbThree;
							BYTE outCards[14] = { 0 };
							DeleteCards(cbCardData, 14, delCards, 3, outCards);
							CString strDeletecards;
							CString strout = _T("删除 ");
							for (int i = 0; i < 3; i++)
							{
								strDeletecards.Format(_T("%02x "), delCards[i]);
								strout += strDeletecards;
							}
							////OutputDebugString(strout);
							GetOneColorNeedMagicCards(outCards, DataCount - 3, nNeedNum, isShun);


						}
					}

				}

			   }



	}
		break;
	}

}
//钻牌
bool CGameLogic::IsMagicCard( BYTE cbCardData )
{
	if (m_BaoMj_MagicType==MagicType_NoMagic)
	{
		return false;
	}
	if (m_BaoMj_MagicType==MagicType_OneMagic)
	{
		if (SwitchToCardIndex(cbCardData)==m_cbMagicIndexFirst)
		{
			return true;
		}
	}
	if (m_BaoMj_MagicType==MagicType_TwoMagic)
	{
		if (SwitchToCardIndex(cbCardData) == m_cbMagicIndexFirst ||
			SwitchToCardIndex(cbCardData) == m_cbMagicIndexSecond)
			return true;
	}


	return false;
}
//test3
bool CGameLogic::test3Combine(const BYTE cbCard1, const BYTE cbCard2, const BYTE cbCard3)
{
	//花色不同 不能组合
	if (GetCardColor(cbCard1) != GetCardColor(cbCard2) || GetCardColor(cbCard1) != GetCardColor(cbCard3))
	{
		return false;
	}

	//刻字
	if (cbCard1 == cbCard2&& cbCard2 == cbCard3)
	{
//		DebugLog(_T("test3Combine 刻字 %02x %02x %02x\r\n"), cbCard1, cbCard2, cbCard3);
		return true;
	}
	//风牌不能组成顺子
	if (GetCardColor(cbCard3) == 3)
	{
		return false;
	}
	if (cbCard1 + 1 == cbCard2&& cbCard2 + 1 == cbCard3)
	{
//		DebugLog(_T("test3Combine 顺子 %02x %02x %02x\r\n"), cbCard1, cbCard2, cbCard3);
		return true;
	}
	return false;


}

bool CGameLogic::test3combineToShun(const BYTE cbCard1, const BYTE cbCard2, const BYTE cbCard3)
{
	//花色不同 不能组合
	if (GetCardColor(cbCard1) != GetCardColor(cbCard2) || GetCardColor(cbCard1) != GetCardColor(cbCard3))
	{
		return false;
	}

	//风牌不能组成顺子
	if (GetCardColor(cbCard3) == 3)
	{
		return false;
	}
	if (cbCard1 + 1 == cbCard2&& cbCard2 + 1 == cbCard3)
	{
		//		DebugLog(_T("test3Combine 顺子 %02x %02x %02x\r\n"), cbCard1, cbCard2, cbCard3);
		return true;
	}
	return false;
}

//test2
bool CGameLogic::test2Combine(const BYTE cbCard1, const BYTE cbCard2)
{
	if (cbCard1 == cbCard2)
	{
//		DebugLog(_T("test3Combine peng %02x %02x \r\n"), cbCard1, cbCard2);
		return true;
	}
	return false;
}

//排序,根据牌值排序
bool CGameLogic::SortCardList( BYTE cbCardData[MAX_COUNT], BYTE cbCardCount )
{
	//数目过虑
	if (cbCardCount==0||cbCardCount>MAX_COUNT) return false;

	//排序操作
	bool bSorted=true;
	BYTE cbSwitchData=0,cbLast=cbCardCount-1;
	do
	{
		bSorted=true;
		for (BYTE i=0;i<cbLast;i++)
		{
			if (cbCardData[i]>cbCardData[i+1])
			{
				//设置标志
				bSorted=false;

				//扑克数据
				cbSwitchData=cbCardData[i];
				cbCardData[i]=cbCardData[i+1];
				cbCardData[i+1]=cbSwitchData;
			}	
		}
		cbLast--;
	} while(bSorted==false);

	return true;
}

//编码
//WORD占两个字节，
//num占高三位，剩下给倍数
//uFangShu 7位
//PaiZhi 占用低六位，
WORD CGameLogic::GetValue(BYTE uNum, BYTE uFangShu, WORD PaiZhi)
{
	WORD mcd = PaiZhi | (uFangShu << 6) | (uNum << 13);
	return mcd;
}
//解码
BYTE CGameLogic::DeCodeCard(const WORD cbCardData)
{
	BYTE TempCardData = cbCardData & 0x003F;
	return TempCardData;
}
//解码番薯
BYTE CGameLogic::DeCodeFanshu(const WORD cbCardData)
{
	//BYTE num = (cbCardData & 0x3800) >> 11;
	BYTE fanshu = (cbCardData & 0x07C0) >> 6;
	//BYTE TempCardData = cbCardData & 0x003F;
	return fanshu;
}

bool CGameLogic::PeiPai(BYTE ParZhi[MAX_REPERTORY_ZJ])
{
	std::ifstream in;
	std::string filename = "zuopai.dat";
	in.open(filename);
	if (!in.is_open())
	{
		return false;
	}
	static BYTE TempCardData[MAX_REPERTORY_ZJ];
	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_ZJ)
	{
		return false;
	}
	for (BYTE i = 0; i < MAX_REPERTORY_ZJ; i++)
	{
		ASSERT(i < MAX_REPERTORY_ZJ);
		ParZhi[i] = TempCardData[MAX_REPERTORY_ZJ - i - 1];
	}
	return true;
}
BYTE CGameLogic::GetEndCard(BYTE cbCardIndex[MAX_INDEX])
{
	for (BYTE i = MAX_INDEX - 1; i >= 0; i--)
	{
		if (cbCardIndex[i] > 0 && !IsMagicCard(SwitchToCardData(i)))
		{
			return SwitchToCardData(i);
		}
	}
	if (m_BaoMj_MagicType==MagicType_OneMagic)
	{
		return SwitchToCardData(m_cbMagicIndexFirst);
	}
	if (m_BaoMj_MagicType==MagicType_TwoMagic)
	{
		if (m_cbMagicIndexFirst > m_cbMagicIndexSecond)
		{
			return SwitchToCardData(m_cbMagicIndexFirst);
		}
		return SwitchToCardData(m_cbMagicIndexSecond);
	}
	
}
/*
// 胡法分析函数
*/
//大对子
bool CGameLogic::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 CGameLogic::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++)
	//{
	//	BYTE cbCenterCard = WeaveItem[i].cbCenterCard;
	//	if ((cbCenterCard&MASK_COLOR) != cbCardColor)	return false;
	//}
	//return true;
	BYTE TmpcbCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX);

	//////////////////////////////////////////////////////////////////////////
	//有风牌 不是青一色
	int cbItemColor = -1;
	for (int i = 0; i < cbItemCount; i++)
	{
		BYTE cbColor = GetCardColor(WeaveItem[i].cbCenterCard);
		if (cbColor == Color_Feng)
		{
			return false;
		}
		if (cbItemColor == -1)
		{
			cbItemColor = cbColor;
		}
		if (cbItemColor != cbColor)
		{
			return false;
		}
	}

	

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

	//删除风 删除财神 判断是否是一色

	int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex);

	//如果有 东南西北中发白 不可能是青一色
	bool bHasFeng2 = false;
	for (int i = 1; i < 8; i++)
	{
		if (TmpcbCardIndex[26 + i] >0 )
		{
			return false;
		}

	}

	if (cbItemColor != -1)
	{
		for (BYTE i = 0; i < 27; i++){
			if (TmpcbCardIndex[i] != 0)
			{
				if (GetCardColor(SwitchToCardData(i)) != cbItemColor)
				{
					return false;
				}
			}
		}
	}
	else
	{
		BYTE cbFirst = 0;
		//遍历前 27张0-26
		//得到第一张颜色 如果后面的颜色与第一个不一样，返回false
		for (BYTE i = 0; i < 27; i++){
			if (TmpcbCardIndex[i] != 0)
			{
				if (cbFirst == 0)
				{
					cbFirst = SwitchToCardData(i);
					continue;
				}
				if (GetCardColor(cbFirst) != GetCardColor(SwitchToCardData(i)))
				{
					return false;
				}
			}

		}
	}
	return true;
}

//门前清
bool CGameLogic::IsMenQianQing(const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount)
{
	for (int i = 0; i < cbWeaveCount; i++)
	{
		if (WeaveItem[i].cbWeaveKind & (WIK_LEFT|WIK_RIGHT|WIK_CENTER|WIK_PENG|WIK_MING_GANG|WIK_BU_GANG))
		{
			return false;
		}
	}
	return true;
}

bool CGameLogic::HaveFengKe(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE& cbItemCount,int nCardIndex)
{
	if (cbCardIndex[nCardIndex] + GetMaigcCardCount(cbCardIndex)<3)
	{
		return false;
	}
	//手牌已经有3个或以上 东风，则不需要计算了，有
	BYTE cbCardTmpIndex[MAX_INDEX];
	ZeroMemory(cbCardTmpIndex, MAX_INDEX);
	CopyMemory(cbCardTmpIndex, cbCardIndex, MAX_INDEX);
	if (cbCardTmpIndex[nCardIndex] >= 3 && !IsMagicCard(SwitchToCardData(nCardIndex))){
		//手牌减去3个东风
		cbCardTmpIndex[nCardIndex] -= 3;
		WeaveItem[cbItemCount].cbCenterCard = SwitchToCardData(nCardIndex);
		WeaveItem[cbItemCount].cbWeaveKind = WIK_PENG;
		CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX);
		cbItemCount = cbItemCount + 1;
		return true;
	}
	int nCountGang=0;
	BYTE cbIndex[4] = { 0 };
	for (int i = 0; i < MAX_INDEX;i++)
	{
		if (cbCardTmpIndex[i]==0)
		{
			continue;
		}
		if (cbCardTmpIndex[i]==4&&!IsMagicCard(SwitchToCardData(i)))
		{
			cbIndex[nCountGang++]=i;
		}
	}
	if (nCountGang>=2)
	{
	
		BYTE cbCardTmp2Index[MAX_INDEX];
		ZeroMemory(cbCardTmp2Index, MAX_INDEX);
		CopyMemory(cbCardTmp2Index, cbCardTmpIndex, MAX_INDEX);
		int nMagicTmpCount = DeleteMagicCards(cbCardTmp2Index);

		for (int i = 0; i < nCountGang; i++)
		{
			cbCardTmp2Index[cbIndex[i]] = 1;
		}

		if (nMagicTmpCount>3)
		{
			nMagicTmpCount -= 3;
		}
		if (!TestHu(cbCardTmp2Index, nMagicTmpCount, WeaveItem, cbItemCount))
		{
			return false;
		}
	}
	//如果手牌有 1/2 东风，怎计算一下 拿财神配合一下 剩下的牌胡不胡 
// 	if (cbCardIndex[nCardIndex]>0)
// 	{
	int nMagic = GetMaigcCardCount(cbCardIndex);


		if (cbCardIndex[nCardIndex] !=0&& IsMagicCard(SwitchToCardData(nCardIndex)))//
		{
			if (nMagic<3)
			{
				return false;
			}

			//减去三个财神 判断能不能胡
			if (DeleteMagicCards(cbCardTmpIndex, 3) != 3){
				return false;
			}
			
			{
				tagWeaveItem TmpWeaveItem[7];
				ZeroMemory(TmpWeaveItem, sizeof(TmpWeaveItem));
				CopyMemory(TmpWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbItemCount);
				int cbItemCountTmp = cbItemCount;
				TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex);

				TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG;

				if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp))
				{
					cbItemCount = cbItemCountTmp + 1;
					CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX);
					CopyMemory(WeaveItem, TmpWeaveItem, sizeof(tagWeaveItem)*cbItemCount);

					return true;
				}
			}
//////////////////////////////////////////////////////////////////////////////
	
			//减去4个财神 判断能不能胡
			ZeroMemory(cbCardTmpIndex, MAX_INDEX);
			CopyMemory(cbCardTmpIndex, cbCardIndex, MAX_INDEX);

			if (GetMaigcCardCount(cbCardIndex)>=4)
			{
				if (DeleteMagicCards(cbCardTmpIndex, 4) != 4){
					return false;
				}
				{
					tagWeaveItem TmpWeaveItem[7];
					ZeroMemory(TmpWeaveItem, sizeof(TmpWeaveItem));
					CopyMemory(TmpWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbItemCount);
					int cbItemCountTmp = cbItemCount;
					TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex);

					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SAN_MING_GANG;

					if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp))
					{
						cbItemCount = cbItemCountTmp + 1;
						CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX);
						CopyMemory(WeaveItem, TmpWeaveItem, sizeof(tagWeaveItem)*cbItemCount);

						return true;
					}

				}
			}
		

		

		}
		else
		{
			if (nMagic + cbCardIndex[nCardIndex] < 3)
			{
				return false;
			}
		}
		
		//组成3张刻字
		int nDeleteMagic = 0;
		if (cbCardIndex[nCardIndex]<4)
		{
			nDeleteMagic = 3 - cbCardIndex[nCardIndex];
			cbCardTmpIndex[nCardIndex] = 0;
			if (DeleteMagicCards(cbCardTmpIndex, nDeleteMagic) == nDeleteMagic)
			{
				tagWeaveItem TmpWeaveItem[7];
				ZeroMemory(TmpWeaveItem, sizeof(TmpWeaveItem));
				CopyMemory(TmpWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbItemCount);
				int cbItemCountTmp = cbItemCount;
				TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex);
				if (nDeleteMagic == 1)
				{
					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_DAN_PENG;
				}
				else if (nDeleteMagic == 2)
				{
					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG;
				}
				else
				{
					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG;
				}

				if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp))
				{
					cbItemCount = cbItemCountTmp + 1;
					CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX);
					CopyMemory(WeaveItem, TmpWeaveItem, sizeof(tagWeaveItem)*cbItemCount);

					return true;
				}
			}
		}
		
	
		//组成4张杠
		{
			ZeroMemory(cbCardTmpIndex, MAX_INDEX);
			CopyMemory(cbCardTmpIndex, cbCardIndex, MAX_INDEX);
			if (nMagic + cbCardIndex[nCardIndex]<4)
			{
				return false;
			}
			int nDeleteMagic = 4 - cbCardIndex[nCardIndex];
			cbCardTmpIndex[nCardIndex] = 0;
			if (DeleteMagicCards(cbCardTmpIndex, nDeleteMagic) == nDeleteMagic)
			{
				tagWeaveItem TmpWeaveItem[7];
				CopyMemory(TmpWeaveItem, WeaveItem, sizeof(WeaveItem));
				int cbItemCountTmp = cbItemCount;
				TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex);
				if (nDeleteMagic == 1)
				{
					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_DAN_MING_GANG;
				}
				else if (nDeleteMagic == 2)
				{
					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG;
				}
				else{
					TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SAN_MING_GANG;
				}
				if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp))
				{
					CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX);
					CopyMemory(WeaveItem, TmpWeaveItem, sizeof(TmpWeaveItem));
					cbItemCount = cbItemCountTmp+1;
					return true;
				}
			}
		}

//	}

	return false;
}

//获取癞子个数
BYTE CGameLogic::GetMaigcCardCount(const BYTE cbCardIndex[MAX_INDEX])
{
	if (m_BaoMj_MagicType==MagicType_NoMagic)
	{
		return 0;
	}
	if (m_BaoMj_MagicType==MagicType_OneMagic)
	{
		return cbCardIndex[m_cbMagicIndexFirst];
	}
	if (m_BaoMj_MagicType==MagicType_TwoMagic)
	{
		return cbCardIndex[m_cbMagicIndexFirst] + cbCardIndex[m_cbMagicIndexSecond];
	}
	return 0;
}
//对财神牌可变牌判断

void CGameLogic::IsCanChangCardAndCount(const BYTE cbCardIndex[MAX_INDEX], BYTE Fanhui[MAX_INDEX])
{
	//目的 减少后续的计算里量
	//遍历手牌，将包含的牌 附近的2张牌 设置为1，因为只有相关的牌才可能产生影响，不产生影响的牌 不必要计算
	//如果手牌没有万字 则可以在后续计算时 排除万字计算

	ZeroMemory(Fanhui, MAX_INDEX);
	for (int UserCardIndex = 0; UserCardIndex < MAX_INDEX; UserCardIndex++)
	{
		if (UserCardIndex>31||UserCardIndex==27)
		{
			Fanhui[UserCardIndex] = 1;
			continue;
		}
		if (cbCardIndex[UserCardIndex] != 0)
		{
			if (UserCardIndex < 27)
			{
				if ((UserCardIndex % 9) > 2 && (UserCardIndex % 9) < 7)
				{
					//如果有 3-7 的手牌 则把前后2张牌 都设置为 有用的牌，留下来计算
					for (int j = UserCardIndex - 2; j <= UserCardIndex + 2; j++)
					{
						Fanhui[j] = 1;
					}
				}
				else if ((UserCardIndex % 9) <= 2)
				{
					//如水果是1-2 则把后两张设置为可用
					BYTE GaoWei = UserCardIndex / 9;
					for (int j = 9 * GaoWei; j <= UserCardIndex + 2; j++)
					{
						Fanhui[j] = 1;
					}
				}
				else
				{
					//如水果是8-9 则把前两张设置为可用
					for (int j = UserCardIndex - 2; j < (1 + UserCardIndex / 9) * 9; j++)
					{
						Fanhui[j] = 1;
					}
				}
			}
			else
			{
				//风牌都设置为1
				Fanhui[UserCardIndex] = 1;
			}
		}
	}

}

void CGameLogic::ShowMagicData()
{
	if (mMagicDataCount==0)
	{
		return;
	}
	CString strData;
	strData = _T("财神充当以下牌 ");
	for (int i = 0; i < mMagicDataCount;i++)
	{
		mMagicReplaceCard[SwitchToCardIndex(mMagicData[i])] = 1;
		CString strTmpData;
		strTmpData.Format(_T(" %02x "), mMagicData[i]);
		strData.Append(strTmpData);
	}
	strData.Append(_T("\r\n"));
	////OutputDebugString(strData);
}

void CGameLogic::ShowMagicReplaceData()
{
	CString strData;
	strData = _T("ShowMagicReplaceData 财神充当以下牌 ----------\r\n");
	for (int n = 0; n < MAX_INDEX;n++)
	{
		if (mMagicReplaceCard[n]>0)
		{
			CString strTmpData;
			strTmpData.Format(_T(" %02x "), SwitchToCardData(n));
			strData.Append(strTmpData);
		}
	}
	strData.Append(_T("\r\n"));
	////OutputDebugString(strData);
}
//删掉pSrc数组中有和pDeleteCards中的nDelCount个元素相等的元素，再将删了元素的数组pSrc，重新按序放入一个新的数组中Cards
void CGameLogic::DeleteCards(const BYTE* pSrc, int nCount, const BYTE* pDeleteCards, int nDelCount, BYTE  Cards[14]) {


	BYTE * pTmpSrc = new BYTE[nCount];
	ZeroMemory(pTmpSrc, nCount);
	CopyMemory(pTmpSrc, pSrc, nCount);

	for (int i = 0; i < nDelCount; i++)
	{
		for (int nSrc = 0; nSrc < nCount; nSrc++) {
			if (pDeleteCards[i]== pTmpSrc[nSrc])
			{
				pTmpSrc[nSrc] = 0;
				break;
			}
		}
	}
	int nCountOut = 0;
	ZeroMemory(Cards, 14);
	for (int i = 0; i < nCount; i++)
	{
		if (pTmpSrc[i]!=0)
		{
			Cards[nCountOut++] = pTmpSrc[i];
			
		}
	}
	delete pTmpSrc;
	pTmpSrc = NULL;
}



BOOL CGameLogic::IsCanHuAllCards(BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount)
{
	for (int i = 0; i < MAX_INDEX; i++)
	{
		if (cbCardIndex[i]==4)
		{
			continue;
		}
		cbCardIndex[i]++;
		if (!AnalyseCardNew(cbCardIndex, WeaveItem,cbWeaveCount))
		{
			cbCardIndex[i]--;
			return FALSE;
		}
		//CChiHuRight cht;
		//BYTE cbData;
		//if (AnalyseChiHuCard(cbCardIndex,WeaveItem,cbWeaveCount,SwitchToCardData(i),cht,cbData)==WIK_NULL)
		//{
		//	return FALSE;
		//}
		cbCardIndex[i]--;
	}
	return TRUE;
}

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