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

const WORD		CTableFrameSink::m_wPlayerCount = GAME_PLAYER;				//游戏人数;
tagGameRuleCfg	CTableFrameSink::m_stGameRuleCfg;							//房间规则;

enum tagServerTimerEnum
{
	IDI_SEND_CARD = 1,		//发牌计时器;
	IDI_ROB_BANKER,			//抢庄计时器;
	IDI_USER_CHIP,			//下注计时器;
	IDI_OPEN_CARD,			//开牌计时器;
	IDI_GAME_END,			//结束定时器;

	IDT_SEND_CARD = 10000,	//发牌时间;
	IDT_ROB_BANKER = 20000, //抢庄时间;
	IDT_USER_CHIP = 20000,	//下注时间;
	IDT_OPEN_CARD = 20000,	//开牌时间;
	IDT_GAME_END = 2000,	//结束时间;
};

CTableFrameSink::CTableFrameSink()
: m_pITableFrame(nullptr)
, m_pGameServiceOption(nullptr)
, m_dwOwnerID(INVALID_DWORD)
, m_pOpenRuleCfg(nullptr)
{
	m_cbRobBankerCount = 0;
	m_wBankerUser = INVALID_CHAIR;
	ZeroMemory(m_lTableScore, sizeof(m_lTableScore));
	ZeroMemory(m_bActiveUser, sizeof(m_bActiveUser));
	ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
	ZeroMemory(m_cbHandCardCount, sizeof(m_cbHandCardCount));
	ZeroMemory(m_cbHandCardData, sizeof(m_cbHandCardData));
	ZeroMemory(m_wRobBankerUser, sizeof(m_wRobBankerUser));
	ZeroMemory(m_stOpenCardRlt, sizeof(m_stOpenCardRlt));

	ZeroMemory(&m_PrivateEndInfo, sizeof(CMD_S_Private_End_Info));
}

CTableFrameSink::~CTableFrameSink(void)
{
	SafeDelete(m_pOpenRuleCfg);
}

void * CTableFrameSink::QueryInterface(const IID &Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(ITableFrameSink, Guid, dwQueryVer);
	QUERYINTERFACE(ITableUserAction, Guid, dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(ITableFrameSink, Guid, dwQueryVer);
	return nullptr;
}

bool CTableFrameSink::Initialization(IUnknownEx * pIUnknownEx)
{
	ASSERT(nullptr != pIUnknownEx);
	m_pITableFrame = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, ITableFrame);
	ASSERT(nullptr != m_pITableFrame);
	if (nullptr == m_pITableFrame) return false;

	m_pGameServiceOption = m_pITableFrame->GetGameServiceOption();
	ASSERT(nullptr != m_pGameServiceOption);
	if (nullptr == m_pGameServiceOption) return false;

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

	return true;
}

void CTableFrameSink::RepositionSink()
{
	m_cbRobBankerCount = 0;

	ZeroMemory(m_lTableScore, sizeof(m_lTableScore));
	ZeroMemory(m_bActiveUser, sizeof(m_bActiveUser));
	ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
	ZeroMemory(m_cbHandCardCount, sizeof(m_cbHandCardCount));
	ZeroMemory(m_cbHandCardData, sizeof(m_cbHandCardData));
	ZeroMemory(m_wRobBankerUser, sizeof(m_wRobBankerUser));
	ZeroMemory(m_stOpenCardRlt, sizeof(m_stOpenCardRlt));
	if (IsFixBankerMode())
	{
		ASSERT(m_wBankerUser>=0 && m_wBankerUser<GAME_PLAYER);
	}
	else
	{
		m_wBankerUser = INVALID_CHAIR;
	}
}

//游戏状态;
bool CTableFrameSink::IsUserPlaying(WORD wChairID)
{
	return wChairID >= 0 && wChairID < GAME_PLAYER && m_bActiveUser[wChairID];
}

bool CTableFrameSink::OnActionUserSitDown(WORD wChairID, IServerUserItem *pIServerUserItem, bool bLookonUser)
{
	if (!bLookonUser && IsFixBankerMode() && INVALID_CHAIR==m_wBankerUser)
	{
		if (INVALID_DWORD==m_dwOwnerID || pIServerUserItem->GetUserID()==m_dwOwnerID)
		{
			m_wBankerUser = pIServerUserItem->GetChairID();
		}
	}
	return true;
}

bool CTableFrameSink::OnActionUserStandUp(WORD wChairID, IServerUserItem *pIServerUserItem, bool bLookonUser)
{
	if (!bLookonUser && m_pITableFrame->GetSitUserCount()==0)
	{
		m_wBankerUser = INVALID_CHAIR;
	}
	return true;
}

bool CTableFrameSink::OnTimerMessage(DWORD wTimerID, WPARAM wBindParam)
{
	const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
	switch (wTimerID)
	{
	case IDI_SEND_CARD:
	{
		return OnUserSendCard(INVALID_CHAIR);
	}
	case IDI_ROB_BANKER:
	{
		return OnUserRobBanker(INVALID_CHAIR, false);
	}
	case IDI_USER_CHIP:
	{
		return OnUserChipScore(INVALID_CHAIR, 3);
	}
	case IDI_OPEN_CARD:
	{
		return OnUserOpenCard(INVALID_CHAIR);
	}
	case IDI_GAME_END:
	{
		return OnEventGameConclude(INVALID_CHAIR, nullptr, GER_NORMAL);
	}
	}
	return true;
}

