zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/游戏服务器/TableFrameSinkZhiPai.cpp

#include "StdAfx.h"
#include "TableFrameSinkZhiPai.h"


//构造函数
TableFrameSinkZhiPai::TableFrameSinkZhiPai():m_GameLogic(this)
{
	//游戏变量
	m_wBankerUser=INVALID_CHAIR;
	ZeroMemory(m_cbCardIndex, sizeof(m_cbCardIndex)); 
	ZeroMemory(m_cbHuaCardIndex, sizeof(m_cbHuaCardIndex)); 
	ZeroMemory(m_cbCardIndex_Tong, sizeof(m_cbCardIndex_Tong));//用户扑克，保存统的手牌
	ZeroMemory(m_cbHuaCardIndex_Tong, sizeof(m_cbHuaCardIndex_Tong));//三个用户手中各花牌的个数--不同局中，必须清空其值，保存统的手牌
	ZeroMemory(m_cbHuaWeaveCardIndex_Tong, sizeof(m_cbHuaWeaveCardIndex_Tong));//保存统组合的花牌
	ZeroMemory(m_cbGamePlayerHandCard, sizeof(m_cbGamePlayerHandCard));
	ZeroMemory(&m_gameConfig, sizeof(m_gameConfig));
	
	ZeroMemory(m_cbTongCount, sizeof(m_cbTongCount));//操作显示的分数
	ZeroMemory(m_cbOperateScore, sizeof(m_cbOperateScore));//操作显示的分数
	ZeroMemory(m_cbHuaWeaveCardIndex, sizeof(m_cbHuaWeaveCardIndex));
	ZeroMemory(m_bTrustee,sizeof(m_bTrustee));

	ZeroMemory( m_bPlayStatus,sizeof(m_bPlayStatus) );
	ZeroMemory(m_lGameScore, sizeof(m_lGameScore));
	ZeroMemory(m_lGameTatolScore, sizeof(m_lGameTatolScore));
	ZeroMemory(b_QingTong, sizeof(b_QingTong));
	ZeroMemory(m_cbDuiOperator, sizeof(m_cbDuiOperator));

	//出牌信息
	m_cbOutCardData=0;
	m_cbOutCardCount=0;
	m_wOutCardUser=INVALID_CHAIR;
	ZeroMemory(m_cbDiscardCard,sizeof(m_cbDiscardCard));
	ZeroMemory(m_cbDiscardCount,sizeof(m_cbDiscardCount));
	ZeroMemory(m_cbLastDisCardData, sizeof(m_cbLastDisCardData));
	ZeroMemory(m_cbLastDisCount, sizeof(m_cbLastDisCount));
	
	//发牌信息
	m_cbSendCardData=0;
	m_cbSendCardCount=0;
	m_cbLeftCardCount=0;
	ZeroMemory(m_cbRepertoryCard,sizeof(m_cbRepertoryCard));
	ZeroMemory(m_cbRepertoryCard_Two, sizeof(m_cbRepertoryCard_Two));
	ZeroMemory(m_cbRepertoryCard_One, sizeof(m_cbRepertoryCard_One));

	//运行变量
	m_cbProvideCard=0;
	m_wResumeUser=INVALID_CHAIR;
	m_wCurrentUser=INVALID_CHAIR;
	m_wProvideUser=INVALID_CHAIR;

	//状态变量
	m_bSendStatus=false;

	//用户状态
	ZeroMemory(m_bResponse,sizeof(m_bResponse));
	ZeroMemory(m_cbUserAction,sizeof(m_cbUserAction));
	ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard)); 
	ZeroMemory(m_cbOperateCard_FuJia, sizeof(m_cbOperateCard_FuJia));
	ZeroMemory(m_cbPerformAction,sizeof(m_cbPerformAction));

	ZeroMemory(EsponseHuShu, sizeof(EsponseHuShu));//胡数
	ZeroMemory(EsponsePaPoShu, sizeof(EsponsePaPoShu));//爬坡数

	//组合扑克
	ZeroMemory(m_WeaveItemArray,sizeof(m_WeaveItemArray));
	ZeroMemory(m_cbWeaveItemCount,sizeof(m_cbWeaveItemCount));
	ZeroMemory(m_cbWeaveItemCount_HuPai, sizeof(m_cbWeaveItemCount_HuPai));
	ZeroMemory(m_WeaveItemArray_HuPai, sizeof(m_WeaveItemArray_HuPai)); 
	ZeroMemory(&ChiHu, sizeof(ChiHu));

	//结束信息
	ZeroMemory(m_HuPai, sizeof(m_HuPai)); 
	ZeroMemory(m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));
	//组件变量
	m_pITableFrame=NULL;
	m_pGameServiceOption=NULL;

	//m_bReduceBean = false;

	for (int i = 0; i < GAME_PLAY; ++i)
	{
		m_lUserTmpScore[i] = TEMP_MAX_SCORE;	//用户临时积分
	}
	bIsHuang = false;
	m_IsHu = false;
	return;
}

//析构函数
TableFrameSinkZhiPai::~TableFrameSinkZhiPai(void)
{
}

//接口查询
void * TableFrameSinkZhiPai::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	if ((Guid == IID_ITableFrameSink) && (InterfaceVersionCompare(dwQueryVer, VER_ITableFrameSinkZhiPai)))
		return static_cast<ITableFrameSink *>(this);
	QUERYINTERFACE(ITableUserAction, Guid, dwQueryVer);
	if ((Guid == IID_IUnknownEx) && (InterfaceVersionCompare(dwQueryVer, VER_IUnknownEx)))
		return static_cast<IUnknownEx *>(static_cast<ITableFrameSink *>(this));
	return NULL;
}

//初始化
bool TableFrameSinkZhiPai::Initialization(IUnknownEx * pIUnknownEx)
{
	//查询接口
	ASSERT(pIUnknownEx!=NULL);
	m_pITableFrame=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,ITableFrame);
	if (m_pITableFrame==NULL)
		return false;

	//获取参数
	m_pGameServiceOption=m_pITableFrame->GetGameServiceOption();
	ASSERT(m_pGameServiceOption!=NULL);

	//开始模式
	m_pITableFrame->SetStartMode(START_MODE_FULL_READY);

	return true;
}

//复位桌子
VOID TableFrameSinkZhiPai::RepositionSink()
{
	//游戏变量
	ZeroMemory(m_cbCardIndex,sizeof(m_cbCardIndex));
	ZeroMemory(m_cbHuaCardIndex, sizeof(m_cbHuaCardIndex));
	ZeroMemory(m_cbCardIndex_Tong, sizeof(m_cbCardIndex_Tong));//用户扑克，保存统的手牌
	ZeroMemory(m_cbHuaCardIndex_Tong, sizeof(m_cbHuaCardIndex_Tong));//三个用户手中各花牌的个数--不同局中，必须清空其值，保存统的手牌
	ZeroMemory(m_cbHuaWeaveCardIndex_Tong, sizeof(m_cbHuaWeaveCardIndex_Tong));//保存统组合的花牌
	ZeroMemory(m_cbGamePlayerHandCard, sizeof(m_cbGamePlayerHandCard));

	ZeroMemory(m_cbHuaWeaveCardIndex, sizeof(m_cbHuaWeaveCardIndex));
	ZeroMemory(m_bTrustee,sizeof(m_bTrustee));
	ZeroMemory( m_lGameScore,sizeof(m_lGameScore) );
	ZeroMemory( m_bPlayStatus,sizeof(m_bPlayStatus) );
	ZeroMemory(b_QingTong, sizeof(b_QingTong));//请统
	ZeroMemory(m_cbDuiOperator, sizeof(m_cbDuiOperator));
	ZeroMemory(m_cbOperateScore, sizeof(m_cbOperateScore));//操作显示的分数
	ZeroMemory(m_cbTongCount, sizeof(m_cbTongCount));//操作显示的分数

	ZeroMemory(EsponseHuShu, sizeof(EsponseHuShu));//胡数
	ZeroMemory(EsponsePaPoShu, sizeof(EsponsePaPoShu));//爬坡数
	
	//出牌信息
	m_cbOutCardData=0;
	m_cbOutCardCount=0;
	m_wOutCardUser=INVALID_CHAIR;
	ZeroMemory(m_cbDiscardCard,sizeof(m_cbDiscardCard));
	ZeroMemory(m_cbDiscardCount,sizeof(m_cbDiscardCount));
	ZeroMemory(m_cbLastDisCardData, sizeof(m_cbLastDisCardData));
	ZeroMemory(m_cbLastDisCount, sizeof(m_cbLastDisCount));

	//发牌信息
	m_cbSendCardData=0;
	m_cbSendCardCount=0;
	m_cbLeftCardCount=0;
	ZeroMemory(m_cbRepertoryCard,sizeof(m_cbRepertoryCard));
	ZeroMemory(m_cbRepertoryCard_Two, sizeof(m_cbRepertoryCard_Two));
	ZeroMemory(m_cbRepertoryCard_One, sizeof(m_cbRepertoryCard_One));

	//运行变量
	m_cbProvideCard=0;
	m_wResumeUser=INVALID_CHAIR;
	m_wCurrentUser=INVALID_CHAIR;
	m_wProvideUser=INVALID_CHAIR;
	m_wBankerUser = INVALID_CHAIR;

	//状态变量
	m_bSendStatus=false;

	//用户状态
	ZeroMemory(m_bResponse,sizeof(m_bResponse));
	ZeroMemory(m_cbUserAction,sizeof(m_cbUserAction));
	ZeroMemory(m_cbOperateCard,sizeof(m_cbOperateCard));
	ZeroMemory(m_cbOperateCard_FuJia, sizeof(m_cbOperateCard_FuJia));
	ZeroMemory(m_cbPerformAction,sizeof(m_cbPerformAction));

	//组合扑克
	ZeroMemory(m_WeaveItemArray,sizeof(m_WeaveItemArray));
	ZeroMemory(m_cbWeaveItemCount,sizeof(m_cbWeaveItemCount));
	ZeroMemory(m_cbWeaveItemCount_HuPai, sizeof(m_cbWeaveItemCount_HuPai));
	ZeroMemory(m_WeaveItemArray_HuPai, sizeof(m_WeaveItemArray_HuPai));
	ZeroMemory(&ChiHu, sizeof(ChiHu));

	//结束信息
	bIsHuang = false;
	m_IsHu = false;
}

bool TableFrameSinkZhiPai::RepayRecordStart()
{
	m_bReplayRecordStart = true;

	for (GameRecordPacket grp : m_UserReplayRecord)
	{
		delete[] grp.pData;
		grp.pData = nullptr;
	}
	m_UserReplayRecord.clear();//不会释放内存
	m_UserReplayRecord.shrink_to_fit();//释放内存
	return true;
}

bool TableFrameSinkZhiPai::RepayRecordEnd()
{
	if (!m_bReplayRecordStart)
		return false;

	m_bReplayRecordStart = false;
	CMD_GR_ReplayRecordResp urr;
	ZeroMemory(&urr, sizeof(CMD_GR_ReplayRecordResp));

	urr.m_UUID = 0;
	urr.m_UserId = 0;
	urr.m_startTime = time(0);
	urr.m_endTime = time(0);
	urr.m_gameconfig = m_gameConfig;
	//urr.m_UserId = pIServerUserItem->GetUserID();

	for (int j = 0; j < GAME_PLAY; ++j)
	{
		IServerUserItem * pIServerUserItem = m_pITableFrame->GetTableUserItem(j);
		if ((pIServerUserItem == NULL) /*|| (pIServerUserItem->IsClientReady() == false)*/)	
			continue;
		auto& chairInfo = urr.m_chairList[j];
		chairInfo.dwUserId = pIServerUserItem->GetUserID();
		chairInfo.wChairId = pIServerUserItem->GetChairID();
		lstrcpy(chairInfo.userName, pIServerUserItem->GetNickName());
		lstrcpy(chairInfo.headUrl, pIServerUserItem->GetUserInfo ()->szHeadUrl);
	}
	urr.m_recordCount = m_UserReplayRecord.size();

	int GameRecordPacketSize = sizeof(GameRecordPacket) - sizeof(void*);//每条记录头长度
	int totalSize = sizeof(CMD_GR_ReplayRecordResp);//总记录头长度
	for (GameRecordPacket grp : m_UserReplayRecord)
		totalSize += (GameRecordPacketSize + grp.wSize);

	char* replyRecordData = new char[totalSize];
	ZeroMemory(replyRecordData, totalSize);

	CopyMemory(replyRecordData, &urr, sizeof(CMD_GR_ReplayRecordResp));
	int nOffset = sizeof(CMD_GR_ReplayRecordResp);

	
	for (GameRecordPacket grp : m_UserReplayRecord)
	{
		CopyMemory(replyRecordData + nOffset, &grp, GameRecordPacketSize);
		nOffset += GameRecordPacketSize;
		CopyMemory(replyRecordData + nOffset, grp.pData, grp.wSize);
		nOffset += grp.wSize;
	}

	m_pITableFrame->SaveReplayRecord(replyRecordData, totalSize);

	//delete replyRecordData;不能删除，已托管给SaveReplayRecord函数
	return true;
}

bool TableFrameSinkZhiPai::RepayRecord(WORD wChairID, WORD wSubCmdId, void* pData, WORD wSize)
{
	//获取用户
	//char* pNewData = new char[wSize + sizeof(GameRecordPacket)];
	//memcpy(pNewData, pData, wSize);				//修改BYJN 疑似内存溢出
	GameRecordPacket record;
	record.wSize = wSize;
	record.wChairID = wChairID;
	record.wSubCmdID = wSubCmdId;
	record.wMainCmdID = MDM_GF_GAME;
	record.pData = new char[wSize];
	CopyMemory(record.pData, pData, wSize);

	m_UserReplayRecord.push_back(record);
	return true;
}

//游戏开始
bool TableFrameSinkZhiPai::OnEventGameStart()
{
	//椅子数量
	WORD wChairCount = m_pITableFrame->GetChairCount();

	//开始记录回放数据
	RepayRecordStart();
	//重置发牌状态
	m_isCanOutCard = false;
	//重置掉线玩家列表
	m_offlineUsers.clear();
	//设置状态
	m_pITableFrame->SetGameStatus(GS_MJ_PLAY);

	m_gameConfig.wHadPlayCount++;
	if (1 == m_gameConfig.wHadPlayCount || m_wNextBankerUser == INVALID_CHAIR)
	{
		m_wBankerUser = 0;
	}
	else
	{
		m_wBankerUser = m_wNextBankerUser;
	}
	m_wNextBankerUser = INVALID_CHAIR;

	//分发扑克
	switch (bGameType)
	{
	case huapai:
	{
		m_cbLeftCardCount = m_GameLogic.RandCardData(m_cbRepertoryCard_Two, bGameType);
		BYTE byTest[112] = { 0 };
		if (m_GameLogic.PeiPai(byTest, MAX_REPERTORY_HUA_TWO))
			CopyMemory(m_cbRepertoryCard_Two, byTest, sizeof(byTest));
		for (WORD i = 0; i < GAME_PLAY; i++)
		{
			m_bPlayStatus[i] = true;
			m_cbLeftCardCount -= (MAX_COUNT_HUA - 1);//每一个玩家都发出去25张牌，还剩多少
			m_cbSendCardCount += (MAX_COUNT_HUA - 1);//每个玩家加25张牌
			m_GameLogic.SwitchToCardIndex(&m_cbRepertoryCard_Two[m_cbLeftCardCount], MAX_COUNT_HUA - 1, m_cbCardIndex[i]);
			//从牌数据数组中得到花牌个数
			m_GameLogic.GetHuaCard(&m_cbRepertoryCard_Two[m_cbLeftCardCount], MAX_COUNT_HUA - 1, m_cbHuaCardIndex[i]);
		}
		//发送扑克,庄家摸牌
		m_cbSendCardCount++;
		m_cbSendCardData = m_cbRepertoryCard_Two[--m_cbLeftCardCount];
		break;
	}
	case huapai2:
	{
		m_cbLeftCardCount = m_GameLogic.RandCardData(m_cbRepertoryCard_One, bGameType);
		BYTE byTest[111] = { 0 };
		if (m_GameLogic.PeiPai(byTest, MAX_REPERTORY_HUA_ONE))
			CopyMemory(m_cbRepertoryCard_One, byTest, sizeof(byTest));
		for (WORD i = 0; i < GAME_PLAY; i++)
		{
			m_bPlayStatus[i] = true;
			m_cbLeftCardCount -= (MAX_COUNT_HUA - 1);//每一个玩家都发出去25张牌，还剩多少
			m_cbSendCardCount += (MAX_COUNT_HUA - 1);//每个玩家加25张牌
			m_GameLogic.SwitchToCardIndex(&m_cbRepertoryCard_One[m_cbLeftCardCount], MAX_COUNT_HUA - 1, m_cbCardIndex[i]);
			//从牌数据数组中得到花牌个数
			m_GameLogic.GetHuaCard(&m_cbRepertoryCard_One[m_cbLeftCardCount], MAX_COUNT_HUA - 1, m_cbHuaCardIndex[i]);
		}
		//发送扑克,庄家摸牌
		m_cbSendCardCount++;
		m_cbSendCardData = m_cbRepertoryCard_One[--m_cbLeftCardCount];
		break;
	}
	case huapai3:
	{
		m_cbLeftCardCount = m_GameLogic.RandCardData(m_cbRepertoryCard, bGameType);
		BYTE byTest[110] = { 0 };
		if (m_GameLogic.PeiPai(byTest, MAX_REPERTORY_HUA))
			CopyMemory(m_cbRepertoryCard, byTest, sizeof(byTest));
		for (WORD i = 0; i < GAME_PLAY; i++)
		{
			m_bPlayStatus[i] = true;
			m_cbLeftCardCount -= (MAX_COUNT_HUA - 1);//每一个玩家都发出去25张牌，还剩多少
			m_cbSendCardCount += (MAX_COUNT_HUA - 1);//每个玩家加25张牌
			m_GameLogic.SwitchToCardIndex(&m_cbRepertoryCard[m_cbLeftCardCount], MAX_COUNT_HUA - 1, m_cbCardIndex[i]);
			//从牌数据数组中得到花牌个数
			m_GameLogic.GetHuaCard(&m_cbRepertoryCard[m_cbLeftCardCount], MAX_COUNT_HUA - 1, m_cbHuaCardIndex[i]);
		}
		//发送扑克,庄家摸牌
		m_cbSendCardCount++;
		m_cbSendCardData = m_cbRepertoryCard[--m_cbLeftCardCount];
		break;
	}
	default:
		return false;
		break;
	}
	BYTE TempIndex = m_GameLogic.SwitchToCardIndex(m_cbSendCardData);
	m_cbCardIndex[m_wBankerUser][TempIndex]++;//加入手牌
	//如果庄家牌是花牌,保存到庄家花牌索引数组中
	if ((m_cbSendCardData & 0x10) == 0x10)
	{
		m_cbHuaCardIndex[m_wBankerUser][TempIndex / 2]++;
		ASSERT(m_cbHuaCardIndex[m_wBankerUser][TempIndex / 2] <= 2);
	}
	////分析三家的统，泛牌情况
	BYTE ActionCard[GAME_PLAY][6] = { 0 };
	tagGangCardResult_Hua GangCardResult[GAME_PLAY];
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	WORD TempShangJia = ((m_wBankerUser + 2) % GAME_PLAY);
	for (WORD i = 0; i < GAME_PLAY; i++)
	{
		b_QingTong[TempShangJia] = true;
		m_cbUserAction[TempShangJia] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[TempShangJia], m_cbHuaCardIndex[TempShangJia], NULL, 0, GangCardResult[TempShangJia]);
		for (BYTE j = 0; j < GangCardResult[TempShangJia].cbCardCount; j++)
		{
			ActionCard[TempShangJia][j] = GangCardResult[TempShangJia].cbCardData[j];
			b_QingTong[TempShangJia] = false;
		}
		if (b_QingTong[TempShangJia] == false)
		{
			break;
		}
		if (TempShangJia == 0)
		{
			TempShangJia = 2;
		}
		else
		{
			TempShangJia--;
		}
	}
	//设置变量
	m_wProvideUser = m_wBankerUser;
	m_wCurrentUser = m_wBankerUser;

	m_cbProvideCard = m_cbSendCardData;
	m_wResumeUser = m_wCurrentUser;

	//构造数据
	CMD_S_GameStart_Hua GameStart;
	ZeroMemory(&GameStart, sizeof(GameStart));
	GameStart.wBankerUser = m_wBankerUser;
	GameStart.cbLeftCardCount = m_cbLeftCardCount;
	GameStart.cbTotalCardCount = bGameType == huapai3 ? MAX_REPERTORY_HUA : (bGameType == huapai2 ? MAX_REPERTORY_HUA_ONE : MAX_REPERTORY_HUA_TWO);
	GameStart.cbCurrPlay = m_gameConfig.wHadPlayCount;
	GameStart.cbOptTime = GAME_TIMEOUT;

	bool bAllHuanSanZhang = true;
	for (bool bSend : b_QingTong)
	{
		if (0 == bSend)
		{
			bAllHuanSanZhang = false;
			break;
		}
	}

	if (bAllHuanSanZhang || TempShangJia == m_wBankerUser)//起牌所有人都没有统，庄家可以出牌了，且庄家判断胡牌
	{
		//庄家可以出牌了
		m_cbUserAction[m_wBankerUser] |= WIK_BH_WJCP;
		// 胡牌判断
		tagHuCardResult chr;	
		m_cbUserAction[m_wBankerUser] |= m_GameLogic.AnalyseHuCard(m_cbCardIndex[m_wBankerUser], m_cbHuaCardIndex[m_wBankerUser], 0, NULL, 0, m_cbHuaWeaveCardIndex[m_wBankerUser], 0, chr);
	}
	else
	{
		m_wCurrentUser = TempShangJia;
		if (TempShangJia == m_wBankerUser)
		{
			m_cbUserAction[m_wBankerUser] |= WIK_BH_WJCP;
		}
	}

	//发送数据
	for (WORD i = 0; i < GAME_PLAY; i++)
	{
		//设置变量
		GameStart.wCurrentUser = i;
		GameStart.cbUserAction = m_cbUserAction[i];
		CopyMemory(GameStart.ActionCard, ActionCard[i], sizeof(ActionCard[i]));
		GetPaiQiang(i, m_cbGamePlayerHandCard[i]);
		ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));
		CopyMemory(GameStart.cbCardData, m_cbGamePlayerHandCard[i], sizeof(m_cbGamePlayerHandCard[i]));
		//发送数据
		m_pITableFrame->SendTableData(i, SUB_S_GAME_START_HUA, &GameStart, sizeof(GameStart));
	}
	//用户回放
	ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));
	//清手牌 旁观只能发一次
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_START_HUA, &GameStart, sizeof(GameStart));
	//记录回放
	for (BYTE i = 0; i < GAME_PLAY; i++)
	{
		m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameStart.cbCardData[i * 3], m_cbHuaCardIndex[i]);	
	}	
	RepayRecord(INVALID_CHAIR, SUB_S_GAME_START_HUA, &GameStart, sizeof(GameStart));

	if (!bAllHuanSanZhang)
	{
		CMD_S_QingTongNotify QingTong;
		ZeroMemory(&QingTong, sizeof(QingTong));
		QingTong.OperatorUser = TempShangJia;
		QingTong.cbActionMask = m_cbUserAction[TempShangJia];
		CopyMemory(QingTong.cbActionCard, ActionCard[TempShangJia], sizeof(ActionCard[TempShangJia]));

		//发送数据
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
	}
	return true;
}

