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

#include "StdAfx.h"
#include "TableFrameSink.h"


//构造函数
CTableFrameSink::CTableFrameSink():m_GameLogic(this)
{
	//游戏变量
	bGameType = 0;
	m_lSiceCount=0;
	m_wBankerUser=INVALID_CHAIR;
	ZeroMemory(m_cbCardIndex,sizeof(m_cbCardIndex));
	ZeroMemory(m_bTrustee,sizeof(m_bTrustee));
	ZeroMemory( m_cbGenCount,sizeof(m_cbGenCount) );
	ZeroMemory( m_bPlayStatus,sizeof(m_bPlayStatus) );
	ZeroMemory(m_lGameScore, sizeof(m_lGameScore));
	ZeroMemory(m_lGameTatolScore, sizeof(m_lGameTatolScore));
	ZeroMemory(m_HuPai, sizeof(m_HuPai));

	ZeroMemory(m_TabbOutCardCout, sizeof(m_TabbOutCardCout));		//可以打出的牌就听牌的个数
	ZeroMemory(m_TabbOutCardData, sizeof(m_TabbOutCardData));		//具体打哪几张牌
	ZeroMemory(m_TabbTingCardCount, sizeof(m_TabbTingCardCount));	//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
	ZeroMemory(m_TabbTingCardData, sizeof(m_TabbTingCardData));	//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

	m_cbWinCount = 0;
	memset( m_wWinOrder,INVALID_CHAIR,sizeof(m_wWinOrder) );
	ZeroMemory( m_lGameTax,sizeof(m_lGameTax) );

	//出牌信息
	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));
	ZeroMemory(m_OutLaiZi, sizeof(m_OutLaiZi));
	//堆立信息
	m_wHeapHand = INVALID_CHAIR;
	m_wHeapTail = INVALID_CHAIR;
	ZeroMemory(m_cbHeapCardInfo,sizeof(m_cbHeapCardInfo));

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

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

	//状态变量
	m_bSendStatus=false;
	m_bGangStatus = false;
	m_bGangOutStatus = false;
	ZeroMemory(m_bEnjoinChiHu,sizeof(m_bEnjoinChiHu));
	ZeroMemory(m_bEnjoinChiPeng,sizeof(m_bEnjoinChiPeng));

	//用户状态
	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(m_WeaveItemArray,sizeof(m_WeaveItemArray));
	ZeroMemory(m_cbWeaveItemCount,sizeof(m_cbWeaveItemCount));

	//结束信息
	m_cbChiHuCard=0;
	ZeroMemory( m_dwChiHuKind,sizeof(m_dwChiHuKind) );
	memset( m_wProvider,INVALID_CHAIR,sizeof(m_wProvider) );
	ZeroMemory(m_HuPai, sizeof(m_HuPai)); 
	ZeroMemory(m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));
	//组件变量
	m_pITableFrame=NULL;
	m_pGameServiceOption=NULL;

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

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

//接口查询
void * CTableFrameSink::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(ITableFrameSink,Guid,dwQueryVer);
	QUERYINTERFACE(ITableUserAction,Guid,dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(ITableFrameSink,Guid,dwQueryVer);
	return NULL;
}

//初始化
bool CTableFrameSink::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 CTableFrameSink::RepositionSink()
{
	//游戏变量
	m_lSiceCount=0;
	ZeroMemory(m_cbCardIndex,sizeof(m_cbCardIndex));
	ZeroMemory(m_bTrustee,sizeof(m_bTrustee));
	ZeroMemory( m_cbGenCount,sizeof(m_cbGenCount) );
	ZeroMemory( m_lGameScore,sizeof(m_lGameScore) );
	ZeroMemory( m_bPlayStatus,sizeof(m_bPlayStatus) );
	m_cbWinCount = 0;
	memset( m_wWinOrder,INVALID_CHAIR,sizeof(m_wWinOrder) );
	ZeroMemory( m_lGameTax,sizeof(m_lGameTax) );

	ZeroMemory(m_TabbOutCardCout, sizeof(m_TabbOutCardCout));		//可以打出的牌就听牌的个数
	ZeroMemory(m_TabbOutCardData, sizeof(m_TabbOutCardData));		//具体打哪几张牌
	ZeroMemory(m_TabbTingCardCount, sizeof(m_TabbTingCardCount));	//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
	ZeroMemory(m_TabbTingCardData, sizeof(m_TabbTingCardData));	//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据
	
	//出牌信息
	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));
	ZeroMemory(m_OutLaiZi, sizeof(m_OutLaiZi));

	//堆立信息
	m_wHeapHand = INVALID_CHAIR;
	m_wHeapTail = INVALID_CHAIR;
	ZeroMemory(m_cbHeapCardInfo,sizeof(m_cbHeapCardInfo));

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

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

	//状态变量
	m_bSendStatus=false;
	m_bGangStatus = false;
	m_bGangOutStatus = false;
	ZeroMemory(m_bEnjoinChiHu,sizeof(m_bEnjoinChiHu));
	ZeroMemory(m_bEnjoinChiPeng,sizeof(m_bEnjoinChiPeng));

	//用户状态
	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(m_WeaveItemArray,sizeof(m_WeaveItemArray));
	ZeroMemory(m_cbWeaveItemCount,sizeof(m_cbWeaveItemCount));

	//结束信息
	m_cbChiHuCard=0;
	ZeroMemory(m_dwChiHuKind,sizeof(m_dwChiHuKind));
	m_cbLaiZiPiData = 0;
	m_cbLaiZiData = 0;
	bIsHuang = false;

	return;
}


bool CTableFrameSink::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 CTableFrameSink::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_PLAYER; ++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 CTableFrameSink::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 CTableFrameSink::OnEventGameStart()
{
	//椅子数量
	WORD wChairCount = m_pITableFrame->GetChairCount();
	//开始记录回放数据
	RepayRecordStart();
	//重置发牌状态
	m_isCanOutCard = false;
	//重置掉线玩家列表
	m_offlineUsers.clear();
	//设置状态
	m_pITableFrame->SetGameStatus(GS_MJ_PLAY);

	m_gameConfig.wHadPlayCount++;
	//混乱扑克
	m_lSiceCount = MAKELONG(MAKEWORD(rand()%6+1,rand()%6+1),MAKEWORD(rand()%6+1,rand()%6+1));
	m_cbLeftCardCount = m_GameLogic.RandCardData(m_cbRepertoryCard);

	if (1 == m_gameConfig.wHadPlayCount || m_wNextBankerUser == INVALID_CHAIR)
	{
		m_wBankerUser = 0;//((BYTE)(m_lSiceCount >> 24) + (BYTE)(m_lSiceCount >> 16) - 1) % wChairCount;
	}
	else
	{
		m_wBankerUser = m_wNextBankerUser;
	}

	m_wNextBankerUser = INVALID_CHAIR;


	//BYTE byTest[] = {
	//	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,						//万子
	//	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,						//万子
	//	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,						//万子
	//	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,						//万子
	//	0x11, 0x12, 0x13, 0x15, 0x16, 0x17, 0x18, 0x19, 0x21,						//索子
	//	0x26, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,						//同子
	//	0x11, 0x12, 																//索子
	//	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x13,											//索子
	//	0x11, 0x12, 0x13, 0x14, 0x15, 0x17, 0x17, 0x19, 0x19, 0x21, 0x16, 0x18, 0x18,			//索子																											//同子
	//	0x21, 0x22, 0x23, 0x24, 0x25, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x27, 0x29,			//同子
	//	0x14, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x28, 0x29, 0x29, 0x21,			//同子
	//};

	//if (m_GameLogic.PeiPai(byTest))
	//	CopyMemory(m_cbRepertoryCard, byTest, sizeof(byTest));
	
	BYTE cbTakeCount = 0;
	//分发扑克
	for (WORD i=0;i<GAME_PLAYER;i++)
	{
		m_bPlayStatus[i] = true;
		m_cbLeftCardCount-=(MAX_COUNT-1);//每一个玩家都发出去13张牌，还剩多少
		cbTakeCount += (MAX_COUNT - 1);//每个玩家加13张牌
		m_GameLogic.SwitchToCardIndex(&m_cbRepertoryCard[m_cbLeftCardCount],MAX_COUNT-1,m_cbCardIndex[i]);
	}
	//癞子皮
	m_cbSendCardCount++;
	m_cbSendCardData = m_cbRepertoryCard[--m_cbLeftCardCount];
	m_cbLaiZiPiData = m_cbSendCardData;
	//癞子
	if ((m_cbLaiZiPiData&0x0f) == 0x09)
	{
		BYTE m_cbCole = m_cbLaiZiPiData & 0xf0;
		m_cbLaiZiData = m_cbCole | 0x01;
	}
	else
	{
		m_cbLaiZiData = m_cbLaiZiPiData + 1;
	}
	//需要把癞子皮，癞子数据返回给前端
	//发送扑克,庄家摸牌
	m_cbSendCardCount++;
	m_cbSendCardData=m_cbRepertoryCard[--m_cbLeftCardCount];
	m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;

	//设置变量
	m_cbProvideCard=0;
	m_wProvideUser = m_wBankerUser;
	m_wCurrentUser=m_wBankerUser;

	//杠牌判断
	tagGangCardResult GangCardResult;
	m_cbUserAction[m_wBankerUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[m_wBankerUser],m_cbLaiZiData,m_cbLaiZiPiData, NULL, 0, GangCardResult);

	//胡牌判断
	CChiHuRight chr;
	m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]--;
	m_cbUserAction[m_wBankerUser] |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[m_wBankerUser], NULL, 0, m_cbSendCardData, chr, m_cbLaiZiData, bGameType);
	m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;
	BYTE ActionCard[3] = { 0 };//杠哪个牌
	BYTE AntActionCount = 0;//暗杠操作动作次数
	if (m_cbUserAction[m_wBankerUser] != WIK_NULL)
	{
		if (m_cbUserAction[m_wBankerUser] & WIK_GANG)
		{
			for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
			{
				ActionCard[i] = GangCardResult.cbCardData[i];
			}
			/*if ( m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbLaiZiPiData)]==3)
			{
				m_cbUserAction[m_wBankerUser] |= WIK_AN_PIGANG;
				ActionCard[AntActionCount++] = m_cbLaiZiPiData;

			}
			else
			{
				m_cbUserAction[m_wBankerUser] |= WIK_AN_GANG;
				for (BYTE i = 0; i < MAX_INDEX; i++)
				{
					if (m_cbCardIndex[m_wBankerUser][i] == 4 && i != m_GameLogic.SwitchToCardIndex(m_cbLaiZiData))
					{
						ActionCard[AntActionCount++] = m_GameLogic.SwitchToCardData(i);
					}
				}
			}*/
		}
		if (m_cbUserAction[m_wBankerUser] & WIK_ZI_MO)
		{		
			if (m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] == 1 && !(m_cbUserAction[m_wBankerUser] & WIK_YING_ZIMO))
			{
				m_cbUserAction[m_wBankerUser] |= WIK_RUAN_ZIMO;//软自摸
			}
			else
			{
				m_cbUserAction[m_wBankerUser] |= WIK_YING_ZIMO;//硬自摸
			}
		}
	}
	if (bGameType == BanLai && (m_cbUserAction[m_wBankerUser] & WIK_RUAN_ZIMO))
	{
		m_cbUserAction[m_wBankerUser] = m_cbUserAction[m_wBankerUser] & 0xff0ff;
	}
	m_cbProvideCard = m_cbSendCardData;
	m_wResumeUser = m_wCurrentUser;

	//if (m_cbUserAction[m_wBankerUser] != WIK_NULL)
	//	SendOperateNotify();

	//构造数据
	CMD_S_GameStart GameStart;
	GameStart.wBankerUser = m_wBankerUser;
	GameStart.cbLeftCardCount = m_cbLeftCardCount;

	WORD wSice = WORD(m_lSiceCount & 0xffff);
	GameStart.cbSiceLaiZi[0] = HIBYTE(wSice);
	GameStart.cbSiceLaiZi[1] = LOBYTE(wSice);
	GameStart.cbSiceLaiZi[2] = m_cbLaiZiPiData;
	GameStart.cbSiceLaiZi[3] = m_cbLaiZiData;
	GameStart.cbTotalCardCount = MAX_REPERTORY;
	GameStart.cbCurrPlay = m_gameConfig.wHadPlayCount;
	GameStart.cbOptTime = GAME_TIMEOUT;
	//CopyMemory(GameStart.cbHeapCardInfo,m_cbHeapCardInfo,_countof(m_cbHeapCardInfo));
	//发送数据
	for (WORD i=0;i<wChairCount;i++)
	{
		if( !m_bPlayStatus[i] ) continue;
		//设置变量
		GameStart.wCurrentUser = i;
		GameStart.cbUserAction=m_cbUserAction[i];
		ZeroMemory(GameStart.ActionCard, sizeof(GameStart.ActionCard));
		if (i == m_wCurrentUser)
		{
			if (m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)] > 0 && m_wBankerUser == i)
			{
				m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]--;//从手上去掉抓的牌
			}
			else
			{
				return false;
			}
		}
		ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));
		m_GameLogic.SwitchToCardData(m_cbCardIndex[i], &GameStart.cbCardData[MAX_COUNT*i]);
		if (i == m_wCurrentUser)
		{
			CopyMemory(GameStart.ActionCard, ActionCard, sizeof(ActionCard));
			GameStart.cbCardData[i * 14 + 13] = m_cbSendCardData;//把去掉的牌加到数组末尾，
			m_cbCardIndex[m_wBankerUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;//把去掉的加进来
		}
		//if( m_pITableFrame->GetTableUserItem(i)->IsAndroidUser() )
		//{
		//	BYTE bIndex = 1;
		//	for( WORD j=0; j<wChairCount; j++ )
		//	{
		//		if( j == i ) continue;
		//		m_GameLogic.SwitchToCardData(m_cbCardIndex[j],&GameStart.cbCardData[MAX_COUNT*bIndex++]);
		//	}
		//}
		//发送数据
		m_pITableFrame->SendTableData(i, SUB_S_GAME_START, &GameStart, sizeof(GameStart));
	}

	//用户回放
	ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));
	//清手牌 旁观只能发一次
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_START, &GameStart, sizeof(GameStart));
	for (WORD i = 0; i < wChairCount; i++)
		m_GameLogic.SwitchToCardData(m_cbCardIndex[i], &GameStart.cbCardData[MAX_COUNT*i]);
	RepayRecord(INVALID_CHAIR, SUB_S_GAME_START, &GameStart, sizeof(GameStart));
	return true;
}