bool CTableFrameSink::OnGameMessage(WORD wSubCmdID, VOID * pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)
{
	switch (wSubCmdID)
	{
	case SUB_C_SEND_OVER:
		{
			ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
			if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;

			WORD && wChairID = pIServerUserItem->GetChairID();
			ASSERT(IsUserPlaying(wChairID));
			if (!IsUserPlaying(wChairID)) return true;

			return OnUserSendCard(wChairID);
		}
	case SUB_C_ROB_BANKER:
		{
			ASSERT(sizeof(CMD_C_RobBanker) == wDataSize);
			if (sizeof(CMD_C_RobBanker) != wDataSize) return false;

			ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
			if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;

			WORD && wChairID = pIServerUserItem->GetChairID();
			ASSERT(IsUserPlaying(wChairID));
			if (!IsUserPlaying(wChairID)) return true;

			CMD_C_RobBanker *pRobBanker = (CMD_C_RobBanker *)pDataBuffer;
			return OnUserRobBanker(wChairID, pRobBanker->bRob);
		}
	case SUB_C_CHIP_SCORE:
		{
			ASSERT(sizeof(CMD_C_ChipScore) == wDataSize);
			if (sizeof(CMD_C_ChipScore) != wDataSize) return false;

			ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
			if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;

			WORD && wChairID = pIServerUserItem->GetChairID();
			ASSERT(IsUserPlaying(wChairID));
			if (!IsUserPlaying(wChairID)) return true;

			CMD_C_ChipScore *pChipScore = (CMD_C_ChipScore *)pDataBuffer;
			return OnUserChipScore(wChairID, pChipScore->lScore);
		}
	case SUB_C_OPEN_CARD:
		{
			ASSERT(pIServerUserItem->GetUserStatus() == US_PLAYING);
			if (pIServerUserItem->GetUserStatus() != US_PLAYING) return true;

			WORD && wChairID = pIServerUserItem->GetChairID();
			ASSERT(IsUserPlaying(wChairID));
			if (!IsUserPlaying(wChairID)) return true;

			return OnUserOpenCard(wChairID);
		}
	}
	ASSERT(0);
	return false;
}

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

