zhujimajiang_redis/游戏服务器/TableFrameSink_dcs.cpp

#include "StdAfx.h"
#include "TableFrameSink_dcs.h"

#include <algorithm>
#include "../俱乐部/Source/MessageDef/Pb_SparrowMaJiang.pb.h"
#include "../俱乐部/Source/MessageDef/Pb_RecordPacket.pb.h"
//#include "../俱乐部/Source/GlobalDef/Util.h"

//构造函数
CTableFrameSink_dcs::CTableFrameSink_dcs() :m_GameLogic(this)
{
	//游戏变量
	m_startTime = 0;
	mPlayGameUserCount = 4;
	m_lSiceCount = 0;
	m_wBankerUser = INVALID_CHAIR;
	ZeroMemory(m_cbCardIndex, sizeof(m_cbCardIndex));
	ZeroMemory(m_bTrustee, sizeof(m_bTrustee));

	ZeroMemory(m_bPlayStatus, sizeof(m_bPlayStatus));
	ZeroMemory(m_lGameScore, sizeof(m_lGameScore));
	ZeroMemory(m_lGameTatolScore, sizeof(m_lGameTatolScore));
	ZeroMemory(m_HuPai, sizeof(m_HuPai));

	ZeroMemory(m_PaiQuan, sizeof(m_PaiQuan));
	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(LianXuHuPai, sizeof(LianXuHuPai));

	//发牌信息
	m_cbSendCardData = 0;
	m_cbSendCardCount = 0;
	m_cbLeftCardCount = 0;
	m_cbShiJiLeftCardCount = 0;
	ZeroMemory(m_cbRepertoryCard, sizeof(m_cbRepertoryCard));
	m_cbGangCount = 0;//打了几个杠

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

	//状态变量
	//m_bSendStatus=false;
	//	m_bGangStatus = false;
	m_GangPrivedUserID = -1;
	m_bGangOption = 0;
	//m_OutLastLaiZiData = 0; //最后杠牌数据，断线重连用的着
	m_bQiangGang = false;


	//用户状态
	ZeroMemory(m_bResponse, sizeof(m_bResponse));
	ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
	ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
	ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
	ZeroMemory(m_cbOperateCaiCard, sizeof(m_cbOperateCaiCard));
	//组合扑克
	ZeroMemory(m_WeaveItemArray, sizeof(m_WeaveItemArray));
	ZeroMemory(m_cbWeaveItemCount, sizeof(m_cbWeaveItemCount));

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





	//////////////////////////////////////////////////////////////////////////
	CString strCfgFile;
	GetModuleFileName(NULL, strCfgFile.GetBufferSetLength(MAX_PATH), MAX_PATH);
	strCfgFile.ReleaseBuffer();
	WCHAR* pTmp = wcsrchr(strCfgFile.GetBuffer(), L'\\');
	if (pTmp)
	{
		*pTmp = 0;
	}
	PathAppend(strCfgFile.GetBufferSetLength(MAX_PATH), _T("cfg.ini"));
	strCfgFile.ReleaseBuffer();
	GetPrivateProfileString(_T("datpath"), _T("value"), _T(""), mTableDatastrPath.GetBufferSetLength(MAX_PATH), MAX_PATH, strCfgFile.GetBuffer());
	mTableDatastrPath.ReleaseBuffer();


	mBWriteTableData = GetPrivateProfileInt(_T("writedata"), _T("value"), 0, strCfgFile.GetBuffer());

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

	ZeroMemory(m_bUsersGangStatus, GAME_PLAYER);
	ZeroMemory(mCmd_NotifyQianggh, sizeof(mCmd_NotifyQianggh));
	mBCanShowLeft = TRUE;
	//ZeroMemory(mCanDingCaiCard, MAX_INDEX);
	memset(mCanDingCaiCardArray, 4, MAX_INDEX*GAME_PLAYER);
	//memset(mLastCaiCardCountArray, 0, GAME_PLAYER);
	m_bTwoPlayerFlag = FALSE;
	return;
}

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

//接口查询
void * CTableFrameSink_dcs::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	//查询接口
	//#define QUERYINTERFACE(Interface,Guid,dwQueryVer)															
	if ((Guid == IID_ITableFrameSink) && (InterfaceVersionCompare(dwQueryVer, VER_ITableFrameSinkCxz)))
		return static_cast<ITableFrameSink *>(this);
	if ((Guid == IID_ITableUserAction) && (InterfaceVersionCompare(dwQueryVer, VER_ITableUserAction)))
		return static_cast<ITableUserAction *>(this);
	//查询接口
	//#define QUERYINTERFACE_IUNKNOWNEX(BaseInterface,Guid,dwQueryVer)											
	if ((Guid == IID_IUnknownEx) && (InterfaceVersionCompare(dwQueryVer, VER_IUnknownEx)))
		return static_cast<IUnknownEx *>(static_cast<ITableFrameSink *>(this));
	// 
	// 	QUERYINTERFACE(ITableFrameSink,Guid,dwQueryVer);
	// 	QUERYINTERFACE(ITableUserAction,Guid,dwQueryVer);
	// 	QUERYINTERFACE_IUNKNOWNEX(ITableFrameSink,Guid,dwQueryVer);
	return NULL;
}

//初始化
bool CTableFrameSink_dcs::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_dcs::RepositionSink()
{
	//游戏变量
	m_startTime = time(0);
	m_startTime = 0;
	m_lSiceCount = 0;
	ZeroMemory(m_cbCardIndex, sizeof(m_cbCardIndex));
	ZeroMemory(m_bTrustee, sizeof(m_bTrustee));
	//ZeroMemory( m_cbGenCount,sizeof(m_cbGenCount) );
	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_PaiQuan, sizeof(m_PaiQuan));
	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));

	//发牌信息
	m_cbSendCardData = 0;
	m_cbSendCardCount = 0;
	m_cbLeftCardCount = 0;
	m_cbShiJiLeftCardCount = 0;
	ZeroMemory(m_cbRepertoryCard, sizeof(m_cbRepertoryCard));
	m_cbGangCount = 0;//打了几个杠
	//运行变量
	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_GangPrivedUserID = -1;
	m_bGangOption = 0;
	//m_OutLastLaiZiData = 0; //最后杠牌数据，断线重连用的着
	m_bQiangGang = false;

	//用户状态
	ZeroMemory(m_bResponse, sizeof(m_bResponse));
	ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
	ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
	ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
	ZeroMemory(m_cbOperateCaiCard, sizeof(m_cbOperateCaiCard));
	//组合扑克
	ZeroMemory(m_WeaveItemArray, sizeof(m_WeaveItemArray));
	ZeroMemory(m_cbWeaveItemCount, sizeof(m_cbWeaveItemCount));

	//结束信息
	m_cbMagicFirstData = 0;
	m_cbMagicSecondData = 0;
	bIsHuang = false;

	ZeroMemory(m_bUsersGangStatus, GAME_PLAYER);
	ZeroMemory(mCmd_NotifyQianggh, sizeof(mCmd_NotifyQianggh));
	mBCanShowLeft = true;
	memset(mCanDingCaiCardArray, 4, MAX_INDEX*GAME_PLAYER);
	//memset(mLastCaiCardCountArray, 0, GAME_PLAYER);
	return;
}

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

	m_UserReplayRecord.clear();
	return true;
}
bool CTableFrameSink_dcs::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 = m_startTime;
	urr.m_endTime = time(0);
	urr.m_gameconfig = m_gameConfig;
	//urr.m_UserId = pIServerUserItem->GetUserID();

	for (int j = 0; j < mPlayGameUserCount; ++j)
	{
		if (m_bTwoPlayerFlag&&j == TowMjNullseat)
		{
			continue;
		}
		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();

	RecordPacket::PB_CS_S_ReplayRecordResp RecordResp;
	RecordResp.set_m_uuid(urr.m_UUID);
	RecordResp.set_m_userid(urr.m_UserId);
	RecordResp.set_m_starttime(urr.m_startTime);
	RecordResp.set_m_endtime(urr.m_endTime);
	RecordResp.mutable_m_gameconfig()->set_bduolai(m_gameConfig.bDuoLai);
	RecordResp.mutable_m_gameconfig()->set_isowner(m_gameConfig.IsOwner);
	RecordResp.mutable_m_gameconfig()->set_roomid(m_gameConfig.RoomId);
	std::string sPrivateTableID = CW2AEX<1024>(m_gameConfig.sPrivateTableID, CP_UTF8).m_psz;
	RecordResp.mutable_m_gameconfig()->set_sprivatetableid(sPrivateTableID);
	RecordResp.mutable_m_gameconfig()->set_tmp1(m_gameConfig.tmp1);
	RecordResp.mutable_m_gameconfig()->set_tmp2(m_gameConfig.tmp2);
	RecordResp.mutable_m_gameconfig()->set_wdiscore(m_gameConfig.wDiScore);
	RecordResp.mutable_m_gameconfig()->set_wfanfei(m_gameConfig.wFanFei);
	RecordResp.mutable_m_gameconfig()->set_wfengding(m_gameConfig.wFengDing);
	RecordResp.mutable_m_gameconfig()->set_whadplaycount(m_gameConfig.wHadPlayCount);
	RecordResp.mutable_m_gameconfig()->set_wiplimit(m_gameConfig.wIpLimit);
	RecordResp.mutable_m_gameconfig()->set_wplaycountrule(m_gameConfig.wPlayCountRule);
	RecordResp.mutable_m_gameconfig()->set_wsubgameid(m_gameConfig.wSubGameID);
	for (WORD i = 0; i < mPlayGameUserCount; i++)
	{
		RecordPacket::pb_ChairRecord* Record = RecordResp.add_m_chairlist();
		Record->set_wchairid(urr.m_chairList[i].wChairId);
		Record->set_dwuserid(urr.m_chairList[i].dwUserId);
		std::string userName = CW2AEX<1024>(urr.m_chairList[i].userName, CP_UTF8).m_psz;
		std::string headUrl = CW2AEX<1024>(urr.m_chairList[i].headUrl, CP_UTF8).m_psz;
		Record->set_username(userName);
		Record->set_headurl(headUrl);
	}
	for (auto& grp : m_UserReplayRecord)
	{
		RecordPacket::pb_GameRecordPacket* Packet = RecordResp.add_precordpacket();
		Packet->set_wchairid(grp.wchairid());
		Packet->set_wsubcmdid(grp.wsubcmdid());
		Packet->set_wmaincmdid(grp.wmaincmdid());
		Packet->set_pdata(grp.pdata());

	}
	std::string pbresp = RecordResp.SerializePartialAsString();

	m_pITableFrame->SaveReplayRecord((void*)pbresp.c_str(), pbresp.length());

	m_UserReplayRecord.clear();

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

bool CTableFrameSink_dcs::RepayRecord(WORD wChairID, WORD wSubCmdId, void* pData, WORD wSize)
{
	RecordPacket::pb_GameRecordPacket pRecordPacket;
	pRecordPacket.set_wchairid(wChairID);
	pRecordPacket.set_wsubcmdid(wSubCmdId);
	pRecordPacket.set_wmaincmdid(MDM_GF_GAME);
	pRecordPacket.set_pdata((char*)pData, wSize);
	m_UserReplayRecord.push_back(pRecordPacket);
	return true;
}

//游戏开始
bool CTableFrameSink_dcs::OnEventGameStart()
{
	ZeroMemory(m_lGameScore, sizeof(m_lGameScore));
	srand((unsigned)time(NULL)*mGameTableId);
	m_cbMagicFirstData = 0;
	m_cbMagicSecondData = 0;
	//椅子数量
	WORD wChairCount = m_pITableFrame->GetChairCount();

	//开始记录回放数据
	RepayRecordStart();
	//重置发牌状态
	m_isCanOutCard = false;
	//重置掉线玩家列表
	m_offlineUsers.clear();
	//设置状态
	m_pITableFrame->SetGameStatus(GS_MJ_PLAY);
	//打印时间
	DWORD timet = GetTickCount();
	m_gameConfig.wHadPlayCount++;
	//混乱扑克,洗牌
	m_lSiceCount = MAKELONG(MAKEWORD(rand() % 6 + 1, rand() % 6 + 1), MAKEWORD(rand() % 6 + 1, rand() % 6 + 1));

	if (m_bTwoPlayerFlag)
	{
		m_cbLeftCardCount = m_GameLogic.RandCardData_Two(m_cbRepertoryCard);
	}
	else
	{
		m_cbLeftCardCount = m_GameLogic.RandCardData(m_cbRepertoryCard);
	}
	

	WritePaiCardData(m_gameConfig.sPrivateTableID, m_gameConfig.wHadPlayCount);


	if (1 == m_gameConfig.wHadPlayCount || m_wNextBankerUser == INVALID_CHAIR)
	{
		m_wBankerUser = 0;
	}
	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, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,						//索子
	//	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,						//索子
	//	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,						//索子
	//	0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,						//索子
	//	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,						//同子
	//	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,						//同子
	//	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,						//同子
	//	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,						//同子
	//	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,									//风东南西北
	//	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,									//风东南西北
	//	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,									//风东南西北
	//	0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,									//风东南西北 中发白
	//};
	//if (m_GameLogic.PeiPai(byTest))
	//	CopyMemory(m_cbRepertoryCard, byTest, sizeof(byTest));

	//////////////////////////////////////////////////////////////////////////
	ReadGameData();
	/*m_wBankerUser = 2;*/
	//////////////////////////////////////////////////////////////////////////




	//分发扑克
	for (WORD i = 0; i < mPlayGameUserCount; i++)
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		m_bPlayStatus[i] = true;
		m_cbLeftCardCount -= (MAX_COUNT - 1);//每一个玩家都发出去13张牌，还剩多少
		m_cbSendCardCount += (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_cbProvideCard = 0;
	m_wProvideUser = m_wBankerUser & 0x000F;
	m_wCurrentUser = m_wBankerUser & 0x000F;
	WORD ActionCard[6] = { 0 };

	m_GameLogic.SetMagicIndex(MAX_INDEX, MAX_INDEX);


	// 胡牌判断
	CChiHuRight chr;
	BYTE TaiShu = 0;
	m_cbUserAction[m_wCurrentUser] |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[m_wCurrentUser], NULL, 0, m_cbSendCardData, chr, TaiShu);
	m_cbCardIndex[m_wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;
	if (m_cbUserAction[m_wCurrentUser] & WIK_ZI_MO)
	{

		m_cbUserAction[m_wCurrentUser] = WIK_TIAN_ZI_MO;

	}

	std::vector<CanDcsSt> vCards;

	if (GetMagicCardAndTaiNum(m_cbCardIndex[m_wCurrentUser], m_wCurrentUser, m_cbSendCardData, vCards, TRUE))
	{
		m_cbUserAction[m_wCurrentUser] |= WIK_CanDingMagic;
		
	}

	//杠牌判断
	tagGangCardResult GangCardResult;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	m_cbUserAction[m_wCurrentUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[m_wCurrentUser], NULL, 0, GangCardResult);

	for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
	{
		ActionCard[i] = GangCardResult.cbCardData[i];
	}

	m_cbProvideCard = m_cbSendCardData;
	m_wResumeUser = m_wCurrentUser;


	//保存实际剩余的牌
	m_cbShiJiLeftCardCount = m_cbLeftCardCount;

	//牌位第十三顿 截止  倒数第十四牌打完 没人胡牌 流局 
	//根据这个规则 删除26张牌 剩余的牌出完 没人胡牌 就是 流局
	m_cbLeftCardCount -= 26;//

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

	//  [9/22/2017 Zoro] 翻财神和包麻将 不需要这个2个值，但发送时必须给0
	GameStart.cbSliceCheckBankUser[0] = 0;
	GameStart.cbSliceCheckBankUser[1] = 0;
	//////////////////////////////////////////////////////////////////////////

	WORD wSice = WORD(m_lSiceCount & 0xffff);
	GameStart.cbSiceLaiZi[0] = HIBYTE(wSice);//骰子
	GameStart.cbSiceLaiZi[1] = LOBYTE(wSice);//骰子
	GameStart.cbSiceLaiZi[2] = 0;//财神
	GameStart.cbSiceLaiZi[3] = 0;//财神



	if (m_bTwoPlayerFlag)
	{

		GameStart.cbTotalCardCount = MAX_REPERTORY_ZJ_Two;	//麻将总数
	}
	else
	{

		GameStart.cbTotalCardCount = MAX_REPERTORY_ZJ;	//麻将总数
	}

	GameStart.cbCurrPlay = m_gameConfig.wHadPlayCount;//当前局数
	GameStart.cbOptTime = GAME_TIMEOUT;//出牌超时时间
	ZeroMemory(GameStart.ActionCard, sizeof(GameStart.ActionCard));
	CopyMemory(GameStart.ActionCard, ActionCard, sizeof(ActionCard));

	TingCard(m_wCurrentUser);


	//打印时间
	//DWORD t2 = GetTickCount();
	//DWORD hh = t2 - timet;
	//CString csTemp;
	//csTemp.Format(L"时间:%d \r\n", hh);
	//OutputDebugString(csTemp);
	//发送数据
	SparrowMaJiang::PB_CS_S_GameStart GameStarts;
	GameStarts.set_wbankeruser(GameStart.wBankerUser);
	GameStarts.set_cbleftcardcount(GameStart.cbLeftCardCount);
	GameStarts.set_cbtotalcardcount(GameStart.cbTotalCardCount);
	GameStarts.set_cbopttime(GameStart.cbOptTime);
	GameStarts.set_cbcurrplay(GameStart.cbCurrPlay);
	for (WORD j = 0; j < 4; j++)
	{
		GameStarts.add_cbsicelaizi(GameStart.cbSiceLaiZi[j]);
	}
	for (WORD j = 0; j < 6; j++)
	{
		GameStarts.add_actioncard(GameStart.ActionCard[j]);
	}
	for (WORD j = 0; j < 2; j++)
	{
		GameStarts.add_cbslicecheckbankuser(GameStart.cbSliceCheckBankUser[j]);
	}
	//发送数据
	for (WORD i = 0; i < wChairCount; i++)
	{
		//设置变量
		GameStart.wCurrentUser = i;
		GameStart.cbUserAction = m_cbUserAction[i];

		//把庄家 刚刚放入手里的牌剪掉 然后统一 发送数据
		if (i == m_wCurrentUser)
		{
			if (m_cbCardIndex[m_wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)] > 0 && m_wCurrentUser == i)
			{
				m_cbCardIndex[m_wCurrentUser][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)
		{
			GameStart.cbCardData[i * 14 + 13] = m_cbSendCardData;//把去掉的牌加到数组末尾，
			m_cbCardIndex[m_wCurrentUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;//把去掉的加进来
		}
		GameStarts.set_wcurrentuser(GameStart.wCurrentUser);
		GameStarts.set_cbuseraction(GameStart.cbUserAction);
		for (WORD j = 0; j < MAX_COUNT * GAME_PLAYER; j++)
		{
			if (i == 0)
			{
				GameStarts.add_cbcarddata(GameStart.cbCardData[j]);
			}
			else
			{
				GameStarts.set_cbcarddata(j, GameStart.cbCardData[j]);
			}
		}
		//发送数据
		std::string pbdata = GameStarts.SerializePartialAsString();
		//发送数据
		m_pITableFrame->SendTableData(i, SUB_S_GAME_START, (void*)pbdata.c_str(), pbdata.length());
	}
	//用户回放
	ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));
	for (WORD i = 0; i < MAX_COUNT * GAME_PLAYER; i++)
	{
		GameStarts.set_cbcarddata(i, GameStart.cbCardData[i]);
	}
	//清手牌 旁观只能发一次
	std::string pbdata = GameStarts.SerializePartialAsString();
	//发送数据
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_START, (void*)pbdata.c_str(), pbdata.length());

	for (WORD i = 0; i < wChairCount; i++)
		m_GameLogic.SwitchToCardData(m_cbCardIndex[i], &GameStart.cbCardData[MAX_COUNT*i]);
	for (WORD i = 0; i < MAX_COUNT * GAME_PLAYER; i++)
	{
		GameStarts.set_cbcarddata(i, GameStart.cbCardData[i]);
	}
	std::string pbrecord = GameStarts.SerializePartialAsString();
	RepayRecord(INVALID_CHAIR, SUB_S_GAME_START, (void*)pbrecord.c_str(), pbrecord.length());

	if (m_TabbOutCardCout[m_wCurrentUser] > 0)
		HttpTingCard(m_wCurrentUser);
	return true;



	return true;
}

void CTableFrameSink_dcs::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 = 0;// m_lUserTmpScore[i] - TEMP_MAX_SCORE;			//记录临时分
	}
	m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray));

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

