#include "StdAfx.h"
#include "GameLogicCxz.h"
#include "math.h"
#include "TableFrameSinkCxz.h"
#include "fstream"


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

//扑克数据,一脚癞油的基础数据
const BYTE CGameLogicCxz::m_cbCardDataArray[MAX_REPERTORY]=
{
	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,						//同子
};

//三人两房 扑克数据
const BYTE CGameLogicCxz::m_cbCardDataArray_SRLF[MAX_REPERTORY_SRLF] =
{
	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,						//同子
};

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

//构造函数
CGameLogicCxz::CGameLogicCxz(TableFrameSinkCxz* pTableFramSink)
{
	m_cbMagicIndex = MAX_INDEX;
	m_pTableFramSink = pTableFramSink;
}

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

//混乱扑克
BYTE CGameLogicCxz::RandCardData(BYTE cbCardData[])
{
	BYTE cbCardDataTemp[MAX_REPERTORY_SRLF];
	BYTE cbMaxCount = 0;
	//混乱准备
	//if (srlf == m_pTableFramSink->m_gameConfig.wSubGameID)
	//{
	//	CopyMemory(cbCardDataTemp, m_cbCardDataArray_SRLF, sizeof(m_cbCardDataArray_SRLF));
	//	cbMaxCount = MAX_REPERTORY_SRLF;
	//}
	//else {
	CopyMemory(cbCardDataTemp, m_cbCardDataArray_SRLF, sizeof(m_cbCardDataArray_SRLF));
	cbMaxCount = MAX_REPERTORY_SRLF;
	//}
	//混乱扑克
	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 CGameLogicCxz::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 CGameLogicCxz::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 CGameLogicCxz::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 CGameLogicCxz::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 CGameLogicCxz::GetCardCount(const BYTE cbCardIndex[MAX_INDEX])
{
	//数目统计
	BYTE cbCardCount=0;
	for (BYTE i=0;i<MAX_INDEX;i++) 
		cbCardCount+=cbCardIndex[i];

	return cbCardCount;
}

//获取组合
BYTE CGameLogicCxz::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_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_AN_GANG:		//暗杠牌操作
	{
		//设置变量
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbCenterCard;
		cbCardBuffer[2] = cbCenterCard;
		cbCardBuffer[3] = cbCenterCard;

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

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

		return 3;
	}
	case WIK_BU_GANG:
	{
		cbCardBuffer[0] = cbCenterCard;
		cbCardBuffer[1] = cbCenterCard;
		cbCardBuffer[2] = cbCenterCard;
		cbCardBuffer[3] = cbCenterCard;

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

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

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

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

	//上牌等级
	//if (cbUserAction&(WIK_RIGHT|WIK_CENTER|WIK_LEFT)) { return 1; }

	return 0;
}

//胡牌等级
//WORD CGameLogic::GetChiHuActionRank(const CChiHuRight & ChiHuRight)
//{
//	WORD wFanShu = 0;
//
//	if (!(ChiHuRight&CHR_YING_LAIYOU).IsEmpty())
//		wFanShu = 4;
//	else if( !(ChiHuRight&CHR_RUAN_LAIYOU).IsEmpty() )
//		wFanShu = 2;
//	else if (!(ChiHuRight&CHR_YING_ZIMO).IsEmpty())
//		wFanShu = 2;
//	else if (!(ChiHuRight&CHR_RUAN_ZIMO).IsEmpty())
//		wFanShu = 1;
//	ASSERT( wFanShu > 0 );
//	return wFanShu;
//}

//吃牌判断 一脚耐油不需要
/*
BYTE CGameLogic::EstimateEatCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));

	//过滤判断
	if ( cbCurrentCard>=0x31 || IsMagicCard(cbCurrentCard) ) 
		return WIK_NULL;

	//变量定义
	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 CGameLogicCxz::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard, BYTE LaiZiPiData)
{
	//参数效验
	ASSERT(IsValidCard(cbCurrentCard));

	//过滤判断
	if (IsMagicCard(cbCurrentCard))
		return WIK_NULL;
	if (cbCurrentCard == LaiZiPiData)
	{
		BYTE index = SwitchToCardIndex(cbCurrentCard);
		BYTE zhi = cbCardIndex[index];
		return (zhi == 2) ? WIK_MING_PIGANG : WIK_NULL;
	}
	//碰牌判断
	return (cbCardIndex[SwitchToCardIndex(cbCurrentCard)] >= 2) ? WIK_PENG : WIK_NULL;
}

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

	//过滤判断
	if ( IsMagicCard(cbCurrentCard) ) 
		return WIK_NULL;
	BYTE index = SwitchToCardIndex(cbCurrentCard);
	BYTE zhi = cbCardIndex[index];
	//杠牌判断
	return (zhi==3)?WIK_MING_GANG:WIK_NULL;
}

//杠牌分析
int CGameLogicCxz::AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX], const BYTE m_cbLaiZiData, const BYTE m_cbLaiZiPiData, const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult, BYTE bProvideCard, bool bCanAnGang /* = true */)
{
	//设置变量
	int cbActionMask = WIK_NULL;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));

	//手上杠牌
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		if (i == m_cbMagicIndex) continue;
		if (i == SwitchToCardIndex(m_cbLaiZiData))continue;
		if (cbCardIndex[i] == 3)
		{
			BYTE cbCardLaiZiData = SwitchToCardData(i);//用户手上牌有3个一样的牌，把这个牌复制给临时变量
			if (cbCardLaiZiData == m_cbLaiZiPiData)//判断是否是癞子皮
			{
				cbActionMask |= WIK_GANG;
				GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardLaiZiData;//癞子皮杠
			}
		}
		if (cbCardIndex[i] == 4)
		{
			BYTE cbCardData = SwitchToCardData(i);
			cbActionMask |= WIK_GANG;
			GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardData;
		}
	}
	

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

	return cbActionMask;
}