bool CTableFrameSink::OnEventSendGameScene(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbGameStatus, bool bSendSecret)
{
	switch (cbGameStatus)
	{
	case GS_NN_FREE:
		{
			CMD_S_StatusFree stStatusFree = { 0 };
			stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
			stStatusFree.lMinFreeChip = GetMinFreeChip();
			stStatusFree.lMaxFreeChip = GetMaxFreeChip();

			return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusFree, sizeof(stStatusFree));
		}
	case GS_NN_SEND_CARD:
		{
			CMD_S_StatusSend stStatusSend = { 0 };
			stStatusSend.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
			stStatusSend.stStatusFree.lMinFreeChip = GetMinFreeChip();
			stStatusSend.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
			//stStatusSend.stStatusFree.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
			stStatusSend.stStatusFree.cbHandCardCount = MAX_COUNT;
			CopyMemory(stStatusSend.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
			stStatusSend.wBankerUser = m_wBankerUser;
			stStatusSend.cbSendStatus = m_cbUserResponse[wChairID];

			//翻四张抢庄模式;
			//if (m_bActiveUser[wChairID] && BANKER_ROB4 == GetValidConfig()->wBankerRule)
			if (m_bActiveUser[wChairID])
			{
				if (IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
				{
					CopyMemory(stStatusSend.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				}

				//if (IsHasSpecialNiu())
				//{
				//	CopyMemory(stStatusSend.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				//}
				//else if (IsBayonetMode() || (wChairID == m_wBankerUser))
				//{
				//	CopyMemory(stStatusSend.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				//}
			}

			return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusSend, sizeof(stStatusSend));
		}
	case GS_NN_ROB_BANKER:
		{
			ASSERT(INVALID_CHAIR == m_wBankerUser);

			CMD_S_StatusRob stStatusRob = { 0 };
			stStatusRob.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
			stStatusRob.stStatusFree.lMinFreeChip = GetMinFreeChip();
			stStatusRob.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
			//stStatusRob.stStatusFree.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
			stStatusRob.stStatusFree.cbHandCardCount = MAX_COUNT;
			CopyMemory(stStatusRob.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
			CopyMemory(stStatusRob.cbRobStatus, m_cbUserResponse, sizeof(m_cbUserResponse));

			//翻四张抢庄模式;
			//if (m_bActiveUser[wChairID] && BANKER_ROB4 == GetValidConfig()->wBankerRule)
			if (m_bActiveUser[wChairID] && IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
			{
				CopyMemory(stStatusRob.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));

				//if (IsHasSpecialNiu())
				//{
				//	CopyMemory(stStatusRob.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				//}
				//else if (IsBayonetMode() || (wChairID == m_wBankerUser))
				//{
				//	CopyMemory(stStatusRob.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				//}
			}

			return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusRob, sizeof(stStatusRob));
		}
	case GS_NN_USER_CHIP:
		{
			ASSERT(m_wBankerUser>=0 && m_wBankerUser<GAME_PLAYER && IsUserPlaying(m_wBankerUser));
			CMD_S_StatusChip stStatusChip = { 0 };
			stStatusChip.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
			stStatusChip.stStatusFree.lMinFreeChip = GetMinFreeChip();
			stStatusChip.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
			//stStatusChip.stStatusFree.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
			stStatusChip.stStatusFree.cbHandCardCount = MAX_COUNT;
			CopyMemory(stStatusChip.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
			CopyMemory(stStatusChip.cbChipStatus, m_cbUserResponse, sizeof(m_cbUserResponse));
			CopyMemory(stStatusChip.lUserChipScore, m_lTableScore, sizeof(m_lTableScore));
			stStatusChip.wBankerUser = m_wBankerUser;

			//翻四张抢庄模式;
			//if (m_bActiveUser[wChairID] && BANKER_ROB4 == GetValidConfig()->wBankerRule)
			if (m_bActiveUser[wChairID] && IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
			{
				CopyMemory(stStatusChip.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));

				//if (IsHasSpecialNiu())
				//{
				//	CopyMemory(stStatusChip.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				//}
				//else if (IsBayonetMode() || (wChairID == m_wBankerUser))
				//{
				//	CopyMemory(stStatusChip.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT - 1));
				//}
			}

			return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusChip, sizeof(stStatusChip));
		}
	case GS_NN_OPEN_CARD:
		{
			//ASSERT(IsUserPlaying(m_wBankerUser));
			CMD_S_StatusOpen stStatusOpen = { 0 };

			stStatusOpen.wBankerUser = m_wBankerUser;
			stStatusOpen.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
			stStatusOpen.stStatusFree.lMinFreeChip = GetMinFreeChip();
			stStatusOpen.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
			stStatusOpen.stStatusFree.cbHandCardCount = MAX_COUNT;
			CopyMemory(stStatusOpen.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
			CopyMemory(stStatusOpen.lUserChipScore, m_lTableScore, sizeof(m_lTableScore));

			CopyMemory(stStatusOpen.cbOpenStatus, m_cbUserResponse, sizeof(m_cbUserResponse));

			//玩家自己;
			//stStatusOpen.cbOpenStatus = m_cbUserResponse[wChairID];
			if (m_bActiveUser[wChairID] && (0 == m_cbUserResponse[wChairID]))
			{
				CopyMemory(stStatusOpen.cbHandCardData, m_cbHandCardData[wChairID], sizeof(BYTE)*(MAX_COUNT));
			}
			else if (m_bActiveUser[wChairID] && 1 == m_cbUserResponse[wChairID])
			{
				stStatusOpen.cbHandCardType= m_stOpenCardRlt[wChairID].cbCardType;
				CopyMemory(stStatusOpen.cbHandCardData, m_stOpenCardRlt[wChairID].cbSortCard, sizeof(m_stOpenCardRlt[wChairID].cbSortCard));
			}

			return m_pITableFrame->SendGameScene(pIServerUserItem, &stStatusOpen, sizeof(stStatusOpen));
		}
	case GS_NN_SHOW_CARD:
	{
		CMD_S_StatusAllOpen stAllOpen;
		ZeroMemory(&stAllOpen, sizeof(CMD_S_StatusAllOpen));

		stAllOpen.wBankerUser = m_wBankerUser;

		stAllOpen.stStatusFree.lCellScore = m_pITableFrame->GetCellScore();
		stAllOpen.stStatusFree.lMinFreeChip = GetMinFreeChip();
		stAllOpen.stStatusFree.lMaxFreeChip = GetMaxFreeChip();
		stAllOpen.stStatusFree.cbHandCardCount = MAX_COUNT;
		CopyMemory(stAllOpen.stStatusFree.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));

		CopyMemory(stAllOpen.lUserChipScore, m_lTableScore, sizeof(m_lTableScore));
		CopyMemory(stAllOpen.cbOpenStatus, m_cbUserResponse, sizeof(m_cbUserResponse));

		//所有人牌;
		for (WORD i = 0; i < m_wPlayerCount; ++i)
		{
			if (!m_bActiveUser[i]) continue;

			stAllOpen.cbHandCardType[i] = m_stOpenCardRlt[i].cbCardType;
			CopyMemory(stAllOpen.cbHandCardData[i], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
		}

		return m_pITableFrame->SendGameScene(pIServerUserItem, &stAllOpen, sizeof(stAllOpen));
	}
	}

	ASSERT(0);
	return false;
}

bool CTableFrameSink::OnEventGameStart()
{
	//RepositionSink();
	srand(GetTickCount());

	BYTE cbCardBuffer[MAX_COUNT*GAME_PLAYER] = { 0 };
	//m_GameLogic.RandCardList(reinterpret_cast<BYTE *>(m_cbHandCardData), sizeof(m_cbHandCardData), ((GetValidConfig()->wGameRule&RULE_HUA_NIU)==0));
	m_GameLogic.RandCardList(reinterpret_cast<BYTE *>(m_cbHandCardData), sizeof(m_cbHandCardData), false);
	
	for (WORD i = 0; i < m_wPlayerCount; ++i)
	{
		IServerUserItem * pIServerUserItem = m_pITableFrame->GetTableUserItem(i);
		if (nullptr == pIServerUserItem) continue;
		//if (pIServerUserItem->GetUserStatus() != US_PLAYING) continue;

		BYTE cbUserStatus = pIServerUserItem->GetUserStatus();
		BYTE cbReUserStatus = pIServerUserItem->GetReUserStatus();
		if (cbUserStatus == US_PLAYING || (US_OFFLINE == cbUserStatus && cbReUserStatus == US_PLAYING))
		{
			m_bActiveUser[i] = true;
		}
	}

	for (WORD i = 0; i < m_wPlayerCount; ++i)
	{
		m_PrivateEndInfo.aryActiveStatus[i] = m_bActiveUser[i];
	}

	CMD_S_GameStart stGameStart = { 0 };
	stGameStart.wBankerUser = m_wBankerUser;
	//stGameStart.cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
	stGameStart.cbHandCardCount = MAX_COUNT;
	CopyMemory(stGameStart.bActiveStatus, m_bActiveUser, sizeof(m_bActiveUser));
	for (WORD i=0; i<m_wPlayerCount; ++i)
	{
		ZeroMemory(&stGameStart.cbHandCardData, sizeof(stGameStart.cbHandCardData));
		//if ( && BANKER_ROB4==GetValidConfig()->wBankerRule)
		if (m_bActiveUser[i] && IsHasGameRule(eNNRuleEnum_BANKER_ROB4))
		{
			ASSERT(MAX_COUNT == stGameStart.cbHandCardCount);
			CopyMemory(&stGameStart.cbHandCardData, m_cbHandCardData[i], sizeof(BYTE)*(MAX_COUNT-1));
		}

		//if (m_bActiveUser[i])
		//{
		//	if (IsHasSpecialNiu())
		//	{
		//		ASSERT(MAX_COUNT == stGameStart.cbHandCardCount);
		//		CopyMemory(&stGameStart.cbHandCardData, m_cbHandCardData[i], sizeof(BYTE)*(MAX_COUNT - 1));
		//	}
		//	else if (IsBayonetMode() || (i == m_wBankerUser))
		//	{
		//		ASSERT(MAX_COUNT == stGameStart.cbHandCardCount);
		//		CopyMemory(&stGameStart.cbHandCardData, m_cbHandCardData[i], sizeof(BYTE)*MAX_COUNT);
		//	}
		//}

		m_pITableFrame->SendTableData(i, SUB_S_GAME_START, &stGameStart, sizeof(stGameStart));
	}
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_START, &stGameStart, sizeof(stGameStart));

	m_pITableFrame->SetGameStatus(GS_NN_SEND_CARD);
	m_pITableFrame->SetGameTimer(IDI_SEND_CARD, IDT_SEND_CARD, 1, 0);
	return true;
}

bool CTableFrameSink::OnEventGameConclude(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
{
	KillAllTimer();
	m_pITableFrame->KillGameTimer(IDI_GAME_END);

	m_pITableFrame->SetGameStatus(GS_NN_FREE);

	ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));

	switch (cbReason)
	{
	case GER_DISMISS:
		{
			CMD_S_GameEnd stGameEnd = { 0 };
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
			return m_pITableFrame->ConcludeGame(GAME_STATUS_FREE);
		}
	case GER_NORMAL:
		{
			CMD_S_GameEnd stGameEnd = { 0 };
			
			// 拼刺刀模式;
			if (IsBayonetMode())
			{
				ASSERT(m_wBankerUser == INVALID_CHAIR);

				// 寻找最大玩家;
				WORD wWinChairID = INVALID_CHAIR;

				for (WORD i = 0; i < m_wPlayerCount; ++i)
				{
					if (!m_bActiveUser[i]) continue;

					if (wWinChairID == INVALID_CHAIR)
					{
						wWinChairID = i;
					}
					else
					{
						if (!m_GameLogic.CompareCard(m_stOpenCardRlt[wWinChairID], m_stOpenCardRlt[i]))
						{
							wWinChairID = i;
						}
					}
				}

				// 算分;
				LONG lNiuMulti = m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[wWinChairID].cbCardType);

				for (WORD i = 0; i < m_wPlayerCount; ++i)
				{
					if (!m_bActiveUser[i]) continue;
					stGameEnd.cbCardType[i] = m_stOpenCardRlt[i].cbCardType;
					CopyMemory(&stGameEnd.cbHandCardData[i], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
					
					if (i == wWinChairID) continue;

					stGameEnd.lGameScore[wWinChairID] += (m_lTableScore[i] * lNiuMulti);
					stGameEnd.lGameScore[i] = -(m_lTableScore[i] * lNiuMulti);
				}
			}
			else  
			{
				ASSERT(IsUserPlaying(m_wBankerUser));

				// 其他模式;
				for (WORD i = 0; i < m_wPlayerCount; ++i)
				{
					if (!m_bActiveUser[i]) continue;
					stGameEnd.cbCardType[i] = m_stOpenCardRlt[i].cbCardType;
					CopyMemory(&stGameEnd.cbHandCardData[i], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));
					if (i == m_wBankerUser) continue;

					if (m_GameLogic.CompareCard(m_stOpenCardRlt[m_wBankerUser], m_stOpenCardRlt[i]))
					{
						//LONG lNiuMulti = IsHaveNiuFanMode() ? m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[m_wBankerUser].cbCardType) : 1;
						LONG lNiuMulti = m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[m_wBankerUser].cbCardType);
						stGameEnd.lGameScore[m_wBankerUser] += (m_lTableScore[i] * lNiuMulti);
						stGameEnd.lGameScore[i] = -(m_lTableScore[i] * lNiuMulti);
					}
					else
					{
						//LONG lNiuMulti = IsHaveNiuFanMode() ? m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[i].cbCardType) : 1;
						LONG lNiuMulti = m_GameLogic.GetWinNiuFan(m_stOpenCardRlt[i].cbCardType);
						stGameEnd.lGameScore[m_wBankerUser] -= (m_lTableScore[i] * lNiuMulti);
						stGameEnd.lGameScore[i] = m_lTableScore[i] * lNiuMulti;
					}
				}
			}

			//计算税收;
			LONG lRevenue[GAME_PLAYER] = { 0 };
			for (WORD i=0; i<m_wPlayerCount; ++i)
			{
				if (!m_bActiveUser[i]) continue;
				lRevenue[i] = static_cast<LONG>(m_pITableFrame->CalculateRevenue(i, stGameEnd.lGameScore[i]));
				stGameEnd.lGameScore[i] -= lRevenue[i];
				stGameEnd.lRevenue[i] = lRevenue[i];
			}
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END, &stGameEnd, sizeof(stGameEnd));

			//写分;
			tagScoreInfo ScoreInfoArray[GAME_PLAYER];
			ZeroMemory(ScoreInfoArray, sizeof(ScoreInfoArray));
			for (WORD i=0; i<m_wPlayerCount; ++i)
			{
				if (!m_bActiveUser[i]) continue;

				ScoreInfoArray[i].cbType = (stGameEnd.lGameScore[i] >= 0) ? SCORE_TYPE_WIN : SCORE_TYPE_LOSE;
				ScoreInfoArray[i].lRevenue = lRevenue[i];
				ScoreInfoArray[i].lScore = stGameEnd.lGameScore[i];
			}

			m_pITableFrame->addPrivatePlayCout(1);

			//牌局结束后,每8局增加一点经验值;
			if (IsPrivateEnd())
			{
				//tagPrivateFrameParameter* pPrivateFrame = m_pITableFrame->GetPrivateFrameInfo();
				//SCORE lGrade = pPrivateFrame->dwPlayCost;

				//for (WORD i = 0; i < GAME_PLAYER; i++)
				//{
				//	ScoreInfoArray[i].lGrade = lGrade;
				//}

				ScoreInfoArray[0].lGrade = 2;	//房主2倍;
				for (WORD i = 1; i < GAME_PLAYER; i++)
				{
					ScoreInfoArray[i].lGrade = 1;
				}
			}

			DataStream kDataStream;
			m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray), kDataStream);

			/********************************私人场统计****************************************/

			bool isAllWin = true;
			bool isAllLose = true;
			for (WORD i = 0; i < m_wPlayerCount; ++i)
			{
				if (!m_bActiveUser[i]) continue;

				// 赢次数;
				if (stGameEnd.lGameScore[i] >= 0)
				{
					m_PrivateEndInfo.aryResultTypeCount[i][NN_RT_WIN]++;
				}

				// 牛牛次数;
				if (stGameEnd.cbCardType[i] == NIU_TYPE_10)
				{
					m_PrivateEndInfo.aryResultTypeCount[i][NN_RT_NIUNIU]++;
				}

				if ((i != m_wBankerUser) && (stGameEnd.lGameScore[i] > 0))
				{
					// 有闲家赢，就不是通杀;
					if (stGameEnd.lGameScore[i] > 0)
					{
						isAllWin = false;
					}
					// 有闲家输，就不是通赔;
					else if (stGameEnd.lGameScore[i] < 0)
					{
						isAllLose = false;
					}
				}
			}

			if (isAllWin && m_wBankerUser < GAME_PLAYER)
			{
				m_PrivateEndInfo.aryResultTypeCount[m_wBankerUser][NN_RT_ALL_WIN]++;
			}

			if (isAllLose && m_wBankerUser < GAME_PLAYER)
			{
				m_PrivateEndInfo.aryResultTypeCount[m_wBankerUser][NN_RT_ALL_LOSE]++;
			}
			/********************************私人场统计****************************************/

			//处理庄家;
			if (IsRobBankerMode())
			{
				m_wBankerUser = INVALID_CHAIR;
			}
			//else if (BANKER_TURNS == GetValidConfig()->wBankerRule)
			if (IsHasGameRule(eNNRuleEnum_BANKER_TURNS))
			{
				WORD wNextUser = m_wBankerUser;
				for (WORD i=0; i<m_wPlayerCount; ++i)
				{
					if (++wNextUser == m_wPlayerCount)
					{
						wNextUser = 0;
					}
					if (m_bActiveUser[wNextUser])
					{
						m_wBankerUser = wNextUser;
						break;
					}
				}
			}

			m_pITableFrame->ConcludeGame(GAME_STATUS_FREE);
			return true;
		}
	}
	ASSERT(0);
	return false;
}