//游戏结束
bool CTableFrameSink_dcs::OnEventGameConclude(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason, bool bSendState)
{
	bool bFinish = (m_gameConfig.wHadPlayCount >= m_gameConfig.wPlayCountRule) ? 1 : 0;

	switch (cbReason)
	{
	case GER_DELETE_PRIVATE:
		//bFinish = 1;
		//bDelete = true;
		//if (!m_pITableFrame->IsGameStarted())
		//{
		//	DeletePrivateTable(bSendState);
		//	return true;
		//}
		ConcludeGame(GS_MJ_FREE);
		DeletePrivateTable(bSendState);
		return true;
		//下坠
	case GER_NORMAL:		//常规结束
	{

		//变量定义
		CMD_S_GameEnd GameEnd;
		ZeroMemory(&GameEnd, sizeof(GameEnd));
		GameEnd.bFinish = bFinish;//1……
		if (m_cbLeftCardCount <= 0 && bIsHuang)//荒庄了
		{
			
			{
				GameEnd.bOptType = 2;
				//黄装了
				if (m_gameConfig.wHadPlayCount > 1)
				{
					m_wNextBankerUser = m_wBankerUser;
					m_wNextBankerUser = m_wNextBankerUser | 0x0100;
					int userID;
					if (m_wBankerUser > 4)
					{
						userID = m_wBankerUser & 0x00ff;
					}
					else
					{
						userID = m_wBankerUser;
					}
					LianXuHuPai[userID]++;
				}
				else
				{
					/*	m_wNextBankerUser = m_wBankerUser;
						m_wNextBankerUser = m_wNextBankerUser | 0x0100;*/
					LianXuHuPai[m_wBankerUser & 0x00ff]++;
				}



				//黄庄了
				//统计玩家积分,牌值
				for (WORD i = 0; i < mPlayGameUserCount; i++)
				{
					if (m_bTwoPlayerFlag&&i == TowMjNullseat)
					{
						continue;
					}
					GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分4…………
					m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
				}
			}
		}
		else
		{

			GameEnd.bOptType = 1;
			GameEnd.HuPaiCard = m_cbProvideCard;
			GameEnd.wDianpao = m_wProvideUser;

			BYTE TempWanJiaCardCount = 0;
			m_wNextBankerUser = wChairID; //得到下一个坐庄的玩家

			if (LianXuHuPai[wChairID] > 1)
				m_wNextBankerUser = m_wNextBankerUser | 0x0100;

			//统计积分,胡牌得分,玩家牌值
			//保存本局所有用户的积分变动 除了胡牌玩家的
			for (WORD i = 0; i < mPlayGameUserCount; i++)
			{
				if (m_bTwoPlayerFlag&&i == TowMjNullseat)
				{
					continue;
				}
				//m_lGameTatolScore[i] += m_lGameScore[i];
				GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分3…………
				if (i == wChairID && m_wProvideUser == wChairID){
					continue;
				}
				if (m_wProvideUser != wChairID&&i == wChairID)
				{
					m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--;
					m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);

				}
				else
				{
					m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
				}
			}
			//自摸
			if (m_wProvideUser == wChairID)
			{
				//先减去 胡的这张牌
				m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)]--;
				//把剩下的手牌保存到cbCardData
				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_cbShiJiLeftCardCount;//m_cbLeftCardCount + 26 + m_cbGangCount * 6;//剩余牌输量6…………
		CopyMemory(GameEnd.bLeftCardDada, m_cbRepertoryCard, GameEnd.bLeftCardCount);//剩余牌值7………………
		//保存每个玩家的胡牌次数
		CopyMemory(GameEnd.bZimo, m_HuPai, sizeof(m_HuPai));//玩家胡牌次数8…………
		//本次胡牌玩家的id
		GameEnd.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();//获取房间ID，9……//胡牌玩家id
		GameEnd.playGameNum = m_gameConfig.wHadPlayCount;//得到第几局了，10…………
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			if (m_bTwoPlayerFlag&&i == TowMjNullseat)
			{
				continue;
			}
			//保存16局 胡牌积分流水
			m_HuPaiLiuShui[(m_gameConfig.wHadPlayCount - 1) * 4 + i] = m_lGameScore[i];
		}
		CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));//游戏流水，10…………

		for (int i = 0; i < m_gameConfig.wHadPlayCount; i++)
		{
			/*CString strTmp;
			strTmp.Format(_T("胡牌流水->第%d局 %d,%d,%d,%d"), i,m_HuPaiLiuShui[i*4 + 0], m_HuPaiLiuShui[i*4 + 1], m_HuPaiLiuShui[i*4 + 2] , m_HuPaiLiuShui[i*4 + 3]);*/
			//OutputDebugString(strTmp);
		}

		SparrowMaJiang::PB_CS_S_GameEnd pGameEnd;
		pGameEnd.set_bopttype(GameEnd.bOptType);
		pGameEnd.set_bwanjiaid(GameEnd.bWanJiaId);
		pGameEnd.set_wdianpao(GameEnd.wDianpao);
		pGameEnd.set_hupaicard(GameEnd.HuPaiCard);
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			pGameEnd.add_cbwanjiascore(GameEnd.cbWanJiaScore[i]);
			pGameEnd.add_bzimo(GameEnd.bZimo[i]);
		}
		pGameEnd.set_bfinish(GameEnd.bFinish);
		pGameEnd.set_dwownerid(GameEnd.dwOwnerID);
		pGameEnd.set_bleftcardcount(GameEnd.bLeftCardCount);
		for (BYTE i = 0; i < GameEnd.bLeftCardCount; i++)
		{
			pGameEnd.add_bleftcarddada(GameEnd.bLeftCardDada[i]);
		}
		pGameEnd.set_playgamenum(GameEnd.playGameNum);
		for (BYTE i = 0; i < mPlayGameUserCount * 16; i++)
		{
			pGameEnd.add_lgamescoredetail(GameEnd.lGameScoreDetail[i]);
		}
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			SparrowMaJiang::pb_cbCardData* CardData = pGameEnd.add_cbcarddata();
			for (BYTE j = 0; j < 14; j++)
			{
				CardData->add_cbcarddatas(GameEnd.cbCardData[i][j]);
			}
		}
		std::string pbdata = pGameEnd.SerializePartialAsString();
		RepayRecord(INVALID_CHAIR, SUB_S_GAME_END, (void*)pbdata.c_str(), pbdata.length());
		//发送结束信息
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, (void*)pbdata.c_str(), pbdata.length());

		tagScoreInfo ScoreInfoArray[GAME_PLAYER];
		ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));
		for (WORD i = 0; i < mPlayGameUserCount; i++)
		{
			if (m_bTwoPlayerFlag&&i == TowMjNullseat)
			{
				continue;
			}
			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 (bFinish)
			{
				DeletePrivateTable(true);
			}
		

		return true;
	}
	case GER_DISMISS:		//游戏解散
	{
		//变量定义
		CMD_S_GameEnd GameEnd;
		ZeroMemory(&GameEnd, sizeof(GameEnd));
		GameEnd.bFinish = 1;
		GameEnd.bOptType = 3;
		GameEnd.bWanJiaId = wChairID;//玩家座位号 5……
		//保存实际桌子剩下多少能够抓的牌
		GameEnd.bLeftCardCount = m_cbShiJiLeftCardCount;//m_cbLeftCardCount + 26 + m_cbGangCount * 6;//剩余牌输量6…………
		CopyMemory(GameEnd.bLeftCardDada, m_cbRepertoryCard, GameEnd.bLeftCardCount);//剩余牌值7………………
		//保存每个玩家的胡牌次数
		CopyMemory(GameEnd.bZimo, m_HuPai, sizeof(m_HuPai));//玩家胡牌次数8…………
		//本次胡牌玩家的id
		GameEnd.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();//获取房间ID，9……//胡牌玩家id
		GameEnd.playGameNum = m_gameConfig.wHadPlayCount;//得到第几局了，10…………
		for (BYTE i = 0; i < GAME_PLAYER; i++)
		{
			m_GameLogic.SwitchToCardData(m_cbCardIndex[i], GameEnd.cbCardData[i]);
			m_HuPaiLiuShui[(m_gameConfig.wHadPlayCount - 1) * 4 + i] = m_lGameScore[i];
		}
		CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));//游戏流水，10…………
		//统计积分,胡牌得分,玩家牌值
		//保存本局所有用户的积分变动 除了胡牌玩家的
		for (WORD i = 0; i < mPlayGameUserCount; i++)
		{
			if (m_bTwoPlayerFlag&&i == TowMjNullseat)
			{
				continue;
			}
			GameEnd.cbWanJiaScore[i] = m_lGameTatolScore[i];//各玩家积分3…………
		}
		SparrowMaJiang::PB_CS_S_GameEnd pGameEnd;
		pGameEnd.set_bopttype(GameEnd.bOptType);
		pGameEnd.set_bwanjiaid(GameEnd.bWanJiaId);
		pGameEnd.set_wdianpao(GameEnd.wDianpao);
		pGameEnd.set_hupaicard(GameEnd.HuPaiCard);
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			pGameEnd.add_cbwanjiascore(GameEnd.cbWanJiaScore[i]);
			pGameEnd.add_bzimo(GameEnd.bZimo[i]);
		}
		pGameEnd.set_bfinish(GameEnd.bFinish);
		pGameEnd.set_dwownerid(GameEnd.dwOwnerID);
		pGameEnd.set_bleftcardcount(GameEnd.bLeftCardCount);
		for (BYTE i = 0; i < GameEnd.bLeftCardCount; i++)
		{
			pGameEnd.add_bleftcarddada(GameEnd.bLeftCardDada[i]);
		}
		pGameEnd.set_playgamenum(GameEnd.playGameNum);
		for (BYTE i = 0; i < mPlayGameUserCount * 16; i++)
		{
			pGameEnd.add_lgamescoredetail(GameEnd.lGameScoreDetail[i]);
		}
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			SparrowMaJiang::pb_cbCardData* CardData = pGameEnd.add_cbcarddata();
			for (BYTE j = 0; j < 14; j++)
			{
				CardData->add_cbcarddatas(GameEnd.cbCardData[i][j]);
			}
		}
		std::string pbdata = pGameEnd.SerializePartialAsString();
		RepayRecord(INVALID_CHAIR, SUB_S_GAME_END, (void*)pbdata.c_str(), pbdata.length());
		//发送结束信息
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, (void*)pbdata.c_str(), pbdata.length());
		if (m_pITableFrame->GetGameStatus() == GS_MJ_FREE)
		{
			DeletePrivateTable(true);
			return true;
		}
		tagScoreInfo ScoreInfoArray[GAME_PLAYER];
		ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));
		for (WORD i = 0; i < mPlayGameUserCount; i++)
		{
			if (m_bTwoPlayerFlag&&i == TowMjNullseat)
			{
				continue;
			}
			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);
		DeletePrivateTable(bSendState);
		return true;
	}
	case GER_NETWORK_ERROR:		//网络错误
	case GER_USER_LEAVE:		//用户强退
	{
		if (pIServerUserItem!=NULL)
		{
			DWORD dwUserID = pIServerUserItem->GetUserID();
			m_offlineUsers.push_back(dwUserID);
		}

		return true;
	}
	}

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

//发送场景duanxian用户断线重连
bool CTableFrameSink_dcs::OnEventSendGameScene(WORD wChiarID, IServerUserItem * pIServerUserItem, BYTE cbGameStatus, bool bSendSecret)
{
	try
	{
		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 < mPlayGameUserCount; i++)
			{
				if (m_bTwoPlayerFlag&&i == TowMjNullseat)
				{
					continue;
				}
				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 = m_cbTotalCardCount;
// 			if (mBCanShowLeft==TRUE)
// 			{
				StatusPlay.cbLeftCardCount = m_cbLeftCardCount;
// 			}
// 			else
// 			{
// 				StatusPlay.cbLeftCardCount = mTempLeftCount;
// 			}
			
			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] = 0;
			StatusPlay.lSiZi[3] = 0;

			StatusPlay.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();


			CopyMemory(StatusPlay.cbDiscardCard, m_cbDiscardCard, sizeof(StatusPlay.cbDiscardCard));
			CopyMemory(StatusPlay.cbDiscardCount, m_cbDiscardCount, sizeof(StatusPlay.cbDiscardCount));
			StatusPlay.totalOptTime = 10;
			StatusPlay.leftOptTime = 0;
			//组合扑克
			CopyMemory(StatusPlay.WeaveItemArray, m_WeaveItemArray, sizeof(m_WeaveItemArray));
			CopyMemory(StatusPlay.cbWeaveCount, m_cbWeaveItemCount, sizeof(m_cbWeaveItemCount));
			for (BYTE i = 0; i < mPlayGameUserCount; i++)
			{
				if (m_bTwoPlayerFlag&&i == TowMjNullseat)
				{
					continue;
				}
				//StatusPlay.bWanLaiZi[i] = m_OutLaiZi[i];
				//StatusPlay.bWanLaiZi[i] |= (m_OutHongZhongGang[i] << 4);
				//StatusPlay.bWanLaiZi[i] |= (m_OutFaCaiGang[i] << 8);
				StatusPlay.cbCardCount[i] = m_GameLogic.GetCardCount(m_cbCardIndex[i]);
			}
			m_GameLogic.SwitchToCardData(m_cbCardIndex[wChiarID], StatusPlay.cbCardData);//手牌数据
			StatusPlay.cbActionMask = m_cbUserAction[wChiarID];		//需要用到操作码
			if (m_cbUserAction[wChiarID] & (WIK_AN_GANG | WIK_BU_GANG | WIK_DAN_BU_GANG | WIK_DAN_AN_GANG | WIK_SHUANG_AN_GANG | WIK_SAN_AN_GANG | WIK_QUANG_AN_GANG))
			{
				tagGangCardResult GangCardResult;
				ZeroMemory(&GangCardResult, sizeof(GangCardResult));
				m_GameLogic.AnalyseGangCard(m_cbCardIndex[wChiarID], m_WeaveItemArray[wChiarID], m_cbWeaveItemCount[wChiarID], GangCardResult);
				for (BYTE i = 0; i < GangCardResult.cbCardCount; i++)
				{
					StatusPlay.gangCards[i] = GangCardResult.cbCardData[i];
				}

			}
			ASSERT(m_wProvideUser >= 0 && m_wProvideUser <= 3);
			//当前到谁家
			StatusPlay.wCurrentUser = (m_wCurrentUser == INVALID_CHAIR ? m_wProvideUser : m_wCurrentUser);
			BYTE OldUser = 0;//定义一个最后出牌用户
			if ((m_wProvideUser == m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR) || (m_wProvideUser == m_wCurrentUser&&m_wResumeUser == m_wCurrentUser && m_cbProvideCard == 0))//牌权是摸牌得且没出牌
			{
				if (m_bTwoPlayerFlag)
				{
					OldUser = (m_wProvideUser - 2 + GAME_PLAYER) % GAME_PLAYER;
				}
				else
				{
					OldUser = (m_wProvideUser - 1 + mPlayGameUserCount) % mPlayGameUserCount;
				}

				BYTE TempIndex = 0;
				BYTE bDiscardCount = (m_cbDiscardCount[OldUser] - 1) >= 0 ? (m_cbDiscardCount[OldUser] - 1) : 0;
				for (BYTE i = bDiscardCount; i < 40; i++)

				{
					if (m_cbDiscardCard[OldUser][i] == 0)
					{
						TempIndex = i - 1;
						break;
					}
				}
				TempIndex = (TempIndex == 255) ? 0 : TempIndex;
				StatusPlay.bPutCardData[OldUser] = m_cbDiscardCard[OldUser][TempIndex];
				StatusPlay.bPutCardData[wChiarID] = 255;
				//}
			}
			if (m_wProvideUser == m_wOutCardUser && m_wCurrentUser == INVALID_CHAIR)//当有人可以碰且没有碰时候
			{
				StatusPlay.bPutCardData[m_wProvideUser] = m_cbProvideCard;
				StatusPlay.cbDiscardCard[m_wProvideUser][StatusPlay.cbDiscardCount[m_wProvideUser]++] = m_cbProvideCard;
			}
			if (wChiarID == StatusPlay.wCurrentUser&&m_wCurrentUser != INVALID_CHAIR&&m_wCurrentUser != m_wProvideUser)//表示当前牌权就在断线玩家手里，且是轮到他出牌（牌权碰来得）
			{
				ZeroMemory(StatusPlay.cbCardData, sizeof(StatusPlay.cbCardData));
				BYTE TempCardData[MAX_INDEX];
				CopyMemory(TempCardData, m_cbCardIndex[wChiarID], sizeof(TempCardData));

				BYTE TempEndCardData = m_GameLogic.GetEndCard(TempCardData);
				BYTE TempCardIndex = m_GameLogic.SwitchToCardIndex(TempEndCardData);
				if (TempCardData[TempCardIndex] == 0){ ASSERT(false); return false; }
				TempCardData[TempCardIndex]--;
				BYTE cardNum = m_GameLogic.SwitchToCardData(TempCardData, StatusPlay.cbCardData);
				StatusPlay.cbCardData[cardNum] = TempEndCardData;

			}
			if (wChiarID == StatusPlay.wCurrentUser && m_wCurrentUser != INVALID_CHAIR && m_wCurrentUser == m_wProvideUser)//牌权是轮到他抓牌，未打出
			{
				ZeroMemory(StatusPlay.cbCardData, sizeof(StatusPlay.cbCardData));
				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]--;
				BYTE cardNum = m_GameLogic.SwitchToCardData(TempCardData, StatusPlay.cbCardData);
				StatusPlay.cbCardData[cardNum] = m_GameLogic.SwitchToCardData(TempCardIndex);//处理得到最后一张牌数据放最后
				StatusPlay.bPutCardData[wChiarID] = 255;
			}
			if (wChiarID != m_wProvideUser&&m_cbUserAction[wChiarID] & WIK_Qiang_GANG)
			{
				StatusPlay.bPutCardData[wChiarID] = 255;
				StatusPlay.bPutCardData[m_wProvideUser] = m_cbProvideCard;

			}

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

		}
		return false;
	}
	catch (...)
	{
		OutputDebugString(_T("CTableFrameSink::OnEventSendGameScene... 触发异常\r\n"));
		return false;
	}
}

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

//游戏消息处理
void CTableFrameSink_dcs::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;
	m_gameConfig.bDuoLai = 1;
	m_gameConfig.wFengDing = ppConfig->wFengDing;
	m_gameConfig.tmp1 = ppConfig->tmp1;
	if (m_gameConfig.wFengDing == 0 || m_gameConfig.wFengDing == 5)
	{
		mMaxTaiNum = 5;
	}
	else if (m_gameConfig.wFengDing == 6 || m_gameConfig.wFengDing == 7)
	{
		mMaxTaiNum = m_gameConfig.wFengDing;
	}
	else
	{
		mMaxTaiNum = 20;
	}

	lstrcpy(m_gameConfig.sPrivateTableID, sPrivateRoomId.c_str());
	//bGameType = m_gameConfig.wSubGameID;
	//bGameZuiDiFen = m_gameConfig.wDiScore*(bGameType == HongZhong ? 10 : 16);
	m_cbTotalCardCount = MAX_REPERTORY_ZJ;
	//协议修改，值变成 4 3 2 
	if (m_gameConfig.tmp1 == 0)
	{
		mPlayGameUserCount = 4;
	}
	else
	{
		if (m_gameConfig.tmp1 == 2)
		{
			m_bTwoPlayerFlag = TRUE;
			mPlayGameUserCount = 3;
			m_cbTotalCardCount = MAX_REPERTORY_ZJ_Two;
			m_pITableFrame->SetStartMode(START_MODE_ALL_READY);
		}
		else
		{
			mPlayGameUserCount = m_gameConfig.tmp1;
		}

	}


	m_pITableFrame->SetChairCount(mPlayGameUserCount);
	ASSERT(m_gameConfig.wSubGameID >= 0 && m_gameConfig.wSubGameID < MahJongType::count);

	if (!sPrivateRoomId.empty())
	{
		mGameTableId = _wtoi(sPrivateRoomId.c_str());
	}
	else
	{
		mGameTableId = 1;
	}


}
int SignedRemoveRep(BYTE array[], int n)