void CTableFrameSink::DeletePrivateTable(bool bSendState)
{
	tagScoreInfo ScoreInfoArray[GAME_PLAYER];
	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 CTableFrameSink::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:		//常规结束
	{
		if (bSendState && cbReason == GER_NORMAL)
		{
			bSendState = true;
		}
		//变量定义
		CMD_S_GameEnd GameEnd;
		ZeroMemory(&GameEnd, sizeof(GameEnd));
		GameEnd.bFinish = bFinish;//1……
		if (m_cbLeftCardCount <= 0 || bDelete)//荒庄了
		{
			if (!bDelete) GameEnd.bOptType = (bIsHuang == true ? 2 : 1);//庄荒了，需要返回信息
			else GameEnd.bOptType = 3;

			if (GameEnd.bOptType == 1)
			{//海底捞月
				GameEnd.bOptType = 1;
				BYTE TempWanJiaCardCount = 0;
				m_wNextBankerUser = wChairID;
				//统计积分,胡牌得分,玩家牌值
				for (WORD i = 0; i < GAME_PLAYER; i++)
				{
					//m_lGameTatolScore[i] += m_lGameScore[i];
					GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分3…………
					if (i == wChairID)continue;
					m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
				}
				if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--)
				{
					m_GameLogic.SwitchToCardData(m_cbCardIndex[wChairID], GameEnd.cbCardData[wChairID]);
					TempWanJiaCardCount = m_GameLogic.GetCardCount(m_cbCardIndex[wChairID]);
					GameEnd.cbCardData[wChairID][TempWanJiaCardCount] = m_cbProvideCard;//手牌数据4……
					m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
				}
			}
			else
			{
				m_wNextBankerUser = (m_wBankerUser + 1) % 4;
				//黄庄了
				//统计玩家积分,牌值
				for (WORD i = 0; i < GAME_PLAYER; i++)
				{
					GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分4…………
					m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
				}
			}
		}
		else
		{
			GameEnd.bOptType = 1;
			BYTE TempWanJiaCardCount = 0;
			m_wNextBankerUser = wChairID;
			//统计积分,胡牌得分,玩家牌值
			for (WORD i = 0; i < GAME_PLAYER; i++)
			{
				//m_lGameTatolScore[i] += m_lGameScore[i];
				GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分3…………
				if (i == wChairID)continue;
				m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
			}
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--)
			{
				m_GameLogic.SwitchToCardData(m_cbCardIndex[wChairID], GameEnd.cbCardData[wChairID]);
				TempWanJiaCardCount = m_GameLogic.GetCardCount(m_cbCardIndex[wChairID]);
				GameEnd.cbCardData[wChairID][TempWanJiaCardCount] = m_cbProvideCard;//手牌数据4……
				m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
			}
		}	
		GameEnd.bWanJiaId = wChairID;//玩家座位号 5……
		GameEnd.bLeftCardCount = m_cbLeftCardCount;//剩余牌输量6…………
		CopyMemory(GameEnd.bLeftCardDada, m_cbRepertoryCard, m_cbLeftCardCount);//剩余牌值7………………
		CopyMemory(GameEnd.bZimo, m_HuPai, sizeof(m_HuPai));//玩家胡牌次数8…………
		GameEnd.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();//获取房间ID，9……
		GameEnd.playGameNum = m_gameConfig.wHadPlayCount;//得到第几局了，10…………
		for (BYTE i = 0; i < GAME_PLAYER;i++)
		{
			m_HuPaiLiuShui[(m_gameConfig.wHadPlayCount-1)*4+i] = m_lGameScore[i];
		}
		CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));//游戏流水，10…………

		//数据处理
		int iSendLen = 0;
		CMD_S_GameEnd GameEndBuffer;
		BYTE *pOutData = (BYTE *)&GameEndBuffer;
		BYTE *pInData = (BYTE *)&GameEnd;
		ZeroMemory(&GameEndBuffer, sizeof(GameEndBuffer));
		CopyMemory(pOutData, &GameEnd, 85);
		iSendLen = iSendLen + 85;
		pInData = pInData + 85;
		pOutData = pOutData + 85;
		BYTE *pData = (BYTE *)&GameEnd;
		BYTE bNum = GameEnd.bLeftCardCount;

		CopyMemory(pOutData, pInData, bNum);
		iSendLen = iSendLen + bNum;
		pOutData = pOutData + bNum;

		pInData = pInData + CountArray(GameEnd.bLeftCardDada);

		//pInData = pInData + 54;


		bNum = GameEnd.playGameNum;
		pOutData[0] = bNum;
		pInData++;
		pOutData++;
		iSendLen = iSendLen + bNum * 4 * GAME_PLAYER + 1;

		CopyMemory(pOutData, pInData, bNum * 4 * GAME_PLAYER);
		//iSendLen = iSendLen + bNum;

		RepayRecord(INVALID_CHAIR, SUB_S_GAME_END, &GameEndBuffer, iSendLen);

		//发送结束信息
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, &GameEndBuffer, iSendLen);
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, &GameEndBuffer, iSendLen);

		tagScoreInfo ScoreInfoArray[GAME_PLAYER];
		ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));
		for (WORD i = 0; i < GAME_PLAYER; 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;

			//if (i == wChairID)continue;
			//m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
		}
		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 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));

			//设置变量
			//memset(GameEnd.wProvideUser, INVALID_CHAIR, sizeof(GameEnd.wProvideUser));

			//拷贝扑克
			/*for (WORD i = 0;i < GAME_PLAYER;i++)
			{
			GameEnd.cbCardCount[i] = m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
			}*/
			//CopyMemory(GameEnd.lUserTmpScore, m_lUserTmpScore, sizeof(m_lUserTmpScore));

			RepayRecord(INVALID_CHAIR, SUB_S_GAME_END, &GameEnd, sizeof(GameEnd));
			//发送信息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, &GameEnd, sizeof(GameEnd));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, &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;

			////变量定义
			//CMD_S_GameEnd GameEnd;
			//ZeroMemory(&GameEnd,sizeof(GameEnd));
			//GameEnd.wLeftUser = wChairID;
			////结束信息
			//for (WORD i=0;i<GAME_PLAYER;i++)
			//{
			//	GameEnd.cbCardCount[i]=m_GameLogic.SwitchToCardData(m_cbCardIndex[i],GameEnd.cbCardData[i]);
			//	
			//	auto ChiHuRightList = m_ChiHuRight[i];
			//	tagChihuList& chihuList = GameEnd.ChiHuRight[i];
			//	chihuList.chihuCount = ChiHuRightList.size();
			//	if (chihuList.chihuCount > 10)
			//		chihuList.chihuCount = 10;
			//	for (int j = 0; j < chihuList.chihuCount;j++)
			//	{
			//		ChiHuRightList[j].chr.GetRightData(&chihuList.chihuRightData[j], MAX_RIGHT_COUNT);
			//		chihuList.chihuCardData[j] = ChiHuRightList[j].cbChihuCard;
			//		chihuList.wProvideUser[j] = ChiHuRightList[j].wProvideUser;
			//	}
			//	//m_ChiHuRight[i].GetRightData( &GameEnd.dwChiHuRight[i],MAX_RIGHT_COUNT );
			//}
			//LONGLONG lGangScore[GAME_PLAYER];
			//ZeroMemory( lGangScore,sizeof(lGangScore) );
			//////扣分,逃跑者垫付所有刮风下雨的钱,并扣16倍点数*未胡牌玩家.
			//for( WORD i = 0; i < GAME_PLAYER; i++ )
			//{
			//	for( BYTE j = 0; j < m_GangScore[i].cbGangCount; j++ )
			//	{
			//		for( WORD k = 0; k < GAME_PLAYER; k++ )
			//		{
			//			if( m_GangScore[i].lScore[j][k] < 0 ) 
			//				lGangScore[wChairID] += m_GangScore[i].lScore[j][k];
			//			else if( k != wChairID )
			//				lGangScore[k] += m_GangScore[i].lScore[j][k];
			//		}
			//	}
			//}
			//m_bPlayStatus[wChairID] = false;
			//for( WORD i = 0; i < GAME_PLAYER; i++ )
			//{
			//	if( m_bPlayStatus[i] ) 
			//	{
			//		m_lGameScore[i] += 16L*m_pGameServiceOption->lCellScore;
			//		m_lGameScore[wChairID] -= 16L*m_pGameServiceOption->lCellScore;
			//	}
			//	m_lGameScore[i] += lGangScore[i];
			//}
			//tagScoreInfo ScoreInfoArray[GAME_PLAYER];
			//ZeroMemory(&ScoreInfoArray,sizeof(ScoreInfoArray));
			////统计积分
			//for (WORD i=0;i<GAME_PLAYER;i++)
			//{
			//	if( NULL == m_pITableFrame->GetTableUserItem(i) ) continue;
			//	//设置积分
			//	LONG lGameTax = 0L;
			//	if( GAME_GENRE_SCORE != m_pGameServiceOption->wServerType )
			//	{
			//		if (m_lGameScore[i]>0L)
			//		{
			//			lGameTax = m_pITableFrame->CalculateRevenue(i,m_lGameScore[i]);
			//			m_lGameScore[i] -= lGameTax;
			//		}
			//		else
			//		{
			//			//防止负分
			//			IServerUserItem *pUserItem = m_pITableFrame->GetTableUserItem(i);
			//			if( GAME_GENRE_SCORE!=m_pGameServiceOption->wServerType && -m_lGameScore[i] > pUserItem->GetUserScore() )
			//				m_lGameScore[i] = -pUserItem->GetUserScore();
			//		}
			//	}
			//	BYTE ScoreKind;
			//	if( i == wChairID ) ScoreKind = SCORE_TYPE_FLEE;
			//	else 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   = GameEnd.lGameScore[i];
			//	ScoreInfoArray[i].lRevenue = m_lGameTax[i];
			//	ScoreInfoArray[i].cbType   = ScoreKind;
			//}
			////写入积分
			//m_pITableFrame->WriteTableScore(ScoreInfoArray,CountArray(ScoreInfoArray));
			//CopyMemory( GameEnd.lGameScore,m_lGameScore,sizeof(m_lGameScore) );
			//CopyMemory( GameEnd.lGangScore,lGangScore,sizeof(lGangScore) );
			//CopyMemory( GameEnd.wWinOrder,m_wWinOrder,sizeof(m_wWinOrder) );
			//CopyMemory( GameEnd.wProvideUser,m_wProvider,sizeof(m_wProvider) );
			//CopyMemory( GameEnd.wLostFanShu,m_wLostFanShu,sizeof(m_wLostFanShu) );
			//RepayRecord(INVALID_CHAIR, SUB_S_GAME_END, &GameEnd, sizeof(GameEnd));
			////发送结束信息
			//m_pITableFrame->SendTableData( INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd) );
			//m_pITableFrame->SendLookonData( INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd) );
			////结束游戏
			//ConcludeGame(GS_MJ_FREE);
			//return true;
		}
	}

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