int CGameLogicCxz::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, CChiHuRight &ChiHuRight, BYTE m_cbLaiZi, BYTE bSubMit)
{
	if (bSubMit == CXZOneStepLaiYou || bSubMit == CXZBanLai)
	{
		//变量定义
		int cbChiHuKind = WIK_NULL;
		CAnalyseItemArray AnalyseItemArray;

		//设置变量
		AnalyseItemArray.RemoveAll();
		ChiHuRight.SetEmpty();

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

		//cbCurrentCard一定不为0			!!!!!!!!!
		ASSERT(cbCurrentCard != 0);
		if (cbCurrentCard == 0) return WIK_NULL;

		if (!ChiHuRight.IsEmpty())
			cbChiHuKind = WIK_ZI_MO;

		//插入扑克
		if (cbCurrentCard == 0)
		{
			ASSERT(false);
			return false;
		}

		cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;

		BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);//癞子在牌里面的索引
		if (cbCardIndexTemp[LaiZiIndex] > 1)//手上癞子超过2个或者2个，就不能胡牌，必须打掉一个
		{
			return WIK_NULL;
		}
		BYTE isHuPaiCount = 0;
		if (cbCardIndexTemp[LaiZiIndex] == 1 && cbCurrentCard != m_cbLaiZi)
		{
			AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
			if (AnalyseItemArray.GetCount() > 0)
			{
				return WIK_ZI_MO | WIK_YING_ZIMO;
			}
			AnalyseItemArray.RemoveAll();
			cbCardIndexTemp[LaiZiIndex]--;
			cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]--;
			for (BYTE i = 0; i < MAX_INDEX; i++)
			{
				if (i == LaiZiIndex)continue;
				cbCardIndexTemp[i] += 2;
				if (cbCardIndexTemp[i]>5){
					isHuPaiCount++;
					cbCardIndexTemp[i] -= 2; 
					continue;
				}
				AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
				if (AnalyseItemArray.GetCount() > 0)
				{
					isHuPaiCount++;
				}
				AnalyseItemArray.RemoveAll();
				cbCardIndexTemp[i] -= 2;
			}
			if (isHuPaiCount >= 26)
			{
				return WIK_NULL;
			}
			cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
			//分析扑克，cbCardIndexTemp是用户手上的牌，WeaveItem,
			for (BYTE i = 0; i < MAX_INDEX; i++)
			{
				if (i == LaiZiIndex)continue;
				if (cbCardIndexTemp[i]>4)continue;
				cbCardIndexTemp[i]++;
				AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
				//胡牌分析
				if (AnalyseItemArray.GetCount()>0)
				{
					cbChiHuKind = WIK_ZI_MO;
					return cbChiHuKind;
				}
				AnalyseItemArray.RemoveAll();
				cbCardIndexTemp[i]--;
			}
			//if (cbChiHuKind&WIK_ZI_MO)
			//{
			//	cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]--;
			//	for (BYTE i = 0; i < MAX_INDEX; i++)
			//	{
			//		if (i == LaiZiIndex)continue;
			//		cbCardIndexTemp[i] += 2;
			//		AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
			//		if (AnalyseItemArray.GetCount()>0)
			//		{
			//			isHuPaiCount++;
			//		}
			//		cbCardIndexTemp[i] -= 2;
			//	}
			//	if (isHuPaiCount >= 26) //当有癞子时，且癞子是个万能和牌时，需要打掉，或者改牌
			//	{
			//		isHuPaiCount = 0;
			//		return WIK_NULL;
			//	}
			//	cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
			//}			
			cbCardIndexTemp[LaiZiIndex]++;
			return cbChiHuKind;
		}
		else
		{
			if (cbCurrentCard == m_cbLaiZi)
			{
				if (cbCardIndexTemp[LaiZiIndex] != 1)
				{
					ASSERT(false);
					return false;
				}
				AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
				if (AnalyseItemArray.GetCount() > 0)
				{
					return WIK_ZI_MO | WIK_YING_ZIMO;
				}
				cbCardIndexTemp[LaiZiIndex]--;
				//分析扑克，cbCardIndexTemp是用户手上的牌，WeaveItem,
				for (BYTE i = 0; i < MAX_INDEX; i++)
				{
					if (i == LaiZiIndex)continue;
					cbCardIndexTemp[i]++;
					AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
					//胡牌分析
					if (AnalyseItemArray.GetCount()>0)
					{
						cbChiHuKind = WIK_ZI_MO;
						return cbChiHuKind;
					}
					AnalyseItemArray.RemoveAll();
					cbCardIndexTemp[i]--;
				}
				cbCardIndexTemp[LaiZiIndex]++;
				return cbChiHuKind;
			}
			else
			{
				AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
				//胡牌分析
				if (AnalyseItemArray.GetCount() > 0)
				{
					cbChiHuKind |= WIK_ZI_MO;
					cbChiHuKind |= WIK_YING_ZIMO;
				}
				return cbChiHuKind;
			}
		}
		return false;
	}
	if (bSubMit == CXZWuLaiDaoDi)
	{
		//变量定义
		int cbChiHuKind = WIK_NULL;
		CAnalyseItemArray AnalyseItemArray;

		//设置变量
		AnalyseItemArray.RemoveAll();
		ChiHuRight.SetEmpty();

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

		//cbCurrentCard一定不为0			!!!!!!!!!
		ASSERT(cbCurrentCard != 0);
		if (cbCurrentCard == 0) return WIK_NULL;

		if (!ChiHuRight.IsEmpty())
			cbChiHuKind = WIK_ZI_MO;

		//插入扑克
		if (cbCurrentCard == 0)
		{
			ASSERT(false);
			return false;
		}
		cbCardIndexTemp[SwitchToCardIndex(cbCurrentCard)]++;
		BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);//癞子在牌里面的索引
		if (cbCardIndexTemp[LaiZiIndex] > 0)
		{
			return WIK_NULL;
		}
		AnalyseCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, AnalyseItemArray);
		if (AnalyseItemArray.GetCount() > 0)
		{
			cbChiHuKind |= WIK_ZI_MO;
			cbChiHuKind |= WIK_YING_ZIMO;
		}
		return cbChiHuKind;
	}
	return false;
}
//听牌分析,
bool CGameLogicCxz::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *m_cbTingPaiData, BYTE m_cbLaiZi, BYTE subMit, BYTE LaiZiCount)
{
	//复制数据
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));

	BYTE cbCardCount = GetCardCount(cbCardIndexTemp);
	if (cbCardCount > 1 && (cbCardCount - 1) % 3 != 0)
	{
		ASSERT(false);
		return false;
	}
	CChiHuRight chr;

	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		BYTE cbCurrentCard = SwitchToCardData(i);
		if (cbCurrentCard == m_cbLaiZi&&subMit == CXZWuLaiDaoDi)continue;
		if (subMit == CXZBanLai)
		{
			int wikChiHu = AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit);
			if ((LaiZiCount == 0 && (wikChiHu&WIK_YING_ZIMO) == WIK_YING_ZIMO) || (LaiZiCount > 0 && (wikChiHu&WIK_ZI_MO) == WIK_ZI_MO))
				m_cbTingPaiData[i] = 1;
			else
			{
				m_cbTingPaiData[i] = 0;
			}				
		}
		else
		{
			if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit))
				m_cbTingPaiData[i] = 1;
			else
			{
				m_cbTingPaiData[i] = 0;
			}
		}
	}
	return true;
}