{

	int i, left = 0;



	for (i = 0; i < n; i++)//将出现过的位置置负号标志

	{

		if (array[i] > 0) //可以直接做下标

		{

			array[array[i]] = -array[array[i]];

		}

		else

		{

			if (array[-array[i]] > 0) //为正时才是第一次置标志

				array[-array[i]] = -array[-array[i]];

		}

	}





	for (i = 0; i < n; i++)//抽取算法

	{

		if (array[i] < 0) //根据标志顺序保存出现过的值

			array[left++] = i;

	}



	return left;

}
//游戏消息处理
bool CTableFrameSink_dcs::OnGameMessage(WORD wSubCmdID, VOID* pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)
{

	switch (wSubCmdID)
	{
	case SUB_C_OUT_CARD:		//出牌消息
	{
		//定义变量
		SparrowMaJiang::PB_CS_C_OutCard OutCard;
		OutCard.ParseFromArray(pDataBuffer, wDataSize);
		//用户效验
		if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;
		return OnUserOutCard(pIServerUserItem->GetChairID(), OutCard.cbcarddata());
		//	bool bRet= OnUserOutCard(pIServerUserItem->GetChairID(), pOutCard->cbCardData);
		// 		QueryPerformanceCounter(&nEndTime);
		// 		double dwTime;
		// 		dwTime = ((nEndTime.QuadPart - nBeginTime.QuadPart) / nFreq.QuadPart) * 1000;
		// 		if (dwTime > 100){
		// 			CString str;
		// 			str = _T("Zoro 翻财神/包麻将  OnUserOutCard 耗费时间 %d 秒 出牌=%d\r\n牌：", dwTime,pOutCard->cbCardData);
		// 			for (size_t i = 0; i < MAX_INDEX; i++)
		// 			{
		// 				CString tmp;
		// 				tmp.Format(_T("%d"), m_cbCardIndex[pIServerUserItem->GetChairID()][i]);
		// 				str += tmp;
		// 			}
		// 			OutputDebugString(str);
		// 
		// 		}
		// 		return bRet;
	}
	case SUB_C_OPERATE_CARD:	//操作消息
	{
		SparrowMaJiang::PB_CS_C_OperateCard OperateCard;
		OperateCard.ParseFromArray(pDataBuffer, wDataSize);

		//用户效验
		if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;
		CMD_C_OperateCard  pOperateCard;
		for (WORD i = 0; i < 4; i++)
		{
			pOperateCard.cbCaiShenCard[i] = OperateCard.cbcaishencard(i);
		}
		pOperateCard.cbOperateCard = OperateCard.cboperatecard();
		pOperateCard.cbOperateCode = OperateCard.cboperatecode();
		return  OnUserOperateCard(pIServerUserItem->GetChairID(), pOperateCard.cbOperateCode, pOperateCard.cbOperateCard, pOperateCard.cbCaiShenCard);
	}
	case SUB_C_TRUSTEE:  //托管
	{
		SparrowMaJiang::PB_CS_C_Trustee pTrustee;
		pTrustee.ParseFromArray(pDataBuffer, wDataSize);
		m_bTrustee[pIServerUserItem->GetChairID()] = pTrustee.btrustee();
		CMD_S_Trustee Trustee;
		Trustee.bTrustee = pTrustee.btrustee();
		Trustee.wChairID = pIServerUserItem->GetChairID();

		SparrowMaJiang::PB_CS_S_Trustee Trustees;
		Trustees.set_btrustee(Trustee.bTrustee);
		Trustees.set_wchairid(Trustee.wChairID);
		std::string pbdata = Trustees.SerializePartialAsString();
		RepayRecord(INVALID_CHAIR, SUB_S_TRUSTEE, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_TRUSTEE, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_TRUSTEE, (void*)pbdata.c_str(), pbdata.length());

		return true;
	}
	// 	case SUB_C_SELECT_BAO:{
	// 							  CMD_C_BAO *pBaoTai = (CMD_C_BAO *)pDataBuffer;
	// 							  SelectBaoTaiNum(pIServerUserItem->GetChairID(), pBaoTai->cbTaiNum);
	// 							  return true;
	// 	}
	// 	case SUB_C_SELECT_CAI:{
	// 							  CMD_C_Magic *pMagic = (CMD_C_Magic*)pDataBuffer;
	// 							  SelectBaoMagic(pIServerUserItem->GetChairID(), pMagic->cbMagicFirst, pMagic->cbMagicSenced);
	// 							  return true;
	// 	}
	case SUB_C_DING_CAI:{
		//OutputDebugString(_T("丁财神开始"));
		SparrowMaJiang::PB_CS_C_MagicDing pDingCaiBuffer;
		pDingCaiBuffer.ParseFromArray(pDataBuffer, wDataSize);
		//用户效验
		if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;


		if (pDingCaiBuffer.isdingcai())
		{
			//UserDingMagicCard(pIServerUserItem->GetChairID());
			BYTE TempCardIndex[MAX_INDEX] = { 0 };
			CopyMemory(TempCardIndex, m_cbCardIndex[pIServerUserItem->GetChairID()], MAX_INDEX);
			TempCardIndex[m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]--;
			std::vector<CanDcsSt> vCards;
			GetMagicCardAndTaiNum(TempCardIndex, pIServerUserItem->GetChairID(), m_cbSendCardData, vCards);

			CMD_S_DING_CAI_RESULT DcResult;
			ZeroMemory(&DcResult, sizeof(CMD_S_DING_CAI_RESULT));

	

			if (vCards.size() > 0)
			{
				DcResult.cbResult = 1;
				BYTE TempRecordIndex[MAX_INDEX] = { 0 };
				int caiCardsCount = 0;
				BYTE tmpCardMagicLeftAndRight[MAX_COUNT] = { 0 };
				INT  tmpCardMagicLeftAndRightCount = 0;
				//////////////////////////////////////////////////////////////////////////
				// 先获取所有可以作为两边的牌
				//////////////////////////////////////////////////////////////////////////

				for (int i = 0; i < vCards.size();i++)
				{
					if (vCards[i].bDuCanHu)
					{
// 						CString strOut;
// 						strOut.Format(_T("定财神 独财 =%02x 台=%d\r\n"), vCards[i].MagicCard, vCards[i].nTai);
// 						OutputDebugString(strOut);
						continue;
					}
// 					CString strOut;
// 					strOut.Format(_T("定财神 财 =%02x  %02x 台=%d\r\n"), vCards[i].MagicCard, vCards[i].MagicCardNext, vCards[i].nTai);
// 					OutputDebugString(strOut);
					if (GetCardCanHuWithAll(vCards[i].MagicCard, vCards) && !CardInAll(vCards[i].MagicCard, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
					{
						DcResult.caiCards[caiCardsCount] = vCards[i].MagicCard;
						DcResult.caiCards[caiCardsCount] |= DingLeftAndRightGao2;
						caiCardsCount++;
						tmpCardMagicLeftAndRight[tmpCardMagicLeftAndRightCount++] = vCards[i].MagicCard;
					}
					if (vCards[i].MagicCardNext != 0)
					{
						if (GetCardCanHuWithAll(vCards[i].MagicCardNext, vCards) && !CardInAll(vCards[i].MagicCardNext, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
						{
							DcResult.caiCards[caiCardsCount] = vCards[i].MagicCardNext;
							DcResult.caiCards[caiCardsCount] |= DingLeftAndRightGao2;
							caiCardsCount++;
							tmpCardMagicLeftAndRight[tmpCardMagicLeftAndRightCount++] = vCards[i].MagicCardNext;
						}
					}
				}
				for (int i = 0; i < vCards.size(); i++)
				{

					if (vCards[i].bDuCanHu)
					{
						//CString strOut;
						//strOut.Format(_T("定财神 独财 =%02x 台=%d\r\n"), vCards[i].MagicCard, vCards[i].nTai);
						//OutputDebugString(strOut);	
						DcResult.caiCards[caiCardsCount] = vCards[i].MagicCard;
						DcResult.caiCards[caiCardsCount] |= DingDuGao2;
						caiCardsCount++;
						continue;
					}
					else
					{
						//CString strOut;
						//strOut.Format(_T("定财神 财 =%02x  %02x 台=%d\r\n"), vCards[i].MagicCard, vCards[i].MagicCardNext, vCards[i].nTai);
						//OutputDebugString(strOut);
						{
							if (!CardInAll(vCards[i].MagicCard, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
							{
								DcResult.caiCards[caiCardsCount] = vCards[i].MagicCard;
								DcResult.caiCards[caiCardsCount] |= DingRightGao2;
								caiCardsCount++;
							}
							if (!CardInAll(vCards[i].MagicCardNext, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
							{
								DcResult.caiCards[caiCardsCount] = vCards[i].MagicCardNext;
								DcResult.caiCards[caiCardsCount] |= DingLeftGao2;
								caiCardsCount++;
							}
// 							else
// 							{
// 								DcResult.caiCards[caiCardsCount] |= DingDuGao2;
// 								caiCardsCount++;
// 
// 							}
						}

					
					}
				}
//				int caiCardsCount = 0;

// 				for (int i = 0; i < MAX_INDEX; i++)
// 				{
// 					if (TempRecordIndex[i] == 0)
// 					{
// 						continue;
// 					}
// 					if (TempRecordIndex[i] >= MAX_COUNT)
// 					{
// 						DcResult.caiCards[caiCardsCount] = m_GameLogic.SwitchToCardData(i);
// 						DcResult.caiCards[caiCardsCount] |= 0x80;
// 						caiCardsCount++;
// 					}
// 					else
// 					{
// 						DcResult.caiCards[caiCardsCount] = m_GameLogic.SwitchToCardData(i);
// 						caiCardsCount++;
// 					}
// 				}
//  				CString strOut;
// 				for (size_t i = 0; i < caiCardsCount; i++)
// 				{
// 					CString strCards;
// 					strCards.Format(_T("%02x \t"), DcResult.caiCards[i]);
// 					strOut += strCards;
// 				}
// 				OutputDebugString(strOut);

			}
			else
			{
				//OutputDebugString(_T("定财神无"));
				DcResult.cbResult = 2;
			}

			DcResult.cbIsWCHu = false;
			{


				CGameLogic_dcs			TempGameLogic(this);
				TempGameLogic.SetMagicIndex(MAX_INDEX, MAX_INDEX);

				BYTE TaiShu = 0;
				if (TempGameLogic.AnalyseCardNew(m_cbCardIndex[pIServerUserItem->GetChairID()], m_WeaveItemArray[pIServerUserItem->GetChairID()], m_cbWeaveItemCount[pIServerUserItem->GetChairID()]))
				{
					TempGameLogic.mSunTaiJiangInColor = TempGameLogic.mJiangInColor;
					TaiShu = TempGameLogic.AnalyseCardTaiNum(m_cbCardIndex[pIServerUserItem->GetChairID()], m_WeaveItemArray[pIServerUserItem->GetChairID()], m_cbWeaveItemCount[pIServerUserItem->GetChairID()]);

					if (m_bQiangGang)
					{
						TaiShu++;
					}
					if (m_bUsersGangStatus[pIServerUserItem->GetChairID()] == TRUE)
					{
						TaiShu++;
					}

					if (TempGameLogic.AnalyseCardTaiNum_IsQuanZi(m_cbCardIndex[pIServerUserItem->GetChairID()], m_WeaveItemArray[pIServerUserItem->GetChairID()], m_cbWeaveItemCount[pIServerUserItem->GetChairID()]))
					{
						TaiShu = 7;
					}
				}
				if (TaiShu >= DingMagicMinTai)
				{
					DcResult.cbIsWCHu = TRUE;
				//	OutputDebugString(_T("无财胡"));
				}
			}
			SparrowMaJiang::PB_CS_S_DING_CAI_RESULT pDcResult;
			pDcResult.set_cbiswchu(DcResult.cbIsWCHu);
			pDcResult.set_cbresult(DcResult.cbResult);
			for (BYTE j = 0; j < MAX_INDEX; j++)
			{
				pDcResult.add_caicards(DcResult.caiCards[j]);
			}
			std::string pbdate = pDcResult.SerializePartialAsString();
			RepayRecord(pIServerUserItem->GetChairID(), SUB_S_DING_CAI_RESULT, (void*)pbdate.c_str(), pbdate.length());
			//发送消息
			m_pITableFrame->SendTableData(pIServerUserItem->GetChairID(), SUB_S_DING_CAI_RESULT, (void*)pbdate.c_str(), pbdate.length());
		}
		else
		{
			CMD_S_DING_CAI_RESULT DcResult;
			DcResult.cbResult = 0;
			ZeroMemory(DcResult.caiCards, MAX_COUNT);
			//发送消息
			SparrowMaJiang::PB_CS_S_DING_CAI_RESULT pDcResult;
			pDcResult.set_cbiswchu(DcResult.cbIsWCHu);
			pDcResult.set_cbresult(DcResult.cbResult);
			for (BYTE j = 0; j < MAX_INDEX; j++)
			{
				pDcResult.add_caicards(DcResult.caiCards[j]);
			}
			std::string pbdate = pDcResult.SerializePartialAsString();
			RepayRecord(pIServerUserItem->GetChairID(), SUB_S_DING_CAI_RESULT, (void*)pbdate.c_str(), pbdate.length());
			m_pITableFrame->SendTableData(pIServerUserItem->GetChairID(), SUB_S_DING_CAI_RESULT, (void*)pbdate.c_str(), pbdate.length());
			if (m_wCurrentUser == INVALID_CHAIR)
			{
				
				//设置变量
				m_bResponse[pIServerUserItem->GetChairID()] = true;
				m_cbPerformAction[pIServerUserItem->GetChairID()] = WIK_NULL;
				//m_cbOperateCard[wChairID] = cbOperateCard;
				/*CopyMemory(m_cbOperateCaiCard[wChairID], cbCaiShenCard, sizeof(cbCaiShenCard));*/


				//执行动作的优先级判断, WIK_CHI_HU 大于 WIK_PENG 大于 [WIK_RIGHT or WIK_CENTER or WIK_LEFT]
				WORD TempUser = m_wProvideUser;
				WORD wTargetUser = pIServerUserItem->GetChairID();
				int cbTargetAction = WIK_NULL;
				OperatorPriority(TempUser, wTargetUser, cbTargetAction);

 				if (m_bResponse[wTargetUser] == false)//操作判断
				{
					
					m_cbLastDisCardData[pIServerUserItem->GetChairID()][m_cbLastDisCount[pIServerUserItem->GetChairID()]++] = m_cbProvideCard;
					return true;
				}
				if ( cbTargetAction&WIK_Qiang_GANG)//此动作为抢杠胡才会促发
				{
					BYTE cbTargetCaiCard[4] = { 0 };
					CopyMemory(cbTargetCaiCard, m_cbOperateCaiCard[wTargetUser], sizeof(cbTargetCaiCard));

					m_bQiangGang = true;
					ZeroMemory(m_bUsersGangStatus, GAME_PLAYER);
					m_wCurrentUser = wTargetUser;
					//m_wProvideUser = wTargetUser;
					m_cbSendCardData = m_cbProvideCard;
					m_cbCardIndex[wTargetUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;
					m_cbUserAction[wTargetUser] = WIK_Qiang_GANG;
					OnUserOperateCard(wTargetUser, WIK_Qiang_GANG, m_cbProvideCard, cbTargetCaiCard);
					return 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));
				if (m_bQiangGang)
				{
					DispatchCardData(m_wResumeUser,true);
					m_bQiangGang = false;
				}
				else
				{
					DispatchCardData(m_wResumeUser);
				}
				
			}
		}
	//	OutputDebugString(_T("丁财神结束"));
		return true;

	}
	default:
		return false;
	}

	return false;
}
BOOL CTableFrameSink_dcs::GetCardCanHuWithAll(BYTE cbCard, std::vector<CanDcsSt> &vCards)
{
	BOOL FindCount = 0;
	for (int i = 0; i < vCards.size();i++)
	{
		if (vCards[i].bDuCanHu)
		{
			continue;
		}
		if (vCards[i].MagicCard==cbCard||vCards[i].MagicCardNext==cbCard)
		{
			FindCount++;
		}
		if (FindCount>=2)
		{
			break;
		}
	}
	
	return FindCount >= 2;
}
BOOL CTableFrameSink_dcs::CardInAll(BYTE CbCard, BYTE *pByte, int Count)
{
	if (pByte==NULL||Count<=0)
	{
		return FALSE;
	}
	for (int i = 0; i < Count;i++)
	{
		if (CbCard==pByte[i])
		{
			return TRUE;
		}
	}
	return FALSE;
}



void CTableFrameSink_dcs::CalculationMagicCards(BYTE CurrentUserIndex)
{
		EnumAllWeave(CurrentUserIndex);
}

void CTableFrameSink_dcs::EnumAllWeave(BYTE CurrentUserIndex)
{
	
	
	for (int j = 0; j < m_cbWeaveItemCount[CurrentUserIndex]; j++)
	{

			CString strOut;
			switch (m_WeaveItemArray[CurrentUserIndex][j].cbWeaveKind)
			{
			case WIK_PENG:
			case WIK_BU_GANG:
			case WIK_MING_GANG:
			case WIK_AN_GANG:
			{
				//cbCards[nCards++] = WeaveItem[i].cbCenterCard;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard)] = 0;
			
				break;
			}
			case WIK_LEFT:{
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard)] = 0;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard) + 1] = 0;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard) + 2] = 0;
			
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard;
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard + 1;
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard + 2;
				break;
			}
			case WIK_CENTER:{
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard) - 1] = 0;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard)] = 0;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard) + 1] = 0;
				
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard - 1;
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard;
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard + 1;
				break;
			}
			case  WIK_RIGHT:{
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard - 1;
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard - 2;
				// 					cbCards[nCards++] = WeaveItem[i].cbCenterCard;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard) - 1] = 0;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard) - 2] = 0;
				mCanDingCaiCardArray[CurrentUserIndex][m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[CurrentUserIndex][j].cbCenterCard)] = 0;
				
				break;
			}

			default:
				break;
			}
		
		}
	

}

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

//用户断线重连
bool CTableFrameSink_dcs::OnActionUserConnect(WORD wChairID, IServerUserItem * pIServerUserItem)
{
	auto dwUserID = pIServerUserItem->GetUserID();
	if (wChairID > 4 || wChairID < 0)
	{
		OutputDebugString(_T("OnActionUserConnect wChairID Error"));
		return false;
	}
	auto iter = std::find(m_offlineUsers.begin(), m_offlineUsers.end(), dwUserID);
	if (m_TabbOutCardCout[wChairID] > 0)
		HttpTingCard(wChairID);
	if (wChairID != m_wProvideUser&&m_cbUserAction[wChairID] & WIK_Qiang_GANG){
		//mCmd_NotifyQianggh

		SparrowMaJiang::PB_CS_S_NOTIFY_QIANGGH pQiangGang;
		pQiangGang.set_cbactioncard(mCmd_NotifyQianggh->cbActionCard);
		pQiangGang.set_cbactionmask(mCmd_NotifyQianggh->cbActionMask);
		pQiangGang.set_wresumeuser(mCmd_NotifyQianggh->wResumeUser);
		for (BYTE j = 0; j < mPlayGameUserCount; j++)
		{
			pQiangGang.add_caicards(mCmd_NotifyQianggh->caiCards[j]);
		}
		std::string pbdate = pQiangGang.SerializePartialAsString();
		m_pITableFrame->SendTableData(wChairID, SUB_S_NOTIFY_QIANGGH, (void*)pbdate.c_str(), pbdate.length());
	}
	if (iter != end(m_offlineUsers))
	{
		m_offlineUsers.erase(iter);	//玩家重新上线
		return true;
	}


	return true;
}

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