//发送场景
bool CTableFrameSink::OnEventSendGameScene(WORD wChiarID, IServerUserItem * pIServerUserItem, BYTE cbGameStatus, bool bSendSecret)
{
	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_PLAYER; 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 StatusPlay;
			memset(&StatusPlay,0,sizeof(StatusPlay));

			//游戏房主基础配置
			CopyMemory(&StatusPlay.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));
			CopyMemory(StatusPlay.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));
			StatusPlay.cbTotalCardCount = MAX_REPERTORY;
			StatusPlay.cbLeftCardCount = m_cbLeftCardCount;
			StatusPlay.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;

			//游戏变量
			StatusPlay.wBankerUser=m_wBankerUser;
			WORD wSice = WORD(m_lSiceCount & 0xffff);
			StatusPlay.lSiZi[0] = HIBYTE(wSice);
			StatusPlay.lSiZi[1] = LOBYTE(wSice);
			StatusPlay.lSiZi[2] = m_cbLaiZiPiData;
			StatusPlay.lSiZi[3] = m_cbLaiZiData;
			StatusPlay.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();
			CopyMemory(StatusPlay.bWanLaiZi, m_OutLaiZi, sizeof(m_OutLaiZi));
			CopyMemory(StatusPlay.cbDiscardCard, m_cbDiscardCard, sizeof(StatusPlay.cbDiscardCard));
			CopyMemory(StatusPlay.cbDiscardCount, m_cbDiscardCount, sizeof(StatusPlay.cbDiscardCount));
			StatusPlay.totalOptTime = 10;
			StatusPlay.leftOptTime = 0;
			//当前到谁家
			StatusPlay.wCurrentUser = (m_wCurrentUser == INVALID_CHAIR ? m_wProvideUser : m_wCurrentUser);
			BYTE OldUser = 0;//定义一个最后出牌用户
			if (m_wProvideUser == m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR)//牌权是摸牌得且没出牌
			{
				if (m_wProvideUser == 0)
				{
					OldUser = 3;
				}
				else
					OldUser = m_wProvideUser - 1;
				BYTE TempIndex;
				for (BYTE i = 0; i < 55; i++)
				{
					if (m_cbDiscardCard[OldUser][i] == 0)
					{
						TempIndex = i - 1;
						break;
					}
				}	
				if (OldUser>3 || TempIndex == 255)
				{
					OldUser = 0;
					TempIndex = 0;
				}
				StatusPlay.bPutCardData[OldUser] = m_cbDiscardCard[OldUser][TempIndex];
			}
			//if (m_wProvideUser != m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR)//牌权是碰来得且没出牌
			//{
				//OldUser = m_wProvideUser;
				//StatusPlay.bPutCardData[OldUser] = m_cbProvideCard;
			//}
			if (m_wProvideUser == m_wOutCardUser&& m_wCurrentUser == INVALID_CHAIR)//当有人可以碰且没有碰时候
			{
				OldUser = m_wProvideUser;
				StatusPlay.bPutCardData[OldUser] = m_cbProvideCard;				
				StatusPlay.cbDiscardCard[OldUser][StatusPlay.cbDiscardCount[OldUser]++] = m_cbProvideCard;
			}
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				StatusPlay.cbCardCount[i] = m_GameLogic.GetCardCount(m_cbCardIndex[i]);
			}
			//CopyMemory(StatusPlay.cbCardData, m_cbCardIndex[wChiarID], sizeof(StatusPlay.cbCardData));
			m_GameLogic.SwitchToCardData(m_cbCardIndex[wChiarID], StatusPlay.cbCardData);

			StatusPlay.bOutCardCout = m_TabbOutCardCout[wChiarID];														//可以打出的牌就听牌的个数
			CopyMemory(StatusPlay.bOutCardData, m_TabbOutCardData[wChiarID], sizeof(m_TabbOutCardData[wChiarID]));		//具体打哪几张牌
			CopyMemory(StatusPlay.bTingCardCount, m_TabbTingCardCount[wChiarID], sizeof(m_TabbTingCardCount[wChiarID]));//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
			CopyMemory(StatusPlay.bTingCardData, m_TabbTingCardData[wChiarID], sizeof(m_TabbTingCardData[wChiarID]));	//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

			if (wChiarID != StatusPlay.wCurrentUser&&m_wCurrentUser == INVALID_CHAIR)							//表示当前牌权就在断线玩家手里，且是轮到他碰或者杠
			{
				StatusPlay.cbActionMask = m_cbUserAction[wChiarID];		//需要用到操作码

			}
			if (wChiarID == StatusPlay.wCurrentUser&&m_wCurrentUser != INVALID_CHAIR&&m_wCurrentUser != m_wProvideUser)////表示当前牌权就在断线玩家手里，且是轮到他出牌（牌权碰来得）
			{
				ZeroMemory(StatusPlay.cbCardData, sizeof(StatusPlay.cbCardData));
				StatusPlay.cbActionMask = m_cbUserAction[wChiarID];		//需要用到操作码
				BYTE TempIndex = 0;
				if (m_cbUserAction[wChiarID] & WIK_AN_PIGANG)
				{
					StatusPlay.gangCards[TempIndex++] = m_cbLaiZiPiData;
				}
				if (m_cbUserAction[wChiarID] & WIK_AN_GANG)
				{
					for (BYTE i = 0; i < MAX_INDEX;i++)
					{
						if (m_cbCardIndex[wChiarID][i] == 4 && i != m_GameLogic.SwitchToCardIndex(m_cbLaiZiData))
						{
							StatusPlay.gangCards[TempIndex++] = m_GameLogic.SwitchToCardData(i);
							if (TempIndex > 3)
								break;
						}
					}				
				}
				
				BYTE TempCardData[MAX_INDEX];
				CopyMemory(TempCardData, m_cbCardIndex[wChiarID], sizeof(TempCardData));
				BYTE TempCardIndex = 0;
				for (int i = MAX_INDEX - 1; i >= 0; i--)//手牌里面获取最后一张牌，
				{
					if (TempCardData[i] > 0 && m_GameLogic.SwitchToCardData(i) != m_cbLaiZiData)
					{
						TempCardIndex = i;
						break;
					}
				}
				if (TempCardData[TempCardIndex] == 0)ASSERT(false);
				TempCardData[TempCardIndex]--;
				m_GameLogic.SwitchToCardData(TempCardData, StatusPlay.cbCardData);
				BYTE cardNum = m_GameLogic.GetCardCount(TempCardData);
				StatusPlay.cbCardData[cardNum] = m_GameLogic.SwitchToCardData(TempCardIndex);//处理得到最后一张牌数据放最后
			}
			if (wChiarID == StatusPlay.wCurrentUser&&m_wCurrentUser != INVALID_CHAIR&&m_wCurrentUser == m_wProvideUser)//牌权是轮到他抓牌，未打出
			{
				ZeroMemory(StatusPlay.cbCardData, sizeof(StatusPlay.cbCardData));
				StatusPlay.cbActionMask = m_cbUserAction[wChiarID];		//需要用到操作码
				BYTE TempIndex = 0;
				if (m_cbUserAction[wChiarID] & WIK_AN_PIGANG)//|| m_cbUserAction[wChiarID] & WIK_MING_PIGANG)
				{
					StatusPlay.gangCards[TempIndex++] = m_cbLaiZiPiData;
				}
				if (m_cbUserAction[wChiarID] & WIK_AN_GANG)
				{
					for (BYTE i = 0; i < MAX_INDEX; i++)
					{
						if (m_cbCardIndex[wChiarID][i] == 4 && i != m_GameLogic.SwitchToCardIndex(m_cbLaiZiData))
						{
							StatusPlay.gangCards[TempIndex++] = m_GameLogic.SwitchToCardData(i);
							if (TempIndex > 3)
								break;
						}
					}
				}				
				BYTE TempCardData[MAX_INDEX];
				CopyMemory(TempCardData, m_cbCardIndex[wChiarID], sizeof(TempCardData));
				BYTE TempCardIndex = m_GameLogic.SwitchToCardIndex(m_cbProvideCard);
				if (m_cbCardIndex[wChiarID][TempCardIndex] == 0)ASSERT(false);
				TempCardData[TempCardIndex]--;
				m_GameLogic.SwitchToCardData(TempCardData, StatusPlay.cbCardData);
				BYTE cardNum = m_GameLogic.GetCardCount(TempCardData);
				StatusPlay.cbCardData[cardNum] = m_GameLogic.SwitchToCardData(TempCardIndex);//处理得到最后一张牌数据放最后
			}

			//组合扑克
			CopyMemory(StatusPlay.WeaveItemArray,m_WeaveItemArray,sizeof(m_WeaveItemArray));
			CopyMemory(StatusPlay.cbWeaveCount,m_cbWeaveItemCount,sizeof(m_cbWeaveItemCount));

			//扑克数据
			//StatusPlay.cbSendCardData=((m_cbSendCardData!=0)&&(m_wProvideUser==wChiarID))?m_cbSendCardData:0x00;

			//发送场景
			return m_pITableFrame->SendGameScene(pIServerUserItem,&StatusPlay,sizeof(StatusPlay));
		}
	}
	return false;
}

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