//是否听牌
bool CGameLogicCxz::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE m_cbLaiZi, BYTE subMit, BYTE LaiZiCount)
{
	//复制数据
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp));
	BYTE LaiZiIndex = SwitchToCardIndex(m_cbLaiZi);
	CChiHuRight chr;
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		BYTE cbCurrentCard = SwitchToCardData(i);
		if (((i == LaiZiIndex) && (cbCardIndexTemp[i] > 0) && (subMit == CXZOneStepLaiYou || subMit == CXZBanLai)) || (i == LaiZiIndex&& subMit == CXZWuLaiDaoDi))
			continue;
		if (subMit == CXZBanLai && LaiZiCount == 0)
		{
			int wikChiHu = AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit);
			if (WIK_YING_ZIMO & wikChiHu)
			{
				return true;
			}
			else
				continue;
		}
			
		if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbCurrentCard, chr, m_cbLaiZi, subMit))
			return true;
	}
	return false;
}

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

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

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

	return cbPosition;
}

//扑克转换
BYTE CGameLogicCxz::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;
}

//分析扑克
bool CGameLogicCxz::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)
{
	//计算数目
	BYTE cbCardCount = GetCardCount(cbCardIndex);

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

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

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

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

		//牌眼判断
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			if (cbCardIndex[i] == 2 ||
				(m_cbMagicIndex != MAX_INDEX && i != m_cbMagicIndex && cbCardIndex[m_cbMagicIndex] + 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, AnalyseItem.cbCardData[j]);
				}
				AnalyseItem.cbCardEye = SwitchToCardData(i);
				if (cbCardIndex[i] < 2 || i == m_cbMagicIndex)
					AnalyseItem.bMagicEye = true;
				else AnalyseItem.bMagicEye = false;

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

				return true;
			}
		}
		return false;
	}

	//拆分分析，用户手上的临时牌变量
	BYTE cbMagicCardIndex[MAX_INDEX];
	CopyMemory(cbMagicCardIndex, cbCardIndex, sizeof(cbMagicCardIndex));
	BYTE cbMagicCardCount = 0;//用来干什么的不知道
	if (m_cbMagicIndex != MAX_INDEX)
	{
		cbMagicCardCount = cbCardIndex[m_cbMagicIndex];
		if (cbMagicCardIndex[m_cbMagicIndex]) cbMagicCardIndex[m_cbMagicIndex] = 1;		//减小多余组合
	}
	if (cbCardCount >= 3)
	{
		for (BYTE i = 0; i < MAX_INDEX; i++)
		{
			//同牌判断
			if (cbMagicCardIndex[i] + cbMagicCardCount >= 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] = cbMagicCardIndex[i] > 0 ? i : m_cbMagicIndex;
				KindItem[cbKindItemCount].cbValidIndex[1] = cbMagicCardIndex[i] > 1 ? i : m_cbMagicIndex;
				KindItem[cbKindItemCount].cbValidIndex[2] = cbMagicCardIndex[i] > 2 ? i : m_cbMagicIndex;
				cbKindItemCount++;
				if (cbMagicCardIndex[i] + cbMagicCardCount >= 6)
				{
					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] = cbMagicCardIndex[i] > 3 ? i : m_cbMagicIndex;
					KindItem[cbKindItemCount].cbValidIndex[1] = m_cbMagicIndex;
					KindItem[cbKindItemCount].cbValidIndex[2] = m_cbMagicIndex;
					cbKindItemCount++;
				}
			}

			//连牌判断
			if ((i < (MAX_INDEX - 2)) && ((i % 9) < 7))
			{
				//只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合
				if (cbMagicCardCount + cbMagicCardIndex[i] + cbMagicCardIndex[i + 1] + cbMagicCardIndex[i + 2] >= 3)
				{
					BYTE cbIndex[3] = { i == m_cbMagicIndex ? 0 : cbMagicCardIndex[i], (i + 1) == m_cbMagicIndex ? 0 : cbMagicCardIndex[i + 1],
						(i + 2) == m_cbMagicIndex ? 0 : cbMagicCardIndex[i + 2] };
					int nMagicCountTemp = cbMagicCardCount;
					BYTE cbValidIndex[3];
					while (nMagicCountTemp + 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--;
								cbValidIndex[j] = m_cbMagicIndex;
							}
						}
						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);
						if (i == m_cbMagicIndex) bMagicEye = true;
						break;
					}
					else if (i != m_cbMagicIndex &&
						m_cbMagicIndex != MAX_INDEX && cbCardIndexTemp[i] + cbCardIndexTemp[m_cbMagicIndex] == 2)
					{
						cbCardEye = SwitchToCardData(i);
						bMagicEye = true;
					}
				}

				//组合类型
				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,
							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);
}