void CTableFrameSink::KillAllTimer()
{
	m_pITableFrame->KillGameTimer(IDI_SEND_CARD);
	m_pITableFrame->KillGameTimer(IDI_ROB_BANKER);
	m_pITableFrame->KillGameTimer(IDI_USER_CHIP);
	m_pITableFrame->KillGameTimer(IDI_OPEN_CARD);
}

//发送开始下注;
void CTableFrameSink::SendStartChip()
{
	ASSERT(IsUserPlaying(m_wBankerUser));

	CMD_S_StartChip stStartChip = { 0 };
	stStartChip.wBankerUser = m_wBankerUser;
	m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_START_CHIP, &stStartChip, sizeof(stStartChip));
	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_START_CHIP, &stStartChip, sizeof(stStartChip));

	m_pITableFrame->SetGameStatus(GS_NN_USER_CHIP);
	m_pITableFrame->SetGameTimer(IDI_USER_CHIP, IDT_USER_CHIP, 1, 0);
}

//是否由玩家没操作;
bool CTableFrameSink::IsUserNoOperate(bool bIgnoreBanker)
{
	if (bIgnoreBanker)
	{
		for (int i=0; i<m_wPlayerCount; ++i)
		{
			if (!m_bActiveUser[i]) continue;
			if (i == m_wBankerUser) continue;
			if (0 == m_cbUserResponse[i]) return true;
		}
	}
	else
	{
		for (int i=0; i<m_wPlayerCount; ++i)
		{
			if (!m_bActiveUser[i]) continue;
			if (0 == m_cbUserResponse[i]) return true;
		}
	}

	return false;
}