//游戏消息处理
void CTableFrameSink::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_pITableFrame->SetChairCount(GAME_PLAYER);
	ASSERT(m_gameConfig.wSubGameID >= 0 && m_gameConfig.wSubGameID < MahJongType::count);
}

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

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

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

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

		//消息处理
		CMD_C_OperateCard * pOperateCard = (CMD_C_OperateCard *)pDataBuffer;
		return OnUserOperateCard(pIServerUserItem->GetChairID(), pOperateCard->cbOperateCode, pOperateCard->cbOperateCard);
	}
	case SUB_C_TRUSTEE:
	{
		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;
	}
		return false;
	}

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

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

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

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

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

	//游戏房主基础配置
	CopyMemory(&StatusPlay.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));
	CopyMemory(StatusPlay.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));
	StatusPlay.cbTotalCardCount = MAX_REPERTORY;
	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;
		WORD wSice = WORD(m_lSiceCount & 0xffff);
		StatusPlay.lSiZi[0] = HIBYTE(wSice);
		StatusPlay.lSiZi[1] = LOBYTE(wSice);
		StatusPlay.lSiZi[2] = m_cbLaiZiPiData;
		StatusPlay.lSiZi[3] = m_cbLaiZiData;
		StatusPlay.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();
		CopyMemory(StatusPlay.bWanLaiZi, m_OutLaiZi, sizeof(m_OutLaiZi));
		CopyMemory(StatusPlay.cbDiscardCard, m_cbDiscardCard, sizeof(StatusPlay.cbDiscardCard));
		CopyMemory(StatusPlay.cbDiscardCount, m_cbDiscardCount, sizeof(StatusPlay.cbDiscardCount));
		StatusPlay.totalOptTime = 10;
		StatusPlay.leftOptTime = 0;
		//当前到谁家
		StatusPlay.wCurrentUser = (m_wCurrentUser == INVALID_CHAIR ? m_wProvideUser : m_wCurrentUser);
		WORD OldUser = 0;//定义一个最后出牌用户

		if (m_wProvideUser == m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR)//牌权是摸牌得且没出牌
		{
			if (m_wProvideUser == 0)
			{
				OldUser = 3;
			}
			else
				OldUser = m_wProvideUser - 1;
			BYTE TempIndex;
			for (BYTE i = 0; i < 55; i++)
			{
				if (m_cbDiscardCard[OldUser][i] == 0)
				{
					TempIndex = i - 1;
					break;
				}
			}
			if (OldUser>3 || TempIndex == 255)
			{
				OldUser = 0;
				TempIndex = 0;
			}
			StatusPlay.bPutCardData[OldUser] = m_cbDiscardCard[OldUser][TempIndex];
		}
		if (m_wProvideUser == m_wOutCardUser&& m_wCurrentUser == INVALID_CHAIR)//当有人可以碰且没有碰时候
		{
			OldUser = m_wProvideUser;
			StatusPlay.bPutCardData[OldUser] = m_cbProvideCard;
			StatusPlay.cbDiscardCard[OldUser][StatusPlay.cbDiscardCount[OldUser]++] = m_cbProvideCard;
		}

		for (BYTE i = 0; i < GAME_PLAYER; i++)
		{
			StatusPlay.cbCardCount[i] = m_GameLogic.GetCardCount(m_cbCardIndex[i]);
		}
		//组合扑克
		CopyMemory(StatusPlay.WeaveItemArray, m_WeaveItemArray, sizeof(m_WeaveItemArray));
		CopyMemory(StatusPlay.cbWeaveCount, m_cbWeaveItemCount, sizeof(m_cbWeaveItemCount));
	}
	return m_pITableFrame->SendUserItemData(pIServerUserItem, SUB_S_PANGGUAN, &StatusPlay, sizeof(StatusPlay));
}

//用户起来
bool CTableFrameSink::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 CTableFrameSink::OnUserOutCard(WORD wChairID, BYTE cbCardData)
{
	//检查是否可以出牌
	//if (!IsCanOutCard())
	//	return true;
	//效验状态
	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 true;
	if (m_GameLogic.IsValidCard(cbCardData)==false) return false;
	if ((m_GameLogic.GetCardCount(m_cbCardIndex[wChairID]) - 2) % 3 != 0)
	{
		return false;
	}
	//删除扑克
	if (m_GameLogic.RemoveCard(m_cbCardIndex[wChairID],cbCardData)==false)
	{
		ASSERT(FALSE);
		return false;
	}
	ZeroMemory(&m_cbLastDisCardData[wChairID], sizeof(m_cbLastDisCardData[wChairID]));
	m_cbLastDisCount[wChairID] = 0;
	for (BYTE i = 0; i < GAME_PLAYER; i++)
	{
		if (i == wChairID)continue;
		m_cbLastDisCardData[i][m_cbLastDisCount[i]++] = cbCardData;//打出得牌,放到其他玩家得记忆库里面
	}
	
	if (cbCardData == m_cbLaiZiData)
	{
		//设置变量
		m_bSendStatus = true;
		if (!m_bGangStatus)
		{
			m_bGangStatus = true;
			m_bGangOutStatus = true;
		}
		m_cbUserAction[wChairID] = WIK_NULL;
		m_cbPerformAction[wChairID] = WIK_NULL;

		//出牌记录
		m_cbOutCardCount++;
		//m_cbDiscardCard[wChairID][m_cbDiscardCount[wChairID]++] = cbCardData;
		//m_cbDiscardWuYongCard[wChairID][m_cbDiscardWuYongCount[wChairID]++] = cbCardData;
		m_wOutCardUser = INVALID_CHAIR;		//记录出牌人
		m_cbOutCardData = 0;		//记录出牌数据

		//构造数据
		CMD_S_OutCard OutCard;
		OutCard.wOutCardUser = wChairID;
		OutCard.cbOutCardData = cbCardData;
		OutCard.bOptType = 1;//打出的是癞子

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

		m_wProvideUser = wChairID;
		m_cbProvideCard = cbCardData;
		//筹码翻倍,该用户打出的癞子加一
		m_OutLaiZi[wChairID]++;
		//相当于杠牌，摸一张重新出牌
		return DispatchCardData(m_wCurrentUser, true, true);
	}
	else
	{
		//设置变量
		m_bSendStatus = true;
		if (m_bGangStatus)
		{
			m_bGangStatus = false;
			m_bGangOutStatus = true;
		}
		m_cbUserAction[wChairID] = WIK_NULL;
		m_cbPerformAction[wChairID] = WIK_NULL;

		//出牌记录
		m_cbOutCardCount++;	
		//m_cbDiscardCard[wChairID][m_cbDiscardCount[wChairID]++] = cbCardData;
		//m_cbDiscardWuYongCard[wChairID][m_cbDiscardWuYongCount[wChairID]++] = cbCardData;

		m_wOutCardUser = wChairID;		//记录出牌人
		m_cbOutCardData = cbCardData;		//记录出牌数据
		
		//构造数据
		CMD_S_OutCard OutCard;
		OutCard.wOutCardUser = wChairID;
		OutCard.cbOutCardData = cbCardData;
		OutCard.bOptType = 0;

		m_TabbOutCardCout[wChairID] = 255;													//可以打出的牌就听牌的个数
		ZeroMemory(m_TabbOutCardData[wChairID], sizeof(m_TabbOutCardData[wChairID]));		//具体打哪几张牌
		ZeroMemory(m_TabbTingCardCount[wChairID], sizeof(m_TabbTingCardCount[wChairID]));	//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
		ZeroMemory(m_TabbTingCardData[wChairID], sizeof(m_TabbTingCardData[wChairID]));		//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

		BYTE TingParCount = 0;
		BYTE TingParData[MAX_INDEX];
		BYTE  m_cbTingPai[MAX_INDEX];
		ZeroMemory(TingParData, sizeof(TingParData));
		ZeroMemory(m_cbTingPai, sizeof(m_cbTingPai));
		if (m_GameLogic.IsTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbLaiZiData, bGameType, m_OutLaiZi[wChairID]))//是否听牌状态
		{
			//OutCard.bIsTingPai = m_isTingPai[wChairID];
			if (m_GameLogic.AnalyseTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbTingPai, m_cbLaiZiData, bGameType, m_OutLaiZi[wChairID]))
			{
				for (BYTE i = 0; i < MAX_INDEX; i++)
				{
					if (m_cbTingPai[i] == 1)
					{
						TingParData[TingParCount++] = m_GameLogic.SwitchToCardData(i);
						BYTE num = RemainNum(wChairID, TingParData[TingParCount - 1], m_GameLogic.SwitchToCardIndex(cbCardData));
						TingParData[TingParCount - 1] = m_GameLogic.GetValue(num, TingParData[TingParCount - 1]);
					}
				}
				//OutCard.cbTingCardCount = m_cbTingParCount;
			}

			m_TabbTingCardCount[wChairID][0] = TingParCount;
			CopyMemory(m_TabbTingCardData[wChairID][0], TingParData, sizeof(TingParData));
		}

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

		m_wProvideUser = wChairID;
		m_cbProvideCard = cbCardData;

		//用户切换
		m_wCurrentUser = (wChairID + 1) % GAME_PLAYER;
		while (!m_bPlayStatus[m_wCurrentUser])
			m_wCurrentUser = (m_wCurrentUser + 1) % GAME_PLAYER;
		//响应判断
		bool bAroseAction = EstimateUserRespond(wChairID, cbCardData, EstimatKind_OutCard);

		//派发扑克
		if (bAroseAction == false) 
			DispatchCardData(m_wCurrentUser);
		return true;
	}
}