//钻牌
bool CGameLogicCxz::IsMagicCard(BYTE cbCardData)
{
	if( m_cbMagicIndex != MAX_INDEX )
		return SwitchToCardIndex(cbCardData) == m_cbMagicIndex;
	return false;
}
//获取手牌癞子数量
BYTE CGameLogicCxz::GetLaiZiCount(const BYTE cbCardIndex[MAX_INDEX], BYTE m_cbLaiZi)
{
	BYTE LaiZiCount = 0;//判断玩家手上是否有癞子
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		if (cbCardIndex[i] == 0)continue;
		if (SwitchToCardData(i) == m_cbLaiZi)//癞子不能有多个，否则需要打出去
		{
			if (cbCardIndex[i] == 1)
			{
				LaiZiCount = 1;
			}
			else
			{
				LaiZiCount = 2;
			}
		}
	}
	return LaiZiCount;
}

//排序,根据牌值排序
bool CGameLogicCxz::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;
}

byte CGameLogicCxz::GetValue(USHORT uNum, byte PaiZhi)
{
	byte bRet = 0;

	switch (uNum)
	{
	case 0:
		return PaiZhi;
	case 1:
		return PaiZhi + 41;
	case 2:
		return PaiZhi + 82;
	case 3:
		return PaiZhi + 123;
	case 4:
		return PaiZhi + 164;
	default:
		ASSERT(FALSE);
		return 0;
		throw _T("非法数值");
		break;
	}

	return bRet + PaiZhi;
}