//发牌完成;
bool CTableFrameSink::OnUserSendCard(WORD wChairID)
{
	const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
	ASSERT(GS_NN_SEND_CARD == cbGameStatus);
	if (GS_NN_SEND_CARD != cbGameStatus) return true;

	if (INVALID_CHAIR != wChairID)
	{
		ASSERT(IsUserPlaying(wChairID));
		if (!IsUserPlaying(wChairID)) return true;
		ASSERT(0 == m_cbUserResponse[wChairID]);
		if (0 != m_cbUserResponse[wChairID]) return true;
		
		m_cbUserResponse[wChairID] = 1;
		if (IsUserNoOperate(false))	return true;
	}

	m_pITableFrame->KillGameTimer(IDI_SEND_CARD);
	ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));

	//抢庄模式;
	if (IsRobBankerMode())
	{
		ASSERT(INVALID_CHAIR == m_wBankerUser);
		
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_START_ROB);
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_START_ROB);

		m_pITableFrame->SetGameStatus(GS_NN_ROB_BANKER);
		m_pITableFrame->SetGameTimer(IDI_ROB_BANKER, IDT_ROB_BANKER, 1, 0);
	}
	else if (IsBayonetMode())
	{
		m_wBankerUser = INVALID_CHAIR;

		// 让各个玩家都明牌;
		for (int i = 0; i < m_wPlayerCount; ++i)
		{
			m_lTableScore[i] = 1;

			// 调用开牌把牌信息发送给客户端;
			CMD_S_OpenCard stOpenCard = { 0 };
			stOpenCard.wOpenUser = i;
			stOpenCard.cbCardType = 0;
			CopyMemory(stOpenCard.cbCardData, m_cbHandCardData[i], sizeof(m_cbHandCardData[i]));

			m_pITableFrame->SendTableData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
			m_pITableFrame->SendLookonData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
		}

		ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
		m_pITableFrame->SetGameStatus(GS_NN_OPEN_CARD);
		m_pITableFrame->SetGameTimer(IDI_OPEN_CARD, IDT_OPEN_CARD, 1, 0);
	}
	else
	{
		SendStartChip();
	}

	return true;
}