//用户操作
bool CTableFrameSink::OnUserOperateCard(WORD wChairID, int cbOperateCode, BYTE cbOperateCard)
{
	//效验状态
	ASSERT(m_pITableFrame->GetGameStatus()==GS_MJ_PLAY);
	if (m_pITableFrame->GetGameStatus()!=GS_MJ_PLAY)
		return true;
	if (cbOperateCode == WIK_NULL)
	{
		//用户状态
		ZeroMemory(m_bResponse, sizeof(m_bResponse));
		ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
		ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
		ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
		//发送扑克
		if (m_wCurrentUser == INVALID_CHAIR)
			DispatchCardData(m_wResumeUser);
		return true;
	}

	//效验用户	注意：机器人有可能发生此断言
	//ASSERT((wChairID==m_wCurrentUser)||(m_wCurrentUser==INVALID_CHAIR));
	if ((wChairID!=m_wCurrentUser)&&(m_wCurrentUser!=INVALID_CHAIR)) 
		return true;

	int FanKuiAction = WIK_NULL;
	//被动动作
	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;
		if (cbOperateCard != m_cbProvideCard)
		{
			ASSERT(false);
			return true;
		}
		//变量定义
		WORD wTargetUser = wChairID;
		int cbTargetAction = cbOperateCode;

		//设置变量
		m_bResponse[wChairID] = true;
		m_cbPerformAction[wChairID] = cbOperateCode;
		m_cbOperateCard[wChairID] = m_cbProvideCard;

		//在自己未摸下一张牌的一圈内,不能弃上一家而胡下一家，癞油不可以胡打出来的牌的。
		if (cbTargetAction == WIK_NULL && (WIK_CHI_HU&m_cbUserAction[wTargetUser]) && m_wProvideUser != wTargetUser)
			m_bEnjoinChiHu[wTargetUser] = true;

		//执行动作的优先级判断, WIK_CHI_HU 大于 WIK_GANG 大于 WIK_PENG 大于 [WIK_RIGHT or WIK_CENTER or WIK_LEFT]
		//for (WORD i = 0; i < GAME_PLAYER; i++)
		//{
		//	//获取动作
		//	BYTE cbUserAction = (m_bResponse[i] == false) ? m_cbUserAction[i] : m_cbPerformAction[i];
		//	//优先级别
		//	BYTE cbUserActionRank = m_GameLogic.GetUserActionRank(cbUserAction);
		//	BYTE cbTargetActionRank = m_GameLogic.GetUserActionRank(cbTargetAction);
		//	//动作判断
		//	if (cbUserActionRank > cbTargetActionRank)
		//	{
		//		wTargetUser = i;
		//		cbTargetAction = cbUserAction;
		//	}
		//}
		//if (m_bResponse[wTargetUser] == false)
		//	return true;
		//放弃操作
		

		//变量定义
		BYTE cbTargetCard = cbOperateCard;
		m_cbOperateCard[wTargetUser] = cbTargetCard;
		//出牌变量
		m_cbOutCardData = 0;
		m_bSendStatus = true;
		m_wOutCardUser = INVALID_CHAIR;
		m_bEnjoinChiHu[wTargetUser] = true;

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


		//组合扑克
		ASSERT(m_cbWeaveItemCount[wTargetUser] < 4);
		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;
		tagGangCardResult GangCardResult;
		ZeroMemory(&GangCardResult, sizeof(GangCardResult));
		//删除扑克
		switch (cbTargetAction)
		{
		case WIK_PENG:		//碰牌操作
		{
			//删除扑克
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)] < 2)
			{
				return false;
			}
			BYTE cbRemoveCard[] = { cbTargetCard, cbTargetCard };
			VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, 2));
			
			FanKuiAction |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wChairID], m_cbLaiZiData, m_cbLaiZiPiData, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], GangCardResult);
			break;
		}
		case WIK_MING_GANG:		//明杠牌操作
		{
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)] != 3)
			{
				return false;
			}
			BYTE cbRemoveCard[] = { cbTargetCard, cbTargetCard, cbTargetCard };
			VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, CountArray(cbRemoveCard)));
			break;
		}
		case WIK_MING_PIGANG: //明朝天杠牌操作
		{
			//删除扑克,被动动作只存在放杠
			if (cbTargetCard == m_cbLaiZiPiData)
			{
				if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)] != 2)
				{
					ASSERT(false);
					return false;
				}
				//删除扑克
				BYTE cbRemoveCard[] = { cbTargetCard, cbTargetCard };
				VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, 2));
				
				FanKuiAction |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wChairID], m_cbLaiZiData, m_cbLaiZiPiData, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], GangCardResult);
			}
			else false;
			break;
		}
		default:
			ASSERT(FALSE);
			return false;
		}

		//构造结果
		CMD_S_OperateResult OperateResult;
		OperateResult.wOperateUser = wTargetUser;
		OperateResult.cbOperateCard = cbTargetCard;
		OperateResult.cbOperateCode = cbTargetAction;
		OperateResult.wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;
		OperateResult.bOutCardCout = 0;//能出牌个数
		OperateResult.cbActionMask = WIK_NULL;
		ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
		ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
		ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
		ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));
		if (OperateResult.cbOperateCode == WIK_PENG || OperateResult.cbOperateCode == WIK_MING_PIGANG)
		{
			BYTE tempData[MAX_INDEX] = { 0 };
			for (BYTE i = 0; i < MAX_INDEX; i++)
			{
				if (m_cbCardIndex[wChairID][i] == 0)continue;
				BYTE TempLaiZiCount = m_OutLaiZi[wChairID];
				if (m_GameLogic.SwitchToCardData(i) == m_cbLaiZiData)TempLaiZiCount++;
				m_cbCardIndex[wChairID][i]--;
				if (m_GameLogic.IsTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbLaiZiData, bGameType, TempLaiZiCount))
				{
					OperateResult.bOutCardData[OperateResult.bOutCardCout] = m_GameLogic.SwitchToCardData(i);
					BYTE m_cbTingPai[MAX_INDEX] = { 0 };//听牌数组，听哪个牌就把哪个牌设置为1
					BYTE m_cbTingParCount = 0;//听牌数据
					bool BbanlaiTemp = true;
					if (m_GameLogic.AnalyseTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbTingPai, m_cbLaiZiData, bGameType,TempLaiZiCount))
					{
						for (BYTE j = 0; j < MAX_INDEX; j++)
						{
							if (m_cbTingPai[j] == 1)
							{
								BbanlaiTemp = false;
								OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount++] = m_GameLogic.SwitchToCardData(j);
								BYTE num = RemainNum(wChairID, OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount - 1], i);
								OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount - 1] = m_GameLogic.GetValue(num, OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount - 1]);
							}
						}
						OperateResult.bTingCardCount[OperateResult.bOutCardCout] = m_cbTingParCount;
					}
					if ((bGameType == BanLai) && BbanlaiTemp)
					{
						OperateResult.bOutCardData[OperateResult.bOutCardCout] = 0;
						OperateResult.bOutCardCout--;
					}
					OperateResult.bOutCardCout++;
				}
				m_cbCardIndex[wChairID][i]++;
			}
		}

		BYTE TempCount = 0;
			
		if (FanKuiAction != WIK_NULL)
		{
			m_cbUserAction[wChairID] = FanKuiAction;
			for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
			{
				OperateResult.cbActionCard[i] = GangCardResult.cbCardData[i];
			}
			/*if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbLaiZiPiData)]==3)
			{
				OperateResult.cbActionMask |= WIK_AN_PIGANG;
				m_cbUserAction[wChairID] |= WIK_AN_PIGANG;
				OperateResult.cbActionCard[TempCount++] = m_cbLaiZiPiData;
			}
			for (BYTE i = 0; i < MAX_INDEX;i++)
			{
				if (m_cbCardIndex[wChairID][i] == 4 && i != m_GameLogic.SwitchToCardIndex(m_cbLaiZiData))
				{
					OperateResult.cbActionMask |= WIK_AN_GANG;
					m_cbUserAction[wChairID] |= WIK_AN_GANG;
					OperateResult.cbActionCard[TempCount++] = m_GameLogic.SwitchToCardData(i);
				}
			}*/
		}
		if (OperateResult.bOutCardCout != 0)
		{
			m_TabbOutCardCout[wTargetUser] = 0;														//可以打出的牌就听牌的个数
			ZeroMemory(m_TabbOutCardData[wTargetUser], sizeof(m_TabbOutCardData[wTargetUser]));		//具体打哪几张牌
			ZeroMemory(m_TabbTingCardCount[wTargetUser], sizeof(m_TabbTingCardCount[wTargetUser]));	//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
			ZeroMemory(m_TabbTingCardData[wTargetUser], sizeof(m_TabbTingCardData[wTargetUser]));	//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

			m_TabbOutCardCout[wTargetUser] = OperateResult.bOutCardCout;																//可以打出的牌就听牌的个数
			CopyMemory(m_TabbOutCardData[wTargetUser], OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));				//具体打哪几张牌
			CopyMemory(m_TabbTingCardCount[wTargetUser], OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));		//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
			CopyMemory(m_TabbTingCardData[wTargetUser], OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));			//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据
		}
		RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT, &OperateResult, sizeof(OperateResult));
		//发送消息
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, &OperateResult, sizeof(OperateResult));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, &OperateResult, sizeof(OperateResult));

		//设置用户
		m_wCurrentUser = wTargetUser;

		//杠牌处理
		if (cbTargetAction == WIK_MING_GANG || cbTargetAction == WIK_MING_PIGANG)
		{
			//发送信息
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wTargetUser;
			gs.lGangScore[wTargetUser] += m_gameConfig.wDiScore * 3;
			gs.lGangScore[m_wProvideUser] -= m_gameConfig.wDiScore * 3;
			gs.cbOperateCode = cbTargetAction;
			m_lGameScore[wTargetUser] += gs.lGangScore[wTargetUser];
			m_lGameScore[m_wProvideUser] += gs.lGangScore[m_wProvideUser];
			m_lGameTatolScore[wTargetUser] += gs.lGangScore[wTargetUser];
			m_lGameTatolScore[m_wProvideUser] += gs.lGangScore[m_wProvideUser];
			gs.cbWanJiaScore[wTargetUser] = m_lGameTatolScore[wTargetUser];
			gs.cbWanJiaScore[m_wProvideUser] = m_lGameTatolScore[m_wProvideUser];
			for (BYTE i = 0; i < GAME_PLAYER;i++)
			{
				if (i == m_wProvideUser || i == wTargetUser)continue;
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
			}
			
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			//杠得分 //送杠者扣2倍积分
			//BYTE cbIndex = m_GangScore[wTargetUser].cbGangCount++;
			////这里需要及时算分
			//m_GangScore[wTargetUser].lScore[cbIndex][wTargetUser] += m_pGameServiceOption->lCellScore * 3;
			//m_GangScore[wTargetUser].lScore[cbIndex][m_wProvideUser] += -m_pGameServiceOption->lCellScore * 3;

			m_bGangStatus = false;
			m_wDianGangUser = m_wProvideUser;
			if ((cbTargetCard != m_cbLaiZiPiData) && cbTargetAction == WIK_MING_GANG)
			{
				DispatchCardData(wTargetUser, true);
			}
		}
		return true;
	}

	//主动动作
	if (m_wCurrentUser==wChairID) //如果是摸牌用户的操作，比如自摸或者自杠
	{
		//效验操作
		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_AN_GANG:			//暗杠牌操作
		{
			//扑克效验
			ASSERT((cbOperateCode == WIK_NULL) || (cbOperateCode == WIK_ZI_MO) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
			if ((cbOperateCode != WIK_NULL) && (cbOperateCode != WIK_CHI_HU) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
				return false;
			//变量定义
			BYTE cbWeaveIndex = 0xFF;
			BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
			//杠牌处理
			if (m_cbCardIndex[wChairID][cbCardIndex] == 4 && m_GameLogic.SwitchToCardData(cbCardIndex) != m_cbLaiZiPiData)
			{
				//扑克效验
				ASSERT(m_cbCardIndex[wChairID][cbCardIndex] == 4);
				if (m_cbCardIndex[wChairID][cbCardIndex] != 4)
					return false;
				//设置变量
				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;
			}
			else return false;
			//删除扑克
			m_cbCardIndex[wChairID][cbCardIndex] = 0;
			m_wDianGangUser = wChairID;

			//构造结果
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = WIK_NULL;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));

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


			//发送信息
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			//杠牌得分
			int lScore = 0;
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_AN_GANG;
			for (WORD i = 0; i < GAME_PLAYER; i++)
			{
				if (!m_bPlayStatus[i] || i == wChairID) continue;

				gs.lGangScore[i] -= m_gameConfig.wDiScore * 2;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				lScore -= gs.lGangScore[i];
			}
			gs.lGangScore[wChairID] = lScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];
			
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			DispatchCardData(wChairID, true);
			return true;
		}
		case WIK_BU_GANG:
		{
			//扑克效验
			ASSERT((cbOperateCode == WIK_NULL) || (cbOperateCode == WIK_ZI_MO) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
			if ((cbOperateCode != WIK_NULL) && (cbOperateCode != WIK_CHI_HU) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
				return false;
			BYTE cbWeaveIndex = 0xFF;
			BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(m_cbProvideCard);
			//杠牌处理
			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 ((cbCenterCard == m_cbProvideCard) && (cbWeaveKind == WIK_PENG))
					{
						bPublic = true;
						cbWeaveIndex = i;
						break;
					}
				}
				//效验动作
				ASSERT(cbWeaveIndex != 0xFF);
				if (cbWeaveIndex == 0xFF) 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 = m_cbProvideCard;
			}
			else return false;
			//删除扑克
			m_cbCardIndex[wChairID][cbCardIndex] = 0;
			m_wDianGangUser = wChairID;
	
			//构造结果
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = m_cbProvideCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = WIK_NULL;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));

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


			//发送信息
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			//杠牌得分
			int lScore = 0;
			gs.cbOperateCode = WIK_BU_GANG;
			for (WORD i = 0; i < GAME_PLAYER; i++)
			{
				if (!m_bPlayStatus[i] || i == wChairID) continue;
				gs.lGangScore[i] -= m_gameConfig.wDiScore;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				lScore -= gs.lGangScore[i];
			}
			gs.lGangScore[wChairID] = lScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];
			
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			DispatchCardData(wChairID, true);
			return true;
		}
		case WIK_AN_PIGANG:
		{
			//扑克效验
			ASSERT((cbOperateCode == WIK_NULL) || (cbOperateCode == WIK_ZI_MO) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
			if ((cbOperateCode != WIK_NULL) && (cbOperateCode != WIK_CHI_HU) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
				return false;
			BYTE cbWeaveIndex = 0xFF;
			BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
			if (m_cbCardIndex[wChairID][cbCardIndex] == 3 && m_GameLogic.SwitchToCardData(cbCardIndex) == m_cbLaiZiPiData)
			{

				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;
			}
			else return false;
			//删除扑克
			m_cbCardIndex[wChairID][cbCardIndex] = 0;
			m_wDianGangUser = wChairID;

			//构造结果
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = 0;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			if (m_wProvideUser == m_wCurrentUser&&wChairID == m_wCurrentUser)
			{
				CChiHuRight chr;
				BYTE LastTempDate = 0;
				if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] == 1)
				{
					LastTempDate = m_cbLaiZiData;
				}
				else
				{
					LastTempDate = m_cbProvideCard == m_cbLaiZiPiData ? (m_GameLogic.GetEndCard(m_cbCardIndex[wChairID], m_cbLaiZiData)) : m_cbProvideCard;
				}
				BYTE m_cbTempData[MAX_INDEX];
				ZeroMemory(m_cbTempData, sizeof(m_cbTempData));
				CopyMemory(m_cbTempData, m_cbCardIndex[wChairID], sizeof(m_cbTempData));
				m_cbTempData[m_GameLogic.SwitchToCardIndex(LastTempDate)]--;
				OperateResult.cbActionMask |= m_GameLogic.AnalyseChiHuCard(m_cbTempData, m_WeaveItemArray[wChairID],
					m_cbWeaveItemCount[wChairID], LastTempDate, chr, m_cbLaiZiData, bGameType);
				if (OperateResult.cbActionMask&WIK_ZI_MO)
				{
					if (OperateResult.cbActionMask&WIK_YING_ZIMO)
					{
						if (m_bGangStatus)
						{
							OperateResult.cbActionMask |= WIK_YING_LAIYOU;
							m_cbUserAction[wChairID] |= WIK_YING_LAIYOU;
						}
						else
							m_cbUserAction[wChairID] |= WIK_YING_ZIMO;
					}
					else
					{
						if (m_bGangStatus)
						{
							OperateResult.cbActionMask |= WIK_RUAN_LAIYOU;
							m_cbUserAction[wChairID] |= WIK_RUAN_LAIYOU;
						}
						else
						{
							OperateResult.cbActionMask |= WIK_RUAN_ZIMO;
							m_cbUserAction[wChairID] |= WIK_RUAN_ZIMO;
						}
					}
					m_cbProvideCard = LastTempDate;
				}
				if (bGameType == BanLai && (m_cbUserAction[wChairID] & WIK_RUAN_ZIMO) && m_OutLaiZi[wChairID] == 0)
				{
					OperateResult.cbActionMask = OperateResult.cbActionMask & 0xff0ff;
					m_cbUserAction[wChairID] = m_cbUserAction[wChairID] & 0xff0ff;
				}
			}
			tagGangCardResult GangCardResult;
			OperateResult.cbActionMask |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wChairID], m_cbLaiZiData, m_cbLaiZiPiData, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], GangCardResult);
			if (OperateResult.cbActionMask & WIK_GANG)
			{
				m_cbUserAction[wChairID] = OperateResult.cbActionMask;
				for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
				{
					OperateResult.cbActionCard[i] = GangCardResult.cbCardData[i];
				}
				/*BYTE TempCount = 0;
				for (BYTE i = 0; i < MAX_INDEX; i++)
				{
					if (m_cbCardIndex[wChairID][i] == 4 && i != m_GameLogic.SwitchToCardIndex(m_cbLaiZiData))
					{
						OperateResult.cbActionMask |= WIK_AN_GANG;
						m_cbUserAction[wChairID] |= WIK_GANG;
						m_cbUserAction[wChairID] |= WIK_AN_GANG;
						OperateResult.cbActionCard[TempCount++] = m_GameLogic.SwitchToCardData(i);
					}
				}*/
			}
			
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));
			for (BYTE i = 0; i < MAX_INDEX; i++)
			{
				if (m_cbCardIndex[wChairID][i] == 0)continue;
				BYTE TempLaiZiCount = m_OutLaiZi[wChairID];
				if (m_GameLogic.SwitchToCardData(i) == m_cbLaiZiData)TempLaiZiCount++;
				m_cbCardIndex[wChairID][i]--;
				if (m_GameLogic.IsTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbLaiZiData, bGameType, TempLaiZiCount))
				{
					OperateResult.bOutCardData[OperateResult.bOutCardCout] = m_GameLogic.SwitchToCardData(i);
					BYTE m_cbTingPai[MAX_INDEX] = { 0 };//听牌数组，听哪个牌就把哪个牌设置为1
					BYTE m_cbTingParCount = 0;//听牌数据
					bool BbanlaiTemp = true;
					if (m_GameLogic.AnalyseTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbTingPai, m_cbLaiZiData, bGameType,TempLaiZiCount))
					{
						for (BYTE j = 0; j < MAX_INDEX; j++)
						{
							if (m_cbTingPai[j] == 1)
							{
								BbanlaiTemp = false;
								OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount++] = m_GameLogic.SwitchToCardData(j);
								BYTE num = RemainNum(wChairID, OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount - 1], i);
								OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount - 1] = m_GameLogic.GetValue(num, OperateResult.bTingCardData[OperateResult.bOutCardCout][m_cbTingParCount - 1]);
							}
						}
						OperateResult.bTingCardCount[OperateResult.bOutCardCout] = m_cbTingParCount;
					}
					if ((bGameType == BanLai) && BbanlaiTemp)
					{
						OperateResult.bOutCardData[OperateResult.bOutCardCout] = 0;
						OperateResult.bOutCardCout--;
					}
					OperateResult.bOutCardCout++;
				}
				m_cbCardIndex[wChairID][i]++;
			}
			if (OperateResult.bOutCardCout != 0)
			{
				m_TabbOutCardCout[wChairID] = 0;														//可以打出的牌就听牌的个数
				ZeroMemory(m_TabbOutCardData[wChairID], sizeof(m_TabbOutCardData[wChairID]));		//具体打哪几张牌
				ZeroMemory(m_TabbTingCardCount[wChairID], sizeof(m_TabbTingCardCount[wChairID]));	//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
				ZeroMemory(m_TabbTingCardData[wChairID], sizeof(m_TabbTingCardData[wChairID]));	//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

				m_TabbOutCardCout[wChairID] = OperateResult.bOutCardCout;																//可以打出的牌就听牌的个数
				CopyMemory(m_TabbOutCardData[wChairID], OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));				//具体打哪几张牌
				CopyMemory(m_TabbTingCardCount[wChairID], OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));		//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
				CopyMemory(m_TabbTingCardData[wChairID], OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));			//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据
			}
			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT, &OperateResult, sizeof(OperateResult));
			//发送消息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, &OperateResult, sizeof(OperateResult));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, &OperateResult, sizeof(OperateResult));


			//发送信息
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_AN_PIGANG;
			//杠牌得分
			int lScore = 0;
			for (WORD i = 0; i < GAME_PLAYER; i++)
			{
				if (!m_bPlayStatus[i] || i == wChairID) continue;
				gs.lGangScore[i] -= m_gameConfig.wDiScore * 2;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				lScore -= gs.lGangScore[i];

			}
			gs.lGangScore[wChairID] = lScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];
			
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			if (m_cbProvideCard==m_cbLaiZiPiData || wChairID != m_wProvideUser)
				m_cbProvideCard = m_GameLogic.GetEndCard(m_cbCardIndex[wChairID], m_cbLaiZiData);
			m_cbSendCardData = m_cbProvideCard;
			m_wProvideUser = wChairID;
			m_wCurrentUser = wChairID;
			return true;
		}
		case WIK_RUAN_ZIMO:		//自摸和牌
		{
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] != 1)			
			{
				ASSERT(false);
				return false;
			}
			BYTE TempCardData=m_cbProvideCard;
			if (m_cbProvideCard!=m_cbSendCardData)
			{
				ASSERT(false);
				return false;
			}
			int TempAction;
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--;
			CChiHuRight chr;
			TempAction |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
				m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, m_cbLaiZiData,bGameType);
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
			if (TempAction == WIK_NULL) 			
			{
				ASSERT(false);
				return false;
			}
			m_HuPai[wChairID]++;
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = WIK_NULL;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));

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

			BYTE tempLaiZi = 0;//癞子个数超过四个就特殊处理
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				tempLaiZi += m_OutLaiZi[i];
			}
			if (tempLaiZi > 4)			
			{
				ASSERT(false);
				return false;
			}
			//积分变动
			CMD_S_GangScore gs;			
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_RUAN_ZIMO;
			int TempInfoScore = 0;
			BYTE FanShu = 1;
			for (BYTE i = 0; i < GAME_PLAYER; i++)//各个玩家游戏积分变动
			{
				if (i == wChairID)continue;
				FanShu = (FanShu << (m_OutLaiZi[i] + m_OutLaiZi[wChairID]));
				gs.lGangScore[i] -= m_gameConfig.wDiScore*FanShu;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				TempInfoScore -= gs.lGangScore[i];
				FanShu = 1;
			}
			gs.lGangScore[wChairID] = TempInfoScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];
			
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			OnEventGameConclude(wChairID, NULL, GER_NORMAL);
			return true;
		}
		case WIK_YING_ZIMO:
		{
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] > 1)
			{
				ASSERT(false);
				return false;
			}
			if (m_cbProvideCard != m_cbSendCardData)
			{
				ASSERT(false);
				return false;
			}
			BYTE TempCardData = m_cbProvideCard;
			int TempAction;
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--;
			CChiHuRight chr;
			TempAction |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
				m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, m_cbLaiZiData, bGameType);
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
			if (TempAction == WIK_NULL) 
			{
				ASSERT(false);
				return false;
			}
			m_HuPai[wChairID]++;
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = WIK_NULL;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));

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

			BYTE tempLaiZi = 0;//癞子个数超过四个就特殊处理
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				tempLaiZi += m_OutLaiZi[i];
			}
			if (tempLaiZi > 4)
			{
				ASSERT(false);
				return false;
			}
			//积分变动
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_YING_ZIMO;
			int TempInfoScore = 0;
			BYTE FanShu = 1;
			for (BYTE i = 0; i < GAME_PLAYER; i++)//各个玩家游戏积分变动
			{
				if (i == wChairID)continue;
				FanShu = (FanShu << (m_OutLaiZi[i] + m_OutLaiZi[wChairID]));
				gs.lGangScore[i] -= m_gameConfig.wDiScore*FanShu * 2;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				TempInfoScore -= gs.lGangScore[i];
				FanShu = 1;
			}
			gs.lGangScore[wChairID] = TempInfoScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];

			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			OnEventGameConclude(wChairID, NULL, GER_NORMAL);
			return true;
		}
		case WIK_RUAN_LAIYOU:
		{
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] != 1)
			{
				ASSERT(false);
				return false;
			}
			if (!m_bGangStatus)
			{
				m_bGangStatus = false;
				ASSERT(false);
				return false;
			}
			BYTE TempCardData = m_cbProvideCard;
			if (m_cbProvideCard != m_cbSendCardData)
			{
				ASSERT(false);
				return false;
			}
			int TempAction;
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--;
			CChiHuRight chr;
			TempAction |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
				m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, m_cbLaiZiData, bGameType);
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
			if (TempAction == WIK_NULL)
			{
				ASSERT(false);
				return false;
			}
			m_HuPai[wChairID]++;
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = WIK_NULL;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));

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

			BYTE tempLaiZi = 0;//癞子个数超过四个就特殊处理
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				tempLaiZi += m_OutLaiZi[i];
			}
			if (tempLaiZi > 4)return false;
			//积分变动
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_RUAN_LAIYOU;
			int TempInfoScore = 0;
			BYTE FanShu = 1;
			for (BYTE i = 0; i < GAME_PLAYER; i++)//各个玩家游戏积分变动
			{
				if (i == wChairID)continue;
				FanShu = (FanShu << (m_OutLaiZi[i] + m_OutLaiZi[wChairID]));
				gs.lGangScore[i] -= m_gameConfig.wDiScore*FanShu * 2;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				TempInfoScore -= gs.lGangScore[i];
				FanShu = 1;
			}
			gs.lGangScore[wChairID] = TempInfoScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];

			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			OnEventGameConclude(wChairID, NULL, GER_NORMAL);
			return true;
		}
		case WIK_YING_LAIYOU:
		{
			if (m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] > 1)
			{
				ASSERT(false);
				return false;
			}
			if (!m_bGangStatus)
			{
				m_bGangStatus = false;
				ASSERT(false);
				return false;
			}
			BYTE TempCardData = m_cbProvideCard;
			int TempAction;
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--;
			CChiHuRight chr;
			TempAction |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
				m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, m_cbLaiZiData, bGameType);
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]++;
			if (TempAction == WIK_NULL)
			{
				ASSERT(false);
				return false;
			}
			m_HuPai[wChairID]++;
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.wProvideUser = wChairID;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.bOutCardCout = 0;//能出牌个数
			OperateResult.cbActionMask = WIK_NULL;
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			ZeroMemory(OperateResult.bOutCardData, sizeof(OperateResult.bOutCardData));//能出牌具体数据
			ZeroMemory(OperateResult.bTingCardCount, sizeof(OperateResult.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(OperateResult.bTingCardData, sizeof(OperateResult.bTingCardData));

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

			BYTE tempLaiZi = 0;//癞子个数超过四个就特殊处理
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				tempLaiZi += m_OutLaiZi[i];
			}
			if (tempLaiZi > 4)return false;
			//积分变动
			CMD_S_GangScore gs;			
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_YING_LAIYOU;
			int TempInfoScore = 0;
			BYTE FanShu = 1;
			for (BYTE i = 0; i < GAME_PLAYER; i++)//各个玩家游戏积分变动
			{
				if (i == wChairID)continue;
				FanShu = (FanShu << (m_OutLaiZi[i] + m_OutLaiZi[wChairID]));
				gs.lGangScore[i] -= m_gameConfig.wDiScore*FanShu * 4;
				m_lGameScore[i] += gs.lGangScore[i];
				m_lGameTatolScore[i] += gs.lGangScore[i];
				gs.cbWanJiaScore[i] = m_lGameTatolScore[i];
				TempInfoScore -= gs.lGangScore[i];
				FanShu = 1;
			}
			gs.lGangScore[wChairID] = TempInfoScore;
			m_lGameScore[wChairID] += gs.lGangScore[wChairID];
			m_lGameTatolScore[wChairID] += gs.lGangScore[wChairID];
			gs.cbWanJiaScore[wChairID] = m_lGameTatolScore[wChairID];

			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			for (BYTE i = 0; i < GAME_PLAYER; i++)
			{
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, &gs, sizeof(gs));
			OnEventGameConclude(wChairID, NULL, GER_NORMAL);
			return true;
		}
		}
		return true;
	}
	return false;
}