bool CGameLogicCxz::PeiPai(BYTE ParZhi[MAX_REPERTORY_SRLF])
{
	std::ifstream in;
	std::string filename = "zuopai.dat";
	in.open(filename);
	if (!in.is_open())
	{
		return false;
		//ASSERT(false);
	}
	static BYTE TempCardData[MAX_REPERTORY_SRLF];
	//static BYTE TempCardDatar[MAX_REPERTORY];
	ZeroMemory(TempCardData, sizeof(TempCardData));
	//ZeroMemory(TempCardDatar, sizeof(TempCardDatar));
	BYTE tempCount = 0;
	char ch[1];
	while (!in.eof())
	{
		in.read(ch, 1);
		TempCardData[tempCount++] = ch[0];
	}
	in.close(); 
	//TempCardData[108] = 0;
	for (BYTE i = 0; i < MAX_REPERTORY_SRLF; i++)
	{
		ASSERT(i < MAX_REPERTORY_SRLF);
		ParZhi[i] = TempCardData[MAX_REPERTORY_SRLF - i - 1];
	}
	//TempCardDatar[MAX_REPERTORY] = 0;
	return true;
}
BYTE CGameLogicCxz::GetEndCard(const BYTE cbCardIndex[MAX_INDEX], BYTE mLaiZiData)
{
	for (int i = MAX_INDEX - 1; i >= 0; i--)
	{
		if (cbCardIndex[i] > 0 && SwitchToCardData(i) != mLaiZiData)
		{
			return SwitchToCardData(i);
		}
	}
	ASSERT(false);
	return mLaiZiData;
}

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