//叫庄事件;
bool CTableFrameSink::OnUserRobBanker(WORD wChairID, bool bRob)
{
	const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
	ASSERT(GS_NN_ROB_BANKER == cbGameStatus);
	if (GS_NN_ROB_BANKER != cbGameStatus) return true;

	//玩家操作;
	if (INVALID_CHAIR != wChairID)
	{
		ASSERT(IsUserPlaying(wChairID));
		if (!IsUserPlaying(wChairID)) return true;
		ASSERT(0 == m_cbUserResponse[wChairID]);
		if (0 != m_cbUserResponse[wChairID]) return true;

		m_cbUserResponse[wChairID] = bRob ? 2 : 1;
		if (bRob) m_wRobBankerUser[m_cbRobBankerCount++] = wChairID;

		CMD_S_UserRob stUserRob = { 0 };
		stUserRob.wRobUser = wChairID;
		stUserRob.bRobResult = bRob;
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));

		if (IsUserNoOperate(false))	return true;
	}

	//超时，放弃抢庄;
	for (int i=0; i<m_wPlayerCount; ++i)
	{
		if (m_bActiveUser[i] && 0==m_cbUserResponse[i])
		{
			m_cbUserResponse[i] = 1;

			CMD_S_UserRob stUserRob = { 0 };
			stUserRob.wRobUser = i;
			stUserRob.bRobResult = false;
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_ROB, &stUserRob, sizeof(stUserRob));
		}
	}

	//没有人抢庄;
	if (0 == m_cbRobBankerCount)
	{
		for (int i=0; i<m_wPlayerCount; ++i)
		{
			if (m_bActiveUser[i])
			{
				ASSERT(1 == m_cbUserResponse[i]);
				m_wRobBankerUser[m_cbRobBankerCount++] = i;
			}
		}
	}

	m_pITableFrame->KillGameTimer(IDI_ROB_BANKER);
	ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));
	ASSERT(m_cbRobBankerCount > 0);
	m_wBankerUser = m_wRobBankerUser[rand()%m_cbRobBankerCount];

	SendStartChip();
	return true;
}