//发送操作
bool CTableFrameSink::SendOperateNotify()
{
	//发送提示
	for (WORD i=0;i<GAME_PLAYER;i++)
	{
		if (m_cbUserAction[i]!=WIK_NULL)
		{
			//构造数据
			CMD_S_OperateNotify OperateNotify;
			OperateNotify.wResumeUser=m_wResumeUser;
			OperateNotify.cbActionCard=m_cbProvideCard;
			OperateNotify.cbActionMask=m_cbUserAction[i];

			//RepayRecord(i, SUB_S_OPERATE_NOTIFY, &OperateNotify, sizeof(OperateNotify));
			//发送数据
			m_pITableFrame->SendTableData(i,SUB_S_OPERATE_NOTIFY,&OperateNotify,sizeof(OperateNotify));
			
		}
	}
	//m_pITableFrame->SendLookonData(i, SUB_S_OPERATE_NOTIFY, &OperateNotify, sizeof(OperateNotify));
	return true;
}

//派发扑克,wCurrentUser表示给哪个用户，bTail表示是末尾拿牌还是不是，true表示末尾，bLaiZiGang默认false不是癞子杠，true才是
bool CTableFrameSink::DispatchCardData(WORD wCurrentUser,bool bTail,bool bLaiZiGang)
{
	//状态效验
	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_cbChiHuCard = 0;
		m_wProvideUser = INVALID_CHAIR;
		bIsHuang = true;
		OnEventGameConclude(m_wProvideUser, NULL, GER_NORMAL);
		
		return true;
	}

	m_TabbOutCardCout[wCurrentUser] = 0;														//可以打出的牌就听牌的个数
	ZeroMemory(m_TabbOutCardData[wCurrentUser], sizeof(m_TabbOutCardData[wCurrentUser]));		//具体打哪几张牌
	ZeroMemory(m_TabbTingCardCount[wCurrentUser], sizeof(m_TabbTingCardCount[wCurrentUser]));	//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
	ZeroMemory(m_TabbTingCardData[wCurrentUser], sizeof(m_TabbTingCardData[wCurrentUser]));		//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

	//设置变量
	m_cbOutCardData = 0;
	m_wCurrentUser = wCurrentUser;		//记录拿牌人的索引。
	m_wOutCardUser = INVALID_CHAIR;		//置空上次出牌用户的索引
	m_bEnjoinChiHu[wCurrentUser] = false;
	BYTE ActionCard[3] = { 0 };//操作牌值
	BYTE AnActionCount = 0;
	tagGangCardResult GangCardResult;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	//发牌处理
	if (m_bSendStatus == true)
	{
		//发送扑克
		m_cbSendCardCount++;
		m_cbSendCardData = m_cbRepertoryCard[--m_cbLeftCardCount];
		CChiHuRight chr;
		m_cbUserAction[wCurrentUser] |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wCurrentUser], m_WeaveItemArray[wCurrentUser],
			m_cbWeaveItemCount[wCurrentUser], m_cbSendCardData, chr, m_cbLaiZiData, bGameType);

		//加牌
		m_cbCardIndex[wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;

		//设置变量
		m_wProvideUser = wCurrentUser;
		m_cbProvideCard = m_cbSendCardData;

		//杠牌判断
		if (m_cbLeftCardCount > 0 )
		{
			bool bCanAnGang = true;//此true表示自己抓牌，false表示表人打得去检验杠，			
			m_cbUserAction[wCurrentUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wCurrentUser], m_cbLaiZiData, m_cbLaiZiPiData,
				m_WeaveItemArray[wCurrentUser], m_cbWeaveItemCount[wCurrentUser], GangCardResult, m_cbSendCardData);
		}

	}
	if (m_cbUserAction[wCurrentUser]!=WIK_NULL)
	{
		if (m_cbUserAction[wCurrentUser] & WIK_ZI_MO)
		{
			if (bLaiZiGang)
			{
				if (m_cbUserAction[wCurrentUser]&WIK_YING_ZIMO)
				{
					m_cbUserAction[wCurrentUser] = m_cbUserAction[wCurrentUser] & 0xff0ff;
					m_cbUserAction[wCurrentUser] |= WIK_YING_LAIYOU;
				}
				if (m_cbCardIndex[wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] == 1 && !(m_cbUserAction[wCurrentUser] & WIK_YING_LAIYOU))
				{
					m_cbUserAction[wCurrentUser] |= WIK_RUAN_LAIYOU;
				}
				else
				{
					m_cbUserAction[wCurrentUser] |= WIK_YING_LAIYOU;
				}
			}
			else
			{
				if (m_cbCardIndex[wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbLaiZiData)] == 1 && !(m_cbUserAction[wCurrentUser]&WIK_YING_ZIMO))
				{
					m_cbUserAction[wCurrentUser] |= WIK_RUAN_ZIMO;
				}
				else
				{
					m_cbUserAction[wCurrentUser] |= WIK_YING_ZIMO;
				}
			}
		}
		if (m_cbUserAction[wCurrentUser] & WIK_GANG)
		{
			for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
			{
				ActionCard[i] = GangCardResult.cbCardData[i];
			}		
		}
	}
	if (bGameType == BanLai && (m_cbUserAction[wCurrentUser]&WIK_RUAN_ZIMO) && m_OutLaiZi[wCurrentUser] == 0)
	{
		m_cbUserAction[wCurrentUser] = m_cbUserAction[wCurrentUser] & 0xff0ff;
	}
	//构造数据
	
	CMD_S_SendCard SendCard;
	ZeroMemory(&SendCard, sizeof(SendCard));
	SendCard.wCurrentUser = wCurrentUser;
	SendCard.bTail = 0;
	SendCard.bLeftCardCount = m_cbLeftCardCount;
	SendCard.cbActionMask = m_cbUserAction[wCurrentUser];
	SendCard.cbCardData = (m_bSendStatus == true) ? m_cbSendCardData : 0x00;
	BYTE bOutCardCount = 0;//听牌个数
	BYTE bTempCardData[14] = { 0 };
	BYTE bTingCount[14] = { 0 };
	BYTE bTingCardData[14][27] = { 0 };

	SendCard.bOutCardCout = 0;//能出牌个数(由个数决定是否听牌，0表示不可以听牌）
	ZeroMemory(SendCard.bOutCardData, sizeof(SendCard.bOutCardData));//能出牌具体数据
	ZeroMemory(SendCard.bTingCardCount, sizeof(SendCard.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
	ZeroMemory(SendCard.bTingCardData, sizeof(SendCard.bTingCardData));
	BYTE tempData[MAX_INDEX] = { 0 };
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		if (m_cbCardIndex[m_wCurrentUser][i] == 0)continue;
		BYTE TempLaiZiCount = m_OutLaiZi[wCurrentUser];
		if (m_GameLogic.SwitchToCardData(i) == m_cbLaiZiData)TempLaiZiCount++;
		m_cbCardIndex[m_wCurrentUser][i]--;
		if (m_GameLogic.IsTingCard(m_cbCardIndex[m_wCurrentUser], m_WeaveItemArray[m_wCurrentUser], m_cbWeaveItemCount[m_wCurrentUser], m_cbLaiZiData, bGameType, TempLaiZiCount))
		{
			bTempCardData[bOutCardCount] = m_GameLogic.SwitchToCardData(i);
			BYTE m_cbTingPai[MAX_INDEX] = { 0 };//听牌数组，听哪个牌就把哪个牌设置为1
			BYTE m_cbTingParCount = 0;//听牌数据
			bool BbanlaiTemp = true;
			if (m_GameLogic.AnalyseTingCard(m_cbCardIndex[m_wCurrentUser], m_WeaveItemArray[m_wCurrentUser], m_cbWeaveItemCount[m_wCurrentUser], m_cbTingPai, m_cbLaiZiData, bGameType,TempLaiZiCount))
			{
				for (BYTE j = 0; j < MAX_INDEX; j++)
				{
					if (m_cbTingPai[j] == 1)
					{
						BbanlaiTemp = false;
						bTingCardData[bOutCardCount][m_cbTingParCount++] = m_GameLogic.SwitchToCardData(j);
						BYTE num = RemainNum(wCurrentUser, bTingCardData[bOutCardCount][m_cbTingParCount - 1], i);
						bTingCardData[bOutCardCount][m_cbTingParCount - 1] = m_GameLogic.GetValue(num, bTingCardData[bOutCardCount][m_cbTingParCount - 1]);
					}
				}
				bTingCount[bOutCardCount] = m_cbTingParCount;
			}
			if ((bGameType == BanLai) && BbanlaiTemp)
			{
				bTempCardData[bOutCardCount] = 0;
				bOutCardCount--;
			}
			//if (bTingCount[bOutCardCount] > 0)
			bOutCardCount++;
			//else
			//	bTempCardData[bOutCardCount] = 0;
		}
		m_cbCardIndex[m_wCurrentUser][i]++;
	}
	RepayRecord(INVALID_CHAIR, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard) - 378);

	//m_wResumeUser = m_wCurrentUser;//当前为抓牌用户，就算是过，也是还回到自己牌权
	//发送数据
	for (int i = 0; i < GAME_PLAYER; i++)
	{
		if (i == m_wCurrentUser)
		{//发送给摸牌玩家的数据，附带麻将牌面数据
			SendCard.cbCardData = (m_bSendStatus == true) ? m_cbSendCardData : 0x00;
			SendCard.cbActionMask = m_cbUserAction[wCurrentUser];
			SendCard.bOutCardCout = bOutCardCount;
			CopyMemory(SendCard.cbActionCard, ActionCard, sizeof(ActionCard));
			CopyMemory(SendCard.bTingCardCount, bTingCount, sizeof(bTingCount));
			CopyMemory(SendCard.bOutCardData, bTempCardData, sizeof(bTempCardData));
			CopyMemory(SendCard.bTingCardData, bTingCardData, sizeof(bTingCardData));
			m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard));
			//m_pITableFrame->SendLookonData(i, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard));

			m_TabbOutCardCout[m_wCurrentUser] = bOutCardCount;											//可以打出的牌就听牌的个数
			CopyMemory(m_TabbOutCardData[m_wCurrentUser], bTempCardData, sizeof(bTempCardData));		//具体打哪几张牌
			CopyMemory(m_TabbTingCardCount[m_wCurrentUser], bTingCount, sizeof(bTingCount));				//相对应打出牌可听牌个数，索引表示第几张，值是对应对应的听牌个数
			CopyMemory(m_TabbTingCardData[m_wCurrentUser], bTingCardData, sizeof(bTingCardData));		//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据
		}
		else
		{//发送给其他玩家的数据，没有麻将牌面数据（防止客户端作弊）
			SendCard.cbCardData = 0x00;
			SendCard.cbActionMask = 0x0000;
			SendCard.bOutCardCout = 0;//能出牌个数这幅牌出个牌是否可以听牌
			ZeroMemory(SendCard.cbActionCard, sizeof(SendCard.cbActionCard));//对哪个牌操作
			ZeroMemory(SendCard.bOutCardData, sizeof(SendCard.bOutCardData));//能出牌具体数据
			ZeroMemory(SendCard.bTingCardCount, sizeof(SendCard.bTingCardCount));//在出相应牌后能听牌的个数,所以是个二维的
			ZeroMemory(SendCard.bTingCardData, sizeof(SendCard.bTingCardData));
			m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard));
			//m_pITableFrame->SendLookonData(i, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard));
		}
	}
	SendCard.cbActionMask = 0;
	SendCard.cbCardData = 0;
	SendCard.bOutCardCout = 0;
	ZeroMemory(SendCard.bOutCardData, sizeof(SendCard.bOutCardData));
	ZeroMemory(SendCard.bTingCardCount, sizeof(SendCard.cbCardData));
	ZeroMemory(SendCard.bTingCardData, sizeof(SendCard.cbCardData));
	ZeroMemory(SendCard.cbActionCard, sizeof(SendCard.cbCardData));
	//给旁观者的抓牌动作
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard));
	return true;
}