void TableFrameSinkZhiPai::DeletePrivateTable(bool bSendState)
{
	tagScoreInfo ScoreInfoArray[GAME_PLAY];
	ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));

	WORD wChairCount = m_pITableFrame->GetChairCount();
	for (int i = 0; i < wChairCount; ++i)
	{
		IServerUserItem *pIUserItem = m_pITableFrame->GetTableUserItem(i);
		if (pIUserItem == NULL)
			continue;
		ScoreInfoArray[i].cbType = SCORE_TYPE_END;
		ScoreInfoArray[i].lScore = m_lUserTmpScore[i] - TEMP_MAX_SCORE;			//记录临时分
	}
	m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray));

	ConcludeGame(GAME_STATUS_DELETE, bSendState);
	m_pITableFrame->DeletePrivateTableNow();
}

//游戏结束
bool TableFrameSinkZhiPai::OnEventGameConclude(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason, bool bSendState)
{
	bool bFinish = (m_gameConfig.wHadPlayCount >= m_gameConfig.wPlayCountRule) ? 1 : 0;
	bool bDelete = false;
	switch (cbReason)
	{
	case GER_DELETE_PRIVATE:
		bFinish = 1;
		bDelete = true;
		if (!m_pITableFrame->IsGameStarted())
		{
			DeletePrivateTable(bSendState);
			return true;
		}
		//return true;
		//下坠
	case GER_NORMAL:		//常规结束
	{
		CMD_S_GameEnd_Hua GameEnd;
		ZeroMemory(&GameEnd, sizeof(GameEnd));
		GameEnd.bFinish = bFinish;//1……
		GameEnd.bWanJiaId = wChairID;
		if (m_cbLeftCardCount == 0 || bDelete)//荒庄了或者海底捞月,怎么定义荒庄，
		{
			if (!bDelete)
			{
				GameEnd.bOptType = (bIsHuang == true ? 2 : 1);//庄荒了，需要返回信息
			}
			else
				GameEnd.bOptType = 3;

			if (GameEnd.bOptType == 1)
			{	
				int TempDiScore = m_gameConfig.GameScoreType == 0 ? ((((ChiHu.bHuPoint - 17) / 5) + 2)*m_gameConfig.wDiScore) : (ChiHu.bHuPoint*m_gameConfig.wDiScore);
				GameEnd.HuShu = ChiHu.bHuPoint;
				GameEnd.ZhuGold = m_GameLogic.SwitchToCardData(ChiHu.bRealGold);
				BYTE TempWanJiaCardCount = 0;
				m_wNextBankerUser = wChairID;
				if (m_wProvideUser == wChairID)//自摸海底捞月
				{
					for (BYTE i = 0; i < GAME_PLAY; i++)
					{
						if (i == wChairID)continue;
						GameEnd.cbBianDongScore[i] = -TempDiScore;
						m_lGameScore[i] += GameEnd.cbBianDongScore[i];
						m_lGameTatolScore[i] += GameEnd.cbBianDongScore[i];
					}
					GameEnd.cbBianDongScore[wChairID] = 2 * TempDiScore;
					m_lGameScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
					m_lGameTatolScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
				}
				else//海底炮
				{
					GameEnd.bHuPaiCard = m_cbProvideCard;
					int TempScore = 0;
					for (BYTE i = 0; i < GAME_PLAY; i++)
					{
						if (i == wChairID)continue;
						if (i == m_wProvideUser)
						{
							GameEnd.cbBianDongScore[i] = - TempDiScore;
							m_lGameScore[i] += GameEnd.cbBianDongScore[i];
							m_lGameTatolScore[i] += GameEnd.cbBianDongScore[i];							
						}
						else
						{
							GameEnd.cbBianDongScore[i] = (m_gameConfig.GameScoreType == 0 ? (-(TempDiScore - m_gameConfig.wDiScore)) : 0);
							m_lGameTatolScore[i] += GameEnd.cbBianDongScore[i];
							m_lGameScore[i] += GameEnd.cbBianDongScore[i];
						}
						TempScore -= GameEnd.cbBianDongScore[i];
					}
					GameEnd.cbBianDongScore[wChairID] = TempScore;
					m_lGameScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
					m_lGameTatolScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
					m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
					if ((m_cbProvideCard & 0x10) == 0x10)
					{
						m_cbHuaCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard) / 2]++;
						ASSERT(m_cbHuaCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard) / 2] <= 2);
					}
				}												
				for (WORD i = 0; i < GAME_PLAY; i++)
				{
					GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分3…………
					if (i == wChairID && m_wProvideUser == wChairID)continue;
					m_GameLogic.HeBingCardIndex(m_cbCardIndex[i], m_cbCardIndex_Tong[i], m_cbHuaCardIndex[i], m_cbHuaCardIndex_Tong[i]);
					GetGameEndCardIndex(i, GameEnd.cbCardIndex[i]);
					//m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i], m_cbHuaCardIndex[i]);
				}
				if (m_wProvideUser == wChairID)
				{
					m_GameLogic.HeBingCardIndex(m_cbCardIndex[wChairID], m_cbCardIndex_Tong[wChairID], m_cbHuaCardIndex[wChairID], m_cbHuaCardIndex_Tong[wChairID]);
					GetGameEndCardIndex(wChairID, GameEnd.cbCardIndex[wChairID]);
				}				
				GetGameEndPaiQiang(wChairID, GameEnd.YingJiaCard);
			}
			else
			{
				m_wNextBankerUser = (m_wBankerUser + 1) % GAME_PLAY;
				//if (wChairID == INVALID_CHAIR)
				//	m_wNextBankerUser = m_wProvideUser;
				//黄庄了
				//统计玩家积分,牌值
				for (WORD i = 0; i < GAME_PLAY; i++)
				{
					GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分4…………
					m_GameLogic.HeBingCardIndex(m_cbCardIndex[i], m_cbCardIndex_Tong[i], m_cbHuaCardIndex[i], m_cbHuaCardIndex_Tong[i]);
					GetGameEndCardIndex(i, GameEnd.cbCardIndex[i]);
				}
			}
		}
		else   //正常胡牌
		{
			GameEnd.bOptType = 1;
			BYTE TempWanJiaCardCount = 0;
			m_wNextBankerUser = wChairID;
			int TempDiScore = (m_gameConfig.GameScoreType == 0 ? ((((ChiHu.bHuPoint - 17) / 5) + 2)*m_gameConfig.wDiScore) : (ChiHu.bHuPoint*m_gameConfig.wDiScore));
			//int TempDiScore = (((ChiHu.bHuPoint - 17) / 5) + 2)*m_gameConfig.wDiScore;			
			GameEnd.HuShu = ChiHu.bHuPoint;
			GameEnd.ZhuGold = m_GameLogic.SwitchToCardData(ChiHu.bRealGold);
			if (m_wProvideUser == wChairID)//自摸
			{
				for (BYTE i = 0; i < GAME_PLAY; i++)
				{
					if (i == wChairID)continue;
					GameEnd.cbBianDongScore[i] = -TempDiScore;
					m_lGameScore[i] += GameEnd.cbBianDongScore[i];
					m_lGameTatolScore[i] += GameEnd.cbBianDongScore[i];
				}
				GameEnd.cbBianDongScore[wChairID] = 2 * TempDiScore;
				m_lGameScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
				m_lGameTatolScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
			}
			else//炮
			{
				GameEnd.bHuPaiCard = m_cbProvideCard;
				int TempScore = 0;
				for (BYTE i = 0; i < GAME_PLAY; i++)
				{
					if (i == wChairID)continue;
					if (i == m_wProvideUser)
					{
						GameEnd.cbBianDongScore[i] = - TempDiScore;
						m_lGameScore[i] += GameEnd.cbBianDongScore[i];
						m_lGameTatolScore[i] += GameEnd.cbBianDongScore[i];

					}
					else
					{
						GameEnd.cbBianDongScore[i] = (m_gameConfig.GameScoreType == 0 ? (-(TempDiScore - m_gameConfig.wDiScore)) : 0); //-(TempDiScore - m_gameConfig.wDiScore);
						m_lGameTatolScore[i] += GameEnd.cbBianDongScore[i];
						m_lGameScore[i] += GameEnd.cbBianDongScore[i];
					}
					TempScore -= GameEnd.cbBianDongScore[i];
				}
				GameEnd.cbBianDongScore[wChairID] = TempScore;
				m_lGameScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
				m_lGameTatolScore[wChairID] += GameEnd.cbBianDongScore[wChairID];
				m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
				if ((m_cbProvideCard & 0x10) == 0x10)
				{
					m_cbHuaCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard) / 2]++;
					ASSERT(m_cbHuaCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard) / 2] <= 2);
				}
			}
			//积分总变动
			for (BYTE i = 0; i < GAME_PLAY; i++)
			{
				GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分3…………
				if (i == wChairID && m_wProvideUser == wChairID)continue;
				m_GameLogic.HeBingCardIndex(m_cbCardIndex[i], m_cbCardIndex_Tong[i], m_cbHuaCardIndex[i], m_cbHuaCardIndex_Tong[i]);
				GetGameEndCardIndex(i, GameEnd.cbCardIndex[i]);
			}
			if (m_wProvideUser == wChairID)
			{
				m_GameLogic.HeBingCardIndex(m_cbCardIndex[wChairID], m_cbCardIndex_Tong[wChairID], m_cbHuaCardIndex[wChairID], m_cbHuaCardIndex_Tong[wChairID]);
				GetGameEndCardIndex(wChairID, GameEnd.cbCardIndex[wChairID]);
			}
			GetGameEndPaiQiang( wChairID, GameEnd.YingJiaCard);
		}
		CopyMemory(GameEnd.bZimo, m_HuPai, sizeof(m_HuPai));//玩家胡牌次数
		GameEnd.bLeftCardCount = m_cbLeftCardCount;//剩余牌输量
		switch (bGameType)
		{
		case huapai:
		{
			CopyMemory(GameEnd.bLeftCardDada, m_cbRepertoryCard_Two, m_cbLeftCardCount);//剩余牌值
			break;
		}
		case huapai2:
		{
			CopyMemory(GameEnd.bLeftCardDada, m_cbRepertoryCard_One, m_cbLeftCardCount);//剩余牌值
			break;
		}
		case huapai3:
		{
			CopyMemory(GameEnd.bLeftCardDada, m_cbRepertoryCard, m_cbLeftCardCount);//剩余牌值
			break;
		}
		default:
			ASSERT(false);
			break;
		}
		
		GameEnd.playGameNum = m_gameConfig.wHadPlayCount;//得到第几局了，
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			m_HuPaiLiuShui[(m_gameConfig.wHadPlayCount - 1) * 3 + i] = m_lGameScore[i];
		}
		CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));//游戏流水，10…………
		//数据处理
		int iSendLen = 0;
		CMD_S_GameEnd_Hua GameEndBuffer;
		BYTE *pOutData = (BYTE *)&GameEndBuffer;
		BYTE *pInData = (BYTE *)&GameEnd;
		ZeroMemory(&GameEndBuffer, sizeof(GameEndBuffer));
		CopyMemory(pOutData, &GameEnd, 164);
		iSendLen = iSendLen + 164;
		pInData = pInData + 164;
		pOutData = pOutData + 164;
		BYTE *pData = (BYTE *)&GameEnd;
		BYTE bNum = GameEnd.bLeftCardCount;
		CopyMemory(pOutData, pInData, bNum);
		iSendLen = iSendLen + bNum;
		pOutData = pOutData + bNum;
		pInData = pInData + CountArray(GameEnd.bLeftCardDada);
		bNum = GameEnd.playGameNum;
		pOutData[0] = bNum;
		pInData++;
		pOutData++;
		iSendLen = iSendLen + bNum * 4 * GAME_PLAY + 1;
		CopyMemory(pOutData, pInData, bNum * 4 * GAME_PLAY);
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END_HUA, &GameEndBuffer, iSendLen);
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END_HUA, &GameEndBuffer, iSendLen);
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			GameEndBuffer.cbWanJiaScore[i] = m_lGameScore[i];
		}
		RepayRecord(INVALID_CHAIR, SUB_S_GAME_END_HUA, &GameEndBuffer, iSendLen);

		//发送结束信息		

		tagScoreInfo ScoreInfoArray[GAME_PLAY];
		ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));
		for (WORD i = 0; i < GAME_PLAY; i++)
		{
			IServerUserItem *pUserItem = m_pITableFrame->GetTableUserItem(i);
			if (NULL == pUserItem) continue;

			BYTE ScoreKind;
			if (m_lGameScore[i] > 0L) ScoreKind = SCORE_TYPE_WIN;
			else if (m_lGameScore[i] < 0L) ScoreKind = SCORE_TYPE_LOSE;
			else ScoreKind = SCORE_TYPE_DRAW;

			ScoreInfoArray[i].lScore = m_lGameScore[i];
			ScoreInfoArray[i].cbType = ScoreKind;
		}
		m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray));
		ConcludeGame(GS_MJ_FREE);
		if (!bDelete)
		{
			if (bFinish)
			{
				DeletePrivateTable(true);
			}
		}
		else
		{
			if (bFinish)
			{
				DeletePrivateTable(bSendState);
			}
		}
		return true;
	}
	case GER_DISMISS:		//游戏解散
		{
			//变量定义
			CMD_S_GameEnd_Hua GameEnd;
			ZeroMemory(&GameEnd, sizeof(GameEnd));
			GameEnd.bFinish = 1;
			GameEnd.bOptType = 3;
			CopyMemory(GameEnd.bZimo, m_HuPai, sizeof(m_HuPai));
			CopyMemory(GameEnd.cbWanJiaScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));
			//GameEnd.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();
			GameEnd.playGameNum = m_gameConfig.wHadPlayCount;
			CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));

			RepayRecord(INVALID_CHAIR, SUB_S_GAME_END_HUA, &GameEnd, sizeof(GameEnd));
			//发送信息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END_HUA, &GameEnd, sizeof(GameEnd));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END_HUA, &GameEnd, sizeof(GameEnd));

			ConcludeGame(GS_MJ_FREE);
			return true;
		}
	case GER_NETWORK_ERROR:		//网络错误
	case GER_USER_LEAVE:		//用户强退
		{
			DWORD dwUserID = pIServerUserItem->GetUserID();
			m_offlineUsers.push_back(dwUserID);
			return true;
		}
	}

	//错误断言
	ASSERT(FALSE);
	return false;
}