//游戏中途旁观进入
bool CTableFrameSink_dcs::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 = m_cbTotalCardCount;
	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_cbMagicFirstData;
		StatusPlay.lSiZi[3] = m_cbMagicSecondData;

		StatusPlay.dwOwnerID = m_pITableFrame->GetPrivateTableOwnerID();

		CopyMemory(StatusPlay.cbDiscardCard, m_cbDiscardCard, sizeof(StatusPlay.cbDiscardCard));
		CopyMemory(StatusPlay.cbDiscardCount, m_cbDiscardCount, sizeof(StatusPlay.cbDiscardCount));
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			if (m_bTwoPlayerFlag&&i == TowMjNullseat)
			{
				continue;
			}
			//StatusPlay.bWanLaiZi[i] = m_OutLaiZi[i];
			//StatusPlay.bWanLaiZi[i] |= (m_OutHongZhongGang[i] << 4);
			//StatusPlay.bWanLaiZi[i] |= (m_OutFaCaiGang[i] << 8);
			StatusPlay.cbCardCount[i] = m_GameLogic.GetCardCount(m_cbCardIndex[i]);
		}
		StatusPlay.totalOptTime = 10;
		StatusPlay.leftOptTime = 0;
		ASSERT(m_wProvideUser >= 0 && m_wProvideUser <= 3);
		//当前到谁家
		StatusPlay.wCurrentUser = (m_wCurrentUser == INVALID_CHAIR ? m_wProvideUser : m_wCurrentUser);
		WORD OldUser = 0;//定义一个最后出牌用户`

		if (m_wProvideUser == m_wCurrentUser&&m_wOutCardUser == INVALID_CHAIR)//牌权是摸牌得且没出牌
		{
			//if (m_bGangStatus)
			//{
			//	StatusPlay.bPutCardData[m_wProvideUser] = m_OutLastLaiZiData;
			//}
			//else
			//{
			if (m_bTwoPlayerFlag)
			{
				OldUser = (m_wProvideUser - 2 + GAME_PLAYER) % GAME_PLAYER;
			}
			else
			{
				OldUser = (m_wProvideUser - 1 + mPlayGameUserCount) % mPlayGameUserCount;
			}
			BYTE TempIndex = 0;
			BYTE bDiscardCount = (m_cbDiscardCount[OldUser] - 1) >= 0 ? (m_cbDiscardCount[OldUser] - 1) : 0;
			for (BYTE i = bDiscardCount; i < 40; i++)
			{
				if (m_cbDiscardCard[OldUser][i] == 0)
				{
					TempIndex = i - 1;
					break;
				}
			}
			TempIndex = (TempIndex == 255) ? 0 : TempIndex;
			StatusPlay.bPutCardData[OldUser] = m_cbDiscardCard[OldUser][TempIndex];
			//}
		}
		if (m_wProvideUser == m_wOutCardUser&& m_wCurrentUser == INVALID_CHAIR)//当有人可以碰且没有碰时候
		{
			StatusPlay.bPutCardData[m_wProvideUser] = m_cbProvideCard;
			StatusPlay.cbDiscardCard[m_wProvideUser][StatusPlay.cbDiscardCount[m_wProvideUser]++] = m_cbProvideCard;
		}
		//组合扑克
		CopyMemory(StatusPlay.WeaveItemArray, m_WeaveItemArray, sizeof(m_WeaveItemArray));
		CopyMemory(StatusPlay.cbWeaveCount, m_cbWeaveItemCount, sizeof(m_cbWeaveItemCount));


	}

	SparrowMaJiang::PB_CS_S_PangGuan PangGuan;
	PangGuan.mutable_gameconfig()->set_bduolai(StatusPlay.gameConfig.bDuoLai);
	PangGuan.mutable_gameconfig()->set_isowner(StatusPlay.gameConfig.IsOwner);
	PangGuan.mutable_gameconfig()->set_roomid(StatusPlay.gameConfig.RoomId);
	std::string sPrivateTableID = CW2AEX<1024>(StatusPlay.gameConfig.sPrivateTableID, CP_UTF8).m_psz;
	PangGuan.mutable_gameconfig()->set_sprivatetableid(sPrivateTableID);
	PangGuan.mutable_gameconfig()->set_tmp1(StatusPlay.gameConfig.tmp1);
	PangGuan.mutable_gameconfig()->set_tmp2(StatusPlay.gameConfig.tmp2);
	PangGuan.mutable_gameconfig()->set_wdiscore(StatusPlay.gameConfig.wDiScore);
	PangGuan.mutable_gameconfig()->set_wfanfei(StatusPlay.gameConfig.wFanFei);
	PangGuan.mutable_gameconfig()->set_wfengding(StatusPlay.gameConfig.wFengDing);
	PangGuan.mutable_gameconfig()->set_whadplaycount(StatusPlay.gameConfig.wHadPlayCount);
	PangGuan.mutable_gameconfig()->set_wiplimit(StatusPlay.gameConfig.wIpLimit);
	PangGuan.mutable_gameconfig()->set_wplaycountrule(StatusPlay.gameConfig.wPlayCountRule);
	PangGuan.mutable_gameconfig()->set_wsubgameid(StatusPlay.gameConfig.wSubGameID);
	for (BYTE j = 0; j < mPlayGameUserCount; j++)
	{
		PangGuan.add_lusertmpscore(StatusPlay.lUserTmpScore[j]);
		PangGuan.add_bputcarddata(StatusPlay.bPutCardData[j]);
		PangGuan.add_cbcardcount(StatusPlay.cbCardCount[j]);
		PangGuan.add_cbweavecount(StatusPlay.cbWeaveCount[j]);
		PangGuan.add_cbdiscardcount(StatusPlay.cbDiscardCount[j]);
		SparrowMaJiang::pb_cbDiscardCard* DiscardCard = PangGuan.add_cbdiscardcard();
		for (BYTE i = 0; i < 40; i++)
		{
			DiscardCard->add_cbdiscardcard(StatusPlay.cbDiscardCard[j][i]);
		}
		SparrowMaJiang::pb_WeaveItemArray* WeaveItemArray = PangGuan.add_weaveitemarray();
		for (BYTE i = 0; i < 4; i++)
		{
			SparrowMaJiang::pb_WeaveItem* WeaveItem = WeaveItemArray->add_weaveitem();
			WeaveItem->set_cbcentercard(StatusPlay.WeaveItemArray[j][i].cbCenterCard);
			WeaveItem->set_cbpubliccard(StatusPlay.WeaveItemArray[j][i].cbPublicCard);
			WeaveItem->set_cbweavekind(StatusPlay.WeaveItemArray[j][i].cbWeaveKind);
			WeaveItem->set_wprovideuser(StatusPlay.WeaveItemArray[j][i].wProvideUser);
			for (BYTE k = 0; k < 4; k++)
			{
				WeaveItem->add_cbmargicoffset(StatusPlay.WeaveItemArray[j][i].cbMargicOffset[k]);
			}
		}
	}
	PangGuan.set_gamestatus(StatusPlay.GameStatus);
	PangGuan.set_cbtotalcardcount(StatusPlay.cbTotalCardCount);
	PangGuan.set_cbleftcardcount(StatusPlay.cbLeftCardCount);
	PangGuan.set_wbankeruser(StatusPlay.wBankerUser);
	for (BYTE j = 0; j < 4; j++)
	{
		PangGuan.add_lsizi(StatusPlay.lSiZi[j]);
	}
	PangGuan.set_dwownerid(StatusPlay.dwOwnerID);
	PangGuan.set_wcurrentuser(StatusPlay.wCurrentUser);
	PangGuan.set_totalopttime(StatusPlay.totalOptTime);
	PangGuan.set_leftopttime(StatusPlay.leftOptTime);
	std::string pbdata = PangGuan.SerializePartialAsString();
	return m_pITableFrame->SendUserItemData(pIServerUserItem, SUB_S_PANGGUAN, (void*)pbdata.c_str(), pbdata.length());
}

//用户起来
bool CTableFrameSink_dcs::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;

		SparrowMaJiang::PB_CS_S_Trustee Trustees;
		Trustees.set_btrustee(Trustee.bTrustee);
		Trustees.set_wchairid(Trustee.wChairID);
		std::string pbdata = Trustees.SerializePartialAsString();
		RepayRecord(INVALID_CHAIR, SUB_S_TRUSTEE, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_TRUSTEE, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_TRUSTEE, (void*)pbdata.c_str(), pbdata.length());
	}

	return true;
}

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

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

	//效验参数
	if (wChairID != m_wCurrentUser) return false;
	if (m_GameLogic.IsValidCard(cbCardData) == false) return false;
	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;//打出得牌,放到其他玩家得记忆库里面
	//}

	//m_bSendStatus = true;
	//if (m_bGangStatus)
	//{
	//m_OutLastLaiZiData = 0; //最后杠牌数据，断线重连用的着
	//	m_bGangStatus = false;
	ZeroMemory(m_bUsersGangStatus, GAME_PLAYER);
	m_bGangOption = 0;
	m_GangPrivedUserID = -1;
	//m_bGangOutStatus = true;
	//}
	m_cbUserAction[wChairID] = WIK_NULL;
	m_cbPerformAction[wChairID] = WIK_NULL;

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

	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]));		//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据
	BYTE FanHui[MAX_INDEX] = { 0 };
	/*m_GameLogic.IsCanChangCardAndCount(m_cbCardIndex[wChairID], FanHui);
	if (m_GameLogic.IsTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], FanHui))
	{*/
	OutTingCard(wChairID, m_GameLogic.SwitchToCardIndex(m_cbOutCardData));
	//}
	//构造数据
	CMD_S_OutCard OutCard;
	OutCard.wOutCardUser = wChairID;
	OutCard.cbOutCardData = cbCardData;
	OutCard.bOptType = 0;

	SparrowMaJiang::PB_CS_S_OutCard Card;
	Card.set_woutcarduser(OutCard.wOutCardUser);
	Card.set_cboutcarddata(OutCard.cbOutCardData);
	Card.set_bopttype(OutCard.bOptType);
	//发送数据
	std::string pbdata = Card.SerializePartialAsString();
	RepayRecord(INVALID_CHAIR, SUB_S_OUT_CARD, (void*)pbdata.c_str(), pbdata.length());
	//发送消息
	m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OUT_CARD, (void*)pbdata.c_str(), pbdata.length());
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OUT_CARD, (void*)pbdata.c_str(), pbdata.length());
	m_wProvideUser = wChairID;
	m_cbProvideCard = cbCardData;
	//用户切换
	if (m_bTwoPlayerFlag)
	{
		m_wCurrentUser = (wChairID + 2) % GAME_PLAYER;
	}
	else
	{
		m_wCurrentUser = (wChairID + 1) % mPlayGameUserCount;
	}
	//响应判断
	bool bAroseAction = EstimateUserRespond(wChairID, cbCardData, EstimatKind_OutCard);
	//派发扑克
	if (bAroseAction == false)
	{
		DispatchCardData(m_wCurrentUser);
	}
	return true;
}

//用户操作
bool CTableFrameSink_dcs::OnUserOperateCard(WORD wChairID, int cbOperateCode, BYTE cbOperateCard, BYTE cbCaiShenCard[4])
{
	//效验状态
	ASSERT(m_pITableFrame->GetGameStatus() == GS_MJ_PLAY);
	if (m_pITableFrame->GetGameStatus() != GS_MJ_PLAY)
		return true;

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

	tagGangCardResult GangCardResult;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	//被动动作
	if (m_wCurrentUser == INVALID_CHAIR&&wChairID != m_wProvideUser)//表示有人出牌后，下一个人还未摸牌这段时间内，有人对上一张出牌有吃胡、杠、碰等操作
	{
		//效验状态
		if (m_bResponse[wChairID] == true)
			return true;
		if ((cbOperateCode != WIK_NULL) && ((m_cbUserAction[wChairID] & cbOperateCode) == 0) && (cbOperateCode != WIK_Qiang_GANG&&cbOperateCode != WIK_ZI_MO))
			return true;
		//变量定义


		WORD wTargetUser = wChairID;
		int cbTargetAction = cbOperateCode;

		//设置变量
		m_bResponse[wChairID] = true;
		m_cbPerformAction[wChairID] = cbOperateCode;
		m_cbOperateCard[wChairID] = cbOperateCard;
		CopyMemory(m_cbOperateCaiCard[wChairID], cbCaiShenCard, sizeof(cbCaiShenCard));


		//执行动作的优先级判断, WIK_CHI_HU 大于 WIK_PENG 大于 [WIK_RIGHT or WIK_CENTER or WIK_LEFT]
		WORD TmpwProvideUser = m_wProvideUser;
		OperatorPriority(TmpwProvideUser, wTargetUser, cbTargetAction);

		if (m_bResponse[wTargetUser] == false)//操作判断
		{
			if (cbOperateCode == WIK_NULL)
				m_cbLastDisCardData[wChairID][m_cbLastDisCount[wChairID]++] = m_cbProvideCard;
			return true;
		}

		//放弃操作
		if (m_bQiangGang&&cbOperateCard == 0)//此处if 主要用于解决，用户抢杠胡那一刻，断线重连。客户端不知道用户抢的那张牌。所以必须后台强制处理一下。
		{
			m_cbOperateCard[wTargetUser] = m_cbProvideCard;

		}
		else
		{
			m_bQiangGang = false;
		}
		if (cbOperateCode == WIK_NULL &&cbTargetAction == WIK_NULL)
		{
			//用户状态
			ZeroMemory(m_bResponse, sizeof(m_bResponse));
			ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
			ZeroMemory(m_cbOperateCard, sizeof(m_cbOperateCard));
			ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));
			//当该用户点过时 加入该张牌
			//if(wTargetUser==wChairID)
			//{
			m_cbLastDisCardData[wTargetUser][m_cbLastDisCount[wTargetUser]++] = m_cbProvideCard;
			//}
			if (m_wCurrentUser == INVALID_CHAIR)
			{
				DispatchCardData(m_wResumeUser);
			}
				


			return true;
		}
		//变量定义
		BYTE cbTargetCard = m_cbOperateCard[wTargetUser];
		BYTE cbTargetCaiCard[4] = { 0 };
		CopyMemory(cbTargetCaiCard, m_cbOperateCaiCard[wTargetUser], sizeof(cbTargetCaiCard));

		if (cbTargetCard != m_cbProvideCard)//校验很重要
		{
			m_bResponse[wTargetUser] = false;
			ASSERT(false);
			return false;
		}
		//出牌变量
		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));


		//组合扑克	
		if (cbTargetAction&(WIK_LEFT | WIK_CENTER | WIK_RIGHT | WIK_PENG | WIK_MING_GANG))
		{
			ASSERT(m_cbWeaveItemCount[wTargetUser] < 4);
			if (m_cbWeaveItemCount[wTargetUser] > 4)return false;
			WORD wIndex = m_cbWeaveItemCount[wTargetUser]++;
			m_WeaveItemArray[wTargetUser][wIndex].cbPublicCard = TRUE;
			m_WeaveItemArray[wTargetUser][wIndex].cbCenterCard = cbTargetCard;
			m_WeaveItemArray[wTargetUser][wIndex].cbWeaveKind = cbTargetAction;
			m_WeaveItemArray[wTargetUser][wIndex].wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wTargetUser : m_wProvideUser;


			/*if (cbTargetAction& WIK_PENG)
			{
			//当任意一个玩家碰了之后，清理最后一张牌记录 //下一个牌 所有人 都可以碰 所以清零
			ZeroMemory(m_cbLastDisCardData, sizeof(m_cbLastDisCardData));
			ZeroMemory(m_cbLastDisCount, sizeof(m_cbLastDisCount));
			}*/


		}
		if (cbTargetAction &WIK_ZI_MO || cbTargetAction&WIK_Qiang_GANG)//此动作为抢杠胡才会促发
		{
			m_bQiangGang = true;
			ZeroMemory(m_bUsersGangStatus, GAME_PLAYER);
			m_wCurrentUser = wTargetUser;
			//m_wProvideUser = wTargetUser;
			m_cbSendCardData = m_cbProvideCard;
			m_cbCardIndex[wTargetUser][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;
			m_cbUserAction[wTargetUser] = WIK_Qiang_GANG;
			OnUserOperateCard(wTargetUser, WIK_Qiang_GANG, m_cbProvideCard, cbCaiShenCard);
			return true;
		}
		
		DeleteCaiShenCard(wTargetUser, cbTargetCaiCard, cbTargetAction, cbTargetCard);
		//杠牌处理
		if (cbTargetAction & (WIK_MING_GANG | WIK_DAN_MING_GANG | WIK_SHUANG_MING_GANG | WIK_SAN_MING_GANG))
		{
			int cbActionMask = WIK_NULL;
			WORD cbActionCard[6] = { 0 };
			HttpOperateResult(wTargetUser, cbTargetCaiCard, cbTargetAction, cbTargetCard, cbActionMask, cbActionCard);
			//设置用户
			m_wCurrentUser = wTargetUser;
			m_bGangOption = cbTargetAction;
			m_GangPrivedUserID = m_wProvideUser;
			DispatchCardData(wTargetUser, true);
			return true;
		}
		else
		{
			WORD cbActionCard[6] = { 0 };
			int cbActionMask = NULL;

			TingCard(wTargetUser);
			HttpOperateResult(wTargetUser, cbTargetCaiCard, cbTargetAction, cbTargetCard, cbActionMask, cbActionCard);
			//设置用户
			m_wCurrentUser = wTargetUser;
			if (m_TabbOutCardCout[wTargetUser] > 0)//有听牌就发一个听牌协议
			{
				HttpTingCard(wTargetUser);
			}
			return true;
		}
		ASSERT(false);
		return false;
	}
	//主动动作
	if (m_wCurrentUser == wChairID) //如果是摸牌用户的操作，比如自摸或者自杠
	{
		if (IsCanTianhu()&&cbOperateCode==WIK_ZI_MO)
		{
			cbOperateCode = WIK_TIAN_ZI_MO;
		}
		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));
			//发送扑克
			return true;
		}
		//效验操作
		if ((cbOperateCode == WIK_NULL))
			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;
		//执行动作
		if (cbOperateCode & (WIK_TIAN_ZI_MO | WIK_ZI_MO | WIK_Qiang_GANG))
		{
			BYTE TempCardData = m_cbProvideCard;
			if (m_cbProvideCard != m_cbSendCardData || m_cbProvideCard != cbOperateCard)
			{
				ASSERT(false);
				return false;
			}
			int TempAction = 0;
			CChiHuRight chr;
			BYTE TaiShu = 0;
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]--;
			if (cbCaiShenCard == NULL || cbCaiShenCard[1] == 0 && cbCaiShenCard[0] == 0)
			{
				m_GameLogic.SetMagicIndex(MAX_INDEX, MAX_INDEX);
			}
			else
			{
				if (cbCaiShenCard[1] == 0)
				{
					m_GameLogic.SetMagicIndex(m_GameLogic.SwitchToCardIndex(cbCaiShenCard[0]), MAX_INDEX);
				}
				else
				{
					m_GameLogic.SetMagicIndex(m_GameLogic.SwitchToCardIndex(cbCaiShenCard[0]), m_GameLogic.SwitchToCardIndex(cbCaiShenCard[1]));
				}

			}

			TempAction |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
				m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, TaiShu, m_bUsersGangStatus[wChairID], m_bQiangGang);
			if (IsCanTianhu()&&TaiShu>0)
			{
				TempAction = WIK_ZI_MO;
			}
			m_GameLogic.SetMagicIndex(MAX_INDEX, MAX_INDEX);
			m_cbCardIndex[wChairID][m_GameLogic.SwitchToCardIndex(m_cbSendCardData)]++;
			if (TempAction == WIK_NULL)
			{
				OutputDebugString(_T("玩家点了胡牌，但是实际上没有胡"));
				CString str;
				str.Format(_T("此时财神是 %d %d "), cbCaiShenCard[0], cbCaiShenCard[1]);
				OutputDebugString(str);
				ASSERT(false);
				return false;
			}
			m_HuPai[wChairID]++;
			CMD_S_OperateResult OperateResult;
			OperateResult.wOperateUser = wChairID;
			OperateResult.cbOperateCard = cbOperateCard;
			OperateResult.cbOperateCode = cbOperateCode;
			OperateResult.wProvideUser = (m_wProvideUser == INVALID_CHAIR) ? wChairID : m_wProvideUser;

			if (cbCaiShenCard != NULL)
			{
				CopyMemory(OperateResult.cbCaiShenCard, cbCaiShenCard, 4);

			}
			WORD paitype = bHuPaiType(chr);
			if (m_bUsersGangStatus[wChairID] == true)
			{
				paitype |= ZJ_TAI_GangKai;
				//TaiShu++;
			}

			if (m_bQiangGang == true)
			{
				paitype |= ZJ_TAI_QiangGang;
				OperateResult.cbOperateCode = WIK_CHI_HU;

			}


			if (WIK_TIAN_ZI_MO == cbOperateCode)//天胡台数直接到最大
			{
				paitype |= ZJ_TAI_TianHu;
				TaiShu = mMaxTaiNum;
			}
			OperateResult.cbActionMask = TaiShu | (paitype << 16);//异或 然后右移
			ZeroMemory(OperateResult.cbActionCard, sizeof(OperateResult.cbActionCard));
			SparrowMaJiang::PB_CS_S_OperateResult Result;
			Result.set_woperateuser(OperateResult.wOperateUser);
			Result.set_cboperatecard(OperateResult.cbOperateCard);
			Result.set_cboperatecode(OperateResult.cbOperateCode);
			Result.set_wprovideuser(OperateResult.wProvideUser);
			for (BYTE j = 0; j < 4; j++)
			{
				Result.add_cbcaishencard(OperateResult.cbCaiShenCard[j]);
			}
			Result.set_cbactionmask(OperateResult.cbActionMask);
			for (BYTE j = 0; j < 6; j++)
			{
				Result.add_cbactioncard(OperateResult.cbActionCard[j]);
			}
			//发送数据
			std::string pbdata = Result.SerializePartialAsString();
			RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
			//发送消息
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());

			//积分变动
			CMD_S_GangScore gs;
			ZeroMemory(&gs, sizeof(gs));
			gs.wChairId = wChairID;
			gs.cbOperateCode = WIK_ZI_MO;
			if (m_bQiangGang == true){
				gs.cbOperateCode = WIK_CHI_HU;
			}
			else
			{
				gs.cbOperateCode = WIK_ZI_MO;
			}
			int TempInfoScore = 0;
			WORD LaoZhuang = m_wBankerUser & 0x00ff;

			if (LianXuHuPai[LaoZhuang] >= 2)
			{
				TaiShu++;
				//TaiShu = TaiShu > (mMaxTaiNum - 1) ? mMaxTaiNum : ++TaiShu;//老庄台数加1
			}




			/*		if (TaiShu>FengDingTaiNum)
					{
					TaiShu = FengDingTaiNum;

					}*/
			//  [9/11/2017 Zoro] 经与苗苗确认，取消新加需求。所有杠开 都算自摸。
			/*	if (mMjType==1&&m_bGangStatus==true)
				{
				if (m_GangPrivedUserID!=wChairID&&m_GangPrivedUserID!=-1&&wChairID==mbaoMjUserID)
				{
				CaculationScore(wChairID, TaiShu, Win_FangPao, m_GangPrivedUserID, chr, gs);
				}
				else
				{
				CaculationScore(wChairID, TaiShu, Win_ZiMo, m_wProvideUser, chr, gs);
				}
				}
				else
				{*/
			
			//}

			if (cbOperateCode&WIK_Qiang_GANG)
			{
				CaculationScore(wChairID, TaiShu, win_qianggang, m_wProvideUser, chr, gs);
			}
			else
			{
				CaculationScore(wChairID, TaiShu, Win_ZiMo, m_wProvideUser, chr, gs);
			}

			LianXuHuPai[wChairID]++;


			SparrowMaJiang::PB_CS_S_GangScore GangScore;
			GangScore.set_cboperatecode(gs.cbOperateCode);
			for (BYTE j = 0; j < mPlayGameUserCount; j++)
			{
				GangScore.add_cbwanjiascore(gs.cbWanJiaScore[j]);
				GangScore.add_lgangscore(gs.lGangScore[j]);
			}
			GangScore.set_wchairid(gs.wChairId);
			std::string pbscore = GangScore.SerializePartialAsString();
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GANG_SCORE, (void*)pbscore.c_str(), pbscore.length());
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GANG_SCORE, (void*)pbscore.c_str(), pbscore.length());
			for (BYTE i = 0; i < mPlayGameUserCount; i++)
			{
				if (m_bTwoPlayerFlag&&i == TowMjNullseat)
				{
					continue;
				}
				gs.cbWanJiaScore[i] = m_lGameScore[i];
			}
			for (BYTE j = 0; j < mPlayGameUserCount; j++)
			{
				GangScore.set_cbwanjiascore(j, gs.cbWanJiaScore[j]);
			}
			std::string pbscores = GangScore.SerializePartialAsString();
			RepayRecord(INVALID_CHAIR, SUB_S_GANG_SCORE, (void*)pbscores.c_str(), pbscores.length());
			OnEventGameConclude(wChairID, NULL, GER_NORMAL);
			return true;
		}
		if (cbOperateCode & (WIK_DAN_BU_GANG | WIK_BU_GANG))
		{
			DeleteCard(wChairID, cbCaiShenCard, cbOperateCode, cbOperateCard);
			int cbActionMask = WIK_NULL;
			WORD cbActionCard[6] = { 0 };
			HttpOperateResult(wChairID, cbCaiShenCard, cbOperateCode, cbOperateCard, cbActionMask, cbActionCard);
			//响应判断
			m_wProvideUser = wChairID;
			m_bQiangGang = true;
			m_bUsersGangStatus[wChairID] = true;
			bool bAroseAction = false;
			if (cbOperateCard<0x31)
			{
				bAroseAction = EstimateUserRespond(wChairID, cbOperateCard, EstimatKind_GangCard);//补杠，别人可以抢杠胡    
			}
			
			//--201808-10

			// 此处包含bug，如果抢杠的用户选择了过。此时该杠上开花的用户则无法胡杠上开话，会少一台。此bug需要修复 [11/28/2017 Zoro]
			//派发扑克
			if (bAroseAction == false)
			{
				m_bQiangGang = false;
				m_bGangOption = cbOperateCode;
				m_GangPrivedUserID = m_wCurrentUser;
				DispatchCardData(m_wCurrentUser, true);
			}
			else
			{
				//	m_bGangStatus = false;
				m_bQiangGang = true;
			}
			return true;
		}
		DeleteCard(wChairID, cbCaiShenCard, cbOperateCode, cbOperateCard);
		int cbActionMask = WIK_NULL;
		WORD cbActionCard[6] = { 0 };
		HttpOperateResult(wChairID, cbCaiShenCard, cbOperateCode, cbOperateCard, cbActionMask, cbActionCard);
		DispatchCardData(wChairID, true);
		return true;
	}
	return true;
}