bool CTableFrameSink::IsWin(WORD wChairID)
{
	for (auto chairID : m_wWinOrder)
	{
		if (chairID == wChairID)//表示玩家已经开始听牌，则出牌必须是所摸牌
			return true;
	}
	return false;
}

//响应判断
bool CTableFrameSink::EstimateUserRespond(WORD wCenterUser, BYTE cbCenterCard, enEstimatKind EstimatKind)
{
	//变量定义
	bool bAroseAction=false;

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

	//动作判断
	for (WORD i=0;i<GAME_PLAYER;i++)
	{
		//用户过滤
		if (wCenterUser==i||!m_bPlayStatus[i]) continue;
		//出牌类型
		if (EstimatKind==EstimatKind_OutCard)
		{
			//吃碰判断
			//if (m_bEnjoinChiPeng[i]==false)
			//{
			////碰牌判断
			m_cbUserAction[i] |= m_GameLogic.EstimatePengCard(m_cbCardIndex[i], cbCenterCard, m_cbLaiZiPiData);
			//杠牌判断
			if (m_cbLeftCardCount>0 && cbCenterCard != m_cbLaiZiPiData)
			{
				m_cbUserAction[i] |= m_GameLogic.EstimateGangCard(m_cbCardIndex[i], cbCenterCard);
			}
			//}
		}
		//结果判断
		if (m_cbUserAction[i] != WIK_NULL)
		{
			bAroseAction = true;
			if (m_cbUserAction[i]&WIK_PENG)
			{
				BYTE bTemp = 0;
				for (BYTE j = 0; j < m_cbLastDisCount[i]; j++)
				{
					if (m_cbLastDisCardData[i][j] == cbCenterCard)
					{
						bTemp++;
						if (bTemp==2)
						{
							m_cbUserAction[i] = m_cbUserAction[i] & 0xffff7;
							bAroseAction = false;
							break;
						}
						
					}
				}
			}
			break;
		}
	}

	//结果处理
	if (bAroseAction==true) 
	{
		//设置变量
		m_wProvideUser=wCenterUser;
		m_cbProvideCard=cbCenterCard;
		m_wResumeUser=m_wCurrentUser;
		m_wCurrentUser=INVALID_CHAIR;

		//发送提示
		SendOperateNotify();

		return true;
	}
	return false;
}