//发送场景duanxian
bool TableFrameSinkZhiPai::OnEventSendGameScene(WORD wChiarID, IServerUserItem * pIServerUserItem, BYTE cbGameStatus, bool bSendSecret)
{
	if (wChiarID > 2)return false;
	switch (cbGameStatus)
	{
	case GS_MJ_FREE:	//空闲状态
	{
		//变量定义
		CMD_S_StatusFree StatusFree;
		memset(&StatusFree, 0, sizeof(StatusFree));

		//游戏房主基础配置
		CopyMemory(&StatusFree.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));

		for (int i = 0; i < GAME_PLAY; i++)
		{
			StatusFree.lUserTmpScore[i] = (INT)m_lGameTatolScore[i];
		}

		StatusFree.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;
		//构造数据
		StatusFree.UserStat = pIServerUserItem->GetUserInfo()->cbUserStatus;

		//发送场景
		return m_pITableFrame->SendGameScene(pIServerUserItem, &StatusFree, sizeof(StatusFree));
	}
	case GS_MJ_PLAY:	//游戏状态
	{
		//变量定义
		CMD_S_StatusPlay_Hua StatusPlay;
		memset(&StatusPlay, 0, sizeof(StatusPlay));

		//游戏房主基础配置
		CopyMemory(&StatusPlay.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));
		CopyMemory(StatusPlay.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));
		switch (bGameType)
		{
		case(huapai) :
		{
			StatusPlay.cbTotalCardCount = MAX_REPERTORY_HUA_TWO;
			break;
		}
		case(huapai2) :
		{
			StatusPlay.cbTotalCardCount = MAX_REPERTORY_HUA_ONE;
			break;
		}
		case(huapai3) :
		{
			StatusPlay.cbTotalCardCount = MAX_REPERTORY_HUA;
			break;
		}
		default:break;
		}

		StatusPlay.cbLeftCardCount = m_cbLeftCardCount;
		StatusPlay.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;

		//游戏变量
		StatusPlay.wBankerUser = m_wBankerUser;
		CopyMemory(StatusPlay.cbDiscardCard, m_cbDiscardCard, sizeof(StatusPlay.cbDiscardCard));
		CopyMemory(StatusPlay.cbDiscardCount, m_cbDiscardCount, sizeof(StatusPlay.cbDiscardCount));
		CopyMemory(StatusPlay.GameScore, m_cbOperateScore, sizeof(m_cbOperateScore));
		StatusPlay.totalOptTime = 10;
		StatusPlay.leftOptTime = 0;
		//组合扑克
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			StatusPlay.lSiZi[i] = m_cbTongCount[i];
			if (i == wChiarID)
			{
				CopyMemory(StatusPlay.WeaveItemArray[i], m_WeaveItemArray[i], sizeof(m_WeaveItemArray[i]));
				StatusPlay.cbWeaveCount[i] = m_cbWeaveItemCount[i];
			}
			else
			{
				CopyMemory(StatusPlay.WeaveItemArray[i], m_WeaveItemArray_HuPai[i], sizeof(m_WeaveItemArray_HuPai[i]));
				StatusPlay.cbWeaveCount[i] = m_cbWeaveItemCount_HuPai[i];
			}
		}
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			StatusPlay.cbCardCount[i] = m_GameLogic.GetCardCount(m_cbCardIndex[i]);
		}
		if (IsEqual(wChiarID))//手牌数据
		{
			CopyMemory(StatusPlay.cbCardData, m_cbGamePlayerHandCard[wChiarID], sizeof(m_cbGamePlayerHandCard[wChiarID]));
		}
		else
		{
			if (GetPaiQiang(wChiarID, StatusPlay.cbCardData))
				CopyMemory(m_cbGamePlayerHandCard[wChiarID], StatusPlay.cbCardData, sizeof(StatusPlay.cbCardData));
			else
				CopyMemory(StatusPlay.cbCardData, m_cbGamePlayerHandCard[wChiarID], sizeof(m_cbGamePlayerHandCard[wChiarID]));
		}		
		StatusPlay.cbActionMask = m_cbUserAction[wChiarID];		//需要用到操作码
		if (StatusPlay.cbActionMask&(WIK_ZI_MO | WIK_CHI_HU))
		{
			StatusPlay.HuShu = EsponseHuShu[wChiarID];
			StatusPlay.PaPoShu = EsponsePaPoShu[wChiarID];
		}
		if (m_cbUserAction[wChiarID])
		{
			tagGangCardResult_Hua GangCardResult;
			ZeroMemory(&GangCardResult, sizeof(GangCardResult));
			m_GameLogic.AnalyseGangCard(m_cbCardIndex[wChiarID], m_cbHuaCardIndex[wChiarID], m_WeaveItemArray[wChiarID], m_cbWeaveItemCount[wChiarID], GangCardResult);
			for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
			{
				StatusPlay.gangCards[i] = GangCardResult.cbCardData[i];
			}
		}

		//当前到谁家
		StatusPlay.wCurrentUser = (m_wCurrentUser == INVALID_CHAIR ? m_wProvideUser : m_wCurrentUser);
		BYTE OldUser = INVALID_CHAIR;//定义一个最后出牌用户
		if (m_cbOutCardCount == 0 && m_wCurrentUser != m_wProvideUser)
		{
			//发送场景
			if (m_wCurrentUser == wChiarID&&wChiarID == m_wBankerUser)
			{
				StatusPlay.cbActionMask |= WIK_BH_WJCP;
			}
			return m_pITableFrame->SendGameScene(pIServerUserItem, &StatusPlay, sizeof(StatusPlay));
		}
		if (m_cbOutCardCount == 0 && m_wCurrentUser == m_wProvideUser)
		{
			if (m_wCurrentUser == wChiarID && wChiarID == m_wBankerUser && m_cbUserAction[wChiarID] == WIK_NULL)
			{
				StatusPlay.cbActionMask |= WIK_BH_WJCP;
			}			
			//发送场景
			return m_pITableFrame->SendGameScene(pIServerUserItem, &StatusPlay, sizeof(StatusPlay));
		}
		else
		{
			if (m_wProvideUser == m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR)//牌权是摸牌得且没出牌
			{
				if (m_wProvideUser == 0)
				{
					OldUser = 2;
				}
				else
					OldUser = m_wProvideUser - 1;
				BYTE TempIndex = 0;
				for (BYTE i = 0; i < 15; i++)
				{
					if (m_cbDiscardCard[OldUser][i] == 0)
					{
						TempIndex = i - 1;
						break;
					}
				}
				if (TempIndex >= 15)TempIndex = 0;
				StatusPlay.bPutCardData[OldUser] = m_cbDiscardCard[OldUser][TempIndex];
			}
			if (m_wProvideUser == m_wOutCardUser && m_wCurrentUser == INVALID_CHAIR)//当有人可以碰且没有碰时候
			{
				StatusPlay.bPutCardData[m_wProvideUser] = m_cbProvideCard;
				StatusPlay.cbDiscardCard[m_wProvideUser][StatusPlay.cbDiscardCount[m_wProvideUser]++] = m_cbProvideCard;
			}
			if (wChiarID == StatusPlay.wCurrentUser&&m_wCurrentUser != INVALID_CHAIR&&m_wCurrentUser != m_wProvideUser)//表示当前牌权就在断线玩家手里，且是轮到他出牌（牌权碰来得）
			{
				StatusPlay.cbActionMask |= WIK_BH_WJCP;
			}
			if (wChiarID == StatusPlay.wCurrentUser && m_wCurrentUser != INVALID_CHAIR && m_wCurrentUser == m_wProvideUser)//牌权是轮到他抓牌，未打出
			{
				StatusPlay.cbActionMask |= WIK_BH_WJCP;
				//ZeroMemory(StatusPlay.cbCardData, sizeof(StatusPlay.cbCardData));
				//BYTE TempCardData[MAX_INDEX_HUA];
				//BYTE TempCardHuaData[5];
				//CopyMemory(TempCardData, m_cbCardIndex[wChiarID], sizeof(TempCardData));
				//CopyMemory(TempCardHuaData, m_cbHuaCardIndex[wChiarID], sizeof(TempCardHuaData));
				//BYTE TempCardIndex = m_GameLogic.SwitchToCardIndex(m_cbProvideCard);				
				//if (m_cbCardIndex[wChiarID][TempCardIndex] == 0)
				//{
				//	ASSERT(false);
				//	return false;
				//}
				//if ((m_cbProvideCard & 0x10) == 0x10)
				//{
				//	if (m_cbHuaCardIndex[wChiarID][TempCardIndex / 2] == 0)
				//	{
				//		ASSERT(false);
				//		return false;
				//	}
				//	TempCardHuaData[TempCardIndex / 2]--;
				//}
				//TempCardData[TempCardIndex]--;
				//BYTE cardNum = m_GameLogic.SwitchToCardData(TempCardData, StatusPlay.cbCardData, TempCardHuaData);
				//StatusPlay.cbCardData[cardNum] = m_cbProvideCard;//处理得到最后一张牌数据放最后
			}
			//发送场景
			return m_pITableFrame->SendGameScene(pIServerUserItem, &StatusPlay, sizeof(StatusPlay));
		}
	}
	default:return false;
	}
	return false;
}

//定时器事件
bool TableFrameSinkZhiPai::OnTimerMessage(DWORD wTimerID, WPARAM wBindParam)
{
	return false;
}

//游戏消息处理
void TableFrameSinkZhiPai::SetGameConfig(VOID * pDataBuffer, WORD wDataSize, std::wstring sPrivateRoomId)
{
	tagGameConfig* ppConfig = (tagGameConfig*)pDataBuffer;
	m_gameConfig.wSubGameID = ppConfig->wSubGameID;
	m_gameConfig.wDiScore = ppConfig->wPlayRule;
	m_gameConfig.wFanFei = ppConfig->wMaxFanRule;
	m_gameConfig.wIpLimit = ppConfig->wMaxScore;
	m_gameConfig.wPlayCountRule = ppConfig->wPlayCountRule;
	m_gameConfig.RoomId = ppConfig->wHadPlayCount;
	m_gameConfig.wHadPlayCount = 0;
	lstrcpy(m_gameConfig.sPrivateTableID, sPrivateRoomId.c_str());
	bGameType = m_gameConfig.wSubGameID;
	m_gameConfig.GameScoreType = ppConfig->bDuoLai;
	m_pITableFrame->SetChairCount(GAME_PLAY);
	ASSERT(m_gameConfig.wSubGameID >= 0 && m_gameConfig.wSubGameID < MahJongType::count);
}

//游戏消息处理
bool TableFrameSinkZhiPai::OnGameMessage(WORD wSubCmdID, VOID* pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)
{
	switch (wSubCmdID)
	{
	case SUB_C_OUT_CARD_HUA:		//出牌消息
	{
		//效验消息
		/*ASSERT(wDataSize == sizeof(CMD_C_OutCard));
		if (wDataSize != sizeof(CMD_C_OutCard)) return false;*/

		//用户效验
		if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;

		//消息处理
		CMD_C_OutCard_Hua * pOutCard = (CMD_C_OutCard_Hua *)pDataBuffer;
		return OnUserOutCard(pIServerUserItem->GetChairID(), pOutCard->cbCardData, pOutCard->cbCardWeiZhi);
	}
	case SUB_C_OPERATE_CARD_HUA:	//操作消息
	{
		//效验消息
		ASSERT(wDataSize == sizeof(CMD_C_OperateCard_Hua));
		if (wDataSize != sizeof(CMD_C_OperateCard_Hua)) return false;

		//用户效验
		if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;

		//消息处理
		CMD_C_OperateCard_Hua * pOperateCard = (CMD_C_OperateCard_Hua *)pDataBuffer;
		return OnUserOperateCard(pIServerUserItem->GetChairID(), pOperateCard->cbOperateCode, pOperateCard->cbOperateCard, pOperateCard->cbHuaCard);
	}
	case SUB_C_TRUSTEE_HUA:  //托管
	{
		CMD_C_Trustee *pTrustee = (CMD_C_Trustee *)pDataBuffer;
		if (wDataSize != sizeof(CMD_C_Trustee)) return false;


		m_bTrustee[pIServerUserItem->GetChairID()] = pTrustee->bTrustee;
		CMD_S_Trustee Trustee;
		Trustee.bTrustee = pTrustee->bTrustee;
		Trustee.wChairID = pIServerUserItem->GetChairID();

		RepayRecord(INVALID_CHAIR, SUB_S_TRUSTEE, &Trustee, sizeof(Trustee));
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_TRUSTEE, &Trustee, sizeof(Trustee));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_TRUSTEE, &Trustee, sizeof(Trustee));

		return true;
	}	
	case SUB_C_YIWEI_HUA: //玩家手牌移位操作
	{
		//效验消息
		ASSERT(wDataSize == sizeof(CMD_C_YIWEI_HUA));
		if (wDataSize != sizeof(CMD_C_YIWEI_HUA)) return false;
		WORD wChairID = pIServerUserItem->GetChairID();
		if (wChairID > 3)return false;
		CMD_C_YIWEI_HUA * pYiWei = (CMD_C_YIWEI_HUA *)pDataBuffer;
		BYTE TempStartIndex = 0xFF;
		BYTE TempEndIndex = 0xFF;
		if (!m_GameLogic.IsValidCard(pYiWei->cbOperateCard))
		{
			CMD_S_YIWEI_HUA YIWEI;
			YIWEI.bFlag = 2;
			YIWEI.StarIpOne = pYiWei->cbStartIp;
			YIWEI.StarIpTwo = TempStartIndex;
			YIWEI.EndIpOne = pYiWei->cbEndIp;
			YIWEI.EndIpTwo = TempEndIndex;
			YIWEI.CardData = pYiWei->cbOperateCard;
			m_pITableFrame->SendTableData(wChairID, SUB_S_YI_WEI_HUA, &YIWEI, sizeof(YIWEI));
			ASSERT(false);
			return false;
		}
		for (BYTE i = 0; i < 9; i++)
		{
			if (m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][i] == pYiWei->cbOperateCard)
			{
				if (i == 8)
				{
					m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][i] = 0;
				}
				else
				{
					for (BYTE j = i; j < 8; j++)
					{						
						m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][j] = m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][j + 1];
						if (m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][8] != 0 && j == 7)
						{
							m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][8] = 0;
						}
					}
				}				
				TempStartIndex = i;
				break;
			}
		}
		if (TempStartIndex == 0xFF)
		{
			CMD_S_YIWEI_HUA YIWEI;
			YIWEI.bFlag = 3;
			YIWEI.StarIpOne = pYiWei->cbStartIp;
			YIWEI.StarIpTwo = TempStartIndex;
			YIWEI.EndIpOne = pYiWei->cbEndIp;
			YIWEI.EndIpTwo = TempEndIndex;
			YIWEI.CardData = pYiWei->cbOperateCard;
			m_pITableFrame->SendTableData(wChairID, SUB_S_YI_WEI_HUA, &YIWEI, sizeof(YIWEI));
			ASSERT(false);
			return false;
		}
		for (BYTE i = 0; i < 9; i++)
		{
			if (m_cbGamePlayerHandCard[wChairID][pYiWei->cbEndIp][i] == 0)
			{
				m_cbGamePlayerHandCard[wChairID][pYiWei->cbEndIp][i] = pYiWei->cbOperateCard;
				TempEndIndex = i;
				break;
			}
		}
		if (TempEndIndex == 0xFF)
		{
			for (BYTE i = 0; i < 9; i++)
			{
				if (m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][i] == 0)
				{
					m_cbGamePlayerHandCard[wChairID][pYiWei->cbStartIp][i] = pYiWei->cbOperateCard;
					break;
				}
			}
			CMD_S_YIWEI_HUA YIWEI;
			YIWEI.bFlag = 4;
			YIWEI.StarIpOne = pYiWei->cbStartIp;
			YIWEI.StarIpTwo = TempStartIndex;
			YIWEI.EndIpOne = pYiWei->cbEndIp;
			YIWEI.EndIpTwo = TempEndIndex;
			YIWEI.CardData = pYiWei->cbOperateCard;
			m_pITableFrame->SendTableData(wChairID, SUB_S_YI_WEI_HUA, &YIWEI, sizeof(YIWEI));
			ASSERT(false);
			return false;
		}
		else
		{
			CMD_S_YIWEI_HUA YIWEI;
			YIWEI.bFlag = 1;
			YIWEI.StarIpOne = pYiWei->cbStartIp;
			YIWEI.StarIpTwo = TempStartIndex;
			YIWEI.EndIpOne = pYiWei->cbEndIp;
			YIWEI.EndIpTwo = TempEndIndex;
			YIWEI.CardData = pYiWei->cbOperateCard;
			m_pITableFrame->SendTableData(wChairID, SUB_S_YI_WEI_HUA, &YIWEI, sizeof(YIWEI));
			return true;
		}
	}
		return false;
	}

	return false;
}

//框架消息处理
bool TableFrameSinkZhiPai::OnFrameMessage(WORD wSubCmdID, VOID * pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)
{
	return false;
}

//用户断线重连
bool TableFrameSinkZhiPai::OnActionUserConnect(WORD wChairID, IServerUserItem * pIServerUserItem)
{
	auto dwUserID = pIServerUserItem->GetUserID();

	auto iter = std::find(m_offlineUsers.begin(), m_offlineUsers.end(), dwUserID);
	//if (m_TabbOutCardCout[wChairID] > 0)
	//	HttpTingCard(wChairID);
	if (iter != end(m_offlineUsers))
	{
		m_offlineUsers.erase(iter);	//玩家重新上线
		return true;
	}
	return true;
}

//用户坐下
bool TableFrameSinkZhiPai::OnActionUserSitDown(WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
	return true;
}

//游戏中途旁观进入
bool TableFrameSinkZhiPai::PerformLookonLogin(IServerUserItem * pIServerUserItem)
{
	CMD_S_PangGuan_Hua StatusPlay;
	memset(&StatusPlay, 0, sizeof(StatusPlay));

	//游戏房主基础配置
	CopyMemory(&StatusPlay.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));
	CopyMemory(StatusPlay.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));
	//CopyMemory(StatusPlay.bPiaoVal, m_wPiaoFen, sizeof(m_wPiaoFen));
	switch (bGameType)
	{
	case(huapai) :
	{
		StatusPlay.cbTotalCardCount = MAX_REPERTORY_HUA_TWO;
		break;
	}
	case(huapai2) :
	{
		StatusPlay.cbTotalCardCount = MAX_REPERTORY_HUA_ONE;
		break;
	}
	case(huapai3) :
	{
		StatusPlay.cbTotalCardCount = MAX_REPERTORY_HUA;
		break;
	}
	default:break;
	}
	StatusPlay.cbLeftCardCount = m_cbLeftCardCount;
	StatusPlay.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;
	StatusPlay.GameStatus = m_pITableFrame->IsDrawStarted();
	if (StatusPlay.GameStatus)
	{
		//游戏变量
		StatusPlay.wBankerUser = m_wBankerUser;
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			StatusPlay.lSiZi[i] = m_cbTongCount[i];
			StatusPlay.cbCardCount[i] = m_GameLogic.GetCardCount(m_cbCardIndex[i]);
		}
		CopyMemory(StatusPlay.cbDiscardCard, m_cbDiscardCard, sizeof(StatusPlay.cbDiscardCard));
		CopyMemory(StatusPlay.cbDiscardCount, m_cbDiscardCount, sizeof(StatusPlay.cbDiscardCount));
		CopyMemory(StatusPlay.GameScore, m_cbOperateScore, sizeof(m_cbOperateScore));
		//组合扑克
		CopyMemory(StatusPlay.WeaveItemArray, m_WeaveItemArray_HuPai, sizeof(m_WeaveItemArray_HuPai));
		CopyMemory(StatusPlay.cbWeaveCount, m_cbWeaveItemCount_HuPai, sizeof(m_cbWeaveItemCount_HuPai));

		StatusPlay.totalOptTime = 10;
		StatusPlay.leftOptTime = 0;
		//当前到谁家
		StatusPlay.wCurrentUser = (m_wCurrentUser == INVALID_CHAIR ? m_wProvideUser : m_wCurrentUser);
		WORD OldUser = 0;//定义一个最后出牌用户
		if (m_cbOutCardCount == 0 )
		{
			return m_pITableFrame->SendUserItemData(pIServerUserItem, SUB_S_PANGGUAN_HUA, &StatusPlay, sizeof(StatusPlay));
		}
		else
		{
			if (m_wProvideUser == m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR)//牌权是摸牌得且没出牌
			{
				if (m_wProvideUser == 0)
				{
					OldUser = 2;
				}
				else
					OldUser = m_wProvideUser - 1;
				BYTE TempIndex = 0;
				for (BYTE i = 0; i < 15; i++)
				{
					if (m_cbDiscardCard[OldUser][i] == 0)
					{
						TempIndex = i - 1;
						break;
					}
				}
				if (TempIndex == 255)TempIndex = 0;
				StatusPlay.bPutCardData[OldUser] = m_cbDiscardCard[OldUser][TempIndex];			
			}
			if (m_wProvideUser == m_wOutCardUser&& m_wCurrentUser == INVALID_CHAIR)//当有人可以碰且没有碰时候
			{
				OldUser = m_wProvideUser;
				StatusPlay.bPutCardData[m_wProvideUser] = m_cbProvideCard;
				StatusPlay.cbDiscardCard[OldUser][StatusPlay.cbDiscardCount[OldUser]++] = m_cbProvideCard;
			}
		}
	}
	return m_pITableFrame->SendUserItemData(pIServerUserItem, SUB_S_PANGGUAN_HUA, &StatusPlay, sizeof(StatusPlay));
}

//用户起来
bool TableFrameSinkZhiPai::OnActionUserStandUp(WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
	//庄家设置
	//if (bLookonUser == false && !QueryUseTemporaryScore())
	//{
	//	m_bTrustee[wChairID]=false;
	//	CMD_S_Trustee Trustee;
	//	Trustee.bTrustee=false;
	//	Trustee.wChairID = wChairID;

	//	RepayRecord(INVALID_CHAIR, SUB_S_TRUSTEE, &Trustee, sizeof(Trustee));
	//	m_pITableFrame->SendTableData(INVALID_CHAIR,SUB_S_TRUSTEE,&Trustee,sizeof(Trustee));
	//	m_pITableFrame->SendLookonData(INVALID_CHAIR,SUB_S_TRUSTEE,&Trustee,sizeof(Trustee));
	//}

	return true;
}