//发送操作
bool CTableFrameSink_dcs::SendOperateNotify()
{
	//发送提示
	for (WORD i = 0; i < mPlayGameUserCount; i++)
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		if (m_cbUserAction[i] != WIK_NULL)
		{
			//构造数据
			CMD_S_OperateNotify OperateNotify;
			OperateNotify.wResumeUser = m_wResumeUser;
			OperateNotify.cbActionCard = m_cbProvideCard;
			OperateNotify.cbActionMask = m_cbUserAction[i];
			
			SparrowMaJiang::PB_CS_S_OperateNotify Notify;
			Notify.set_wresumeuser(OperateNotify.wResumeUser);
			Notify.set_cbactioncard(OperateNotify.cbActionCard);
			Notify.set_cbactionmask(OperateNotify.cbActionMask);
			std::string pbdata = Notify.SerializePartialAsString();
			//发送数据
			m_pITableFrame->SendTableData(i, SUB_S_OPERATE_NOTIFY, (void*)pbdata.c_str(), pbdata.length());
			
			////-沙  前端需要展示提示数据
			OperateNotify.wResumeUser = i;		
			Notify.set_wresumeuser(OperateNotify.wResumeUser);
			std::string pbdatas = Notify.SerializePartialAsString();
			RepayRecord(i, SUB_S_OPERATE_NOTIFY, (void*)pbdatas.c_str(), pbdata.length());

		}
	}
	//m_pITableFrame->SendLookonData(i, SUB_S_OPERATE_NOTIFY, &OperateNotify, sizeof(OperateNotify));
	return true;
}

//派发扑克,wCurrentUser表示给哪个用户，bTail表示是末尾拿牌还是不是，true表示末尾，同时标示杠牌抓牌
bool CTableFrameSink_dcs::DispatchCardData(WORD wCurrentUser, bool bTail)
{
	//状态效验
	ASSERT(wCurrentUser != INVALID_CHAIR);
	if (wCurrentUser == INVALID_CHAIR)
		return false;
	//丢弃扑克
	if ((m_wOutCardUser != INVALID_CHAIR) && (m_cbOutCardData != 0))
	{
		m_cbDiscardCount[m_wOutCardUser]++;
		m_cbDiscardCard[m_wOutCardUser][m_cbDiscardCount[m_wOutCardUser] - 1] = m_cbOutCardData;
	}
	//荒庄结束
	if (m_cbLeftCardCount == 0)
	{
		//m_cbChiHuCard = 0;
		m_wProvideUser = INVALID_CHAIR;
		bIsHuang = true;
		OnEventGameConclude(m_wProvideUser, NULL, GER_NORMAL);
		return true;
	}
	mBCanShowLeft = TRUE;
	//设置变量
	m_cbOutCardData = 0;
	m_wCurrentUser = wCurrentUser;		//记录拿牌人的索引。
	m_wOutCardUser = INVALID_CHAIR;		//置空上次出牌用户的索引
	BYTE ActionCard[3] = { 0 };			//操作牌值
	BYTE AnActionCount = 0;
	//发送扑克
	m_cbSendCardCount++;
	--m_cbLeftCardCount;//剩余牌减少
	m_cbSendCardData = m_cbRepertoryCard[--m_cbShiJiLeftCardCount];//实际剩余牌减少
	CChiHuRight chr;
	BYTE TaiShu = 0;
	//	m_bGangStatus = bTail;
	m_bUsersGangStatus[wCurrentUser] = bTail;

	m_cbUserAction[wCurrentUser] |= m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[wCurrentUser], m_WeaveItemArray[wCurrentUser],
		m_cbWeaveItemCount[wCurrentUser], m_cbSendCardData, chr, TaiShu, bTail);

	//////////////////////////////////////////////////////////////////////////
	//定财神  判断是否可以定财神
	BYTE TempCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(TempCardIndex, m_cbCardIndex[wCurrentUser], MAX_INDEX);

	std::vector<CanDcsSt> vCards;
	
	if (GetMagicCardAndTaiNum(TempCardIndex, wCurrentUser, m_cbSendCardData, vCards,TRUE))
	{
		m_cbUserAction[wCurrentUser] |= WIK_CanDingMagic;
	}
	//////////////////////////////////////////////////////////////////////////


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

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

	//杠牌判断
	tagGangCardResult GangCardResult;
	ZeroMemory(&GangCardResult, sizeof(GangCardResult));
	if (m_cbLeftCardCount > 0)
	{
		bool bCanAnGang = true;//此true表示自己抓牌，false表示表人打得去检验杠，		
		m_cbUserAction[wCurrentUser] |= m_GameLogic.AnalyseGangCard(m_cbCardIndex[wCurrentUser],
			m_WeaveItemArray[wCurrentUser], m_cbWeaveItemCount[wCurrentUser], GangCardResult);
	}
	//听牌计算
	// 	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]));		//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据
	if (!(m_cbUserAction[wCurrentUser] & WIK_ZI_MO))
		TingCard(m_wCurrentUser);
	//构造数据
	CMD_S_SendCard SendCard;
	ZeroMemory(&SendCard, sizeof(SendCard));
	SendCard.wCurrentUser = wCurrentUser;
	SendCard.bTail = bTail;
	SendCard.bLeftCardCount = m_cbLeftCardCount;
	SendCard.cbActionMask = m_cbUserAction[wCurrentUser];
	SendCard.cbCardData = m_cbSendCardData;
	SparrowMaJiang::PB_CS_S_SendCard Card;
	Card.set_wcurrentuser(SendCard.wCurrentUser);
	Card.set_btail(SendCard.bTail);
	Card.set_bleftcardcount(SendCard.bLeftCardCount);
	Card.set_cbactionmask(SendCard.cbActionMask);
	Card.set_cbcarddata(SendCard.cbCardData);
	std::string pbdatas = Card.SerializePartialAsString();
	RepayRecord(INVALID_CHAIR, SUB_S_SEND_CARD, (void*)pbdatas.c_str(), pbdatas.length());
	//发送数据
	for (int i = 0; i < mPlayGameUserCount; i++)
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		if (i == m_wCurrentUser)
		{
			//发送给摸牌玩家的数据，附带麻将牌面数据
			for (BYTE j = 0; j < GangCardResult.cbCardCount; j++)//先暗杠后补杠牌数据
				SendCard.cbActionCard[j] = GangCardResult.cbCardData[j];
			SendCard.cbCardData = m_cbSendCardData;
			SendCard.cbActionMask = m_cbUserAction[wCurrentUser];
			//m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD, &SendCard, sizeof(SendCard));
			for (BYTE j = 0; j < GangCardResult.cbCardCount; j++)
			{
				Card.add_cbactioncard(SendCard.cbActionCard[j]);
			}
			Card.set_cbactionmask(SendCard.cbActionMask);
			Card.set_cbcarddata(SendCard.cbCardData);
			std::string pbdata = Card.SerializePartialAsString();
			m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD, (void*)pbdata.c_str(), pbdata.length());
		}
		else
		{//发送给其他玩家的数据，没有麻将牌面数据（防止客户端作弊）
			ZeroMemory(SendCard.cbActionCard, sizeof(SendCard.cbActionCard));
			SendCard.cbCardData = 0x00;
			SendCard.cbActionMask = 0x0000;
			for (BYTE j = 0; j < GangCardResult.cbCardCount; j++)
			{
				Card.add_cbactioncard(SendCard.cbActionCard[j]);
			}
			Card.set_cbactionmask(SendCard.cbActionMask);
			Card.set_cbcarddata(SendCard.cbCardData);
			std::string pbdata = Card.SerializePartialAsString();
			m_pITableFrame->SendTableData(i, SUB_S_SEND_CARD, (void*)pbdata.c_str(), pbdata.length());
		}
	}
	SendCard.cbActionMask = 0;
	SendCard.cbCardData = 0;
	Card.set_cbactionmask(SendCard.cbActionMask);
	Card.set_cbcarddata(SendCard.cbCardData);
	std::string pbdata = Card.SerializePartialAsString();
	//给旁观者的抓牌动作
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_SEND_CARD, (void*)pbdata.c_str(), pbdata.length());
	if (m_TabbOutCardCout[m_wCurrentUser] > 0)//有听牌就发一个听牌协议
	{
		HttpTingCard(m_wCurrentUser);
	}
	return true;
}

//响应判断
bool CTableFrameSink_dcs::EstimateUserRespond(WORD wCenterUser, BYTE cbCenterCard, enEstimatKind EstimatKind)
{
	//财神牌不判断
	if (m_GameLogic.IsMagicCard(cbCenterCard))return false;
	//变量定义
	bool bAroseAction[GAME_PLAYER] = { false };
	bool mbAroseAction = false;
	//吃牌判断,出牌玩家下家位置
	WORD wEatUser = (wCenterUser + 1) % mPlayGameUserCount;
	if (m_bTwoPlayerFlag&&wEatUser == TowMjNullseat)
	{
		wEatUser++;
	}
	//用户状态
	ZeroMemory(m_bResponse, sizeof(m_bResponse));
	ZeroMemory(m_cbUserAction, sizeof(m_cbUserAction));
	ZeroMemory(m_cbPerformAction, sizeof(m_cbPerformAction));

	bool bHaveQiangGang = false;
	//动作判断
	for (WORD nUserIndex = 0; nUserIndex < mPlayGameUserCount; nUserIndex++)
	{
		if (m_bTwoPlayerFlag&&nUserIndex == TowMjNullseat)
		{
			continue;
		}
		//用户过滤
		if (wCenterUser == nUserIndex) continue;
		//出牌类型
		if (EstimatKind == EstimatKind_OutCard)
		{
			CChiHuRight Chr;
			BYTE TaiShu = 0;

			int wAction = 0;

			/*	wAction = m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[nUserIndex], m_WeaveItemArray[nUserIndex], m_cbWeaveItemCount[nUserIndex], cbCenterCard, Chr, TaiShu);
				if (wAction != WIK_NULL)
				{
				m_cbUserAction[nUserIndex] = WIK_CHI_HU;
				if (m_cbOutCardCount == 1 &&(m_wBankerUser&0xff)!=nUserIndex&&mMjType==0)
				{
				m_cbUserAction[nUserIndex] = WIK_DI_CHIHU;
				}
				}	*/
			//确定只有下家才能吃牌
			if (wEatUser == nUserIndex)
			{
				m_cbUserAction[nUserIndex] |= m_GameLogic.EstimateEatCard(m_cbCardIndex[nUserIndex], cbCenterCard);
			}
			//碰牌判断
			m_cbUserAction[nUserIndex] |= m_GameLogic.EstimatePengCard(m_cbCardIndex[nUserIndex], cbCenterCard);
			/*if (m_cbUserAction[nUserIndex]& WIK_PENG ||
				m_cbUserAction[nUserIndex] & WIK_DAN_PENG||
				m_cbUserAction[nUserIndex] & WIK_PENG
				)
				{
				if (m_cbLastDisCardData[nUserIndex][m_cbLastDisCount[nUserIndex]]> 0)
				{
				m_cbLastDisCardData[nUserIndex][m_cbLastDisCount[nUserIndex]--]--;

				}

				}*/
			//杠牌判断
			if (m_cbLeftCardCount > 0)
			{
				m_cbUserAction[nUserIndex] |= m_GameLogic.EstimateGangCard(m_cbCardIndex[nUserIndex], cbCenterCard);
			}

		}

		if (EstimatKind == EstimatKind_GangCard)
		{
			CChiHuRight Chr;
			BYTE TaiShu = 0;
			//int wAction = 0;
			int GangStatus = m_bUsersGangStatus[wCenterUser];
			BYTE TempCardIndex[MAX_INDEX] = { 0 };
			CopyMemory(TempCardIndex, m_cbCardIndex[nUserIndex], MAX_INDEX);
			//wAction = m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[nUserIndex], m_WeaveItemArray[nUserIndex], m_cbWeaveItemCount[nUserIndex], cbCenterCard, Chr, TaiShu, false, GangStatus);

			//////////////////////////////////////////////////////////////////////////
			//优先算 无财神胡
			//////////////////////////////////////////////////////////////////////////

			CGameLogic_dcs			TempGameLogic(this);
			BOOL bCanWuMacHu = FALSE;
			TempGameLogic.SetMagicIndex(MAX_INDEX, MAX_INDEX);
			TempCardIndex[TempGameLogic.SwitchToCardIndex(cbCenterCard)]++;
		
			if (TempGameLogic.AnalyseCardNew(TempCardIndex, m_WeaveItemArray[nUserIndex], m_cbWeaveItemCount[nUserIndex]))
			{
				TempGameLogic.mSunTaiJiangInColor = TempGameLogic.mJiangInColor;
				int nTai = TempGameLogic.AnalyseCardTaiNum(TempCardIndex, m_WeaveItemArray[nUserIndex], m_cbWeaveItemCount[nUserIndex]);
				if (nTai>=3)
				{
					bCanWuMacHu = TRUE;
				}
				
			}
			TempCardIndex[TempGameLogic.SwitchToCardIndex(cbCenterCard)]--;
			//////////////////////////////////////////////////////////////////////////

			
			//	TempCardIndex[m_GameLogic.SwitchToCardIndex(cbCenterCard)]++;
			std::vector<CanDcsSt> vCards;
			GetMagicCardAndTaiNum(TempCardIndex, nUserIndex, cbCenterCard, vCards);

			if (vCards.size() > 0)
			{
				BYTE TempRecordIndex[MAX_INDEX] = { 0 };
				int caiCardsCount = 0;
				BYTE tmpCardMagicLeftAndRight[MAX_COUNT] = { 0 };
				INT  tmpCardMagicLeftAndRightCount = 0;

				
					BYTE Cards[2] = { 0 };
					if (vCards[0].bDuCanHu)
					{
						Cards[0] = vCards[0].MagicCard|DingDuGao2;
					}
					else
					{
						if (GetCardCanHuWithAll(vCards[0].MagicCard, vCards) && !CardInAll(vCards[0].MagicCard, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
						{

							Cards[0] = vCards[0].MagicCard | DingLeftAndRightGao2;
							tmpCardMagicLeftAndRight[tmpCardMagicLeftAndRightCount++] = vCards[0].MagicCard;
						}
						if (vCards[0].MagicCardNext != 0)
						{
							if (GetCardCanHuWithAll(vCards[0].MagicCardNext, vCards) && !CardInAll(vCards[0].MagicCardNext, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
							{
								Cards[1] = vCards[0].MagicCardNext | DingLeftAndRightGao2;
								tmpCardMagicLeftAndRight[tmpCardMagicLeftAndRightCount++] = vCards[0].MagicCardNext;
							}
						}	
						if (!CardInAll(vCards[0].MagicCard, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
						{
							Cards[0] = vCards[0].MagicCard | DingRightGao2;
						}
						if (!CardInAll(vCards[0].MagicCardNext, tmpCardMagicLeftAndRight, tmpCardMagicLeftAndRightCount))
						{
							
							Cards[1] = vCards[0].MagicCardNext | DingLeftGao2;
				
						}
					}
				

				CMD_S_NOTIFY_QIANGGH SNotify;
				if (bCanWuMacHu==FALSE)
				{
					SNotify.caiCards[0] = Cards[0];
					SNotify.caiCards[1] = Cards[1];

				}
				else
				{
					SNotify.caiCards[0] = 0;
					SNotify.caiCards[1] = 0;
				}
			
				SNotify.cbActionCard = cbCenterCard;
				SNotify.cbActionMask = WIK_Qiang_GANG;
				SNotify.wResumeUser = wCenterUser;
				
				CopyMemory(&mCmd_NotifyQianggh[nUserIndex], &SNotify, sizeof(CMD_S_NOTIFY_QIANGGH));

				SparrowMaJiang::PB_CS_S_NOTIFY_QIANGGH pQiangGang;
				pQiangGang.set_cbactioncard(SNotify.cbActionCard);
				pQiangGang.set_cbactionmask(SNotify.cbActionMask);
				pQiangGang.set_wresumeuser(SNotify.wResumeUser);
				for (BYTE j = 0; j < mPlayGameUserCount; j++)
				{
					pQiangGang.add_caicards(SNotify.caiCards[j]);
				}
				std::string pbdate = pQiangGang.SerializePartialAsString();
				m_pITableFrame->SendTableData(nUserIndex, SUB_S_NOTIFY_QIANGGH, (void*)pbdate.c_str(), pbdate.length());
				bHaveQiangGang = true;
				m_cbUserAction[nUserIndex] = WIK_Qiang_GANG;
			}


			// 			if (wAction&WIK_ZI_MO)
			// 			{
			// 				m_cbUserAction[nUserIndex] |= WIK_ZI_MO;
			// 			}



		}
		//结果判断
		if (m_cbUserAction[nUserIndex] != WIK_NULL)
		{
			bAroseAction[nUserIndex] = true;
			if (m_cbUserAction[nUserIndex] & (WIK_PENG | WIK_CHI_HU | WIK_PENG_PENG))
			{
				BYTE bTemp = 0;
				//记忆牌有多少张
				for (BYTE j = 0; j < m_cbLastDisCount[nUserIndex]; j++)
				{
					//如果在一圈中 记忆1个一样的牌 则不能操作
					if (m_cbLastDisCardData[nUserIndex][j] == cbCenterCard)
					{
						m_cbUserAction[nUserIndex] = m_cbUserAction[nUserIndex] & (~(WIK_PENG | WIK_CHI_HU | WIK_PENG_PENG));
						if (m_cbUserAction[nUserIndex] == WIK_NULL)
							bAroseAction[nUserIndex] = false;
					}
				}
			}
		}
	}

	for (int nUserIndex = 0; nUserIndex < mPlayGameUserCount; nUserIndex++)
	{
		if (m_bTwoPlayerFlag&&nUserIndex == TowMjNullseat)
		{
			continue;
		}
		if (bAroseAction[nUserIndex] == true)
		{
			mbAroseAction = true;
			break;
		}
	}
	//结果处理
	if (mbAroseAction == true && bHaveQiangGang == FALSE)
	{
		//设置变量
		m_wProvideUser = wCenterUser;
		m_cbProvideCard = cbCenterCard;
		m_wResumeUser = m_wCurrentUser;
		m_wCurrentUser = INVALID_CHAIR;
		//发送提示
		SendOperateNotify();
		return true;
	}
	if (bHaveQiangGang)
	{
		m_wProvideUser = wCenterUser;
		m_cbProvideCard = cbCenterCard;
		m_wResumeUser = m_wCurrentUser;
		m_wCurrentUser = INVALID_CHAIR;
		return true;
	}
	return false;
}
//胡的这张牌 牌堆里面还有几张
//计算方式  服务器上剩余里面的牌，+其他三位位玩家手牌= 该胡牌个数
BYTE CTableFrameSink_dcs::RemainNum(WORD wChairId, const BYTE m_cbCard, BYTE cbOutCardIndex)
{
	BYTE m_cbNum = 0;
	BYTE mCard[MAX_INDEX] = { 0 }; //把所有当前用户可以看到的牌 都扔到这个数组中
	BYTE TempIndex = m_GameLogic.SwitchToCardIndex(m_cbCard);


	for (BYTE i = 0; i < mPlayGameUserCount; i++)
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		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)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 3;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_LEFT)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard + 1)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard + 2)]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_RIGHT)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard - 1)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard - 2)]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_CENTER)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard - 1)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard + 1)]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_MING_GANG || (i == wChairId&&m_WeaveItemArray[i][k].cbWeaveKind == WIK_AN_GANG))
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 4;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind& (WIK_SHUANG_CAICHI | WIK_SHUANG_PENG | WIK_DAN_CHI))
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[0])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[1])]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_DAN_PENG)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 2;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[0])]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_DAN_MING_GANG || (i == wChairId && m_WeaveItemArray[i][k].cbWeaveKind == WIK_DAN_AN_GANG))
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 3;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[0])]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_SHUANG_MING_GANG || (i == wChairId && m_WeaveItemArray[i][k].cbWeaveKind == WIK_SHUANG_AN_GANG))
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 2;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[0])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[1])]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind == WIK_SAN_MING_GANG || (i == wChairId && m_WeaveItemArray[i][k].cbWeaveKind == WIK_SAN_AN_GANG))
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] += 1;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[0])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[1])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[2])]++;
			}
			if (i == wChairId && m_WeaveItemArray[i][k].cbWeaveKind == WIK_QUANG_AN_GANG)
			{
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[0])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[1])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[2])]++;
				mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[3])]++;
			}
			if (m_WeaveItemArray[i][k].cbWeaveKind & (WIK_BU_GANG | WIK_DAN_BU_GANG))
			{
				for (int m = 0; m < 4; m++)
				{
					if (m_WeaveItemArray[i][k].cbMargicOffset[m] != 0)
						mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbMargicOffset[m])]++;
					else
						mCard[m_GameLogic.SwitchToCardIndex(m_WeaveItemArray[i][k].cbCenterCard)] ++;
				}
			}
		}
	}
	//8个财神变7个 在加回来一个

	//非包麻将 需要计算翻财神的那张牌
	BYTE cbMagicFirstIndex = m_GameLogic.SwitchToCardIndex(m_cbMagicFirstData);
	if (mCard[cbMagicFirstIndex] < 4)
	{
		mCard[cbMagicFirstIndex]++;
	}

	//非包麻将 不需要把财神那张牌加入落地牌


	//增加自己假设去掉的牌 这样才真正的标示 牌桌加手牌
	mCard[cbOutCardIndex]++;
	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 = 0;
	return m_cbNum;
}
//对手牌遍历，并把该牌减去，然后分析这13张拍能胡什么
bool CTableFrameSink_dcs::TingCard(WORD wChairID)
{
	m_PaiQuan[wChairID] = 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]));		//具体听牌数据，一维索引表示打出牌的第几个，二维索引表示听牌的第几个，值表示牌数据

	BYTE WilEnumCard[MAX_INDEX] = { 0 };
	m_GameLogic.IsCanChangCardAndCount(m_cbCardIndex[wChairID], WilEnumCard);

	for (BYTE i = 0; i < MAX_INDEX; i++)
	{
		if (m_cbCardIndex[wChairID][i] == 0)continue;
		if (--m_cbCardIndex[wChairID][i] < 0){ ASSERT(false); return false; }
		//if (m_GameLogic.IsTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID],FanHui))
		//{
		m_TabbOutCardData[wChairID][m_TabbOutCardCout[wChairID]] = m_GameLogic.SwitchToCardData(i);
		BYTE m_cbTingPai[MAX_INDEX] = { 0 };//听牌数组，听哪个牌就把哪个牌设置为1
		BYTE m_cbTingParCount = 0;			//听牌数据




		if (m_GameLogic.AnalyseTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbTingPai, WilEnumCard, wChairID))
		{
			for (BYTE j = 0; j < MAX_INDEX; j++)
			{
				if (m_cbTingPai[j] > 0)
				{
					if (m_cbTingParCount == 19)
					{
						m_cbTingParCount++;
						break;
					}
					m_TabbTingCardData[wChairID][m_TabbOutCardCout[wChairID]][m_cbTingParCount++] = m_GameLogic.SwitchToCardData(j);
					//计算所胡的这张牌 还剩余几张
					BYTE num = RemainNum(wChairID, m_TabbTingCardData[wChairID][m_TabbOutCardCout[wChairID]][m_cbTingParCount - 1], i);
					m_TabbTingCardData[wChairID][m_TabbOutCardCout[wChairID]][m_cbTingParCount - 1] = m_GameLogic.GetValue(num, m_cbTingPai[j], m_TabbTingCardData[wChairID][m_TabbOutCardCout[wChairID]][m_cbTingParCount - 1]);
				}
			}
			if (m_cbTingParCount == 20)
			{
				m_TabbTingCardCount[wChairID][m_TabbOutCardCout[wChairID]] = 255;
				ZeroMemory(m_TabbTingCardData[wChairID][m_TabbOutCardCout[wChairID]], m_cbTingParCount);
			}
			else
				m_TabbTingCardCount[wChairID][m_TabbOutCardCout[wChairID]] = m_cbTingParCount;
		}
		if (m_cbTingParCount > 0)
			m_TabbOutCardCout[wChairID]++;
		else{ m_TabbOutCardData[wChairID][m_TabbOutCardCout[wChairID]] = 0; }
		//}
		m_cbCardIndex[wChairID][i]++;
	}
	return true;
}