int CTableFrameSink::GetGenCount(WORD wChairId, CChiHuRight& chr)
{
	int cbGenCount = 0;
	//根,青龙七对和龙七对不算根
	//if ((chr&CHR_QING_LONG_QI_DUI).IsEmpty() && (chr&CHR_LONG_QI_DUI).IsEmpty())
	//{
	BYTE cbCardIndexTemp[MAX_INDEX];
	CopyMemory(cbCardIndexTemp, m_cbCardIndex[wChairId], sizeof(cbCardIndexTemp));
	for (BYTE i = 0; i < m_cbWeaveItemCount[wChairId]; i++)
	{
		// 抢杠过滤
		bool bQiangGang = false;
		if (m_WeaveItemArray[wChairId][i].cbWeaveKind == WIK_GANG)
		{
			for (BYTE k = 0; k < GAME_PLAYER; k++)
			{
				if (m_cbQiangGangCardData[k] == m_WeaveItemArray[wChairId][i].cbCenterCard) bQiangGang = true;
			}
		}
		if (bQiangGang) continue;

		BYTE cbCardBuffer[4];
		BYTE cbCardCount = m_GameLogic.GetWeaveCard(m_WeaveItemArray[wChairId][i].cbWeaveKind,
			m_WeaveItemArray[wChairId][i].cbCenterCard, cbCardBuffer);
		for (BYTE j = 0; j < cbCardCount; j++)
		{
			BYTE cbIndex = m_GameLogic.SwitchToCardIndex(cbCardBuffer[j]);
			cbCardIndexTemp[cbIndex]++;
		}
	}
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		if (cbCardIndexTemp[i] == 4) cbGenCount++;
	}
	return cbGenCount;
}

BYTE CTableFrameSink::RemainNum(WORD wChairId, const BYTE m_cbCard,BYTE bIndex)
{
	BYTE m_cbNum = 0;
	BYTE mCard[MAX_INDEX] = { 0 };
	BYTE TempIndex = m_GameLogic.SwitchToCardIndex(m_cbCard);
	BYTE LaiZiIndex = m_GameLogic.SwitchToCardIndex(m_cbLaiZiData);
	BYTE LaiZiPiIndex = m_GameLogic.SwitchToCardIndex(m_cbLaiZiPiData);
	for (BYTE i = 0; i < GAME_PLAYER; i++)
	{

		mCard[LaiZiIndex] += m_OutLaiZi[i];//癞子数
		for (BYTE j = 0; j < m_cbDiscardCount[i]; j++)//丢弃数
		{
			mCard[m_GameLogic.SwitchToCardIndex(m_cbDiscardCard[i][j])]++;

		}
		for (BYTE k = 0; k < m_cbWeaveItemCount[i]; k++)//摆出来的牌
		{
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_PENG || m_WeaveItemArray[i][k].cbWeaveKind == WIK_AN_PIGANG || m_WeaveItemArray[i][k].cbWeaveKind == WIK_MING_PIGANG)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 3;
			}
			else
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 4;
			}
		}
	}
	mCard[LaiZiPiIndex]++;
	mCard[bIndex]++;
	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		mCard[i] += m_cbCardIndex[wChairId][i];
	}

	m_cbNum = 4 - mCard[TempIndex];
	ASSERT(m_cbNum >= 0 && m_cbNum <= 4);
	if (m_cbNum < 0 || m_cbNum>4)m_cbNum = 0;
	return m_cbNum;
}