//用户出牌
bool TableFrameSinkZhiPai::OnUserOutCard(WORD wChairID, BYTE cbCardData, BYTE cbWeiZhi)
{
	//效验状态
	ASSERT(m_pITableFrame->GetGameStatus() == GS_MJ_PLAY);
	if (m_pITableFrame->GetGameStatus() != GS_MJ_PLAY) return true;

	//错误断言
	ASSERT(wChairID == m_wCurrentUser);
	ASSERT(m_GameLogic.IsValidCard(cbCardData) == true);

	//效验参数
	if (wChairID != m_wCurrentUser) return false;
	if (m_GameLogic.IsValidCard(cbCardData) == false) return false;

	//删除牌墙
	BYTE TempWeiZhi = 0xFF;
	if (cbWeiZhi == 0 || cbWeiZhi > 8)
	{
		for (BYTE i = 0; i < 9; i++)
		{
			for (BYTE j = 0; j < 9; j++)
			{
				if (m_cbGamePlayerHandCard[m_wCurrentUser][i][j] == cbCardData)
				{
					for (BYTE k = j; k < 8; k++)
					{
						m_cbGamePlayerHandCard[m_wCurrentUser][i][k] = m_cbGamePlayerHandCard[m_wCurrentUser][i][k + 1];
					}
					TempWeiZhi = j;
					break;
				}
			}
			if (TempWeiZhi != 0xFF)
			{
				break;
			}
		}
		if (TempWeiZhi == 0xFF)
		{
			return false;
		}
	}
	else
	{
		for (BYTE j = 0; j < 9; j++)
		{
			if (m_cbGamePlayerHandCard[m_wCurrentUser][cbWeiZhi][j] == cbCardData)
			{
				for (BYTE k = j; k < 8; k++)
				{
					m_cbGamePlayerHandCard[m_wCurrentUser][cbWeiZhi][k] = m_cbGamePlayerHandCard[m_wCurrentUser][cbWeiZhi][k + 1];
				}
				TempWeiZhi = j;
				break;
			}
		}
		if (TempWeiZhi == 0xFF)
		{
			for (BYTE i = 0; i < 9; i++)
			{
				for (BYTE j = 0; j < 9; j++)
				{
					if (m_cbGamePlayerHandCard[m_wCurrentUser][i][j] == cbCardData)
					{
						for (BYTE k = j; k < 8; k++)
						{
							m_cbGamePlayerHandCard[m_wCurrentUser][i][k] = m_cbGamePlayerHandCard[m_wCurrentUser][i][k + 1];
						}
						TempWeiZhi = j;
						break;
					}
				}
				if (TempWeiZhi != 0xFF)
				{
					break;
				}
			}
			if (TempWeiZhi == 0xFF)
			{
				return false;
			}
		}
	}
	//删除扑克
	if (m_GameLogic.RemoveCard(m_cbCardIndex[wChairID], cbCardData) == false)
	{
		ASSERT(FALSE);
		return false;
	}
	if ((cbCardData & 0x10) == 0x10)
	{
		BYTE TempIndex = m_GameLogic.SwitchToCardIndex(cbCardData);
		ASSERT(m_cbHuaCardIndex[m_wCurrentUser][TempIndex / 2] > 0);
		if (m_cbHuaCardIndex[m_wCurrentUser][TempIndex / 2] == 0)
		{
			ASSERT(false);
			return false;
		}
		m_cbHuaCardIndex[m_wCurrentUser][TempIndex / 2]--;
	}

	ZeroMemory(&m_cbLastDisCardData[wChairID], sizeof(m_cbLastDisCardData[wChairID]));//本玩家记忆库数据清零
	m_cbLastDisCount[wChairID] = 0;

	//出牌记录
	m_cbOutCardCount++;
	m_wOutCardUser = wChairID;			//记录出牌人
	m_cbOutCardData = cbCardData;		//记录出牌数据

	//构造数据
	CMD_S_OutCard OutCard;
	OutCard.wOutCardUser = wChairID;
	OutCard.cbOutCardData = cbCardData;
	OutCard.bOptType = 0;
	RepayRecord(INVALID_CHAIR, SUB_S_OUT_CARD_HUA, &OutCard, sizeof(OutCard));
	//发送消息
	m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OUT_CARD_HUA, &OutCard, sizeof(OutCard));
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OUT_CARD_HUA, &OutCard, sizeof(OutCard));
	m_wProvideUser = wChairID;
	m_cbProvideCard = cbCardData;
	//用户切换
	m_wCurrentUser = (wChairID + 1) % GAME_PLAY;

	m_cbUserAction[wChairID] = WIK_NULL;
	m_cbPerformAction[wChairID] = WIK_NULL;

	//响应判断
	bool bAroseAction = EstimateUserRespond(wChairID, cbCardData, EstimatKind_OutCard);
	
	//派发扑克
	if (bAroseAction == false)
	{
		DispatchCardData(m_wCurrentUser);
	}
	return true;
}