bool CTableFrameSink_dcs::OutTingCard(WORD wChairID, BYTE cardIndex)
{
	m_PaiQuan[wChairID] = 1;
	m_TabbOutCardCout[wChairID] = 1;														//可以打出的牌就听牌的个数，当打出牌已经完成，默认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 m_cbTingPai[MAX_INDEX] = { 0 };//听牌数组，听哪个牌就把哪个牌设置为1
	BYTE m_cbTingParCount = 0;//听牌数据
	BYTE FanHui[MAX_INDEX] = { 0 };
	m_GameLogic.IsCanChangCardAndCount(m_cbCardIndex[wChairID], FanHui);
	if (m_GameLogic.AnalyseTingCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], m_cbTingPai, FanHui, wChairID))
	{
		for (BYTE j = 0; j < MAX_INDEX; j++)
		{
			if (m_cbTingPai[j] > 0)
			{
				if (m_cbTingParCount == 19)
				{
					m_cbTingParCount++;
					break;
				}
				m_TabbTingCardData[wChairID][0][m_cbTingParCount++] = m_GameLogic.SwitchToCardData(j);
				//用户ID			
				BYTE num = RemainNum(wChairID, m_TabbTingCardData[wChairID][0][m_cbTingParCount - 1], cardIndex);
				m_TabbTingCardData[wChairID][0][m_cbTingParCount - 1] = m_GameLogic.GetValue(num, m_cbTingPai[j], m_TabbTingCardData[wChairID][0][m_cbTingParCount - 1]);
			}
		}
		if (m_cbTingParCount == 20)
		{
			m_TabbTingCardCount[wChairID][0] = 255;
			ZeroMemory(m_TabbTingCardData[wChairID][0], m_cbTingParCount);
		}
		else
		{
			m_TabbTingCardCount[wChairID][0] = m_cbTingParCount;
		}
		return true;
	}
	return false;
}

void CTableFrameSink_dcs::HttpTingCard(WORD wChairID)
{
	CMD_S_TingCard strTingCard;
	ZeroMemory(&strTingCard, sizeof(strTingCard));
	strTingCard.bPaiQuan = m_PaiQuan[wChairID];
	strTingCard.bOutCardCout = m_TabbOutCardCout[wChairID];
	CopyMemory(strTingCard.bOutCardData, m_TabbOutCardData[wChairID], sizeof(m_TabbOutCardData[wChairID]));
	CopyMemory(strTingCard.bTingCardCount, m_TabbTingCardCount[wChairID], sizeof(m_TabbTingCardCount[wChairID]));
	CopyMemory(strTingCard.bTingCardData, m_TabbTingCardData[wChairID], sizeof(m_TabbTingCardData[wChairID]));

	SparrowMaJiang::PB_CS_S_TingCard Card;
	Card.set_bpaiquan(strTingCard.bPaiQuan);
	Card.set_boutcardcout(strTingCard.bOutCardCout);
	for (BYTE j = 0; j < strTingCard.bOutCardCout; j++)
	{
		Card.add_boutcarddata(strTingCard.bOutCardData[j]);
	}
	for (BYTE j = 0; j < strTingCard.bOutCardCout; j++)
	{
		Card.add_btingcardcount(strTingCard.bTingCardCount[j]);
	}
	for (BYTE i = 0; i < strTingCard.bOutCardCout; i++)
	{
		SparrowMaJiang::pb_bTingCardData* CardData = Card.add_btingcarddata();
		for (BYTE j = 0; j < strTingCard.bTingCardCount[i]; j++)
		{
			CardData->add_btingcarddatas(strTingCard.bTingCardData[i][j]);
		}
	}
	std::string pbdata = Card.SerializePartialAsString();
	m_pITableFrame->SendTableData(wChairID, SUB_S_TING_CARD, (void*)pbdata.c_str(), pbdata.length());
}

void CTableFrameSink_dcs::HttpOperateResult(WORD wChairID, BYTE cbCaiShenCard[4], int cbOperateCode, BYTE cbOperateCard, int cbActionMask, WORD cbActionCard[6])
{
	if (cbOperateCode & WIK_GANG_GANG)
	{//构造结果
		CMD_S_OperateResult OperateResult;
		memset(&OperateResult, 0, sizeof(OperateResult));
		OperateResult.wOperateUser = wChairID;
		OperateResult.wProvideUser = wChairID;
		OperateResult.cbOperateCode = cbOperateCode;
		OperateResult.cbOperateCard = cbOperateCard;
		CopyMemory(OperateResult.cbCaiShenCard, cbCaiShenCard, sizeof(OperateResult.cbCaiShenCard));
		OperateResult.cbActionMask = cbActionMask;
		CopyMemory(OperateResult.cbActionCard, cbActionCard, sizeof(OperateResult.cbActionCard));
		SparrowMaJiang::PB_CS_S_OperateResult Result;
		Result.set_woperateuser(OperateResult.wOperateUser);
		Result.set_cboperatecard(OperateResult.cbOperateCard);
		Result.set_cboperatecode(OperateResult.cbOperateCode);
		Result.set_wprovideuser(OperateResult.wProvideUser);
		for (BYTE j = 0; j < 4; j++)
		{
			Result.add_cbcaishencard(OperateResult.cbCaiShenCard[j]);
		}
		Result.set_cbactionmask(OperateResult.cbActionMask);
		for (BYTE j = 0; j < 6; j++)
		{
			Result.add_cbactioncard(OperateResult.cbActionCard[j]);
		}
		//发送数据
		std::string pbdata = Result.SerializePartialAsString();
		RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
		//发送消息
		m_pITableFrame->SendTableData(wChairID, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
		ZeroMemory(OperateResult.cbCaiShenCard, sizeof(OperateResult.cbCaiShenCard));
		for (BYTE j = 0; j < 4; j++)
		{
			Result.add_cbcaishencard(OperateResult.cbCaiShenCard[j]);
		}
		for (BYTE i = 0; i < mPlayGameUserCount; i++)
		{
			if (m_bTwoPlayerFlag&&i == TowMjNullseat)
			{
				continue;
			}
			if (i == wChairID)continue;
			//发送消息
			m_pITableFrame->SendTableData(i, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
		}
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
	}
	else
	{
		CMD_S_OperateResult OperateResult;
		memset(&OperateResult, 0, sizeof(OperateResult));
		OperateResult.wOperateUser = wChairID;
		OperateResult.wProvideUser = m_wProvideUser;
		if (cbOperateCode &(WIK_DAN_BU_GANG | WIK_BU_GANG))
			OperateResult.wProvideUser = wChairID;
		OperateResult.cbOperateCode = cbOperateCode;
		OperateResult.cbOperateCard = cbOperateCard;
		CopyMemory(OperateResult.cbCaiShenCard, cbCaiShenCard, sizeof(OperateResult.cbCaiShenCard));
		OperateResult.cbActionMask = cbActionMask;
		CopyMemory(OperateResult.cbActionCard, cbActionCard, sizeof(OperateResult.cbActionCard));
		SparrowMaJiang::PB_CS_S_OperateResult Result;
		Result.set_woperateuser(OperateResult.wOperateUser);
		Result.set_cboperatecard(OperateResult.cbOperateCard);
		Result.set_cboperatecode(OperateResult.cbOperateCode);
		Result.set_wprovideuser(OperateResult.wProvideUser);
		for (BYTE j = 0; j < 4; j++)
		{
			Result.add_cbcaishencard(OperateResult.cbCaiShenCard[j]);
		}
		Result.set_cbactionmask(OperateResult.cbActionMask);
		for (BYTE j = 0; j < 6; j++)
		{
			Result.add_cbactioncard(OperateResult.cbActionCard[j]);
		}
		//发送数据
		std::string pbdata = Result.SerializePartialAsString();
		RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
		//发送消息
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_RESULT, (void*)pbdata.c_str(), pbdata.length());
	}
}

BYTE CTableFrameSink_dcs::GetNextMagicCardData(BYTE cbMagicCardFirstData)
{
	BYTE TmpCardData = 0;
	BYTE HuaSe = m_GameLogic.GetCardColor(cbMagicCardFirstData);
	switch (HuaSe)
	{
	case 0:
	case 1:
	case 2:
	{
		if ((cbMagicCardFirstData & MASK_VALUE) == 0x09)
		{
			TmpCardData = (cbMagicCardFirstData & MASK_COLOR) | 0x01;
		}
		else
		{
			TmpCardData = cbMagicCardFirstData + 1;
		}
		break;
	}
	case 3:
	{
		if ((cbMagicCardFirstData & MASK_VALUE) == 0x04)
		{
			TmpCardData = (cbMagicCardFirstData & MASK_COLOR) | 0x01;
		}
		else if ((cbMagicCardFirstData & MASK_VALUE) == 0x07)
		{
			TmpCardData = cbMagicCardFirstData - 2;
		}
		else
		{
			TmpCardData = cbMagicCardFirstData + 1;
		}
		break;
	}
	default:
	{
		ASSERT(false);
		break;
	}
	}
	return TmpCardData;
}

BYTE CTableFrameSink_dcs::GetLastMagicCardData(BYTE cbMagicCardFirstIndex)
{
	BYTE TmpCardData = 0;
	BYTE HuaSe = m_GameLogic.GetCardColor(cbMagicCardFirstIndex);
	switch (HuaSe)
	{
	case 0:
	case 1:
	case 2:
	{
		if ((cbMagicCardFirstIndex & MASK_VALUE) == 0x01)
		{
			TmpCardData = (cbMagicCardFirstIndex & MASK_COLOR) | 0x09;
		}
		else
		{
			TmpCardData = cbMagicCardFirstIndex - 1;
		}
		break;
	}
	case 3:
	{
		if ((cbMagicCardFirstIndex & MASK_VALUE) == 0x01)
		{
			TmpCardData = (cbMagicCardFirstIndex & MASK_COLOR) | 0x04;
		}
		else if ((cbMagicCardFirstIndex & MASK_VALUE) == 0x05)
		{
			TmpCardData = cbMagicCardFirstIndex + 2;
		}
		else
		{
			TmpCardData = cbMagicCardFirstIndex - 1;
		}
		break;
	}
	default:
	{
		ASSERT(false);
		break;
	}
	}
	return TmpCardData;
}

void CTableFrameSink_dcs::FanMagicCaculation(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CChiHuRight chr, CMD_S_GangScore& cmd_Score)
{
	int 	tmpScorTai = 1;
	if (nTai >= 3)
	{
	tmpScorTai = nTai - 2;
	}
	switch (WinWay)
	{
	case  win_qianggang:{
		WinQiangGang_Score(WinChairID, tmpScorTai, WinWay, provideUserID, chr, cmd_Score);
		break;
	}
	case  Win_ZiMo:{
		WinFanMagic_ZiMo_Score(WinChairID, tmpScorTai, WinWay, provideUserID, cmd_Score);
		break;
	}
	case win_DiHu:{
		WinFanMagic_DiHu_Score(WinChairID, tmpScorTai, WinWay, provideUserID, cmd_Score);
		break;
	}
	default:
		break;
	}
}


/*
int TempInfoScore = 0;
int nFengDingNum = m_gameConfig.wDiScore*pow(2, mMaxTaiNum);
for (BYTE i = 0; i < mPlayGameUserCount; i++)//各个玩家游戏积分变动
{
if (i == WinChairID)continue;
LianXuHuPai[i] = 0;

if (m_gameConfig.wDiScore *pow(2, nTai) >= nFengDingNum)
{
cmd_Score.lGangScore[i] -= nFengDingNum;
}
else {
cmd_Score.lGangScore[i] -= m_gameConfig.wDiScore *pow(2, nTai);
}


m_lGameScore[i] += cmd_Score.lGangScore[i];
m_lGameTatolScore[i] += cmd_Score.lGangScore[i];
cmd_Score.cbWanJiaScore[i] = m_lGameTatolScore[i];

TempInfoScore -= cmd_Score.lGangScore[i];
}
cmd_Score.lGangScore[WinChairID] = TempInfoScore;
m_lGameScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
m_lGameTatolScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
cmd_Score.cbWanJiaScore[WinChairID] = m_lGameTatolScore[WinChairID];
*/

void CTableFrameSink_dcs::WinQiangGang_Score(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CChiHuRight chr, CMD_S_GangScore& cmd_Score)
{

	//计算4家积分变动 输家 同时包赔3家的
	int TempInfoScore = 0;
	int nFengDingNum = m_gameConfig.wDiScore*pow(2, mMaxTaiNum-2);		//32
	for (BYTE i = 0; i < mPlayGameUserCount; i++)//各个玩家游戏积分变动
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		if (i == WinChairID)continue;
		LianXuHuPai[i] = 0;
		if (i == m_wProvideUser)
		{
			int nOneUserScore = 0;
			if (m_gameConfig.wDiScore *pow(2, nTai) >= nFengDingNum)
			{
				nOneUserScore -= nFengDingNum;
			}
			else {
				nOneUserScore -= m_gameConfig.wDiScore *pow(2, nTai);
			}
			cmd_Score.lGangScore[i] += nOneUserScore;
			TempInfoScore -= nOneUserScore;
		}
		else
		{
			int nOneUserScore = 0;
			if (m_gameConfig.wDiScore *pow(2, nTai) >= nFengDingNum)
			{
				nOneUserScore -= nFengDingNum;
			}
			else {
				nOneUserScore -= (m_gameConfig.wDiScore*pow(2, nTai));

			}
			cmd_Score.lGangScore[provideUserID] += nOneUserScore;


			m_lGameTatolScore[i] += cmd_Score.lGangScore[i];
			cmd_Score.cbWanJiaScore[i] = m_lGameTatolScore[i];
			TempInfoScore -= nOneUserScore;
		}

	}

	m_lGameScore[m_wProvideUser] += cmd_Score.lGangScore[m_wProvideUser];
	m_lGameTatolScore[m_wProvideUser] += cmd_Score.lGangScore[m_wProvideUser];
	cmd_Score.cbWanJiaScore[m_wProvideUser] = m_lGameTatolScore[m_wProvideUser];

	cmd_Score.lGangScore[WinChairID] = TempInfoScore;
	m_lGameScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
	m_lGameTatolScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
	cmd_Score.cbWanJiaScore[WinChairID] = m_lGameTatolScore[WinChairID];
}