//加注事件;
bool CTableFrameSink::OnUserChipScore(WORD wChairID, LONG lScore)
{
	const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
	ASSERT(GS_NN_USER_CHIP == cbGameStatus);
	if (GS_NN_USER_CHIP != cbGameStatus) return true;

	//ASSERT(IsUserPlaying(wChairID));
	ASSERT(wChairID != m_wBankerUser);

	//玩家操作;
	if (INVALID_CHAIR != wChairID)
	{
		ASSERT(IsUserPlaying(wChairID));
		if (!IsUserPlaying(wChairID)) return true;
		ASSERT(0 == m_cbUserResponse[wChairID]);
		if (0 != m_cbUserResponse[wChairID]) return true;

		m_cbUserResponse[wChairID] = 1;
		m_lTableScore[wChairID] = lScore;

		CMD_S_UserChip stUserChip = { 0 };
		stUserChip.wChipUser = wChairID;
		stUserChip.lChipScore = lScore;
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));

		if (IsUserNoOperate(true)) return true;
	}

	//超时,没下注处理;
	for (int i=0; i<m_wPlayerCount; ++i)
	{
		if (!m_bActiveUser[i] || i==m_wBankerUser)
		{
			continue;
		}

		if (0 == m_cbUserResponse[i])
		{
			//完成下注;
			m_cbUserResponse[i] = 1;
			m_lTableScore[i] = lScore;
			//发送消息;
			CMD_S_UserChip stUserChip = { 0 };
			stUserChip.wChipUser = i;
			stUserChip.lChipScore = (GetMinFreeChip()>0?GetMaxFreeChip():1);
			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_USER_CHIP, &stUserChip, sizeof(stUserChip));
		}
	}

	// 让各个玩家都明牌;
	for (int i = 0; i < m_wPlayerCount; ++i)
	{
		// 调用开牌把牌信息发送给客户端;
		CMD_S_OpenCard stOpenCard = { 0 };
		stOpenCard.wOpenUser = i;
		stOpenCard.cbCardType = 0;
		CopyMemory(stOpenCard.cbCardData, m_cbHandCardData[i], sizeof(m_cbHandCardData[i]));

		m_pITableFrame->SendTableData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
		m_pITableFrame->SendLookonData(i, SUB_S_START_OPEN, &stOpenCard, sizeof(stOpenCard));
	}

	m_pITableFrame->KillGameTimer(IDI_USER_CHIP);
	ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));

	//m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_START_OPEN);
	//m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_START_OPEN);

	m_pITableFrame->SetGameStatus(GS_NN_OPEN_CARD);
	m_pITableFrame->SetGameTimer(IDI_OPEN_CARD, IDT_OPEN_CARD, 1, 0);

	return true;
}

//摊牌事件;
bool CTableFrameSink::OnUserOpenCard(WORD wChairID)
{
	const BYTE && cbGameStatus = m_pITableFrame->GetGameStatus();
	ASSERT(GS_NN_OPEN_CARD == cbGameStatus);
	if (GS_NN_OPEN_CARD != cbGameStatus) return true;

	//BYTE cbHandCardCount = IsThreeCardMode() ? (MAX_COUNT-2) : MAX_COUNT;
	BYTE cbHandCardCount = MAX_COUNT;

	//玩家操作;
	if (INVALID_CHAIR != wChairID)
	{
		ASSERT(IsUserPlaying(wChairID));
		if (!IsUserPlaying(wChairID)) return true;
		ASSERT(0 == m_cbUserResponse[wChairID]);
		if (0 != m_cbUserResponse[wChairID]) return true;

		//完成开牌;
		m_cbUserResponse[wChairID] = 1;
		m_stOpenCardRlt[wChairID].cbMaxCard = m_GameLogic.GetMaxCard(m_cbHandCardData[wChairID], cbHandCardCount);
		m_stOpenCardRlt[wChairID].cbCardType = m_GameLogic.GetCardType(m_cbHandCardData[wChairID], cbHandCardCount, m_stOpenCardRlt[wChairID].cbSortCard, 
			IsHasGameRule(eNNRuleEnum_WHN), IsHasGameRule(eNNRuleEnum_BOMB), IsHasGameRule(eNNRuleEnum_WXN));

		CMD_S_OpenCard stOpenCard = { 0 };
		stOpenCard.wOpenUser = wChairID;
		stOpenCard.cbCardType = m_stOpenCardRlt[wChairID].cbCardType;
		CopyMemory(stOpenCard.cbCardData, m_stOpenCardRlt[wChairID].cbSortCard, sizeof(stOpenCard.cbCardData));
		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));

		if (IsUserNoOperate(false))	return true;
	}

	//超时,没开牌处理;
	for (int i=0; i<m_wPlayerCount; ++i)
	{
		if (!m_bActiveUser[i]) continue;
		if (0 == m_cbUserResponse[i])
		{
			m_cbUserResponse[i] = 1;
			m_stOpenCardRlt[i].cbMaxCard = m_GameLogic.GetMaxCard(m_cbHandCardData[i], cbHandCardCount);
			m_stOpenCardRlt[i].cbCardType = m_GameLogic.GetCardType(m_cbHandCardData[i], cbHandCardCount, m_stOpenCardRlt[i].cbSortCard,
				IsHasGameRule(eNNRuleEnum_WHN), IsHasGameRule(eNNRuleEnum_BOMB), IsHasGameRule(eNNRuleEnum_WXN));

			//CMD_S_OpenCard stOpenCard = { 0 };
			//stOpenCard.wOpenUser = i;
			//stOpenCard.cbCardType = m_stOpenCardRlt[i].cbCardType;
			//CopyMemory(stOpenCard.cbCardData, m_stOpenCardRlt[i].cbSortCard, sizeof(stOpenCard.cbCardData));
			//m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
			//m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPEN_CARD, &stOpenCard, sizeof(stOpenCard));
		}
	}

	// 所有人开始开牌CMD_S_AllOpenCard;
	CMD_S_AllOpenCard allOpenCard;
	ZeroMemory(&allOpenCard, sizeof(allOpenCard));

	for (int i = 0; i < m_wPlayerCount; ++i)
	{
		allOpenCard.bActiveStatus[i] = m_bActiveUser[i];

		if (!m_bActiveUser[i]) continue;
		allOpenCard.cbCardType[i] = m_stOpenCardRlt[i].cbCardType;
		CopyMemory(&allOpenCard.cbHandCardData[i][0], m_stOpenCardRlt[i].cbSortCard, sizeof(m_stOpenCardRlt[i].cbSortCard));

		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_ALL_OPEN_CARD, &allOpenCard, sizeof(allOpenCard));
	}

	m_pITableFrame->SetGameStatus(GS_NN_SHOW_CARD);

	m_pITableFrame->KillGameTimer(IDI_OPEN_CARD);
	//ZeroMemory(m_cbUserResponse, sizeof(m_cbUserResponse));

	//结束游戏;
	m_pITableFrame->SetGameTimer(IDI_GAME_END, IDT_GAME_END, 1, 0);
	//OnEventGameConclude(INVALID_CHAIR, nullptr, GER_NORMAL);
	return true;
}