//用户操作,
bool TableFrameSinkZhiPai::OnUserOperateCard(WORD wChairID, int cbOperateCode, BYTE cbOperateCard, BYTE cbHuaCard[])
{
	//效验状态
	ASSERT(m_pITableFrame->GetGameStatus() == GS_MJ_PLAY);
	if (m_pITableFrame->GetGameStatus() != GS_MJ_PLAY)
		return true;
	//反馈动作
	int FanKuiAction = WIK_NULL;
	tagGangCardResult_Hua GangCardResult;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	//被动动作
	//表示有人出牌后，下一个人还未摸牌这段时间内，有人对上一张出牌有吃胡、杠、碰等操作
	if (m_wCurrentUser == INVALID_CHAIR && wChairID != m_wProvideUser)
	{
		//效验状态
		if (m_bResponse[wChairID] == true)
			return true;
		//效验操作 -- 操作码不为空，并且当前用户不可执行该操作
		if ((cbOperateCode != WIK_NULL) && ((m_cbUserAction[wChairID] & cbOperateCode) == 0))
			return true;
		//变量定义
		WORD wTargetUser = wChairID;
		int cbTargetAction = cbOperateCode;
		//设置变量
		m_bResponse[wChairID] = true;
		m_cbPerformAction[wChairID] = cbOperateCode;
		m_cbOperateCard[wChairID] = cbOperateCard;
		CopyMemory(m_cbOperateCard_FuJia[wChairID], cbHuaCard, sizeof(m_cbOperateCard_FuJia[wChairID]));
		if (cbOperateCode == WIK_NULL)
		{
			m_cbLastDisCardData[wChairID][m_cbLastDisCount[wChairID]++] = m_cbProvideCard;
		}

		OperatorPriority(m_wProvideUser, wTargetUser, cbTargetAction);
		//操作优先级最高用户还未操作,
		if (m_bResponse[wTargetUser] == false)
		{
			return true;
		}

		//放弃操作		
		if (cbOperateCode == WIK_NULL &&cbTargetAction == WIK_NULL)
		{			
			ZeroMemory(m_bResponse, sizeof(m_bResponse));
			ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
			ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
			ZeroMemory(m_cbOperateCard_FuJia, sizeof(m_cbOperateCard_FuJia));			
			ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
			ZeroMemory(EsponseHuShu, sizeof(EsponseHuShu));//胡数
			ZeroMemory(EsponsePaPoShu, sizeof(EsponsePaPoShu));//爬坡数
			if (m_wCurrentUser == INVALID_CHAIR)
			{
				DispatchCardData(m_wResumeUser);
			}
			return true;
		}
		//变量定义
		BYTE cbTargetCard = m_cbOperateCard[wTargetUser];
		//校验前端传过来的牌值是否和后台一致
		if ( cbTargetCard != m_cbProvideCard)
		{
			m_bResponse[wTargetUser] = false;
			return false;
		}

		//出牌变量
		m_cbOutCardData = 0;
		m_bSendStatus = true;
		m_wOutCardUser = INVALID_CHAIR;

		//组合扑克	
		if (!(cbTargetAction&(WIK_CHI_HU)))
		{
			ASSERT(m_cbWeaveItemCount[wTargetUser] < 8);
			if (m_cbWeaveItemCount[wTargetUser] > 8)return false;
			/*WORD wIndex = m_cbWeaveItemCount[wTargetUser]++;
			m_WeaveItemArray[wTargetUser][wIndex].cbPublicCard = TRUE;
			m_WeaveItemArray[wTargetUser][wIndex].cbCenterCard = cbTargetCard;
			m_WeaveItemArray[wTargetUser][wIndex].cbWeaveKind = cbTargetAction;
			m_WeaveItemArray[wTargetUser][wIndex].wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;*/
		}
		BYTE wIndex = 0;
		BYTE TempCount_Hu = 0;
		//删除扑克
		switch (cbTargetAction)
		{
		case WIK_DUI:		//碰牌操作
		{
			BYTE TempCardData[2] = { 0 };
			//删除扑克
			BYTE  TempIndex = m_GameLogic.SwitchToCardIndex(cbTargetCard);
			if (m_cbCardIndex[wTargetUser][TempIndex] >= 2)
			{				
				wIndex = m_cbWeaveItemCount[wTargetUser]++;
				m_WeaveItemArray[wTargetUser][wIndex].cbPublicCard = TRUE;
				m_WeaveItemArray[wTargetUser][wIndex].cbCenterCard = (cbTargetCard & 0xEF);
				m_WeaveItemArray[wTargetUser][wIndex].cbWeaveKind = WIK_DUI;
				m_WeaveItemArray[wTargetUser][wIndex].wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;

				TempCount_Hu = m_cbWeaveItemCount_HuPai[wTargetUser]++;
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbPublicCard = TRUE;
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbCenterCard = (cbTargetCard & 0xEF);
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbWeaveKind = WIK_DUI;
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;

				ASSERT(m_cbCardIndex[wTargetUser][TempIndex] >= 2);
				m_cbCardIndex[wTargetUser][TempIndex] -= 2;	
				if ((cbTargetCard & 0x10) == 0x10)//别人打了个花牌
				{
					if (m_cbOperateCard_FuJia[wTargetUser][0] == cbTargetCard)//手牌有一个花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						ASSERT(m_cbHuaCardIndex[wTargetUser][TempIndex / 2] > 0);
						m_cbHuaCardIndex[wTargetUser][TempIndex / 2]--;

						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[1] = cbTargetCard;
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[1] = cbTargetCard;
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;

						TempCardData[0] = cbTargetCard;
						TempCardData[1] = (cbTargetCard & 0x0F);
					}
					else//手牌没有花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[0] = cbTargetCard;
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[0] = cbTargetCard;
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						TempCardData[0] = (cbTargetCard & 0x0F);
						TempCardData[1] = (cbTargetCard & 0x0F);
					}
				}
				else//打了个普通牌
				{
					if (m_cbOperateCard_FuJia[wTargetUser][0] != 0 && (m_cbOperateCard_FuJia[wTargetUser][0] & 0x10 == 0x10))//手牌有一个花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						ASSERT(m_cbHuaCardIndex[wTargetUser][TempIndex / 2] > 0);
						m_cbHuaCardIndex[wTargetUser][TempIndex / 2]--;

						TempCardData[0] = (cbTargetCard | 0x10);						
					}
					if (m_cbOperateCard_FuJia[wTargetUser][1] != 0 && (m_cbOperateCard_FuJia[wTargetUser][1] & 0x10 == 0x10))//手牌有两个个花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[1] = m_cbOperateCard_FuJia[wTargetUser][1];
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[1] = m_cbOperateCard_FuJia[wTargetUser][1];
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						ASSERT(m_cbHuaCardIndex[wTargetUser][TempIndex / 2] > 0);
						m_cbHuaCardIndex[wTargetUser][TempIndex / 2]--;

						TempCardData[1] = (cbTargetCard | 0x10);
					}
					if (TempCardData[0] == 0)
					{
						TempCardData[0] = cbTargetCard;
					}
					if (TempCardData[1] == 0)
					{
						TempCardData[1] = cbTargetCard;
					}
				}
			}
			else
			{
				m_bResponse[wTargetUser] = false;
				return false;
			}
			m_cbDuiOperator[wTargetUser]++;
			if (!DeleteHandCardData(wTargetUser, TempCardData, 2))
			{
				m_bResponse[wTargetUser] = false;
				return false;
			}
			m_cbOperateScore[wTargetUser] += GetOperatorScore(WIK_DUI, TempIndex, m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset);
			/*if (m_cbLeftCardCount > 0)
			{
				FanKuiAction |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wTargetUser], m_cbHuaCardIndex[wTargetUser], m_WeaveItemArray[wTargetUser],
					m_cbWeaveItemCount[wTargetUser], m_WeaveItemArray_AnTong[wTargetUser], m_cbWeaveItemCount_AnTong[wTargetUser], GangCardResult, b_wIsGangTing[wTargetUser]);
			}*/
			//TingCard(wTargetUser);
			break;
		}
		case WIK_SAN_ZHAO:		//明补操作 -- 补张后不可将该牌再用于组合。补张的牌其他玩家不可吃、碰，可以胡。
		{
			BYTE TempCardData[3] = { 0 };
			BYTE TempIndex = m_GameLogic.SwitchToCardIndex(cbTargetCard);
			if (m_cbCardIndex[wTargetUser][TempIndex] >= 3)
			{				
				wIndex = m_cbWeaveItemCount[wTargetUser]++;
				m_WeaveItemArray[wTargetUser][wIndex].cbPublicCard = TRUE;
				m_WeaveItemArray[wTargetUser][wIndex].cbCenterCard = (cbTargetCard & 0xEF);
				m_WeaveItemArray[wTargetUser][wIndex].cbWeaveKind = WIK_SAN_ZHAO;
				m_WeaveItemArray[wTargetUser][wIndex].wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;

				TempCount_Hu = m_cbWeaveItemCount_HuPai[wTargetUser]++;
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbPublicCard = TRUE;
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbCenterCard = (cbTargetCard & 0xEF);
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbWeaveKind = WIK_SAN_ZHAO;
				m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;

				ASSERT(m_cbCardIndex[wTargetUser][TempIndex] >= 3);
				m_cbCardIndex[wTargetUser][TempIndex] -= 3;
				if ((cbTargetCard & 0x10) == 0x10)//别人打了个花牌
				{
					if (m_cbOperateCard_FuJia[wTargetUser][0] == cbTargetCard)//手牌有一个花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						ASSERT(m_cbHuaCardIndex[wTargetUser][TempIndex / 2] > 0);
						m_cbHuaCardIndex[wTargetUser][TempIndex / 2]--;

						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[1] = cbTargetCard;
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[1] = cbTargetCard;
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						TempCardData[0] = cbTargetCard;
						TempCardData[1] = (cbTargetCard & 0x0F);
						TempCardData[2] = (cbTargetCard & 0x0F);
					}
					else
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[0] = cbTargetCard;
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[0] = cbTargetCard;
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;

						TempCardData[0] = (cbTargetCard & 0x0F);
						TempCardData[1] = (cbTargetCard & 0x0F);
						TempCardData[2] = (cbTargetCard & 0x0F);
					}
				}
				else
				{
					if (m_cbOperateCard_FuJia[wTargetUser][0] != 0 && (m_cbOperateCard_FuJia[wTargetUser][0] & 0x10 == 0x10))//手牌有一个花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[0] = m_cbOperateCard_FuJia[wTargetUser][0];
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						ASSERT(m_cbHuaCardIndex[wTargetUser][TempIndex / 2] > 0);
						m_cbHuaCardIndex[wTargetUser][TempIndex / 2]--;
						TempCardData[0] = (cbTargetCard | 0x10);
					}
					if (m_cbOperateCard_FuJia[wTargetUser][1] != 0 && (m_cbOperateCard_FuJia[wTargetUser][1] & 0x10 == 0x10))//手牌有两个个花牌
					{
						m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset[1] = m_cbOperateCard_FuJia[wTargetUser][1];
						m_WeaveItemArray_HuPai[wTargetUser][TempCount_Hu].cbMargicOffset[1] = m_cbOperateCard_FuJia[wTargetUser][1];
						m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2]++;
						m_cbHuaWeaveCardIndex_Tong[wTargetUser][TempIndex / 2]++;
						ASSERT(m_cbHuaCardIndex[wTargetUser][TempIndex / 2] > 0);
						m_cbHuaCardIndex[wTargetUser][TempIndex / 2]--;
						TempCardData[1] = (cbTargetCard | 0x10);
					}
					if (TempCardData[0] == 0)
					{
						TempCardData[0] = cbTargetCard;
					}
					if (TempCardData[1] == 0)
					{
						TempCardData[1] = cbTargetCard;
					}
					TempCardData[2] = cbTargetCard;
				}				
			}
			else
			{
				m_bResponse[wTargetUser] = false;
				return false;
			}
			if (!DeleteHandCardData(wTargetUser, TempCardData, 3))
			{
				m_bResponse[wTargetUser] = false;
				return false;
			}
			m_cbOperateScore[wTargetUser] += GetOperatorScore(WIK_SAN_ZHAO, TempIndex, m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset);
			//BYTE cbRemoveCard[] = { cbTargetCard, cbTargetCard, cbTargetCard };
			//VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, CountArray(cbRemoveCard)));
			//m_MingBuNum[wTargetUser]++;
			break;
		}		
		case WIK_CHI_HU:
		{
			int TempAction = WIK_NULL;
			BYTE TempCardIndex[MAX_INDEX_HUA] = { 0 };
			BYTE TempHuaCardIndex[5] = { 0 };
			CopyMemory(TempCardIndex, m_cbCardIndex[wTargetUser], sizeof(TempCardIndex));
			CopyMemory(TempHuaCardIndex, m_cbHuaCardIndex[wTargetUser], sizeof(TempHuaCardIndex));
			m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[wTargetUser], TempHuaCardIndex, m_cbHuaCardIndex_Tong[wTargetUser]);
			TempAction |= m_GameLogic.AnalyseHuCard(TempCardIndex, TempHuaCardIndex, m_cbProvideCard, m_WeaveItemArray_HuPai[wTargetUser], m_cbWeaveItemCount_HuPai[wTargetUser], m_cbHuaWeaveCardIndex[wTargetUser], m_cbTongCount[wTargetUser], ChiHu);
			if (TempAction == WIK_NULL)
			{
				return false;
			}
			m_HuPai[wTargetUser]++;
			CMD_S_OperateResult_Hua OperateResult;
			ZeroMemory(&OperateResult, sizeof(OperateResult));
			OperateResult.wOperateUser = wTargetUser;
			OperateResult.cbOperateCard = cbTargetCard;
			OperateResult.cbOperateCode = cbTargetAction;
			OperateResult.wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;
			//RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			//发送消息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			
			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			//结束
			OnEventGameConclude(wTargetUser, NULL, GER_NORMAL);
			return true;
		}
		case WIK_SI_ZHAO:
		{
			BYTE TempCardData[4] = { 0 };
			BYTE TempIndex = m_GameLogic.SwitchToCardIndex(cbTargetCard);
			if (TempIndex == 0 || TempIndex == 2 || TempIndex == 4 || TempIndex == 6 || TempIndex == 8)
			{
				for (BYTE i = 0; i < m_cbWeaveItemCount[wTargetUser]; i++)
				{
					if (m_WeaveItemArray[wTargetUser][i].cbWeaveKind == WIK_SI_TONG && ((m_WeaveItemArray[wTargetUser][i].cbCenterCard & 0x0F) == (cbTargetCard & 0x0F)) && m_WeaveItemArray[wTargetUser][i].cbCenterCard < 0x20)
					{
						if ((cbTargetCard & 0x10) == 0x10)
						{
							m_WeaveItemArray[wTargetUser][i].cbMargicOffset[1] = cbTargetCard;

							ASSERT(m_cbCardIndex_Tong[wTargetUser][TempIndex] >= 4);
							ASSERT(m_cbHuaCardIndex_Tong[wTargetUser][TempIndex / 2] >= 1);
							m_cbCardIndex_Tong[wTargetUser][TempIndex] -= 4;
							m_cbHuaCardIndex_Tong[wTargetUser][TempIndex / 2] --;

							TempCardData[0] = cbTargetCard;
							TempCardData[1] = (cbTargetCard & 0x0F);
							TempCardData[2] = (cbTargetCard & 0x0F);
							TempCardData[3] = (cbTargetCard & 0x0F);
						}
						else
						{
							ASSERT(m_cbCardIndex_Tong[wTargetUser][TempIndex] >= 4);
							ASSERT(m_cbHuaCardIndex_Tong[wTargetUser][TempIndex / 2] >= 2);
							m_cbCardIndex_Tong[wTargetUser][TempIndex] -= 4;
							m_cbHuaCardIndex_Tong[wTargetUser][TempIndex / 2] -= 2;
							TempCardData[0] = cbTargetCard;
							TempCardData[1] = cbTargetCard;
							TempCardData[2] = (cbTargetCard | 0x10);
							TempCardData[3] = (cbTargetCard | 0x10);
						}
						m_WeaveItemArray[wTargetUser][i].cbWeaveKind = WIK_SI_ZHAO;

						m_WeaveItemArray_HuPai[wTargetUser][m_cbWeaveItemCount_HuPai[wTargetUser]].cbCenterCard = (cbTargetCard & 0x0F);
						m_WeaveItemArray_HuPai[wTargetUser][m_cbWeaveItemCount_HuPai[wTargetUser]].cbWeaveKind = WIK_SI_ZHAO;
						m_WeaveItemArray_HuPai[wTargetUser][m_cbWeaveItemCount_HuPai[wTargetUser]].cbMargicOffset[0] = (cbTargetCard | 0x10);
						m_WeaveItemArray_HuPai[wTargetUser][m_cbWeaveItemCount_HuPai[wTargetUser]].cbMargicOffset[1] = (cbTargetCard | 0x10);
						m_cbWeaveItemCount_HuPai[wTargetUser]++;
						break;
					}
				}
				m_cbHuaWeaveCardIndex[wTargetUser][TempIndex / 2] += 2;
			}
			else
			{
				for (BYTE i = 0; i < m_cbWeaveItemCount[wTargetUser]; i++)
				{
					if (m_WeaveItemArray[wTargetUser][i].cbWeaveKind == WIK_SI_TONG && m_WeaveItemArray[wTargetUser][i].cbCenterCard == cbTargetCard)
					{
						ASSERT(m_cbCardIndex_Tong[wTargetUser][TempIndex] >= 4);
						m_cbCardIndex_Tong[wTargetUser][TempIndex] -= 4;
						TempCardData[0] = cbTargetCard;
						TempCardData[1] = cbTargetCard;
						TempCardData[2] = cbTargetCard;
						TempCardData[3] = cbTargetCard;
						m_WeaveItemArray[wTargetUser][i].cbWeaveKind = WIK_SI_ZHAO;

						m_WeaveItemArray_HuPai[wTargetUser][m_cbWeaveItemCount_HuPai[wTargetUser]].cbCenterCard = cbTargetCard;
						m_WeaveItemArray_HuPai[wTargetUser][m_cbWeaveItemCount_HuPai[wTargetUser]].cbWeaveKind = WIK_SI_ZHAO;
						m_cbWeaveItemCount_HuPai[wTargetUser]++;
						break;
					}
				}
			}
			if (!DeleteHandCardData(wTargetUser, TempCardData, 4))
			{
				m_bResponse[wTargetUser] = false;
				return false;
			}
			m_cbOperateScore[wTargetUser] += GetOperatorScore(WIK_SI_ZHAO, TempIndex, m_WeaveItemArray[wTargetUser][wIndex].cbMargicOffset);
			m_cbTongCount[wTargetUser]--;
			break;
		}
		default:
			ASSERT(FALSE);
			return false;
		}

		//用户状态
		ZeroMemory(m_bResponse, sizeof(m_bResponse));
		ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
		ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));			
		ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
		ZeroMemory(EsponseHuShu, sizeof(EsponseHuShu));//胡数
		ZeroMemory(EsponsePaPoShu, sizeof(EsponsePaPoShu));//爬坡数

		//构造结果
		CMD_S_OperateResult_Hua OperateResult;
		OperateResult.wOperateUser = wTargetUser;
		OperateResult.cbOperateCard = cbTargetCard;
		OperateResult.cbOperateCode = cbTargetAction;
		OperateResult.wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;
		OperateResult.cbActionMask = FanKuiAction | WIK_BH_WJCP;
		OperateResult.cbOperateScore = m_cbOperateScore[wTargetUser];
		CopyMemory(OperateResult.cbHuaGangCard, m_cbOperateCard_FuJia[wTargetUser], sizeof(OperateResult.cbHuaGangCard));
		ZeroMemory(m_cbOperateCard_FuJia, sizeof(m_cbOperateCard_FuJia));
		ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
		if (FanKuiAction != WIK_NULL)
		{
			m_cbUserAction[wTargetUser] = FanKuiAction;
			OperateResult.cbActionMask = FanKuiAction;
			for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
			{
				OperateResult.cbActionCard[i] = GangCardResult.cbCardData[i];
			}
		}
		//RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
		//发送消息
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
		RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
		//设置用户
		m_wCurrentUser = wTargetUser;
		//杠牌处理
		if (cbTargetAction == WIK_SAN_ZHAO || cbTargetAction == WIK_SI_ZHAO)
		{
			DispatchCardData(wTargetUser);
		}
		return true;
	}
	//主动动作
	if (m_wCurrentUser==wChairID) //如果是摸牌用户的操作，比如自摸或者自杠
	{
		if (cbOperateCode == WIK_NULL)
		{
			if (m_cbOutCardCount == 0 && (m_cbUserAction[wChairID]&(WIK_SI_TONG|WIK_WU_TONG)))
			{
				ZeroMemory(m_bResponse, sizeof(m_bResponse));
				ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
				ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
				ZeroMemory(m_cbOperateCard_FuJia, sizeof(m_cbOperateCard_FuJia));
				ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
				ZeroMemory(EsponseHuShu, sizeof(EsponseHuShu));//胡数
				ZeroMemory(EsponsePaPoShu, sizeof(EsponsePaPoShu));//爬坡数
				b_QingTong[wChairID] = true;
				if (wChairID != m_wBankerUser)
				{
					WORD TempNextUser = INVALID_CHAIR;
					if (wChairID == 0)
					{
						TempNextUser = 2;
					}
					else
					{
						TempNextUser = wChairID-1;
					}
					b_QingTong[TempNextUser] = true;
					tagGangCardResult_Hua GangCardResult;
					ZeroMemory(&GangCardResult, sizeof(GangCardResult));
					m_cbUserAction[TempNextUser] = m_GameLogic.AnalyseGangCard(m_cbCardIndex[TempNextUser], m_cbHuaCardIndex[TempNextUser], m_WeaveItemArray[TempNextUser], m_cbWeaveItemCount[TempNextUser], GangCardResult);
					if (m_cbUserAction[TempNextUser] & WIK_SI_TONG)
					{
						b_QingTong[TempNextUser] = false;
						if (TempNextUser == m_wBankerUser)
						{
							m_cbUserAction[TempNextUser] |= WIK_BH_WJCP;
						}
						CMD_S_QingTongNotify QingTong;
						ZeroMemory(&QingTong, sizeof(QingTong));
						QingTong.OperatorUser = TempNextUser;
						//*QingTong.cbActionMask = m_cbUserAction[TempNextUser];
						for (BYTE i = 0; i < GAME_PLAY; i++)
						{
							if (i == TempNextUser)
							{
								QingTong.cbActionMask = m_cbUserAction[TempNextUser];
								CopyMemory(QingTong.cbActionCard, GangCardResult.cbCardData, sizeof(GangCardResult.cbCardData));
								m_pITableFrame->SendTableData(TempNextUser, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
							}
							else
							{
								QingTong.cbActionMask = WIK_NULL;
								ZeroMemory(QingTong.cbActionCard, sizeof(QingTong.cbActionCard));
								m_pITableFrame->SendTableData(i, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
							}
						}						
						m_wCurrentUser = TempNextUser;
						return true;
					}
					if (TempNextUser != m_wBankerUser)
					{
						if (TempNextUser == 0)
						{
							TempNextUser = 2;
						}
						else
						{
							TempNextUser--;
						}
						ASSERT(TempNextUser == m_wBankerUser);
						b_QingTong[TempNextUser] = true;
						tagGangCardResult_Hua GangCardResultBank;
						ZeroMemory(&GangCardResultBank, sizeof(GangCardResultBank));
						m_cbUserAction[TempNextUser] = m_GameLogic.AnalyseGangCard(m_cbCardIndex[TempNextUser], m_cbHuaCardIndex[TempNextUser], m_WeaveItemArray[TempNextUser], m_cbWeaveItemCount[TempNextUser], GangCardResultBank);
						m_cbUserAction[TempNextUser] |= WIK_BH_WJCP;
						CMD_S_QingTongNotify QingTong;
						ZeroMemory(&QingTong, sizeof(QingTong));
						QingTong.OperatorUser = TempNextUser;
						for (BYTE i = 0; i < GAME_PLAY; i++)
						{
							if (i == TempNextUser)
							{
								QingTong.cbActionMask = m_cbUserAction[TempNextUser];
								CopyMemory(QingTong.cbActionCard, GangCardResultBank.cbCardData, sizeof(GangCardResultBank.cbCardData));
								m_pITableFrame->SendTableData(TempNextUser, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
							}
							else
							{
								QingTong.cbActionMask = WIK_NULL;
								ZeroMemory(QingTong.cbActionCard, sizeof(QingTong.cbActionCard));
								m_pITableFrame->SendTableData(i, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
							}
						}
						m_wCurrentUser = TempNextUser;
						return true;
					}
					else
					{
						CMD_S_QingTongNotify TongZhi;
						ZeroMemory(&TongZhi, sizeof(TongZhi));
						TongZhi.OperatorUser = m_wBankerUser;
						m_cbUserAction[m_wBankerUser] = WIK_BH_WJCP;
						TongZhi.cbActionMask = m_cbUserAction[m_wBankerUser];
						m_pITableFrame->SendTableData(m_wBankerUser, SUB_S_QINGTONG_NOTIFY_HUA, &TongZhi, sizeof(TongZhi));
						m_wCurrentUser = m_wBankerUser;
						return true;						
					}
				}
				else if (wChairID == m_wBankerUser)
				{
					CMD_S_QingTongNotify TongZhi;
					ZeroMemory(&TongZhi, sizeof(TongZhi));
					TongZhi.OperatorUser = m_wBankerUser;
					m_cbUserAction[m_wBankerUser] = WIK_BH_WJCP;
					TongZhi.cbActionMask = m_cbUserAction[m_wBankerUser];
					m_pITableFrame->SendTableData(m_wBankerUser, SUB_S_QINGTONG_NOTIFY_HUA, &TongZhi, sizeof(TongZhi));
					m_wCurrentUser = m_wBankerUser;
					return true;
				}
				return true;
			}
			//用户状态
			ZeroMemory(m_bResponse, sizeof(m_bResponse));
			ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
			ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
			ZeroMemory(m_cbOperateCard_FuJia, sizeof(m_cbOperateCard_FuJia));			
			ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
			return true;
		}
		//效验操作
		if ((cbOperateCode==WIK_NULL)||((m_cbUserAction[wChairID]&cbOperateCode)==0))
			return true;

		//设置变量
		m_bSendStatus=true;
		//m_bEnjoinChiHu[m_wCurrentUser]=true;
		//m_cbUserAction[m_wCurrentUser]=WIK_NULL;
		//m_cbPerformAction[m_wCurrentUser]=WIK_NULL;

		bool bPublic=false;

		//执行动作
		switch (cbOperateCode)
		{
		case WIK_SI_TONG:			//四筒
		{
			//扑克效验
			ASSERT((cbOperateCode == WIK_SI_TONG) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
			if ((cbOperateCode != WIK_SI_TONG) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
				return false;
			//变量定义
			BYTE cbWeaveIndex = 0xFF;
			BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
			BYTE TempCount = 0;
			//杠牌处理
			if (cbCardIndex == 0 || cbCardIndex == 2 || cbCardIndex == 4 || cbCardIndex == 6 || cbCardIndex == 8)
			{
				if ((cbCardIndex == 0 || cbCardIndex == 8) && m_cbCardIndex[wChairID][cbCardIndex] >= 4)
				{
					bPublic = false;
					cbWeaveIndex = m_cbWeaveItemCount[wChairID]++;
					m_WeaveItemArray[wChairID][cbWeaveIndex].cbPublicCard = FALSE;
					m_WeaveItemArray[wChairID][cbWeaveIndex].wProvideUser = wChairID;
					m_WeaveItemArray[wChairID][cbWeaveIndex].cbWeaveKind = cbOperateCode;
					m_WeaveItemArray[wChairID][cbWeaveIndex].cbCenterCard = (cbOperateCard & 0xEF);
					CopyMemory(m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, cbHuaCard, sizeof(m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset));
					if (cbHuaCard[0] != 0 && (cbHuaCard[0] & 0x10) == 0x10)
					{
						ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
						m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
						m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
					}
					if (cbHuaCard[1] != 0 && (cbHuaCard[1] & 0x10) == 0x10)
					{
						ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
						m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
						m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
					}
				}
				else if ((cbCardIndex == 2 || cbCardIndex == 4 || cbCardIndex == 6) && (m_cbCardIndex[wChairID][cbCardIndex] + m_cbCardIndex[wChairID][22]) >= 4)
				{
					bPublic = false;
					cbWeaveIndex = m_cbWeaveItemCount[wChairID]++;
					m_WeaveItemArray[wChairID][cbWeaveIndex].cbPublicCard = FALSE;
					m_WeaveItemArray[wChairID][cbWeaveIndex].wProvideUser = wChairID;
					m_WeaveItemArray[wChairID][cbWeaveIndex].cbWeaveKind = cbOperateCode;
					m_WeaveItemArray[wChairID][cbWeaveIndex].cbCenterCard = (cbOperateCard & 0xEF);
					CopyMemory(m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, cbHuaCard, sizeof(m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset));
					if (cbHuaCard[0] != 0 && (cbHuaCard[0] & 0x10) == 0x10)
					{
						ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
						m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
						m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
					}
					if (cbHuaCard[1] != 0 && (cbHuaCard[1] & 0x10) == 0x10)
					{
						ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
						m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
						m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
					}
					if (cbHuaCard[2] == 0x2D)
					{
						ASSERT(m_cbCardIndex[wChairID][22] > 0);
						m_cbCardIndex[wChairID][22]--;
						m_cbCardIndex_Tong[wChairID][22]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						TempCount++;
					}
					if (cbHuaCard[3] == 0x2D)
					{
						ASSERT(m_cbCardIndex[wChairID][22] > 0);
						m_cbCardIndex[wChairID][22]--;
						m_cbCardIndex_Tong[wChairID][22]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						TempCount++;
					}
				}
				else
				{
					ASSERT(false);
					return false;
				}
			}
			else if (m_cbCardIndex[wChairID][cbCardIndex] >= 4)
			{	
				//设置变量
				bPublic = false;
				cbWeaveIndex = m_cbWeaveItemCount[wChairID]++;
				m_WeaveItemArray[wChairID][cbWeaveIndex].cbPublicCard = FALSE;
				m_WeaveItemArray[wChairID][cbWeaveIndex].wProvideUser = wChairID;
				m_WeaveItemArray[wChairID][cbWeaveIndex].cbWeaveKind = cbOperateCode;
				m_WeaveItemArray[wChairID][cbWeaveIndex].cbCenterCard = cbOperateCard;
				//CopyMemory(m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, cbHuaCard, sizeof(m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset));
			}
			else
			{
				ASSERT(false);
				return false;
			}
			m_cbUserAction[m_wCurrentUser]=WIK_NULL;
			m_cbPerformAction[m_wCurrentUser]=WIK_NULL;
			//删除扑克	
			ASSERT(m_cbCardIndex[wChairID][cbCardIndex] >= (4 - TempCount));
			m_cbCardIndex[wChairID][cbCardIndex] -= (4 - TempCount);
			m_cbCardIndex_Tong[wChairID][cbCardIndex] += (4 - TempCount);
			m_cbTongCount[wChairID]++;
			//m_wDianGangUser = wChairID;	
			//构造结果
			CMD_S_OperateResult_Hua OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.cbActionMask = WIK_NULL;
			OperateResult.cbOperateScore = m_cbOperateScore[wChairID];
			CopyMemory(OperateResult.cbHuaGangCard, m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, sizeof(OperateResult.cbHuaGangCard));
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			//发送消息
			for (BYTE i = 0; i < GAME_PLAY; i++)
			{
				if (i == wChairID)
				{
					OperateResult.cbOperateCard = cbOperateCard;
					CopyMemory(OperateResult.cbHuaGangCard, m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, sizeof(OperateResult.cbHuaGangCard));
					m_pITableFrame->SendTableData(i, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
				}
				else
				{
					OperateResult.cbOperateCard = 0;
					ZeroMemory(OperateResult.cbHuaGangCard, sizeof(OperateResult.cbHuaGangCard));
					m_pITableFrame->SendTableData(i, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
				}
				
			}
			OperateResult.cbOperateCard = 0;
			ZeroMemory(OperateResult.cbHuaGangCard, sizeof(OperateResult.cbHuaGangCard));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			OperateResult.cbOperateCard = cbOperateCard;
			CopyMemory(OperateResult.cbHuaGangCard, m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, sizeof(OperateResult.cbHuaGangCard));
			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			if (m_cbOutCardCount == 0 && wChairID != m_wBankerUser)
			{
				DispatchCardData(wChairID, true);
			}
			else
			{
				DispatchCardData(wChairID);
			}			
			return true;
		}
		case WIK_WU_TONG:		//五统
		{
			//扑克效验
			ASSERT((cbOperateCode == WIK_NULL) || (cbOperateCode == WIK_WU_TONG) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
			if ((cbOperateCode != WIK_WU_TONG) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
				return false;
			BYTE cbWeaveIndex = 0xFF;
			BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
			//寻找组合
			for (BYTE i = 0; i < m_cbWeaveItemCount[wChairID]; i++)
			{
				BYTE cbWeaveKind = m_WeaveItemArray[wChairID][i].cbWeaveKind;
				BYTE cbCenterCard = m_WeaveItemArray[wChairID][i].cbCenterCard;
				if (cbWeaveKind == WIK_SI_TONG)
				{
					if (((cbOperateCard & 0x20) == 0x20) && ((cbCenterCard & 0x20) == 0x20))
					{
						if (cbCenterCard == cbOperateCard)
						{
							bPublic = true;
							cbWeaveIndex = i;
							break;
						}
					}
					else
					{
						if ((cbCenterCard & 0x0F) == (cbOperateCard & 0x0F))
						{
							bPublic = true;
							cbWeaveIndex = i;
							break;
						}
					}
				}
			}
			//效验动作
			ASSERT(cbWeaveIndex != 0xFF);
			if (cbWeaveIndex == 0xFF) return false;
			
			//删除扑克	
			if (cbCardIndex == 2 || cbCardIndex == 4 || cbCardIndex == 6)
			{
				if (cbHuaCard[2] == 0x2D)
				{
					m_cbCardIndex[wChairID][22]--;
					m_cbCardIndex_Tong[wChairID][22]++;
					//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
					if (m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[2] == cbOperateCard)
					{
						m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[3] == cbOperateCard;
					}
					else
					{
						m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[2] == cbOperateCard;
					}
				}				
				else if (cbHuaCard[0] == cbOperateCard)
				{
					ASSERT(m_cbCardIndex[wChairID][cbCardIndex] > 0);
					m_cbCardIndex[wChairID][cbCardIndex] --;
					ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
					m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
					m_cbCardIndex_Tong[wChairID][cbCardIndex]++;
					m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
					//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
					ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
					if (m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[0] == cbOperateCard)
					{
						m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[1] == cbOperateCard;
					}
					else
					{
						ASSERT(false);
						m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[0] == cbOperateCard;
					}
				}
				else if (m_cbCardIndex[wChairID][cbCardIndex] >= 1)
				{
					if (m_cbHuaCardIndex[wChairID][cbCardIndex / 2] >= 1)
					{
						ASSERT(m_cbCardIndex[wChairID][cbCardIndex] > 0);
						m_cbCardIndex[wChairID][cbCardIndex] --;
						ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
						m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
						m_cbCardIndex_Tong[wChairID][cbCardIndex]++;
						m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
						if (m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[0] == cbHuaCard[0])
						{
							m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[1] == cbHuaCard[0];
						}
						else
						{
							ASSERT(false);
						}
					}
					else
					{
						ASSERT(m_cbCardIndex[wChairID][cbCardIndex] > 0);
						m_cbCardIndex[wChairID][cbCardIndex] --;
						m_cbCardIndex_Tong[wChairID][cbCardIndex]++;
					}
				}
				else
				{
					ASSERT(false);
					return false;
				}
			}
			else
			{
				if (m_cbCardIndex[wChairID][cbCardIndex] >= 1)//表示续杠类型
				{										
					if (cbOperateCard == cbHuaCard[0])
					{
						ASSERT(m_cbCardIndex[wChairID][cbCardIndex] > 0);
						m_cbCardIndex[wChairID][cbCardIndex] --;
						ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
						m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
						m_cbCardIndex_Tong[wChairID][cbCardIndex]++;
						m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;
						ASSERT(m_cbHuaCardIndex_Tong[wChairID][cbCardIndex / 2] <= 2);
						if (m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[0] == cbOperateCard)
						{
							m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[1] == cbOperateCard;
						}
						else
						{
							m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[0] == cbOperateCard;
						}
					}
					else
					{
						m_cbCardIndex[wChairID][cbCardIndex] --;
						m_cbCardIndex_Tong[wChairID][cbCardIndex]++;
					}
				}
				else
				{
					ASSERT(false);
					return false;
				}
			}
			//组合扑克
			m_WeaveItemArray[wChairID][cbWeaveIndex].cbPublicCard = TRUE;
			m_WeaveItemArray[wChairID][cbWeaveIndex].wProvideUser = wChairID;
			m_WeaveItemArray[wChairID][cbWeaveIndex].cbWeaveKind = cbOperateCode;
			m_WeaveItemArray[wChairID][cbWeaveIndex].cbCenterCard = cbOperateCard;
			m_cbUserAction[m_wCurrentUser] = WIK_NULL;
			m_cbPerformAction[m_wCurrentUser] = WIK_NULL;
			m_cbTongCount[wChairID]++;
			//构造结果
			CMD_S_OperateResult_Hua OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			//OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.cbActionMask = WIK_NULL;
			OperateResult.cbOperateScore = m_cbOperateScore[wChairID];
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			//CopyMemory(OperateResult.cbHuaGangCard, m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset, sizeof(OperateResult.cbHuaGangCard));
			//发送消息
			for (BYTE i = 0; i < GAME_PLAY; i++)
			{
				if (i == wChairID)
				{
					OperateResult.cbOperateCard = cbOperateCard;
					CopyMemory(OperateResult.cbHuaGangCard, cbHuaCard, sizeof(OperateResult.cbHuaGangCard));
					m_pITableFrame->SendTableData(i, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
				}
				else
				{
					OperateResult.cbOperateCard = 0;
					ZeroMemory(OperateResult.cbHuaGangCard, sizeof(OperateResult.cbHuaGangCard));
					m_pITableFrame->SendTableData(i, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
				}

			}
			OperateResult.cbOperateCard = 0;
			ZeroMemory(OperateResult.cbHuaGangCard, sizeof(OperateResult.cbHuaGangCard));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			OperateResult.cbOperateCard = cbOperateCard;
			CopyMemory(OperateResult.cbHuaGangCard, cbHuaCard, sizeof(OperateResult.cbHuaGangCard));
			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));

			//派发扑克
			if (m_cbOutCardCount == 0 && wChairID != m_wBankerUser)
			{
				DispatchCardData(m_wCurrentUser,true);
				return true;
			}
			else
			{
				DispatchCardData(m_wCurrentUser);
				return true;
			}
			return true;
		}
		case WIK_SI_ZHAO:		//补招，泛
		{
			//扑克效验
			ASSERT((cbOperateCode == WIK_NULL) || (cbOperateCode == WIK_SI_ZHAO) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
			if ((cbOperateCode != WIK_SI_ZHAO) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
				return false;
			BYTE cbWeaveIndex = 0xFF;
			BYTE cbWeaveIndex_Hu = 0xFF;
			BYTE TempScore = 0;
			BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
			//杠牌处理
			if (m_cbCardIndex[wChairID][cbCardIndex] == 1)//表示续杠类型
			{
				//寻找组合
				for (BYTE i = 0; i < m_cbWeaveItemCount[wChairID]; i++)
				{
					BYTE cbWeaveKind = m_WeaveItemArray[wChairID][i].cbWeaveKind;
					BYTE cbCenterCard = m_WeaveItemArray[wChairID][i].cbCenterCard;
					if ((cbWeaveKind == WIK_SAN_ZHAO) && (m_GameLogic.SwitchToCardIndex(cbCenterCard) == cbCardIndex))
					{
						bPublic = true;
						cbWeaveIndex = i;
						break;
					}
				}
				//效验动作
				ASSERT(cbWeaveIndex != 0xFF);
				if (cbWeaveIndex == 0xFF) return false;
				TempScore = GetOperatorScore(WIK_SAN_ZHAO, cbCardIndex, m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset);
				//组合扑克
				m_WeaveItemArray[wChairID][cbWeaveIndex].cbPublicCard = TRUE;
				m_WeaveItemArray[wChairID][cbWeaveIndex].wProvideUser = wChairID;
				m_WeaveItemArray[wChairID][cbWeaveIndex].cbWeaveKind = cbOperateCode;
				m_WeaveItemArray[wChairID][cbWeaveIndex].cbCenterCard = (cbOperateCard & 0xEF);

				for (BYTE i = 0; i < m_cbWeaveItemCount_HuPai[wChairID]; i++)
				{
					BYTE cbWeaveKind = m_WeaveItemArray_HuPai[wChairID][i].cbWeaveKind;
					BYTE cbCenterCard = m_WeaveItemArray_HuPai[wChairID][i].cbCenterCard;
					if ((cbWeaveKind == WIK_SAN_ZHAO) && (m_GameLogic.SwitchToCardIndex(cbCenterCard) == cbCardIndex))
					{
						bPublic = true;
						cbWeaveIndex_Hu = i;
						break;
					}
				}
				ASSERT(cbWeaveIndex_Hu != 0xFF);
				if (cbWeaveIndex_Hu == 0xFF) return false;
				//组合扑克
				m_WeaveItemArray_HuPai[wChairID][cbWeaveIndex_Hu].cbPublicCard = TRUE;
				m_WeaveItemArray_HuPai[wChairID][cbWeaveIndex_Hu].cbCenterCard = (cbOperateCard & 0xEF);
				m_WeaveItemArray_HuPai[wChairID][cbWeaveIndex_Hu].cbWeaveKind = cbOperateCode;
				m_WeaveItemArray_HuPai[wChairID][cbWeaveIndex_Hu].wProvideUser = wChairID;
				if (cbOperateCard & 0x10)
				{
					ASSERT(m_cbHuaCardIndex[wChairID][cbCardIndex / 2] > 0);
					m_cbHuaCardIndex[wChairID][cbCardIndex / 2]--;
					m_cbHuaWeaveCardIndex[wChairID][cbCardIndex / 2]++;
					//m_cbHuaWeaveCardIndex_Tong[wChairID][cbCardIndex / 2]++;

					m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset[1] = cbOperateCard;
					m_WeaveItemArray_HuPai[wChairID][cbWeaveIndex_Hu].cbMargicOffset[1] = cbOperateCard;
				}
			}
			else
				return false;
			BYTE TempCardData[1] = { cbOperateCard };
			if(!DeleteHandCardData(wChairID, TempCardData, 1))
			{
				return false;
			}
			//删除扑克
			ASSERT(m_cbCardIndex[wChairID][cbCardIndex] > 0);
			m_cbCardIndex[wChairID][cbCardIndex]--;
			m_cbOperateScore[wChairID] += GetOperatorScore(WIK_SI_ZHAO, cbCardIndex, m_WeaveItemArray[wChairID][cbWeaveIndex].cbMargicOffset);
			m_cbOperateScore[wChairID] -= TempScore;
			//m_wDianGangUser = wChairID;
			m_cbUserAction[m_wCurrentUser] = WIK_NULL;
			m_cbPerformAction[m_wCurrentUser] = WIK_NULL;
			//构造结果
			CMD_S_OperateResult_Hua OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.cbOperateScore = m_cbOperateScore[wChairID];
			OperateResult.cbActionMask = WIK_NULL;
			CopyMemory(OperateResult.cbHuaGangCard, cbHuaCard, sizeof(OperateResult.cbHuaGangCard));
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));

			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			//发送消息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));

			DispatchCardData(m_wCurrentUser);
			return true;	
		}
		case WIK_ZI_MO:		//自摸和牌
		{
			int TempAction = WIK_NULL;
			BYTE TempCardIndex[MAX_INDEX_HUA] = { 0 };
			BYTE TempHuaCardIndex[5] = { 0 };
			CopyMemory(TempCardIndex, m_cbCardIndex[wChairID], sizeof(TempCardIndex));
			CopyMemory(TempHuaCardIndex, m_cbHuaCardIndex[wChairID], sizeof(TempHuaCardIndex));
			m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[wChairID], TempHuaCardIndex, m_cbHuaCardIndex_Tong[wChairID]);
			TempAction |= m_GameLogic.AnalyseHuCard(TempCardIndex, TempHuaCardIndex, 0, m_WeaveItemArray_HuPai[wChairID], m_cbWeaveItemCount_HuPai[wChairID], m_cbHuaWeaveCardIndex[wChairID], m_cbTongCount[wChairID], ChiHu);
			if (TempAction == WIK_NULL)
			{
				return false;
			}
			m_HuPai[wChairID]++;
			CMD_S_OperateResult_Hua OperateResult;
			ZeroMemory(&OperateResult, sizeof(OperateResult));
			OperateResult.wOperateUser = wChairID;
			OperateResult.cbOperateCard = m_cbProvideCard;
			OperateResult.cbOperateCode = WIK_ZI_MO;
			OperateResult.wProvideUser = wChairID;
			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			//发送消息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT_HUA, &OperateResult, sizeof(OperateResult));

			//结束
			OnEventGameConclude(wChairID, NULL, GER_NORMAL);
			return true;
		}
		default:
			ASSERT(FALSE);
			return false;
		}
		return true;
	}
	return true;
}

//发送操作
bool TableFrameSinkZhiPai::SendOperateNotify()
{
	//发送提示
	for (WORD i=0;i<GAME_PLAY;i++)
	{
		if (m_cbUserAction[i]!=WIK_NULL)
		{
			//构造数据
			CMD_S_OperateNotify_Hua OperateNotify;
			ZeroMemory(&OperateNotify, sizeof(OperateNotify));
			OperateNotify.wResumeUser=m_wResumeUser;
			OperateNotify.cbActionCard=m_cbProvideCard;
			OperateNotify.cbActionMask=m_cbUserAction[i];
			if (OperateNotify.cbActionMask&WIK_CHI_HU)
			{
				OperateNotify.HuShu = EsponseHuShu[i];
				OperateNotify.PaPo = EsponsePaPoShu[i];
			}
			//发送数据
			m_pITableFrame->SendTableData(i, SUB_S_OPERATE_NOTIFY_HUA, &OperateNotify, sizeof(OperateNotify));
		}
	}
	return true;
}

//派发扑克,wCurrentUser表示给哪个用户，bTail表示是末尾拿牌还是不是，true表示末尾
bool TableFrameSinkZhiPai::DispatchCardData(WORD wCurrentUser, bool bTail)
{
	//状态效验
	ASSERT(wCurrentUser != INVALID_CHAIR);
	if (wCurrentUser == INVALID_CHAIR)
		return false;

	//丢弃扑克
	if ((m_wOutCardUser != INVALID_CHAIR) && (m_cbOutCardData != 0))
	{
		m_cbDiscardCount[m_wOutCardUser]++;
		m_cbDiscardCard[m_wOutCardUser][m_cbDiscardCount[m_wOutCardUser] - 1] = m_cbOutCardData;
	}
	//荒庄结束
	if (m_cbLeftCardCount == 0)
	{
		m_wProvideUser = (wCurrentUser + 1) % GAME_PLAY;
		bIsHuang = true;
		OnEventGameConclude(INVALID_CHAIR, NULL, GER_NORMAL);
		return true;
	}

	//设置变量
	m_cbOutCardData = 0;
	m_wCurrentUser = wCurrentUser;		//当前玩家
	m_wOutCardUser = INVALID_CHAIR;		//置空上次出牌用户的索引
	BYTE ActionCard[6] = { 0 };			//操作牌值
	//发送扑克
	DWORD timet = GetTickCount();
	m_cbSendCardCount++;
	switch (bGameType)
	{
	case huapai:
	{
		m_cbSendCardData = m_cbRepertoryCard_Two[--m_cbLeftCardCount];
		break;
	}
	case huapai2:
	{
		m_cbSendCardData = m_cbRepertoryCard_One[--m_cbLeftCardCount];
		break;
	}
	case huapai3:
	{
		m_cbSendCardData = m_cbRepertoryCard[--m_cbLeftCardCount];
		break;
	}
	default:
	{
		ASSERT(false);
		break;
	}
	}
	//加牌
	m_cbCardIndex[wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;
	if ((m_cbSendCardData & 0x10) == 0x10)
	{
		BYTE TempIndex = m_GameLogic.SwitchToCardIndex(m_cbSendCardData);
		m_cbHuaCardIndex[wCurrentUser][TempIndex / 2]++;
	}
	BYTE TempWeiZhi = 0xff;
	for (BYTE i = 0; i < 9; i++)
	{
		if (m_cbGamePlayerHandCard[wCurrentUser][8][i] == 0)
		{
			m_cbGamePlayerHandCard[wCurrentUser][8][i] = m_cbSendCardData;
			TempWeiZhi = i;
			break;
		}
	}
	if (TempWeiZhi == 0xff)
	{
		for (BYTE i = 0; i < 9; i++)
		{
			if (m_cbGamePlayerHandCard[wCurrentUser][7][i] == 0)
			{
				m_cbGamePlayerHandCard[wCurrentUser][7][i] = m_cbSendCardData;
				TempWeiZhi = i;
				break;
			}
		}
	}
	ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
	if (bTail == false)
	{
		tagHuCardResult chr;
		BYTE TempCardIndex[MAX_INDEX_HUA] = { 0 };
		BYTE TempHuaCardIndex[5] = { 0 };
		CopyMemory(TempCardIndex, m_cbCardIndex[wCurrentUser], sizeof(TempCardIndex));
		CopyMemory(TempHuaCardIndex, m_cbHuaCardIndex[wCurrentUser], sizeof(TempHuaCardIndex));
		m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[wCurrentUser], TempHuaCardIndex, m_cbHuaCardIndex_Tong[wCurrentUser]);
		m_cbUserAction[wCurrentUser] |= m_GameLogic.AnalyseHuCard(TempCardIndex, TempHuaCardIndex, 0, m_WeaveItemArray_HuPai[wCurrentUser], m_cbWeaveItemCount_HuPai[wCurrentUser], m_cbHuaWeaveCardIndex[wCurrentUser], m_cbTongCount[wCurrentUser], chr);
		if (m_cbUserAction[wCurrentUser] & WIK_ZI_MO)
		{
			EsponseHuShu[wCurrentUser] = chr.bHuPoint;
			if (m_gameConfig.GameScoreType == 0)
			{
				EsponsePaPoShu[wCurrentUser] = (chr.bHuPoint - 17) / 5 + 1;
			}
		}
	}

	
	//设置变量
	m_wProvideUser = wCurrentUser;	//提供人，
	m_cbProvideCard = m_cbSendCardData; //提供牌，

	//杠牌判断
	tagGangCardResult_Hua GangCardResult;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	if (m_cbLeftCardCount > 0)
	{
		m_cbUserAction[wCurrentUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wCurrentUser], m_cbHuaCardIndex[wCurrentUser],
			m_WeaveItemArray[wCurrentUser], m_cbWeaveItemCount[wCurrentUser], GangCardResult);
	}
	WORD TempNextUser = INVALID_CHAIR;//临时用户，记录当前用户的下一个可以请统用户
	if (bTail&&m_cbOutCardCount == 0 && m_cbUserAction[wCurrentUser] == WIK_NULL&&wCurrentUser != m_wBankerUser)//当前用户五统了，进行下一家判断
	{
		if (wCurrentUser == 0)
		{
			TempNextUser = 2;
		}
		else
		{
			TempNextUser = wCurrentUser - 1;
		}
		m_cbUserAction[TempNextUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[TempNextUser], m_cbHuaCardIndex[TempNextUser],
			m_WeaveItemArray[TempNextUser], m_cbWeaveItemCount[TempNextUser], GangCardResult);
		if (TempNextUser != m_wBankerUser && m_cbUserAction[TempNextUser] == WIK_NULL)
		{
			if (TempNextUser == 0)
			{
				TempNextUser = 2;
			}
			else
			{
				TempNextUser--;
			}
			m_cbUserAction[TempNextUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[TempNextUser], m_cbHuaCardIndex[TempNextUser],
				m_WeaveItemArray[TempNextUser], m_cbWeaveItemCount[TempNextUser], GangCardResult);
		}
	}
	

	DWORD t2 = GetTickCount();
	DWORD hh = t2 - timet;
	CString csTemp;
	//csTemp.Format(L"时间:%d \r\n", hh);
	OutputDebugString(csTemp);

	//构造数据.
	CMD_S_SendCard_Hua SendCard;
	ZeroMemory(&SendCard, sizeof(SendCard));
	SendCard.wCurrentUser = wCurrentUser;
	SendCard.bTail = bTail;
	SendCard.bLeftCardCount = m_cbLeftCardCount;
	m_cbUserAction[wCurrentUser] |= (bTail == false ? WIK_BH_WJCP : WIK_NULL);
	SendCard.cbCardData = m_cbSendCardData;
	RepayRecord(INVALID_CHAIR, SUB_S_SEND_CARD_HUA, &SendCard, sizeof(SendCard));

	//发送数据
	for (int i = 0; i < GAME_PLAY; i++)
	{
		if (i == m_wCurrentUser)
		{//发送给摸牌玩家的数据，附带麻将牌面数据
			for (BYTE j = 0; j < GangCardResult.cbCardCount; j++)
				SendCard.cbActionCard[j] = GangCardResult.cbCardData[j];

			SendCard.cbCardData = m_cbSendCardData;
			SendCard.cbActionMask = m_cbUserAction[wCurrentUser];
			if (SendCard.cbActionMask & WIK_ZI_MO)
			{
				SendCard.HuShu = EsponseHuShu[i];
				SendCard.PaPoShu = EsponsePaPoShu[i];				
			}
			m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD_HUA, &SendCard, sizeof(SendCard));
		}
		else
		{//发送给其他玩家的数据，没有麻将牌面数据（防止客户端作弊）
			ZeroMemory(SendCard.cbActionCard, sizeof(SendCard.cbActionCard));
			SendCard.cbCardData = 0x00;
			SendCard.cbActionMask = m_cbUserAction[i];
			SendCard.HuShu = 0;
			SendCard.PaPoShu = 0;
			m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD_HUA, &SendCard, sizeof(SendCard));
		}
	}
	SendCard.cbActionMask = 0;
	SendCard.cbCardData = 0;
	ZeroMemory(SendCard.cbActionCard, sizeof(SendCard.cbActionCard));
	//给旁观者的抓牌动作
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_SEND_CARD_HUA, &SendCard, sizeof(SendCard));

	if (bTail&&m_cbOutCardCount == 0 && TempNextUser != INVALID_CHAIR && (m_cbUserAction[TempNextUser] == WIK_SI_TONG))
	{
		CMD_S_QingTongNotify QingTong;
		ZeroMemory(&QingTong, sizeof(QingTong));
		QingTong.OperatorUser = TempNextUser;
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			if (i == TempNextUser)
			{
				if (i == m_wBankerUser)
				{
					m_cbUserAction[TempNextUser] |= WIK_BH_WJCP;
				}
				QingTong.cbActionMask = m_cbUserAction[TempNextUser];
				CopyMemory(QingTong.cbActionCard, GangCardResult.cbCardData, sizeof(GangCardResult.cbCardData));
				m_pITableFrame->SendTableData(TempNextUser, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
				m_wCurrentUser = TempNextUser;
			}
			else
			{
				QingTong.cbActionMask = WIK_NULL;
				ZeroMemory(QingTong.cbActionCard, sizeof(QingTong.cbActionCard));
				m_pITableFrame->SendTableData(i, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
			}			
		}	
		m_wCurrentUser = TempNextUser;
		return true;
	}
	if (bTail&&m_cbOutCardCount == 0 && TempNextUser == m_wBankerUser && m_cbUserAction[TempNextUser] == WIK_NULL)
	{
		CMD_S_QingTongNotify QingTong;
		ZeroMemory(&QingTong, sizeof(QingTong));
		QingTong.OperatorUser = TempNextUser;
		for (BYTE i = 0; i < GAME_PLAY; i++)
		{
			if (i == TempNextUser)
			{
				m_cbUserAction[TempNextUser] = WIK_BH_WJCP;
				QingTong.cbActionMask = WIK_BH_WJCP;
				m_pITableFrame->SendTableData(TempNextUser, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
			}
			else
			{
				QingTong.cbActionMask = WIK_NULL;
				m_pITableFrame->SendTableData(i, SUB_S_QINGTONG_NOTIFY_HUA, &QingTong, sizeof(QingTong));
			}
		}
		m_wCurrentUser = m_wBankerUser;
	}
	return true;
	//if (m_TabbOutCardCout[m_wCurrentUser] > 0)//有听牌就发一个听牌协议
	//{
	//	HttpTingCard(m_wCurrentUser);
	//}
	//if (b_wIsGangTing[wCurrentUser] && m_cbUserAction[wCurrentUser] == WIK_NULL)//上面是发完起牌动作，开始判断是否是听牌
	//{
	//	m_pITableFrame->SetGameTimer(13, 1000, -1, wCurrentUser);//调用定时器，自动出牌
	//}
}

//响应判断
bool TableFrameSinkZhiPai::EstimateUserRespond(WORD wCenterUser, BYTE cbCenterCard, enEstimatKind EstimatKind)
{
	//变量定义
	bool bAroseAction[GAME_PLAY] = { false };
	bool mbAroseAction = false;	
	//用户状态
	ZeroMemory(m_bResponse, sizeof(m_bResponse));
	ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
	ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
	ZeroMemory(EsponseHuShu, sizeof(EsponseHuShu));//胡数
	ZeroMemory(EsponsePaPoShu, sizeof(EsponsePaPoShu));//爬坡数
	if (cbCenterCard == 0x2D)return false;
	//动作判断
	for (WORD i = 0; i < GAME_PLAY; i++)
	{
		//用户过滤
		if (wCenterUser == i)
			continue;
		//出牌类型
		if (EstimatKind == EstimatKind_OutCard)
		{
			tagHuCardResult chr;
			BYTE TempCardIndex[MAX_INDEX_HUA] = { 0 };
			BYTE TempHuaCardIndex[5] = { 0 };
			CopyMemory(TempCardIndex, m_cbCardIndex[i], sizeof(TempCardIndex));
			CopyMemory(TempHuaCardIndex, m_cbHuaCardIndex[i], sizeof(TempHuaCardIndex));
			m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[i], TempHuaCardIndex, m_cbHuaCardIndex_Tong[i]);
			int wAction = m_GameLogic.AnalyseHuCard(TempCardIndex, TempHuaCardIndex, cbCenterCard, m_WeaveItemArray_HuPai[i], m_cbWeaveItemCount_HuPai[i], m_cbHuaWeaveCardIndex[i], m_cbTongCount[i], chr);
			if (wAction != WIK_NULL)
			{
				m_cbUserAction[i] = WIK_CHI_HU;
				EsponseHuShu[i] = chr.bHuPoint;
				EsponsePaPoShu[i] = (chr.bHuPoint - 17) / 5 + 1;
			}
			if (m_cbDuiOperator[i] < 2)
			{
				//碰牌判断
				m_cbUserAction[i] |= m_GameLogic.EstimatePengCard(m_cbCardIndex[i], cbCenterCard);
			}			
			if (m_cbLeftCardCount > 0)//杠牌判断
			{
				m_cbUserAction[i] |= m_GameLogic.EstimateGangCard(m_cbCardIndex[i], cbCenterCard, m_WeaveItemArray[i], m_cbWeaveItemCount[i]);
			}
		}

		//结果判断
		if (m_cbUserAction[i] != WIK_NULL)
		{
			bAroseAction[i] = true;
			if (m_cbUserAction[i] & (WIK_CHI_HU | WIK_DUI))
			{
				//记忆牌有多少张
				for (BYTE j = 0; j < m_cbLastDisCount[i]; j++)
				{
					//如果在一圈中 记忆2个一样的牌 则不能操作
					if (m_cbLastDisCardData[i][j] == cbCenterCard)
					{
						m_cbUserAction[i] = m_cbUserAction[i] & (~(WIK_CHI_HU | WIK_DUI));
						if (m_cbUserAction[i] == WIK_NULL)
							bAroseAction[i] = false;
					}
				}
			}
		}
	}//动作判断for结束
	for (int i = 0; i < GAME_PLAY; i++)
	{
		if (bAroseAction[i] == true)
		{
			mbAroseAction = true;
			break;
		}
	}
	if (mbAroseAction)
	{
		m_wProvideUser = wCenterUser;
		m_cbProvideCard = cbCenterCard;
		m_wResumeUser = m_wCurrentUser;
		m_wCurrentUser = INVALID_CHAIR;
		SendOperateNotify();
		return mbAroseAction;
	}
	return mbAroseAction;
}

//操作优先级
//优先级判断
bool TableFrameSinkZhiPai::OperatorPriority(WORD TempUser, WORD &wTargetUser, int &cbTargetAction)
{
	if (wTargetUser == (TempUser + 1) % GAME_PLAY)
	{
		WORD TempUser1 = (TempUser + 2) % GAME_PLAY;
		//获取动作
		int cbUserAction = (m_bResponse[TempUser1] == false) ? m_cbUserAction[TempUser1] : m_cbPerformAction[TempUser1];
		//优先级别
		BYTE cbUserActionRank = m_GameLogic.GetUserActionRank(cbUserAction);
		BYTE cbTargetActionRank = m_GameLogic.GetUserActionRank(cbTargetAction);
		//动作判断
		if (cbUserActionRank > cbTargetActionRank)
		{
			wTargetUser = TempUser1;
			cbTargetAction = cbUserAction;
			return true;
		}
	}
	else if (wTargetUser == (TempUser + 2) % GAME_PLAY)
	{
		WORD TempUser1 = (TempUser + 1) % GAME_PLAY;

		//获取动作
		int cbUserAction1 = (m_bResponse[TempUser1] == false) ? m_cbUserAction[TempUser1] : m_cbPerformAction[TempUser1];
		//优先级别
		BYTE cbUserActionRank1 = m_GameLogic.GetUserActionRank(cbUserAction1);
		BYTE cbTargetActionRank = m_GameLogic.GetUserActionRank(cbTargetAction);
		//动作判断
		if (cbUserActionRank1 > cbTargetActionRank)
		{
			wTargetUser = TempUser1;
			cbTargetAction = cbUserAction1;
			return true;
		}
		if (cbUserActionRank1 == cbTargetActionRank && cbUserActionRank1 == 5 && m_bResponse[TempUser1] == false)
		{
			wTargetUser = TempUser1;
			cbTargetAction = cbUserAction1;
			return true;
		}
		if (cbUserActionRank1 == cbTargetActionRank && cbUserActionRank1 ==2 && m_bResponse[TempUser1] == false)
		{
			wTargetUser = TempUser1;
			cbTargetAction = cbUserAction1;
			return true;
		}
	}
	return true;
}

bool TableFrameSinkZhiPai::GetGameEndPaiQiang(WORD wChairID, BYTE GameEndCard[9][5])
{
	BYTE TempCount = 0;
	BYTE TempCardIndex[MAX_INDEX_HUA] = { 0 };//手牌
	BYTE TempHuaCardIndex[5] = { 0 };
	//BYTE TempCardIndex_Tong[MAX_INDEX_HUA] = { 0 };//捅出去的手牌
	//BYTE TempHuaCardIndex_Tong[5] = { 0 };
	CopyMemory(TempCardIndex, m_cbCardIndex[wChairID], sizeof(TempCardIndex));
	CopyMemory(TempHuaCardIndex, m_cbHuaCardIndex[wChairID], sizeof(TempHuaCardIndex));
	//m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[wChairID], TempHuaCardIndex, m_cbHuaCardIndex_Tong[wChairID]);
	//CopyMemory(TempCardIndex_Tong, m_cbCardIndex_Tong[wChairID], sizeof(TempCardIndex_Tong));
	//CopyMemory(TempHuaCardIndex_Tong, m_cbHuaCardIndex_Tong[wChairID], sizeof(TempHuaCardIndex_Tong));
	//bool IsTongXiangDui = false;//false统的个数没变了，true表示统的个数变了
	//BYTE TongNum = 0;
	//
	//for (BYTE i = 0; i < m_cbWeaveItemCount[wChairID]; i++)//扫描我们的统组合是否存在游戏结束里面，如果存在就不管了，如果不存在，就需要把统组合里面的牌值回归给手牌里面
	//{
	//	if (m_WeaveItemArray[wChairID][i].cbWeaveKind==WIK_SI_TONG)
	//	{
	//		bool IsHupaiZuHe = false;//false表示胡牌组合里面没有这个行牌组合
	//		for (BYTE j = 0; j < 8; j++)
	//		{
	//			if (ChiHu.AnalyseItem.cbWeaveKind[j]==WIK_SI_TONG  && ChiHu.AnalyseItem.cbCenterCard[j] == m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[wChairID][i].cbCenterCard))
	//			{
	//				IsHupaiZuHe = true;
	//				break;
	//			}
	//			if (ChiHu.AnalyseItem.cbWeaveKind[j] == WIK_DUI  && ChiHu.AnalyseItem.cbCenterCard[j] == m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[wChairID][i].cbCenterCard))
	//			{
	//				if (ChiHu.AnalyseItem.cbCenterCard[j] == 2 || ChiHu.AnalyseItem.cbCenterCard[j] == 4 || ChiHu.AnalyseItem.cbCenterCard[j] == 6)
	//				{
	//				}
	//				IsHupaiZuHe = true;
	//				break;
	//			}
	//		}
	//		if (IsHupaiZuHe)
	//		{
	//			continue;
	//		}
	//	}
	//	if (m_WeaveItemArray[wChairID][i].cbWeaveKind == WIK_WU_TONG)
	//	{
	//	}
	//}
	//if (TongNum < m_WeaveItemArray[wChairID] - m_WeaveItemArray_HuPai[wChairID])
	//{
	//	IsTongXiangDui = true;
	//}
	for (BYTE i = 0; i < 8; i++)
	{
		BYTE TempIndex = ChiHu.AnalyseItem.cbCenterCard[i];
		BYTE TempCardData = m_GameLogic.SwitchToCardData(TempIndex);
		switch (ChiHu.AnalyseItem.cbWeaveKind[i])
		{
		case WIK_QI_TA:
		{
			if (ChiHu.AnalyseItem.cbCenterCard[i] < (10 - 2))//连牌
			{
				for (BYTE j = 0; j < 3; j++)
				{
					if (TempCardData == 1 || TempCardData == 3 || TempCardData == 5 || TempCardData == 7 || TempCardData == 9)
					{
						if (TempCardData == 3 || TempCardData == 5 || TempCardData == 7)
						{
							if (TempHuaCardIndex[TempIndex / 2] > 0)
							{
								GameEndCard[TempCount][j] = (TempCardData | 0x10);
								ASSERT(TempCardIndex[TempIndex] > 0);
								TempCardIndex[TempIndex]--;
								ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
								TempHuaCardIndex[TempIndex / 2]--;
							}
							else if (TempCardIndex[TempIndex] == 0 && TempCardIndex[22] > 0)
							{
								GameEndCard[TempCount][j] = 0x2D;
								ASSERT(TempCardIndex[22] > 0);
								TempCardIndex[22]--;
							}
							else if (TempCardIndex[TempIndex] > 0)
							{
								GameEndCard[TempCount][j] = TempCardData;
								ASSERT(TempCardIndex[TempIndex] > 0);
								TempCardIndex[TempIndex]--;
							}
						}
						else
						{
							if (TempHuaCardIndex[TempIndex / 2] > 0)
							{
								GameEndCard[TempCount][j] = (TempCardData | 0x10);
								ASSERT(TempCardIndex[TempIndex] > 0);
								TempCardIndex[TempIndex]--;
								ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
								TempHuaCardIndex[TempIndex / 2]--;
							}
							else
							{
								GameEndCard[TempCount][j] = TempCardData;
								ASSERT(TempCardIndex[TempIndex] > 0);
								TempCardIndex[TempIndex]--;
							}
						}
					}
					else
					{
						GameEndCard[TempCount][j] = TempCardData;
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex]--;
					}
					TempCardData++;
					TempIndex++;
				}
				TempCount++;
				continue;
			}
			//孔乙已:孔
			if (ChiHu.AnalyseItem.cbCenterCard[i] == 10)
			{
				ASSERT(TempCardIndex[10] > 0);
				TempCardIndex[10]--;
				GameEndCard[TempCount][0] = TempCardData;
				if (TempHuaCardIndex[0] > 0)
				{
					GameEndCard[TempCount][1] = 0x11;
					ASSERT(TempCardIndex[0] > 0);
					ASSERT(TempHuaCardIndex[0] > 0);
					TempCardIndex[0]--;
					TempHuaCardIndex[0]--;
				}
				else
				{
					ASSERT(TempCardIndex[0] > 0);
					TempCardIndex[0]--;
					GameEndCard[TempCount][1] = 1;
				}
				ASSERT(TempCardIndex[11] > 0);
				TempCardIndex[11]--;
				GameEndCard[TempCount][2] = TempCardData + 1;
				TempCount++;
				continue;
			}
			//上大人:上
			if (ChiHu.AnalyseItem.cbCenterCard[i] == 12)
			{
				ASSERT(TempCardIndex[12] > 0);
				TempCardIndex[12]--;
				ASSERT(TempCardIndex[13] > 0);
				TempCardIndex[13]--;
				ASSERT(TempCardIndex[14] > 0);
				TempCardIndex[14]--;
				GameEndCard[TempCount][0] = TempCardData;
				GameEndCard[TempCount][1] = TempCardData + 1;
				GameEndCard[TempCount][2] = TempCardData + 2;
				TempCount++;
				continue;
			}
			//七十土:土
			if (ChiHu.AnalyseItem.cbCenterCard[i] == 15)
			{
				if (TempHuaCardIndex[3] > 0)
				{
					ASSERT(TempCardIndex[6] > 0);
					TempCardIndex[6]--;
					ASSERT(TempHuaCardIndex[3] > 0);
					TempHuaCardIndex[3]--;
					GameEndCard[TempCount][0] = 0x17;
				}
				else if (TempCardIndex[22] > 0 && TempCardIndex[6] == 0)
				{
					GameEndCard[TempCount][0] = 0x2D;
					ASSERT(TempCardIndex[22] > 0);
					TempCardIndex[22]--;
				}
				else
				{
					ASSERT(TempCardIndex[6] > 0);
					TempCardIndex[6]--;
					GameEndCard[TempCount][0] = 7;
				}
				ASSERT(TempCardIndex[9] > 0);
				TempCardIndex[9]--;
				GameEndCard[TempCount][1] = 10;
				ASSERT(TempCardIndex[15] > 0);
				TempCardIndex[15]--;
				GameEndCard[TempCount][2] = TempCardData;
				TempCount++;
				continue;
			}
			//化三千:化
			if (ChiHu.AnalyseItem.cbCenterCard[i] == 16)
			{
				ASSERT(TempCardIndex[16] > 0);
				TempCardIndex[16]--;
				GameEndCard[TempCount][0] = TempCardData;
				if (TempHuaCardIndex[1] > 0)
				{
					ASSERT(TempCardIndex[2] > 0);
					TempCardIndex[2]--;
					ASSERT(TempHuaCardIndex[1] > 0);
					TempHuaCardIndex[1]--;
					GameEndCard[TempCount][1] = 0x13;
				}
				else if (TempCardIndex[22] > 0 && TempCardIndex[2] == 0)
				{
					GameEndCard[TempCount][1] = 0x2D;
					ASSERT(TempCardIndex[22] > 0);
					TempCardIndex[22]--;
				}
				else
				{
					ASSERT(TempCardIndex[2] > 0);
					TempCardIndex[2]--;
					GameEndCard[TempCount][1] = 3;
				}
				ASSERT(TempCardIndex[17] > 0);
				TempCardIndex[17]--;
				GameEndCard[TempCount][2] = TempCardData + 1;
				TempCount++;
				continue;
			}
			//可知礼
			if (ChiHu.AnalyseItem.cbCenterCard[i] == 18)
			{
				ASSERT(TempCardIndex[18] > 0);
				TempCardIndex[18]--;
				ASSERT(TempCardIndex[19] > 0);
				TempCardIndex[19]--;
				ASSERT(TempCardIndex[20] > 0);
				TempCardIndex[20]--;
				GameEndCard[TempCount][0] = TempCardData;
				GameEndCard[TempCount][1] = TempCardData + 1;
				GameEndCard[TempCount][2] = TempCardData + 2;
				TempCount++;
				continue;
			}
			//八九子
			if (ChiHu.AnalyseItem.cbCenterCard[i] == 21)
			{
				ASSERT(TempCardIndex[7] > 0);
				TempCardIndex[7]--;
				GameEndCard[TempCount][0] = 8;
				if (TempHuaCardIndex[4] > 0)
				{
					ASSERT(TempCardIndex[8] > 0);
					TempCardIndex[8]--;
					ASSERT(TempHuaCardIndex[4] > 0);
					TempHuaCardIndex[4]--;
					GameEndCard[TempCount][1] = 0x19;
				}
				else
				{
					ASSERT(TempCardIndex[8] > 0);
					TempCardIndex[8]--;
					GameEndCard[TempCount][1] = 9;
				}
				ASSERT(TempCardIndex[21] > 0);
				TempCardIndex[21]--;
				GameEndCard[TempCount][2] = TempCardData;
				TempCount++;
				continue;
			}
			break;
		}
		case WIK_SI_TONG:
		{
			if (TempIndex == 2 || TempIndex == 4 || TempIndex == 6)
			{
				for (BYTE j = 0; j < 4; j++)
				{
					if (TempHuaCardIndex[TempIndex / 2] > 0)
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex] --;
						ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
						TempHuaCardIndex[TempIndex / 2] --;
						GameEndCard[TempCount][j] = (TempCardData | 0x10);
					}
					else if (TempCardIndex[TempIndex] > 0)
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex] --;
						GameEndCard[TempCount][j] = TempCardData;
					}
					else if (TempCardIndex[22] > 0)
					{
						ASSERT(TempCardIndex[22] > 0);
						TempCardIndex[22] --;
						GameEndCard[TempCount][j] = 0x2D;
					}
					else
					{
						ASSERT(false);
					}
				}
			}
			else
			{
				for (BYTE j = 0; j < 4; j++)
				{
					if (TempIndex == 8 || TempIndex == 0)
					{
						if (TempHuaCardIndex[TempIndex / 2] > 0)
						{
							ASSERT(TempCardIndex[TempIndex] > 0);
							TempCardIndex[TempIndex]--;
							ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
							TempHuaCardIndex[TempIndex / 2]--;
							GameEndCard[TempCount][j] = (TempCardData | 0x10);
						}
						else if (TempCardIndex[TempIndex / 2] > 0)
						{
							ASSERT(TempCardIndex[TempIndex] > 0);
							TempCardIndex[TempIndex]--;
							GameEndCard[TempCount][j] = TempCardData;
						}
						else
						{
							ASSERT(false);
						}
					}
					else
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex]--;
						GameEndCard[TempCount][j] = TempCardData;
					}
				}
			}
			TempCount++;
			break;
		}
		case WIK_WU_TONG:
		{
			if (TempIndex == 2 || TempIndex == 4 || TempIndex == 6)
			{
				for (BYTE j = 0; j < 5; j++)
				{
					if (TempHuaCardIndex[TempIndex / 2] > 0)
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex] --;
						ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
						TempHuaCardIndex[TempIndex / 2] --;
						GameEndCard[TempCount][j] = (TempCardData | 0x10);
					}
					else if (TempCardIndex[TempIndex] > 0)
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex] --;
						GameEndCard[TempCount][j] = TempCardData;
					}
					else if (TempCardIndex[22] > 0)
					{
						ASSERT(TempCardIndex[22] > 0);
						TempCardIndex[22] --;
						GameEndCard[TempCount][j] = 0x2D;
					}
					else
					{
						ASSERT(false);
					}
				}
			}
			else
			{
				for (BYTE j = 0; j < 5; j++)
				{
					if (TempIndex == 8 || TempIndex == 0)
					{
						if (TempHuaCardIndex[TempIndex / 2] > 0)
						{
							ASSERT(TempCardIndex[TempIndex] > 0);
							TempCardIndex[TempIndex]--;
							ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
							TempHuaCardIndex[TempIndex / 2]--;
							GameEndCard[TempCount][j] = (TempCardData | 0x10);
						}
						else if (TempCardIndex[TempIndex / 2] > 0)
						{
							ASSERT(TempCardIndex[TempIndex] > 0);
							TempCardIndex[TempIndex]--;
							GameEndCard[TempCount][j] = TempCardData;
						}
						else
						{
							ASSERT(false);
						}
					}
					else
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex]--;
						GameEndCard[TempCount][j] = TempCardData;
					}
				}
			}
			TempCount++;
			break;
		}
		case WIK_DUI:
		{
			if ((TempIndex == 2 || TempIndex == 4 || TempIndex == 6) && (TempCardIndex[22] + TempCardIndex[TempIndex]) >= 3)
			{
				for (BYTE j = 0; j < 3; j++)
				{
					if (TempHuaCardIndex[TempIndex / 2] > 0)
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex] --;
						ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
						TempHuaCardIndex[TempIndex / 2] --;
						GameEndCard[TempCount][j] = (TempCardData | 0x10);
					}
					else if (TempCardIndex[TempIndex] > 0)
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex] --;
						GameEndCard[TempCount][j] = TempCardData;
					}
					else if (TempCardIndex[22] > 0)
					{
						ASSERT(TempCardIndex[22] > 0);
						TempCardIndex[22] --;
						GameEndCard[TempCount][j] = 0x2D;
					}
					else
					{
						ASSERT(false);
					}
				}
				TempCount++;
				break;
			}
			else if (TempCardIndex[TempIndex] >= 3)
			{
				for (BYTE j = 0; j < 3; j++)
				{
					if (TempIndex == 8 || TempIndex == 0)
					{
						if (TempHuaCardIndex[TempIndex / 2] > 0)
						{
							ASSERT(TempCardIndex[TempIndex] > 0);
							TempCardIndex[TempIndex]--;
							ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
							TempHuaCardIndex[TempIndex / 2]--;
							GameEndCard[TempCount][j] = (TempCardData | 0x10);
						}
						else if (TempCardIndex[TempIndex] > 0)
						{
							ASSERT(TempCardIndex[TempIndex] > 0);
							TempCardIndex[TempIndex]--;
							GameEndCard[TempCount][j] = TempCardData;
						}
						else
						{
							ASSERT(false);
						}
					}
					else
					{
						ASSERT(TempCardIndex[TempIndex] > 0);
						TempCardIndex[TempIndex]--;
						GameEndCard[TempCount][j] = TempCardData;
					}
				}
				TempCount++;
				break;
			}
			break;
		}
		case WIK_SAN_ZHAO:
		{
			break;
		}
		case WIK_SI_ZHAO:
		{
			break;
		}
		default:
			break;
		}
	}
	if (ChiHu.AnalyseItem.cbCardEye[0] == 2 || ChiHu.AnalyseItem.cbCardEye[0] == 4 || ChiHu.AnalyseItem.cbCardEye[0] == 6)
	{
		if (TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[0] / 2] > 0)
		{
			GameEndCard[TempCount][0] = ((ChiHu.AnalyseItem.cbCardEye[0] + 1) | 0X10);
			TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[0] / 2]--;
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]]--;
		}
		else if (TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]] > 0)
		{
			GameEndCard[TempCount][0] = ChiHu.AnalyseItem.cbCardEye[0] + 1;
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]]--;
		}
		else if (TempCardIndex[22] > 0)
		{
			GameEndCard[TempCount][0] = 0x2D;
			TempCardIndex[22]--;
		}
		else
		{
			ASSERT(false);
			GameEndCard[TempCount][0] = ChiHu.AnalyseItem.cbCardEye[0] + 1;
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]]--;
		}
	}
	else
	{
		if (ChiHu.AnalyseItem.cbCardEye[0] == 0 || ChiHu.AnalyseItem.cbCardEye[0] == 8)
		{
			if (TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[0] / 2] > 0)
			{
				GameEndCard[TempCount][0] = ((ChiHu.AnalyseItem.cbCardEye[0] + 1) | 0X10);
				TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[0] / 2]--;
				TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]]--;
			}
			else
			{
				GameEndCard[TempCount][0] = ChiHu.AnalyseItem.cbCardEye[0] + 1;
				TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]]--;
			}
		}
		else
		{
			GameEndCard[TempCount][0] = m_GameLogic.SwitchToCardData(ChiHu.AnalyseItem.cbCardEye[0]);
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[0]]--;
		}
	}
	if (ChiHu.AnalyseItem.cbCardEye[1] == 2 || ChiHu.AnalyseItem.cbCardEye[1] == 4 || ChiHu.AnalyseItem.cbCardEye[1] == 6)
	{
		if (TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[1] / 2] > 0)
		{
			GameEndCard[TempCount][0] = ((ChiHu.AnalyseItem.cbCardEye[1] + 1) | 0X10);
			TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[1] / 2]--;
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]]--;
		}
		else if (TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]] > 0)
		{
			GameEndCard[TempCount][1] = ChiHu.AnalyseItem.cbCardEye[1] + 1;
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]]--;
		}
		else if (TempCardIndex[22] > 0)
		{
			GameEndCard[TempCount][1] = 0x2D;
			TempCardIndex[22]--;
		}
		else
		{
			ASSERT(false);
			GameEndCard[TempCount][1] = ChiHu.AnalyseItem.cbCardEye[1] + 1;
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]]--;
		}
	}
	else
	{
		if (ChiHu.AnalyseItem.cbCardEye[1] == 0 || ChiHu.AnalyseItem.cbCardEye[1] == 8)
		{
			if (TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[1] / 2] > 0)
			{
				GameEndCard[TempCount][1] = ((ChiHu.AnalyseItem.cbCardEye[1] + 1) | 0X10);
				TempHuaCardIndex[ChiHu.AnalyseItem.cbCardEye[1] / 2]--;
				TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]]--;
			}
			else
			{
				GameEndCard[TempCount][1] = ChiHu.AnalyseItem.cbCardEye[1] + 1;
				TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]]--;
			}
		}
		else
		{
			GameEndCard[TempCount][1] = m_GameLogic.SwitchToCardData(ChiHu.AnalyseItem.cbCardEye[1]);
			TempCardIndex[ChiHu.AnalyseItem.cbCardEye[1]]--;
		}
	}
	TempCount++;
	for (BYTE i = 0; i < m_cbWeaveItemCount_HuPai[wChairID]; i++)
	{
		switch (m_WeaveItemArray_HuPai[wChairID][i].cbWeaveKind)
		{
		case WIK_DUI:
		{
			BYTE  CountFour = 0;
			if (m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[0] != 0)
			{
				GameEndCard[TempCount][CountFour] = m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[0];
				CountFour++;
			}
			if (m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[1] != 0)
			{
				GameEndCard[TempCount][CountFour] = m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[1];
				CountFour++;
			}
			for (BYTE k = CountFour; k < 3; k++)
			{
				GameEndCard[TempCount][k] = m_WeaveItemArray_HuPai[wChairID][i].cbCenterCard;
			}
			TempCount++;
			break;
		}
		case WIK_SAN_ZHAO:
		{
			BYTE  CountFour = 0;
			if (m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[0] != 0)
			{
				GameEndCard[TempCount][CountFour] = m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[0];
				CountFour++;
			}
			if (m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[1] != 0)
			{
				GameEndCard[TempCount][CountFour] = m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[1];
				CountFour++;
			}
			for (BYTE k = CountFour; k < 4; k++)
			{
				GameEndCard[TempCount][k] = m_WeaveItemArray_HuPai[wChairID][i].cbCenterCard;
			}
			TempCount++;
			break;
		}
		case WIK_SI_ZHAO:
		{
			BYTE  CountFour = 0;
			if (m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[0] != 0)
			{
				GameEndCard[TempCount][CountFour] = m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[0];
				CountFour++;
			}
			if (m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[1] != 0)
			{
				GameEndCard[TempCount][CountFour] = m_WeaveItemArray_HuPai[wChairID][i].cbMargicOffset[1];
				CountFour++;
			}
			for (BYTE k = CountFour; k < 5; k++)
			{
				GameEndCard[TempCount][k] = m_WeaveItemArray_HuPai[wChairID][i].cbCenterCard;
			}
			TempCount++;
			break;
		}
		default:
			break;
		}
	}
	ASSERT(TempCount <= 9);
	return true;
}