//
//void CTableFrameSink_dcs::WinFanMagic_FangPao_Score(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CChiHuRight chr, CMD_S_GangScore& cmd_Score)
//{
//	int TempInfoScore = 0;
//	int nFengDingNum = m_gameConfig.wDiScore*pow(2, mMaxTaiNum);
//	for (BYTE i = 0; i < mPlayGameUserCount; i++)//各个玩家游戏积分变动
//	{
//		if (i == WinChairID)continue;
//		LianXuHuPai[i] = 0;
//		if (i == m_wProvideUser)
//		{
//			if (m_gameConfig.wDiScore *pow(2, nTai) >= nFengDingNum)
//			{
//				cmd_Score.lGangScore[i] -= nFengDingNum;
//			}
//			else {
//				cmd_Score.lGangScore[i] -= m_gameConfig.wDiScore *pow(2, nTai);
//			}
//			
//
//			m_lGameScore[i] += cmd_Score.lGangScore[i];
//			m_lGameTatolScore[i] += cmd_Score.lGangScore[i];
//			cmd_Score.cbWanJiaScore[i] = m_lGameTatolScore[i];
//		}
//		else
//		{
//			if (m_gameConfig.wDiScore *pow(2, nTai) / 2 >= nFengDingNum)
//				{
//				cmd_Score.lGangScore[i] -= nFengDingNum;
//				}
//				else {
//					cmd_Score.lGangScore[i] -= (m_gameConfig.wDiScore*pow(2, nTai) / 2);
//				}
//				m_lGameScore[i] += cmd_Score.lGangScore[i];
//				m_lGameTatolScore[i] += cmd_Score.lGangScore[i];
//				cmd_Score.cbWanJiaScore[i] = m_lGameTatolScore[i];
//		}
//		TempInfoScore -= cmd_Score.lGangScore[i];
//	}
//	cmd_Score.lGangScore[WinChairID] = TempInfoScore;
//	m_lGameScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
//	m_lGameTatolScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
//	cmd_Score.cbWanJiaScore[WinChairID] = m_lGameTatolScore[WinChairID];
//}
//
//void CTableFrameSink_dcs::WinFangMagic_FangPao_QingYiSe_Score(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CChiHuRight Userchr, CMD_S_GangScore& cmd_Score)
//{
//	int ProvideUserHaveTwoTai=false;
//	for (int i = 0; i < MAX_INDEX;i++)
//	{
//		CChiHuRight chr;
//		BYTE nTaiShu=0;
//		int TempAction;
//		TempAction = m_GameLogic.AnalyseChiHuCard(m_cbCardIndex[provideUserID], m_WeaveItemArray[provideUserID],
//			m_cbWeaveItemCount[provideUserID], m_GameLogic.SwitchToCardData(i), chr, nTaiShu);
//		if (TempAction!=WIK_NULL&&nTaiShu>2)
//		{
//			ProvideUserHaveTwoTai = true;
//			break;
//		}
//		if (TempAction!=WIK_NULL&&nTaiShu==2)
//		{
//			if (TempAction&ZJ_TAI_WuMagic)
//			{
//				continue;
//			}
//			else
//			{
//				ProvideUserHaveTwoTai = true;
//				break;
//			}
//		}
//	}
//
//	if (ProvideUserHaveTwoTai)
//	{
//		WinFanMagic_FangPao_Score(WinChairID, nTai, WinWay, provideUserID, Userchr, cmd_Score);
//	}
//	else
//	{
//		//计算4家积分变动 输家 同时包赔3家的
//		int TempInfoScore = 0;
//		int nFengDingNum = m_gameConfig.wDiScore*pow(2, mMaxTaiNum);		//32
//		for (BYTE i = 0; i < mPlayGameUserCount; i++)//各个玩家游戏积分变动
//		{
//			if (i == WinChairID)continue;
//			LianXuHuPai[i] = 0;
//			if (i == m_wProvideUser)
//			{
//				int nOneUserScore = 0;
//				if (m_gameConfig.wDiScore *pow(2, nTai) >= nFengDingNum)
//				{
//					nOneUserScore -= nFengDingNum;
//				}
//				else {
//					nOneUserScore -= m_gameConfig.wDiScore *pow(2, nTai);
//				}
//				cmd_Score.lGangScore[i] += nOneUserScore;
//				TempInfoScore -= nOneUserScore;
//			}
//			else
//			{
//				int nOneUserScore = 0;
//				if (m_gameConfig.wDiScore *pow(2, nTai) / 2 >= nFengDingNum)
//				{
//					nOneUserScore -= nFengDingNum;
//				}
//				else {
//					nOneUserScore -= (m_gameConfig.wDiScore*pow(2, nTai) / 2);
//
//				}
//				cmd_Score.lGangScore[provideUserID] += nOneUserScore;
//
//
//				m_lGameTatolScore[i] += cmd_Score.lGangScore[i];
//				cmd_Score.cbWanJiaScore[i] = m_lGameTatolScore[i];
//				TempInfoScore -= nOneUserScore;
//			}
//			
//		}
//
//		m_lGameScore[m_wProvideUser] += cmd_Score.lGangScore[m_wProvideUser];
//		m_lGameTatolScore[m_wProvideUser] += cmd_Score.lGangScore[m_wProvideUser];
//		cmd_Score.cbWanJiaScore[m_wProvideUser] = m_lGameTatolScore[m_wProvideUser];
//
//		cmd_Score.lGangScore[WinChairID] = TempInfoScore;
//		m_lGameScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
//		m_lGameTatolScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
//		cmd_Score.cbWanJiaScore[WinChairID] = m_lGameTatolScore[WinChairID];
//	}
//
//}

void CTableFrameSink_dcs::WinFanMagic_ZiMo_Score(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CMD_S_GangScore& cmd_Score)
{
	int TempInfoScore = 0;
	int nFengDingNum = m_gameConfig.wDiScore*pow(2, mMaxTaiNum-2);
	for (BYTE i = 0; i < mPlayGameUserCount; i++)//各个玩家游戏积分变动
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		if (i == WinChairID)continue;
		LianXuHuPai[i] = 0;

		if (m_gameConfig.wDiScore *pow(2, nTai) >= nFengDingNum)
		{
			cmd_Score.lGangScore[i] -= nFengDingNum;
		}
		else {
			cmd_Score.lGangScore[i] -= m_gameConfig.wDiScore *pow(2, nTai);
		}


		m_lGameScore[i] += cmd_Score.lGangScore[i];
		m_lGameTatolScore[i] += cmd_Score.lGangScore[i];
		cmd_Score.cbWanJiaScore[i] = m_lGameTatolScore[i];

		TempInfoScore -= cmd_Score.lGangScore[i];
	}
	cmd_Score.lGangScore[WinChairID] = TempInfoScore;
	m_lGameScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
	m_lGameTatolScore[WinChairID] += cmd_Score.lGangScore[WinChairID];
	cmd_Score.cbWanJiaScore[WinChairID] = m_lGameTatolScore[WinChairID];
}

void CTableFrameSink_dcs::WinFanMagic_DiHu_Score(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CMD_S_GangScore& cmd_Score)
{
	WinFanMagic_ZiMo_Score(WinChairID, nTai, WinWay, provideUserID, cmd_Score);
}


void CTableFrameSink_dcs::CaculationScore(BYTE WinChairID, BYTE nTai, BYTE WinWay, BYTE provideUserID, CChiHuRight UserChr, CMD_S_GangScore& cmd_Score)
{

	FanMagicCaculation(WinChairID, nTai, WinWay, provideUserID, UserChr, cmd_Score);


}

void CTableFrameSink_dcs::WritePaiCardData(TCHAR* TableId, int count)
{

	if (!mBWriteTableData)
	{
		return;
	}
	SYSTEMTIME stTime;
	GetLocalTime(&stTime);
	CString sTimerDir;
	sTimerDir.Format(_T("%d月%d日-%d时"), stTime.wMonth, stTime.wDay, stTime.wHour);
	CString strFileName;
	if (mTableDatastrPath.IsEmpty())
	{
		strFileName.Format(_T("TableData\\%s\\Table_%s_%d.dat"), TableId, sTimerDir.GetBuffer(), count);
	}
	else
	{
		strFileName.Format(_T("%s\\TableData\\%s\\Table_%s_%d.dat"), mTableDatastrPath.GetBuffer(), sTimerDir.GetBuffer(), TableId, count);
	}

	CString strCreate;
	strCreate = mTableDatastrPath;
	PathAppend(strCreate.GetBufferSetLength(MAX_PATH), _T("\\TableData"));
	strCreate.ReleaseBuffer();

	if (!PathFileExists(strCreate.GetBuffer()))
	{
		CreateDirectory(strCreate.GetBuffer(), NULL);
	}
	PathAppend(strCreate.GetBufferSetLength(MAX_PATH), sTimerDir.GetBuffer());
	strCreate.ReleaseBuffer();
	if (!PathFileExists(strCreate.GetBuffer()))
	{
		CreateDirectory(strCreate.GetBuffer(), NULL);
	}

	HANDLE hFile = CreateFile(strFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_NEW, NULL, NULL);
	if (hFile != INVALID_HANDLE_VALUE)
	{
		DWORD dwWrite;
		WriteFile(hFile, m_cbRepertoryCard, m_cbTotalCardCount, &dwWrite, NULL);
		CloseHandle(hFile);
	}

}

void CTableFrameSink_dcs::ReadGameData()
{
	CString strFileName;
	strFileName = _T("Table.dat");
	if (!PathFileExists(_T("Table.dat")))
	{
		return;
	}

	HANDLE hFile = CreateFile(strFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, NULL, NULL);
	if (hFile != INVALID_HANDLE_VALUE)
	{
		DWORD dwRead;
		DWORD dwFileSize;
		DWORD fileSize = GetFileSize(hFile, &dwFileSize);
		if (fileSize != m_cbTotalCardCount)
		{
			CloseHandle(hFile);
			return;
		}
		SetFilePointer(hFile, 0, 0, FILE_BEGIN);

		//BYTE tmpCard[MAX_REPERTORY_ZJ] = { 0 };

		ReadFile(hFile, m_cbRepertoryCard, m_cbTotalCardCount, &dwRead, NULL);

		CloseHandle(hFile);

		/*	for (BYTE i = 0; i < MAX_REPERTORY_ZJ; i++)
			{
			ASSERT(i < MAX_REPERTORY_ZJ);
			m_cbRepertoryCard[i] = tmpCard[MAX_REPERTORY_ZJ - i - 1];
			}
			*/
	}
}
//打印玩家所有积分
void CTableFrameSink_dcs::PrintUsersScore(LPCTSTR lpstrInfo)
{
	//OutputDebugString(lpstrInfo);
	CString strInfo;
	for (int i = 0; i < mPlayGameUserCount; i++)
	{
		if (m_bTwoPlayerFlag&&i == TowMjNullseat)
		{
			continue;
		}
		CString strTmp;
		strTmp.Format(_T("UserID =%d 本次变更积分 %d 本局剩余拥有积分%d"),
			i, m_lGameScore[i], m_lGameTatolScore[i]);
		//OutputDebugString(strTmp);
	}
}

bool CTableFrameSink_dcs::UserDingMagicCard(WORD wChairID)
{
	//获取玩家手牌
	//获取玩家已经吃碰的牌
	//将吃碰的牌 在手牌中删除。
	//将手牌作为财神 进行判断 是否可以胡牌
	//m_cbCardIndex[wTargetUser], m_WeaveItemArray[wTargetUser],
	//	m_cbWeaveItemCount[wTargetUser],

	BYTE tmpRecordDcsCars[MAX_COUNT] = { 0 };
	BYTE tmpRecordDscCardsOld[MAX_COUNT] = { 0 };
	int nRecordCount = 0;

	BYTE TempUserCards[MAX_INDEX] = { 0 };
	CopyMemory(TempUserCards, m_cbCardIndex[wChairID], MAX_INDEX);
	BYTE WeaveCards[MAX_COUNT] = { 0 };
	int nCount = 0;
	GetOneWeaveItemCards(m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], WeaveCards, nCount);

	for (int i = 0; i < nCount; i++)
	{
		int nIndex = m_GameLogic.SwitchToCardIndex(WeaveCards[i]);
		TempUserCards[nIndex] = 0;
	}

	//减去手牌中定财神 与 Weave冲突的牌。
	//计算2次 第一次 计算独财神  第二次 计算连续财神
	for (int i = 0; i < MAX_INDEX; i++)//第一次循环 把所有能够读财神的记录了。
	{
		if (TempUserCards[i] == 0)
		{
			continue;
		}
		TempUserCards[i] = 0;
		CGameLogic_dcs			TempGameLogic(this);

		BYTE cbCard = TempGameLogic.SwitchToCardData(i);

		if (CardInCardArray(cbCard, WeaveCards, nCount))
		{
			continue;
		}

		TempGameLogic.SetMagicIndex(TempGameLogic.SwitchToCardIndex(cbCard), MAX_INDEX);

		BYTE TaiShu = 0;
		// 			BYTE TempAction = TempGameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
		// 				m_cbWeaveItemCount[wChairID], NULL, chr, TaiShu);
		if (TempGameLogic.AnalyseCardNew(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]))
		{
			TempGameLogic.mSunTaiJiangInColor = TempGameLogic.mJiangInColor;
			TaiShu = TempGameLogic.AnalyseCardTaiNum(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]);
		}
		if (TaiShu >= DingMagicMinTai)
		{

			tmpRecordDcsCars[nRecordCount] = cbCard;
			tmpRecordDscCardsOld[nRecordCount] = cbCard;
			tmpRecordDcsCars[nRecordCount] |= 0x80;
			nRecordCount++;
		}

	}
	//把手牌中已经能够独财胡的 左右2张牌都干掉。

	for (size_t i = 0; i < nRecordCount; i++)
	{

		BYTE cbCard = GetNextMagicCardData(tmpRecordDscCardsOld[i]);
		if (TempUserCards[m_GameLogic.SwitchToCardIndex(cbCard)]>0)
		{
			TempUserCards[m_GameLogic.SwitchToCardIndex(cbCard)] = 0;
			tmpRecordDcsCars[nRecordCount] = cbCard;
			tmpRecordDscCardsOld[nRecordCount] = cbCard;
			nRecordCount++;
		}
		cbCard = GetLastMagicCardData(tmpRecordDscCardsOld[i]);
		if (TempUserCards[m_GameLogic.SwitchToCardIndex(cbCard)] > 0)
		{
			TempUserCards[m_GameLogic.SwitchToCardIndex(cbCard)] = 0;
			tmpRecordDcsCars[nRecordCount] = cbCard;
			tmpRecordDscCardsOld[nRecordCount] = cbCard;
			nRecordCount++;
		}
	}

	//在手牌中 寻找连续的2张牌 进行胡牌判断


	std::vector<CaiCards> TmpCards;
	GetLianXuCards(TempUserCards, TmpCards);

	for (int i = 0; i < TmpCards.size(); i++)
	{
		CGameLogic_dcs			TempGameLogic(this);
		TempGameLogic.SetMagicIndex(TempGameLogic.SwitchToCardIndex(TmpCards[i].firstCardIndex), TmpCards[i].secCardIndex);
		CChiHuRight chr;
		BYTE TaiShu = 0;
		BYTE TempAction = TempGameLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
			m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, TaiShu);
		if (TempAction == WIK_ZI_MO&&TaiShu >= DingMagicMinTai)
		{

			tmpRecordDcsCars[nRecordCount++] = m_GameLogic.SwitchToCardData(TmpCards[i].firstCardIndex);
			tmpRecordDcsCars[nRecordCount++] = m_GameLogic.SwitchToCardData(TmpCards[i].secCardIndex);
		}
	}

	//////////////////////////////////////////////////////////////////////////
	//判定无财神
	//////////////////////////////////////////////////////////////////////////
	CMD_S_DING_CAI_RESULT DcResult;
	DcResult.cbIsWCHu = false;
	{


		CGameLogic_dcs			TempGameLogic(this);
		TempGameLogic.SetMagicIndex(MAX_INDEX, MAX_INDEX);

		BYTE TaiShu = 0;
		if (TempGameLogic.AnalyseCardNew(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]))
		{
			TempGameLogic.mSunTaiJiangInColor = TempGameLogic.mJiangInColor;
			TaiShu = TempGameLogic.AnalyseCardTaiNum(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]);
		}
		if (TaiShu >= DingMagicMinTai)
		{
			DcResult.cbIsWCHu = TRUE;
			OutputDebugString(_T("无财胡"));
		}
	}




	if (nRecordCount >= 1)
	{
		DcResult.cbResult = 1;
	}
	else
	{
		DcResult.cbResult = 0;
	}
	for (int i = 0; i < nRecordCount; i++)
	{
		CString str;
		if ((tmpRecordDcsCars[i] & 0x80) != 0)
		{

			str.Format(_T("独财神 %02x"), tmpRecordDcsCars[i] ^ 0x80);
			OutputDebugString(str);
		}
		else{
			str.Format(_T("财神 %02x"), tmpRecordDcsCars[i]);
			OutputDebugString(str);
		}
	}

	CopyMemory(DcResult.caiCards, tmpRecordDcsCars, nRecordCount);
	SparrowMaJiang::PB_CS_S_DING_CAI_RESULT pDcResult;
	pDcResult.set_cbiswchu(DcResult.cbIsWCHu);
	pDcResult.set_cbresult(DcResult.cbResult);
	for (BYTE j = 0; j < MAX_INDEX; j++)
	{
		pDcResult.add_caicards(DcResult.caiCards[j]);
	}
	std::string pbdate = pDcResult.SerializePartialAsString();
	RepayRecord(wChairID, SUB_S_DING_CAI_RESULT, (void*)pbdate.c_str(), pbdate.length());
	//发送消息
	m_pITableFrame->SendTableData(wChairID, SUB_S_DING_CAI_RESULT, (void*)pbdate.c_str(), pbdate.length());

	return TRUE;
}


bool CTableFrameSink_dcs::GetOneWeaveItemCards(const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE * cbCards, INT & CardsCount)
{
	int nCards = 0;
	for (int i = 0; i < cbWeaveCount; i++)
	{
		switch (WeaveItem[i].cbWeaveKind)
		{
		case WIK_PENG:
		case WIK_BU_GANG:
		case WIK_MING_GANG:
		case WIK_AN_GANG:
		{
			cbCards[nCards++] = WeaveItem[i].cbCenterCard;
			break;
		}
		case WIK_LEFT:{
			cbCards[nCards++] = WeaveItem[i].cbCenterCard;
			cbCards[nCards++] = WeaveItem[i].cbCenterCard + 1;
			cbCards[nCards++] = WeaveItem[i].cbCenterCard + 2;
			break;
		}
		case WIK_CENTER:{
			cbCards[nCards++] = WeaveItem[i].cbCenterCard - 1;
			cbCards[nCards++] = WeaveItem[i].cbCenterCard;
			cbCards[nCards++] = WeaveItem[i].cbCenterCard + 1;
			break;
		}
		case  WIK_RIGHT:{
			cbCards[nCards++] = WeaveItem[i].cbCenterCard - 1;
			cbCards[nCards++] = WeaveItem[i].cbCenterCard - 2;
			cbCards[nCards++] = WeaveItem[i].cbCenterCard;
			break;
		}

		default:
			break;
		}
	}
	CardsCount = nCards;
	return TRUE;
}

bool CTableFrameSink_dcs::CardInCardArray(BYTE cbCard, BYTE* cbCards, int nCount)
{
	for (int i = 0; i < nCount; i++)
	{
		if (cbCards[i] == cbCard)
		{
			return true;
		}
	}
	return false;
}


bool CTableFrameSink_dcs::GetLianXuCards(BYTE* CardsIndex, std::vector<CaiCards> &vCards)
{
	for (int i = 0; i < MAX_INDEX; i++)
	{
		if (CardsIndex[i] == 0)
		{
			continue;
		}

		int nNextIndex = m_GameLogic.SwitchToCardIndex(GetNextMagicCardData(i));
		if (CardsIndex[nNextIndex] > 0)
		{
			CaiCards tmp;
			tmp.firstCardIndex = i;
			tmp.firstCardIndex = nNextIndex;
			vCards.push_back(tmp);
		}
	}
	return true;
}
#include<algorithm>
bool comp(const CanDcsSt &a, const CanDcsSt &b){
	return a.nTai > b.nTai;
}
//获取14张手牌（包括落地牌），能够当作财神的牌，以及此牌当财神时胡的 台数
bool CTableFrameSink_dcs::GetMagicCardAndTaiNum(BYTE* cardsIndex, WORD wChairID, BYTE cbCenterCard, std::vector<CanDcsSt> &vCards, BOOL FindOneExit )
{
	//ZeroMemory(mCanDingCaiCardArray[wChairID], MAX_INDEX);
	memset(mCanDingCaiCardArray[wChairID], 4, MAX_INDEX);
	if (m_bQiangGang==true)
	{
		mCanDingCaiCardArray[wChairID][m_GameLogic.SwitchToCardIndex(cbCenterCard)] = 0;
	}
  	CalculationMagicCards(wChairID);
	//第一步 根据落地派 获取能够当财神的牌的组合
	BYTE CanMakeMagic[MAX_COUNT] = { 0 };
	std::vector<CanMadeMagic> vCanMadeMagics;
	cardsIndex[m_GameLogic.SwitchToCardIndex(cbCenterCard)]++;
	GetCanMadeMagicCards(cardsIndex, vCanMadeMagics,wChairID);
	cardsIndex[m_GameLogic.SwitchToCardIndex(cbCenterCard)]--;
	std::vector<CanMadeMagic>::iterator it = vCanMadeMagics.begin();
	for (; it != vCanMadeMagics.end(); it++)
	{

		int nTai = GetTaiNumFromCards(cardsIndex, wChairID, cbCenterCard, it->firstIndex, it->SecIndex, m_bQiangGang);

		if (nTai>0&&IsCanTianhu()&&FindOneExit==FALSE)
		{
			nTai = mMaxTaiNum;
		}
		if (nTai >= DingMagicMinTai)
		{
			CanDcsSt st;
			st.nTai = nTai;
			if (it->SecIndex == MAX_INDEX)
			{
				st.bDuCanHu = true;
				st.MagicCard = m_GameLogic.SwitchToCardData(it->firstIndex);
				st.MagicCardNext = 0;
			}
			else
			{
				st.bDuCanHu = false;
				st.MagicCard = m_GameLogic.SwitchToCardData(it->firstIndex);
				st.MagicCardNext = m_GameLogic.SwitchToCardData(it->SecIndex);
			}
			if (m_bQiangGang)
			{
				if (st.MagicCard == cbCenterCard || st.MagicCardNext == cbCenterCard)
				{
					continue;
				}
			}
			
			vCards.push_back(st);
			if (FindOneExit)
			{
				break;
			}
		}
	}
	std::sort(vCards.begin(), vCards.end(), comp);
	return vCards.size() > 0;
}