//读取服务器配置;
bool CTableFrameSink::ReadServerConfig(const tagGameServiceOption *pGameServiceOption)
{
	//TCHAR szDir[MAX_PATH];
	//GetModuleFileName(NULL, szDir, MAX_PATH);
	//PathRemoveFileSpec(szDir);
	//CString strFileName;
	//strFileName.Format(_T("%s\\%sServer.ini"), szDir, EXPORT_NAME);

	//TCHAR szApp[32] = _T("Config");
	//try
	//{
	//	m_stGameRuleCfg.wGameRule = GetPrivateProfileInt(szApp, _T("GameRule"), RULE_HUA_NIU, strFileName);
	//	m_stGameRuleCfg.wBankerRule = GetPrivateProfileInt(szApp, _T("BankerRule"), BANKER_ROB4, strFileName);
	//	m_stGameRuleCfg.cbMinFreeChip = GetPrivateProfileInt(szApp, _T("MinFreeChip"), 0, strFileName);
	//	m_stGameRuleCfg.cbMaxFreeChip = GetPrivateProfileInt(szApp, _T("MaxFreeChip"), 0, strFileName);
	//	return true;
	//} catch (...) {
	//	ASSERT(0);
	//}
	return false;
}

////////////////////////////// 私人场 ////////////////////////////////////////////
void CTableFrameSink::SetPrivateInfo(BYTE bGameTypeIdex, DWORD bGameRuleIdex)
{

}

void CTableFrameSink::ResetPrivateEndInfo()
{
	ZeroMemory(&m_PrivateEndInfo, sizeof(CMD_S_Private_End_Info));
	m_wBankerUser = INVALID_CHAIR;
}

//获得私人场结束信息流;
void CTableFrameSink::GetPrivateEndInfo(DataStream &kDataStream, bool bSend)
{
	//m_PrivateEndInfo.StreamValue(kDataStream, bSend);
	for (WORD i = 0; i < GAME_PLAYER; i++)
	{
		// 总积分
		IServerUserItem* pServerUserItem = m_pITableFrame->GetTableUserItem(i);
		if (pServerUserItem)
		{
			m_PrivateEndInfo.lAllScore[i] = pServerUserItem->GetUserScore();
		}
	}

	tagPrivateFrameRecordInfo* pPrivateRecord = m_pITableFrame->GetPrivateFrameRecord();
	m_PrivateEndInfo.cbFinishCout = pPrivateRecord->cbFinishCout;

	m_PrivateEndInfo.StreamValue(kDataStream, bSend);
}

//判断私人场是否结束;
bool CTableFrameSink::IsPrivateEnd()
{
	if (m_pITableFrame == nullptr) return false;

	tagPrivateFrameParameter* pPrivateFrame = m_pITableFrame->GetPrivateFrameInfo();
	tagPrivateFrameRecordInfo* pPrivateRecord = m_pITableFrame->GetPrivateFrameRecord();

	if ((pPrivateFrame == nullptr) || (pPrivateRecord == nullptr)) return false;

	if (pPrivateFrame->cbGameCout <= pPrivateRecord->cbFinishCout)
	{
		return true;
	}

	return false;
}

//是否有相应规则;
bool CTableFrameSink::IsHasGameRule(eNNRuleEnum eType)
{
	ASSERT(m_pITableFrame != nullptr);
	if (m_pITableFrame == nullptr) return false;

	const tagPrivateFrameParameter* pPrivateFrame = m_pITableFrame->GetPrivateFrameInfo();
	if (nullptr == pPrivateFrame) return false;
	if (0 == pPrivateFrame->dwRoomNum) return false;

	return ((pPrivateFrame->dwGameRule & eType) == eType);
}