bool TableFrameSinkZhiPai::GetGameEndCardIndex(WORD wChairID, BYTE TempCardIndex[28])
{
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		if (m_cbCardIndex[wChairID][i] != 0)
		{
			if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
			{
				for (BYTE k = 0; k < m_cbHuaCardIndex[wChairID][i / 2]; k++)
				{
					TempCardIndex[MAX_INDEX_HUA + i / 2]++;
				}
				for (BYTE k = 0; k < (m_cbCardIndex[wChairID][i] - m_cbHuaCardIndex[wChairID][i / 2]); k++)
				{
					TempCardIndex[i]++;
				}
			}
			else
			{
				TempCardIndex[i] = m_cbCardIndex[wChairID][i];
			}
		}
	}
	return true;
}

bool TableFrameSinkZhiPai::GetPaiQiang(WORD wChairID, BYTE HandCardData[9][9])
{
	ZeroMemory(HandCardData, sizeof(HandCardData));
	BYTE Line = 0;//行
	BYTE Row = 0;//列
	BYTE TempCardIndex[MAX_INDEX_HUA] = { 0 };
	BYTE TempHuaCardIndex[5] = { 0 };
	CopyMemory(TempCardIndex, m_cbCardIndex[wChairID], sizeof(TempCardIndex));
	CopyMemory(TempHuaCardIndex, m_cbHuaCardIndex[wChairID], sizeof(TempHuaCardIndex));
	m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[wChairID], TempHuaCardIndex, m_cbHuaCardIndex_Tong[wChairID]);
	if (wChairID == m_wBankerUser && m_cbOutCardCount == 0)
	{
		BYTE TempIndex = m_GameLogic.SwitchToCardIndex(m_cbSendCardData);
		ASSERT(TempCardIndex[TempIndex] > 0);
		if (TempCardIndex[TempIndex] > 0 && TempCardIndex[TempIndex] < 6)
		{
			TempCardIndex[TempIndex]--;
			if ((m_cbSendCardData & 0x10) == 0x10)
			{
				ASSERT(TempHuaCardIndex[TempIndex / 2] > 0);
				if (TempHuaCardIndex[TempIndex / 2] > 0 && TempHuaCardIndex[TempIndex / 2] < 3)
				{
					TempHuaCardIndex[TempIndex / 2]--;
				}
				else
				{
					TempHuaCardIndex[TempIndex / 2] = 0;
					return false;
				}
			}
		}
		else
		{
			TempCardIndex[TempIndex] = 0;
			return false;
		}
	}
	//m_GameLogic.HeBingCardIndex(TempCardIndex, m_cbCardIndex_Tong[wChairID], TempHuaCardIndex, m_cbHuaCardIndex_Tong[wChairID]);
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		if (TempCardIndex[i] == 5)
		{
			if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
			{
				if (TempHuaCardIndex[i / 2] < 3)
				{
					//将花牌数组中花牌个数保存到牌数据中
					for (BYTE k = 0; k < TempHuaCardIndex[i / 2]; k++)
					{
						HandCardData[Line][Row++] = 0x10 | (i + 1);
					}
					//将剩下的画白皮的
					for (BYTE j = 0; j < (TempCardIndex[i] - TempHuaCardIndex[i / 2]); j++)
					{
						HandCardData[Line][Row++] = 0x00 | (i + 1);
					}
					Line++;
					Row = 0;
					TempHuaCardIndex[i / 2] = 0;
				}
				else
				{
					return false;
				}
			}
			//普通牌处理
			else
			{
				for (BYTE j = 0; j<TempCardIndex[i]; j++)
				{
					HandCardData[Line][Row++] = m_GameLogic.SwitchToCardData(i);
				}
				Line++;
				Row = 0;
			}
			TempCardIndex[i] = 0;
		}
	}
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		if (TempCardIndex[i] == 4)
		{
			if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
			{
				if (TempHuaCardIndex[i / 2] < 3)
				{
					//将花牌数组中花牌个数保存到牌数据中
					for (BYTE k = 0; k < TempHuaCardIndex[i / 2]; k++)
					{
						HandCardData[Line][Row++] = 0x10 | (i + 1);
					}
					//将剩下的画白皮的
					for (BYTE j = 0; j < (TempCardIndex[i] - TempHuaCardIndex[i / 2]); j++)
					{
						HandCardData[Line][Row++] = 0x00 | (i + 1);
					}
					Line++;
					Row = 0;
					TempHuaCardIndex[i / 2] = 0;
				}
				else
				{
					return false;
				}
			}
			//普通牌处理
			else
			{
				for (BYTE j = 0; j<TempCardIndex[i]; j++)
				{
					HandCardData[Line][Row++] = m_GameLogic.SwitchToCardData(i);
				}
				Line++;
				Row = 0;
			}
			TempCardIndex[i] = 0;
		}
	}
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		if (TempCardIndex[i] == 3)
		{
			if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
			{
				if (TempHuaCardIndex[i / 2] < 3)
				{
					//将花牌数组中花牌个数保存到牌数据中
					for (BYTE k = 0; k < TempHuaCardIndex[i / 2]; k++)
					{
						HandCardData[Line][Row++] = 0x10 | (i + 1);
					}
					//将剩下的画白皮的
					for (BYTE j = 0; j < (TempCardIndex[i] - TempHuaCardIndex[i / 2]); j++)
					{
						HandCardData[Line][Row++] = 0x00 | (i + 1);
					}
					Line++;
					Row = 0;
					TempHuaCardIndex[i / 2] = 0;
				}
				else
				{
					return false;
				}
			}
			//普通牌处理
			else
			{
				for (BYTE j = 0; j<TempCardIndex[i]; j++)
				{
					HandCardData[Line][Row++] = m_GameLogic.SwitchToCardData(i);
				}
				Line++;
				Row = 0;
			}
			TempCardIndex[i] = 0;
		}
	}
	if (TempCardIndex[12] != 0 || TempCardIndex[13] != 0 || TempCardIndex[14] != 0)
	{
		if (TempCardIndex[12] < 6 && TempCardIndex[13] < 6 && TempCardIndex[14] < 6)
		{
			for (BYTE j = 0; j < TempCardIndex[12]; j++)
			{
				HandCardData[Line][Row++] = 0x23;
			}
			for (BYTE j = 0; j < TempCardIndex[13]; j++)
			{
				HandCardData[Line][Row++] = 0x24;
			}
			for (BYTE j = 0; j < TempCardIndex[14]; j++)
			{
				HandCardData[Line][Row++] = 0x25;
			}
			Line++;
			Row = 0;
			TempCardIndex[12] = 0;
			TempCardIndex[13] = 0;
			TempCardIndex[14] = 0;
		}
		else
		{
			return false;
		}
	}
	if (TempCardIndex[18] != 0 || TempCardIndex[19] != 0 || TempCardIndex[20] != 0)
	{
		if (TempCardIndex[18] < 6 && TempCardIndex[19] < 6 && TempCardIndex[20] < 6)
		{
			for (BYTE j = 0; j < TempCardIndex[18]; j++)
			{
				HandCardData[Line][Row++] = 0x29;
			}
			for (BYTE j = 0; j < TempCardIndex[19]; j++)
			{
				HandCardData[Line][Row++] = 0x2A;
			}
			for (BYTE j = 0; j < TempCardIndex[20]; j++)
			{
				HandCardData[Line][Row++] = 0x2B;
			}
			Line++;
			Row = 0;
			TempCardIndex[18] = 0;
			TempCardIndex[19] = 0;
			TempCardIndex[20] = 0;
			ASSERT(Line <= 9);
		}
		else
		{
			return false;
		}
	}
	if (Line >= 8)
	{
		ASSERT(Line == 8);
		for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
		{
			if (TempCardIndex[i] > 0)
			{
				if (TempCardIndex[i] < 6)
				{
					if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
					{
						if (TempHuaCardIndex[i / 2] < 3)
						{
							//将花牌数组中花牌个数保存到牌数据中
							for (BYTE k = 0; k < TempHuaCardIndex[i / 2]; k++)
							{
								HandCardData[Line][Row++] = 0x10 | (i + 1);
							}
							//将剩下的画白皮的
							for (BYTE j = 0; j < (TempCardIndex[i] - TempHuaCardIndex[i / 2]); j++)
							{
								HandCardData[Line][Row++] = 0x00 | (i + 1);
							}
							TempHuaCardIndex[i / 2] = 0;
						}
						else
						{
							return false;
						}
					}
					//普通牌处理
					else
					{
						for (BYTE j = 0; j < TempCardIndex[i]; j++)
						{
							HandCardData[Line][Row++] = m_GameLogic.SwitchToCardData(i);
						}
					}
					TempCardIndex[i] = 0;
				}
				else
				{
					return false;
				}
			}
			ASSERT(Row <= 9);
		}
		//Line++;
		//Row = 0;
	}
	else
	{
		for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
		{
			if (TempCardIndex[i] > 0)
			{
				if (TempCardIndex[i] < 6)
				{
					if (Row > 3 && Line < 8)
					{
						Line++;
						Row = 0;
					}
					if (i == 0 || i == 2 || i == 4 || i == 6 || i == 8)
					{
						if (TempHuaCardIndex[i / 2] < 3)
						{
							//将花牌数组中花牌个数保存到牌数据中
							for (BYTE k = 0; k < TempHuaCardIndex[i / 2]; k++)
							{
								HandCardData[Line][Row++] = 0x10 | (i + 1);
							}
							//将剩下的画白皮的
							for (BYTE j = 0; j < (TempCardIndex[i] - TempHuaCardIndex[i / 2]); j++)
							{
								HandCardData[Line][Row++] = 0x00 | (i + 1);
							}
							TempHuaCardIndex[i / 2] = 0;
						}
						else
						{
							return false;
						}
					}
					//普通牌处理
					else
					{
						for (BYTE j = 0; j < TempCardIndex[i]; j++)
						{
							HandCardData[Line][Row++] = m_GameLogic.SwitchToCardData(i);
						}
					}
					TempCardIndex[i] = 0;
				}
				else
				{
					return false;
				}
			}
			ASSERT(Row <= 9);
		}
	}
	if (wChairID == m_wBankerUser && m_cbOutCardCount == 0)
	{
		if (Line >= 8)
		{
			HandCardData[Line][Row++] = m_cbSendCardData;
		}
		else
		{
			HandCardData[8][0] = m_cbSendCardData;
		}
	}
	ASSERT(Line <= 9);
	if (Line <= 9)
		return true;
	else
		return false;
}