bool CTableFrameSink_dcs::GetCanMadeMagicCards(BYTE* cardsIndex, std::vector<CanMadeMagic> &vCards, BYTE currentUserIndex)
{

	//手牌 和mCanDingCaiCard 对比。值=4的 则可以当作财神

	for (int i = 0; i < MAX_INDEX;i++)
	{
		if (cardsIndex[i]==0)
		{
			//不是手牌的先排除
			continue;
		}
		if (mCanDingCaiCardArray[currentUserIndex][i] == 4)
		{
			CanMadeMagic macgic;
			macgic.firstIndex = i;
			macgic.SecIndex = MAX_INDEX;
			vCards.push_back(macgic);
			int NextIndex = m_GameLogic.SwitchToCardIndex(GetNextMagicCardData(m_GameLogic.SwitchToCardData(i)));
			if (mCanDingCaiCardArray[currentUserIndex][NextIndex] == 4 && cardsIndex[NextIndex]>0)
			{
				CanMadeMagic macgic;
				macgic.firstIndex = i;
				macgic.SecIndex = m_GameLogic.SwitchToCardIndex(GetNextMagicCardData(m_GameLogic.SwitchToCardData(i)));
				vCards.push_back(macgic);
			}
		}
	}


// 
// 
// 	BYTE TempUserCards[MAX_INDEX] = { 0 };
// 	CopyMemory(TempUserCards, cardsIndex, MAX_INDEX);
// 	BYTE WeaveCards[MAX_COUNT] = { 0 };
// 	int nCount = 0;
// 	GetOneWeaveItemCards(WeaveItem, cbWeaveCount, WeaveCards, nCount);
// 
// 	for (int i = 0; i < nCount; i++)
// 	{
// 		int nIndex = m_GameLogic.SwitchToCardIndex(WeaveCards[i]);
// 		TempUserCards[nIndex] = 0;
// 	}
// 	for (int i = 0; i < MAX_INDEX; i++)
// 	{
// 		if (TempUserCards[i] == 0)
// 		{
// 			continue;
// 		}
// 		CanMadeMagic macgic;
// 		macgic.firstIndex = i;
// 		macgic.SecIndex = MAX_INDEX;
// 		vCards.push_back(macgic);
// 
// 		if (TempUserCards[m_GameLogic.SwitchToCardIndex(GetNextMagicCardData(m_GameLogic.SwitchToCardData(i)))]>0)
// 		{
// 			CanMadeMagic macgic;
// 			macgic.firstIndex = i;
// 			macgic.SecIndex = m_GameLogic.SwitchToCardIndex(GetNextMagicCardData(m_GameLogic.SwitchToCardData(i)));
// 			vCards.push_back(macgic);
// 		}
// 
// 	}
	return true;
}

byte CTableFrameSink_dcs::GetTaiNumFromCards(BYTE* cardsIndex, WORD wChairID, BYTE cbCenterCard, BYTE firstIndex, BYTE secIndex, bool bQiangGang/*=false*/)
{
	CGameLogic_dcs dscLogic(this);
	dscLogic.SetMagicIndex(firstIndex, secIndex);
	CChiHuRight chr;
	BYTE TaiShu = 0;
	BYTE szCardIndex[MAX_INDEX] = { 0 };
	CopyMemory(szCardIndex, cardsIndex, MAX_INDEX);
	szCardIndex[dscLogic.SwitchToCardIndex(cbCenterCard)]++;
	if (dscLogic.AnalyseCardNew(szCardIndex, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]))
	{
		dscLogic.mSunTaiJiangInColor = dscLogic.mJiangInColor;
		int nMagicCount = dscLogic.GetMaigcCardCount(szCardIndex);
		if (bQiangGang&&nMagicCount!=0)
		{
			BYTE szCardIndexDeleteMagic[MAX_INDEX] = { 0 };
			CopyMemory(szCardIndexDeleteMagic, cardsIndex, MAX_INDEX);
	
			CChiHuRight chihuright;
			
			if (WIK_ZI_MO == dscLogic.AnalyseChiHuCard_DeleteMagic(szCardIndexDeleteMagic, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], cbCenterCard, chihuright, TaiShu, FALSE, TRUE))
			{
				return TaiShu;
			}
			return 0;
		}

		dscLogic.m_cbHuCard = cbCenterCard;
		int TmpJiangInColor = dscLogic.mJiangInColor;
		dscLogic.mSunTaiJiangInColor = dscLogic.mJiangInColor;
		int nTai = dscLogic.AnalyseCardTaiNum(szCardIndex, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID], bQiangGang==TRUE?FALSE:TRUE);
		if (bQiangGang)
		{
			nTai++;
		}
		if (m_bUsersGangStatus[wChairID]==TRUE)
		{
			nTai++;
		}
		if (nTai>=3)
		{
			if (dscLogic.AnalyseCardTaiNum_IsDuMagic(szCardIndex, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]))
			{
				nTai++;
			}
			if (dscLogic.AnalyseCardTaiNum_IsQuanZi(szCardIndex, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]))
			{
				nTai = 7;
			}
		}
	
// 		if (dscLogic.AnalyseCardTaiNum_IsWuMagic(szCardIndex, m_WeaveItemArray[wChairID], m_cbWeaveItemCount[wChairID]))
// 		{
// 			nTai = 7;
// 		}

		return nTai;

	}
	// 	BYTE TempAction = dscLogic.AnalyseChiHuCard(m_cbCardIndex[wChairID], m_WeaveItemArray[wChairID],
	// 		m_cbWeaveItemCount[wChairID], m_cbSendCardData, chr, TaiShu,false,bQiangGang);
	// 	if (TempAction == WIK_ZI_MO)
	// 	{
	// 		return TaiShu;
	// 	}
	return 0;
}

BOOL CTableFrameSink_dcs::IsCanTianhu()
{
	if (m_cbOutCardCount>0)
	{
		return FALSE;
	}
	if (m_bTwoPlayerFlag)
	{
		if (m_cbSendCardCount != ((13 * mPlayGameUserCount-1) + 1))
		{
			return FALSE;
		}
	}
	else
	{
		if (m_cbSendCardCount != ((13 * mPlayGameUserCount) + 1))
		{
			return FALSE;
		}
	}

	return TRUE;
	// 打出牌数目为0  并且 m_cbSendCardCount 发牌数据等于玩家数+1 
}


//被动操作删除手牌
bool CTableFrameSink_dcs::DeleteCaiShenCard(WORD wTargetUser, BYTE cbTargetCaiCard[4], int cbTargetAction, BYTE cbTargetCard)
{
	switch (cbTargetAction)
	{
	case WIK_LEFT:		//上牌操作,左吃
	{
		//删除扑克
		BYTE cbRemoveCard[3];
		BYTE cbMagicCard[4] = { 0 };
		m_GameLogic.GetWeaveCard(WIK_LEFT, cbTargetCard, cbMagicCard, cbRemoveCard);
		VERIFY(m_GameLogic.RemoveCard(cbRemoveCard, 3, &cbTargetCard, 1));
		VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, 2));
		return true;
	}
	case WIK_RIGHT:		//上牌操作,右吃
	{
		//删除扑克
		BYTE cbRemoveCard[3];
		BYTE cbMagicCard[4] = { 0 };
		m_GameLogic.GetWeaveCard(WIK_RIGHT, cbTargetCard, cbMagicCard, cbRemoveCard);
		VERIFY(m_GameLogic.RemoveCard(cbRemoveCard, 3, &cbTargetCard, 1));
		VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, 2));
		return true;
	}
	case WIK_CENTER:	//上牌操作,中吃
	{
		//删除扑克
		BYTE cbRemoveCard[3];
		BYTE cbMagicCard[4] = { 0 };
		m_GameLogic.GetWeaveCard(WIK_CENTER, cbTargetCard, cbMagicCard, cbRemoveCard);
		VERIFY(m_GameLogic.RemoveCard(cbRemoveCard, 3, &cbTargetCard, 1));
		VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, 2));
		return true;
	}
	case WIK_PENG:		//碰牌操作
	{
		//删除扑克
		if (m_cbCardIndex[wTargetUser][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)] < 2)
		{
			ASSERT(false);
			return false;
		}
		BYTE cbRemoveCard[] = { cbTargetCard, cbTargetCard };
		VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, 2));
		return true;
	}
	case WIK_MING_GANG:		//明杠牌操作
	case WIK_BU_GANG:
	{
		if (m_cbCardIndex[wTargetUser][m_GameLogic.SwitchToCardIndex(m_cbProvideCard)] != 3)
		{
			ASSERT(false);
			return false;
		}
		BYTE cbRemoveCard[] = { cbTargetCard, cbTargetCard, cbTargetCard };
		VERIFY(m_GameLogic.RemoveCard(m_cbCardIndex[wTargetUser], cbRemoveCard, CountArray(cbRemoveCard)));
		if (mPlayGameUserCount == 4)
		{
			mBCanShowLeft = FALSE;
			mTempLeftCount = m_cbLeftCardCount;
			if (m_cbLeftCardCount > 6)//扣除3墩可摸的牌
			{
				m_cbLeftCardCount -= 6;
		
			}
				
			else//少于三墩就只有一张可以抓的牌咯
			{
				mTempLeftCount = m_cbLeftCardCount;
			
			}
		}
		if (mPlayGameUserCount != 4)
		{
			mBCanShowLeft = FALSE;
			if (m_cbLeftCardCount > 4)//扣除2墩可摸的牌
			{
				m_cbLeftCardCount -= 4;
			
			}
				
			else//少于二墩就只有一张可以抓的牌咯
			{
				
				m_cbLeftCardCount = 1;
			}
		}

		m_cbGangCount++;//打了几个杠
		return true;
	}
	default:
	{
		ASSERT(false);
		return false;
	}
	}
}
//自主操作删除手牌
bool CTableFrameSink_dcs::DeleteCard(WORD wChairID, BYTE cbCaiShenCard[4], int cbOperateCode, BYTE cbOperateCard)
{
	switch (cbOperateCode)
	{
	case WIK_AN_GANG:			//暗杠牌操作
	{
		//扑克效验
		ASSERT((cbOperateCode == WIK_AN_GANG) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
		if ((cbOperateCode != WIK_AN_GANG) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
			return false;
		//变量定义
		BYTE cbWeaveIndex = 0xFF;
		BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
		//杠牌处理
		if (m_cbCardIndex[wChairID][cbCardIndex] == 4)
		{
			//扑克效验
			ASSERT(m_cbCardIndex[wChairID][cbCardIndex] == 4);
			if (m_cbCardIndex[wChairID][cbCardIndex] != 4)
			{
				ASSERT(false);
				return 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
		{
			ASSERT(FALSE);
			return false;
		}
		//删除扑克
		m_cbCardIndex[wChairID][cbCardIndex] = 0;
		//////////////////////////////////////////////////////////////////////////
		if (mPlayGameUserCount == 4)
		{
			mBCanShowLeft = FALSE;
			mTempLeftCount = m_cbLeftCardCount;
			if (m_cbLeftCardCount > 6)//扣除3墩可摸的牌
			{
				m_cbLeftCardCount -= 6;
				
			}

			else//少于三墩就只有一张可以抓的牌咯
			{
			
				m_cbLeftCardCount = 1;
			}
		}
		if (mPlayGameUserCount != 4)
		{
			mBCanShowLeft = FALSE;
			if (m_cbLeftCardCount > 4)//扣除2墩可摸的牌
			{
				m_cbLeftCardCount -= 4;
		
			}

			else//少于二墩就只有一张可以抓的牌咯
			{

				m_cbLeftCardCount = 1;
			}
		}
		//////////////////////////////////////////////////////////////////////////

		m_cbGangCount++;//打了几个杠
		return true;
	}
	case WIK_BU_GANG:
	{
		//扑克效验
		ASSERT((cbOperateCode == WIK_NULL) || (cbOperateCode == WIK_BU_GANG) || (m_GameLogic.IsValidCard(cbOperateCard) == true));
		if ((cbOperateCode != WIK_BU_GANG) && (m_GameLogic.IsValidCard(cbOperateCard) == false))
			return false;
		BYTE cbWeaveIndex = 0xFF;
		BYTE cbCardIndex = m_GameLogic.SwitchToCardIndex(cbOperateCard);
		//杠牌处理
		if (m_cbCardIndex[wChairID][cbCardIndex] >= 1)//表示续杠类型
		{
			//寻找组合
			for (BYTE i = 0; i < m_cbWeaveItemCount[wChairID]; i++)
			{
				INT cbWeaveKind = m_WeaveItemArray[wChairID][i].cbWeaveKind;
				BYTE cbCenterCard = m_WeaveItemArray[wChairID][i].cbCenterCard;
				if ((cbCenterCard == cbOperateCard) && (cbWeaveKind &(WIK_DAN_PENG | WIK_PENG | WIK_SHUANG_PENG)))
				{
					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 = cbOperateCard;
		}
		else
		{
			ASSERT(false);
			return false;
		}
		//删除扑克
		m_cbCardIndex[wChairID][cbCardIndex] -= 1;
		if (mPlayGameUserCount == 4)
		{
			mBCanShowLeft = FALSE;
			mTempLeftCount = m_cbLeftCardCount;
			if (m_cbLeftCardCount > 6)//扣除3墩可摸的牌
			{
				m_cbLeftCardCount -= 6;
			
			}

			else//少于三墩就只有一张可以抓的牌咯
			{
				m_cbLeftCardCount = 1;
			}
		}
		if (mPlayGameUserCount != 4)
		{
			mBCanShowLeft = FALSE;
			if (m_cbLeftCardCount > 4)//扣除2墩可摸的牌
			{
				m_cbLeftCardCount -= 4;
			}

			else//少于二墩就只有一张可以抓的牌咯
			{
				m_cbLeftCardCount = 1;
			}
		}
		//////////////////////////////////////////////////////////////////////////

		m_cbGangCount++;//打了几个杠
		return true;
	}
	default:
	{
		ASSERT(false);
		return false;
	};
	}
}
//优先级判断
/*
提供牌的用户
当前操作的用户
当前用户的操作
*/
bool CTableFrameSink_dcs::OperatorPriority(WORD TmpwProvideUser, WORD &wOptUser, int &cbTargetAction)
{
	for (WORD UserPlayIndex = 0; UserPlayIndex < mPlayGameUserCount; UserPlayIndex++)//除了打牌人,操作人与其他两位对操作优先级
	{
		if (m_bTwoPlayerFlag&&UserPlayIndex == TowMjNullseat)
		{
			continue;
		}
		TmpwProvideUser = (TmpwProvideUser + 1) % mPlayGameUserCount;//temp=temp->next
		if (TmpwProvideUser == wOptUser)continue;
		//获取动作
		int cbUserAction = (m_bResponse[TmpwProvideUser] == false) ? m_cbUserAction[TmpwProvideUser] : m_cbPerformAction[TmpwProvideUser];
		//优先级别
		BYTE cbUserActionRank = m_GameLogic.GetUserActionRank(cbUserAction);
		BYTE cbTargetActionRank = m_GameLogic.GetUserActionRank(cbTargetAction);
		//动作判断
		if (cbUserActionRank > cbTargetActionRank)
		{
			wOptUser = TmpwProvideUser;
			cbTargetAction = cbUserAction;
			continue;
		}
		if (cbUserActionRank == cbTargetActionRank && cbTargetActionRank != WIK_NULL)
		{
			if (UserPlayIndex == 2)//肯定和其他人都比了，最后一次两个人的操作一样，且表示操作人不在末端操作人
			{
				return true;
			}
			else if (UserPlayIndex == 1)//对比一次，对比了两次说明操作人不是下家的下家；操作人只能是第一家或者最后一家,如果是第一家操作：，如果是最后一家
			{
				WORD TempTempUser = (TmpwProvideUser + 1) % mPlayGameUserCount;
				if (wOptUser == TempTempUser)//确定操作人是最后一个,这是第二次对比
				{
					wOptUser = TmpwProvideUser;
					cbTargetAction = cbUserAction;
					return true;
				}
				else//第一次对比，确定操作人是出牌人下家，这个时候再把他和后面一个人的牌权对比
				{
					int cbUserAction = (m_bResponse[TempTempUser] == false) ? m_cbUserAction[TempTempUser] : m_cbPerformAction[TempTempUser];
					//优先级别
					BYTE cbUserActionRank = m_GameLogic.GetUserActionRank(cbUserAction);
					BYTE cbTargetActionRank = m_GameLogic.GetUserActionRank(cbTargetAction);
					if (cbUserActionRank > cbTargetActionRank)
					{
						wOptUser = TempTempUser;
						cbTargetAction = cbUserAction;
						return true;
					}
					break;
				}
			}
			else//冲上来就比了一次，说操作人不是打牌人下家
			{
				wOptUser = TmpwProvideUser;
				cbTargetAction = cbUserAction;
				WORD TempTempUser = (TmpwProvideUser + 1) % mPlayGameUserCount;
				if (wOptUser == TempTempUser)TempTempUser = (TempTempUser + 1) % mPlayGameUserCount;//如果在中间就换一个人
				int cbUserAction = (m_bResponse[TempTempUser] == false) ? m_cbUserAction[TempTempUser] : m_cbPerformAction[TempTempUser];
				//优先级别
				BYTE cbUserActionRank = m_GameLogic.GetUserActionRank(cbUserAction);
				BYTE cbTargetActionRank = m_GameLogic.GetUserActionRank(cbTargetAction);
				if (cbUserActionRank > cbTargetActionRank)
				{
					wOptUser = TempTempUser;
					cbTargetAction = cbUserAction;
					return true;
				}
				return true;
			}
		}
	}
	return true;
}

int CTableFrameSink_dcs::bHuPaiType(CChiHuRight &CChiHuRight)
{
	int hutype = 0;
	if (!(CChiHuRight&ZJ_TAI_QingYiSe).IsEmpty())
	{
		hutype |= ZJ_TAI_QingYiSe;
	}
	if (!(CChiHuRight&ZJ_TAI_DongFeng).IsEmpty())
	{
		hutype |= ZJ_TAI_DongFeng;
	}
	if (!(CChiHuRight&ZJ_TAI_WuMagic).IsEmpty())
	{
		hutype |= ZJ_TAI_WuMagic;
	}
	if (!(CChiHuRight&ZJ_TAI_QuanShun).IsEmpty())
	{
		hutype |= ZJ_TAI_QuanShun;
	}
	if (!(CChiHuRight&ZJ_TAI_PengPeng).IsEmpty())
	{
		hutype |= ZJ_TAI_PengPeng;
	}
	if (!(CChiHuRight&ZJ_TAI_HunYiSe).IsEmpty())
	{
		hutype |= ZJ_TAI_HunYiSe;
	}
// 	if (!(CChiHuRight&ZJ_TAI_Gang).IsEmpty())
// 	{
// 		hutype |= ZJ_TAI_Gang;
// 	}
	if (!(CChiHuRight&ZJ_TAI_ZFB).IsEmpty())
	{
		hutype |= ZJ_TAI_ZFB;
	}
	if (!(CChiHuRight&ZJ_TAI_QuanZi).IsEmpty())
	{
		hutype |= ZJ_TAI_QuanZi;
	}
	if (!(CChiHuRight&ZJ_TAI_ZHAHU).IsEmpty())
	{
		hutype = ZJ_TAI_ZHAHU;
	}
	if (!(CChiHuRight&ZJ_TAI_Gang).IsEmpty())//单财胡
	{
		OutputDebugString(_T("增加 单财胡 +1"));
		hutype |= ZJ_TAI_Gang;
	}

	return hutype;
}