bool TableFrameSinkZhiPai::DeleteHandCardData(WORD wChairID, BYTE CardData[], BYTE CardCount)
{
	for (BYTE i = 0; i < CardCount; i++)
	{
		BYTE TempBreakIndex = 0xFF;
		for (BYTE m = 0; m < 9; m++)
		{
			for (BYTE h = 0; h < 9; h++)
			{
				if (m_cbGamePlayerHandCard[wChairID][m][h] == 0)
				{
					break;
				}
				if (m_cbGamePlayerHandCard[wChairID][m][h] == CardData[i])
				{
					for (BYTE j = h; j < 8; j++)
					{
						m_cbGamePlayerHandCard[wChairID][m][j] = m_cbGamePlayerHandCard[wChairID][m][j + 1];
					}
					TempBreakIndex = h;
					break;
				}
			}
			if (TempBreakIndex != 0xFF)
			{
				break;
			}
		}
		if (TempBreakIndex == 0xFF)
		{
			return false;
		}
	}
	return true;
}

BYTE TableFrameSinkZhiPai::GetOperatorScore(INT OperatorCode, BYTE OperatorCardIndex,BYTE HuaCard[4])
{
	BYTE TempScore = 0;
	switch (OperatorCode)
	{
	case WIK_DUI:
	{
		if (OperatorCardIndex == 2 || OperatorCardIndex == 4 || OperatorCardIndex == 6)
		{
			TempScore += 5;
			for (BYTE i = 0; i < 4;i++)
			{
				if (HuaCard[i] != 0)
				{
					TempScore++;
				}
			}
		}
		else if (OperatorCardIndex == 12 || OperatorCardIndex == 13 || OperatorCardIndex == 14 || OperatorCardIndex == 18 || OperatorCardIndex == 19 || OperatorCardIndex == 20)
		{
			TempScore++;
		}
		else if (OperatorCardIndex == 0 || OperatorCardIndex == 8)
		{
			for (BYTE i = 0; i < 4; i++)
			{
				if (HuaCard[i] != 0)
				{
					TempScore++;
				}
			}
		}
		return TempScore;
	}
	case WIK_SAN_ZHAO:
	{
		if (OperatorCardIndex == 2 || OperatorCardIndex == 4 || OperatorCardIndex == 6 )
		{
			TempScore = 12;
			if (HuaCard[1] != 0)
			{
				TempScore = 14;
			}
		}
		else if (OperatorCardIndex == 12 || OperatorCardIndex == 13 || OperatorCardIndex == 14 || OperatorCardIndex == 18 || OperatorCardIndex == 19 || OperatorCardIndex == 20)
		{
			TempScore += 4;
		}
		else if (OperatorCardIndex == 0 || OperatorCardIndex == 8)
		{
			TempScore += 2;
			for (BYTE i = 0; i < 4; i++)
			{
				if (HuaCard[i] != 0)
				{
					TempScore++;
				}
			}
		}
		else
		{
			TempScore += 2;
		}
		return TempScore;
	}
	case WIK_SI_ZHAO:
	{
		if (OperatorCardIndex == 2 || OperatorCardIndex == 4 || OperatorCardIndex == 6)
		{
			TempScore = 28;
		}
		else if (OperatorCardIndex == 12 || OperatorCardIndex == 13 || OperatorCardIndex == 14 || OperatorCardIndex == 18 || OperatorCardIndex == 19 || OperatorCardIndex == 20)
		{
			TempScore = 8;
		}
		else if (OperatorCardIndex == 0 || OperatorCardIndex == 8)
		{
			TempScore =6;
		}
		else
		{
			TempScore = 4;
		}
		return TempScore;
	}
	default:
		break;
	}
}

bool TableFrameSinkZhiPai::IsEqual(WORD wChairID)
{
	BYTE TempCardShouIndex[MAX_INDEX_HUA] = { 0 };
	CopyMemory(TempCardShouIndex, m_cbCardIndex[wChairID], sizeof(m_cbCardIndex[wChairID]));
	for (BYTE i = 0; i < MAX_INDEX_HUA; i++)
	{
		TempCardShouIndex[i] += m_cbCardIndex_Tong[wChairID][i];
	}
	BYTE TempCardShouCount1 = m_GameLogic.GetCardCount(TempCardShouIndex);
	BYTE TempCardShouCount2 = 0;
	for (BYTE i = 0; i < 9; i++)
	{
		for (BYTE j = 0; j < 9; j++)
		{
			if (m_cbGamePlayerHandCard[wChairID][i][j] == 0)
			{
				break;
			}
			TempCardShouCount2++;
		}
	}
	return TempCardShouCount1 == TempCardShouCount2 ? true : false;
}