#include "StdAfx.h"
#include "PrivateGame.h"
#include "..\游戏服务器\DataBasePacket.h"
#include <math.h> 

////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


////////////////////////////////////////////////////////////////////////////////////////////////////////////
//构造函数
PriaveteGame::PriaveteGame()
{
	m_pGameServiceOption=NULL;
	m_pGameServiceAttrib=NULL;

	//内核接口
	m_pTableInfo=NULL;
	m_pITimerEngine=NULL;
	m_pIDataBaseEngine=NULL;
	m_pITCPNetworkEngineEvent=NULL;

	//服务接口
	m_pIGameServiceFrame=NULL;
	m_pIServerUserManager=NULL;
	m_pAndroidUserManager=NULL;

	ZeroMemory(&m_kPrivateInfo, sizeof(CMD_GR_Private_Info));
}

PriaveteGame::~PriaveteGame(void)
{
	//释放资源
	SafeDeleteArray(m_pTableInfo);

	//关闭定时器
	m_pITimerEngine->KillTimer(IDI_DISMISS_WAITE_END);
}

//接口查询
VOID* PriaveteGame::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{	
	QUERYINTERFACE(IGamePrivateItem,Guid,dwQueryVer);
	QUERYINTERFACE(IPrivateEventSink,Guid,dwQueryVer);
	QUERYINTERFACE(IServerUserItemSink,Guid,dwQueryVer);	
	QUERYINTERFACE_IUNKNOWNEX(IGamePrivateItem,Guid,dwQueryVer);
	return NULL;
}

//绑定桌子
bool PriaveteGame::BindTableFrame(ITableFrame * pTableFrame,WORD wTableID)
{
	if(pTableFrame==NULL || wTableID>m_pGameServiceOption->wTableCount)
	{
		ASSERT(false);
		return false;
	}

	//创建钩子
	CTableFramePrivate * pTableFrameHook=new CTableFramePrivate();
	pTableFrameHook->InitTableFramePrivate(QUERY_OBJECT_PTR_INTERFACE(pTableFrame,IUnknownEx));
	pTableFrameHook->SetPrivateEventSink(QUERY_OBJECT_PTR_INTERFACE(this,IUnknownEx));

	//设置接口
	pTableFrame->SetTableFramePrivate(QUERY_OBJECT_PTR_INTERFACE(pTableFrameHook,IUnknownEx));
	m_pTableInfo[wTableID].pITableFrame=pTableFrame;
	m_pTableInfo[wTableID].restValue();


	return true;
}

//初始化接口
bool PriaveteGame::InitPrivateInterface(tagPrivateManagerParameter & MatchManagerParameter)
{
	m_pGameServiceOption=MatchManagerParameter.pGameServiceOption;
	m_pGameServiceAttrib=MatchManagerParameter.pGameServiceAttrib;

	//内核组件
	m_pITimerEngine=MatchManagerParameter.pITimerEngine;
	m_pIDataBaseEngine=MatchManagerParameter.pICorrespondManager;
	m_pITCPNetworkEngineEvent=MatchManagerParameter.pTCPNetworkEngine;

	//服务组件		
	m_pIGameServiceFrame=MatchManagerParameter.pIMainServiceFrame;		
	m_pIServerUserManager=MatchManagerParameter.pIServerUserManager;
	m_pAndroidUserManager=MatchManagerParameter.pIAndroidUserManager;
	m_pIServerUserItemSink=MatchManagerParameter.pIServerUserItemSink;

	//创建桌子
	if (m_pTableInfo==NULL)
	{
		m_pTableInfo = new PrivateTableInfo[m_pGameServiceOption->wTableCount];
	}

	////读取初始积分  获取路径
	//TCHAR szWorkDir[MAX_PATH] = TEXT("");
	//CWHService::GetWorkDirectory(szWorkDir, CountArray(szWorkDir));

	////构造路径
	//TCHAR szIniFile[MAX_PATH] = TEXT("");
	//_sntprintf_s(szIniFile, CountArray(szIniFile), TEXT("%s\\ServerParameter.ini"), szWorkDir);

	////读取配置
	//CWHIniData IniData;
	//IniData.SetIniFilePath(szIniFile);

	//CString strSubItem;
	//strSubItem.Format(_T("Server%dInitScore"), m_pGameServiceOption->wServerID);

	//读取配置
	//m_nInitScore = IniData.ReadInt(TEXT("ServerInfo"), strSubItem, 95);

	return true;
}
void PriaveteGame::OnStartService()
{
	//变量定义
	DBR_GR_Private_Info kPrivateInfo;
	ZeroMemory(&kPrivateInfo,sizeof(kPrivateInfo));
	kPrivateInfo.wKindID=m_pGameServiceOption->wKindID;
	m_pIDataBaseEngine->PostDataBaseRequest(0L,DBR_GR_PRIVATE_INFO,0L,&kPrivateInfo,sizeof(kPrivateInfo));

	//定时器;
	m_pITimerEngine->SetTimer(IDI_DISMISS_WAITE_END,5000L,TIMES_INFINITY,0);
	m_pITimerEngine->SetTimer(IDI_CREATE_UNION_ROOM, CREATE_UNION_TIME * 1000L, TIMES_INFINITY, 0);
	
	m_pITimerEngine->SetTimer(IDI_LOAD_UNION_ROOM, 5000L, 1, 0);
}

//时间事件
bool PriaveteGame::OnEventTimer(DWORD dwTimerID, WPARAM dwBindParameter)
{	
	switch(dwTimerID)
	{
	case IDI_DISMISS_WAITE_END:				//解散等待时间 10s
		{
			for(int i = 0;i<m_pGameServiceOption->wTableCount;i++)
			{
				PrivateTableInfo* pTableInfo = &m_pTableInfo[i];
				if (pTableInfo->bInEnd)
				{
					pTableInfo->fAgainPastTime += 5.0f;
					if (pTableInfo->fAgainPastTime >= AGAIN_WAITE_TIME)
					{
						ClearRoom(pTableInfo);
					}
				}

				//已经创建并且没有开始的桌子
				if (pTableInfo->dwCreaterUserID>0 && !pTableInfo->bStart)
				{
					// 自动代开房间不解散;
					if ((pTableInfo->dwGameRuleIdex&ePrivateTableCommonRule_DaiKaiFang) == 0)
					{
						pTableInfo->fCreateTime += 5.0f;

						if (pTableInfo->fCreateTime >= CREATE_PRIVATE_FREE_TIME)
						{
							DismissRoom(pTableInfo);
						}
					}
					else // 自动代开房间玩家离线5分钟自动离开游戏房间;
					{
						ITableFrame* pTableFrame = pTableInfo->pITableFrame;
						ASSERT(pTableFrame != NULL);
						if (pTableFrame != NULL && pTableFrame->GetSitUserCount() > 0)
						{
							for (int i = 0; i < pTableFrame->GetChairCount(); i++)
							{
								IServerUserItem* pUserItem = pTableFrame->GetTableUserItem(i);
								if (pUserItem && pUserItem->GetTableID() != INVALID_TABLE && pUserItem->GetUserStatus() == US_OFFLINE)
								{
									pTableInfo->fOfflineTimes[i] += 5.0f;

									// 自动离开;
									if (pTableInfo->fOfflineTimes[i] >= UNION_OFFLINE_LEAVE_TIME)
									{
										pTableFrame->PerformStandUpActionEx(pUserItem);
										
										pTableInfo->fOfflineTimes[i] = 0;
									}
								}
							}
						}
					}
				}

				// 申请解散超时;
				if (pTableInfo->kDismissChairID.size() > 0)
				{
					pTableInfo->fDismissPastTime += 5.0f;
					if (pTableInfo->fDismissPastTime >= DISMISS_WAITE_TIME)
					{
						// 无拒绝解散玩家,才进行解散;
						if (pTableInfo->kNotAgreeChairID.size() < 1)
						{
							DismissRoom(pTableInfo);
						}

						pTableInfo->kNotAgreeChairID.clear();
						pTableInfo->kDismissChairID.clear();
						pTableInfo->fDismissPastTime = 0;
					}
				}

				// 游戏开始时间;
				if (pTableInfo->bStart)
				{
					//pTableInfo->fGameStartTime += 5.0f;
					if (pTableInfo->IsOffLineUser())
					{
						pTableInfo->fGameStartTime += 5.0f;
					}
					else
					{
						pTableInfo->fGameStartTime = 0.0f;
					}
				}
			}
			return true;
		}
	case IDI_CREATE_UNION_ROOM:
	{
		if (m_UnionRoomList.kList.size() > 0)
		{
			// 查找是否有带开信息未开启;
			for (int i = 0; i < (int)m_UnionRoomList.kList.size(); i++)
			{
				CMD_GR_AutoCreatePrivate& kInfo = m_UnionRoomList.kList[i];

				PrivateTableInfo* pTableInfo = GetPrivateTableInfoByDaikaiIndex(kInfo.dwIndex);
				if (pTableInfo == nullptr)
				{
					AutoCreateUnionRoom(kInfo);
				}
			}
		}
		//else
		//{
		//	DBR_GR_UnionRoomInfo UnionRoom;
		//	ZeroMemory(&UnionRoom, sizeof(DBR_GR_UnionRoomInfo));
		//	UnionRoom.wServerID = m_pGameServiceOption->wServerID;
		//	UnionRoom.wKindID = m_pGameServiceOption->wKindID;
		//	m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_UNION_ROOM_INFO, 0L, &UnionRoom, sizeof(UnionRoom));
		//}

		return true;
	}
	case IDI_LOAD_UNION_ROOM:
	{
		DBR_GR_UnionRoomInfo UnionRoom;
		ZeroMemory(&UnionRoom, sizeof(DBR_GR_UnionRoomInfo));
		UnionRoom.wServerID = m_pGameServiceOption->wServerID;
		UnionRoom.wKindID = m_pGameServiceOption->wKindID;
		m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_UNION_ROOM_INFO, 0L, &UnionRoom, sizeof(UnionRoom));
		
		return true;
	}
	}
	
	// 重置自由人数场;
	if (dwTimerID >= IDI_AUTO_USER_RESET && dwTimerID < (IDI_AUTO_USER_RESET + m_pGameServiceOption->wTableCount))
	{
		m_pITimerEngine->KillTimer(dwTimerID);

		WORD wTableID = dwTimerID - IDI_AUTO_USER_RESET;

		PrivateTableInfo* pTableInfo = &m_pTableInfo[wTableID];

		if (pTableInfo != nullptr && pTableInfo->IsAutoUserCountRule())
		{
			if (pTableInfo->bInEnd || pTableInfo->bStart) return true;
			
			pTableInfo->mReadyInfo.reset();

			// 通知客户端可以重新准备;
			tagAutoUserStatus autoUserStatus;
			autoUserStatus.bStartGame = true;
			SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
		}
	
	}
	
	return true;
}

//代开信息是否已经开启;
PrivateTableInfo* PriaveteGame::GetPrivateTableInfoByDaikaiIndex(DWORD dwDaikaiIndex)
{
	for (int i = 0; i < m_pGameServiceOption->wTableCount; i++)
	{
		PrivateTableInfo* pTableInfo = &m_pTableInfo[i];

		if (!pTableInfo->bStart && pTableInfo->m_dwDaikaiIndex == dwDaikaiIndex)
		{
			return pTableInfo;
		}
	}

	return nullptr;
}

//发送数据
bool PriaveteGame::SendData(IServerUserItem * pIServerUserItem, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
	if(pIServerUserItem!=NULL)
		return m_pIGameServiceFrame->SendData(pIServerUserItem,wMainCmdID,wSubCmdID,pData,wDataSize);
	else
		return m_pIGameServiceFrame->SendData(BG_ALL_CLIENT, wMainCmdID,wSubCmdID, pData, wDataSize);

	return true;
}
bool PriaveteGame::SendTableData(ITableFrame*	pITableFrame, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
	return pITableFrame->SendTableData(INVALID_CHAIR,wSubCmdID,pData,wDataSize,wMainCmdID);
}
void PriaveteGame::CreatePrivateCost(PrivateTableInfo* pTableInfo)
{
	if (pTableInfo->cbRoomType == Type_Private)
	{
		CString strDebugInfo;
		strDebugInfo.Format(_T("RoomID[%d], dwUserID[%d], dwCost[%d]"), pTableInfo->dwRoomNum, pTableInfo->dwCreaterUserID, pTableInfo->dwPlayCost);
		::OutputDebugString(strDebugInfo.GetBuffer());

		// 不是工会开房扣费，工会开房已经提前扣费;
		if (pTableInfo->dwUnionCode == 0)
		{
			if (pTableInfo->IsCardAARule())
			{
				EveryOnePrivateCost(pTableInfo, true);
			}
			else
			{
				CreaterPlayerPrivateCost(pTableInfo);
			}
		}
	}
	else if (pTableInfo->cbRoomType == Type_Public)
	{
		EveryOnePrivateCost(pTableInfo, false);
	}

}

PrivateTableInfo* PriaveteGame::getTableInfoByRoomID(DWORD dwRoomID)
{
	for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
	{
		if (m_pTableInfo[i].dwRoomNum == dwRoomID)
		{
			return &m_pTableInfo[i];
		}
	}
	return NULL;
}
PrivateTableInfo* PriaveteGame::getTableInfoByCreaterID(DWORD dwUserID)
{
	for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
	{
		if (m_pTableInfo[i].dwCreaterUserID == dwUserID)
		{
			return &m_pTableInfo[i];
		}
	}
	return NULL;
}
PrivateTableInfo* PriaveteGame::getTableInfoByTableID(DWORD dwRoomID)
{

	for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
	{
		if (m_pTableInfo[i].pITableFrame && m_pTableInfo[i].pITableFrame->GetTableID() == dwRoomID)
		{
			return &m_pTableInfo[i];
		}
	}
	return NULL;
}
PrivateTableInfo* PriaveteGame::getTableInfoByTableFrame(ITableFrame* pTableFrame)
{
	for (int i = 0;i<m_pGameServiceOption->wTableCount;i++)
	{
		if (m_pTableInfo[i].pITableFrame == pTableFrame)
		{
			return &m_pTableInfo[i];
		}
	}
	return NULL;
}

//数据库事件
bool PriaveteGame::OnEventDataBase(WORD wRequestID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
	switch (wRequestID)
	{
	case DBO_GR_PRIVATE_INFO:		//私人场信息
		{
			//参数效验
			if(wDataSize>sizeof(DBO_GR_Private_Info)) return false;

			//提取数据
			DBO_GR_Private_Info * pPrivate = (DBO_GR_Private_Info*)pData;
			m_kPrivateInfo.wKindID = pPrivate->wKindID;
			m_kPrivateInfo.lCostGold = pPrivate->lCostGold;
			memcpy(&m_kPrivateInfo.bPlayCout,pPrivate->bPlayCout,sizeof(m_kPrivateInfo.bPlayCout));
			memcpy(&m_kPrivateInfo.lPlayCost,pPrivate->lPlayCost,sizeof(m_kPrivateInfo.lPlayCost));
			break;
		}
	case DBO_GR_CREATE_PRIVATE:		//私人场信息
		{
			if (pIServerUserItem == nullptr) return false;
			OnEventCreatePrivate(wRequestID,pIServerUserItem,pData,wDataSize,"");
			break;
		}
	case DBO_GR_SINGLE_RECORD:
		{
			//参数效验;
			if (wDataSize != sizeof(DBO_GR_SingleGameRecord)) return false;

			DBO_GR_SingleGameRecord* pSingleGameRecord = (DBO_GR_SingleGameRecord*)pData;
			PrivateTableInfo* pTableInfo = getTableInfoByCreaterID(pSingleGameRecord->dwCreaterUserID);
			if ( NULL != pTableInfo )
			{
				pTableInfo->kTotalRecord.iRecordID = pSingleGameRecord->dwRecordID;
			}
			break;
		}
	case DBO_GR_CREATE_UNION_ROOM:
		{
			//参数效验;
			if (wDataSize != sizeof(DBO_GR_CreateUnionRoomResult)) return false;

			DBO_GR_CreateUnionRoomResult* pUnionRoomResult = (DBO_GR_CreateUnionRoomResult*)pData;

			PrivateTableInfo* pTableInfo = getTableInfoByRoomID(pUnionRoomResult->dwRoomID);
			if (NULL != pTableInfo)
			{
				pTableInfo->dwUnionConsumerID = pUnionRoomResult->dwUnionConsumerID;
			}

			break;
		}
	case DBO_GR_JOIN_UNION_ROOM:
		{
			//参数效验;
			if (wDataSize != sizeof(DBO_GR_JoinUnionRoomResult)) return false;
			if (pIServerUserItem == nullptr) return false;

			DBO_GR_JoinUnionRoomResult* pJoinUnionRoomResult = (DBO_GR_JoinUnionRoomResult*)pData;

			// 可以加入;
			if (pJoinUnionRoomResult->bSucess)
			{
				PrivateTableInfo* pTableInfo = getTableInfoByRoomID(pJoinUnionRoomResult->dwRoomID);
				if (NULL != pTableInfo)
				{
					//joinPrivateRoom(pIServerUserItem, pTableInfo->pITableFrame);
					joinPrivateRoom(pIServerUserItem, pTableInfo, pJoinUnionRoomResult->lUnionScore);
				}
			}
			else
			{
				m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, pJoinUnionRoomResult->szDescribeString, SMT_EJECT);
			}
			break;
		}
	case DBO_GR_UnionRoomInfo:
	{
		// 判断服务器维护;
		if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true) return true;

		// 确保空;
		if (m_UnionRoomList.kList.size() > 0)
		{
			m_UnionRoomList.kList.clear();
		}

		DataStream kDataStream(pData, wDataSize);
		m_UnionRoomList.StreamValue(kDataStream, false);

		for (int i = 0; i < (int)m_UnionRoomList.kList.size(); i++)
		{
			CMD_GR_AutoCreatePrivate& kInfo = m_UnionRoomList.kList[i];
			PrivateTableInfo* pTableInfo = GetPrivateTableInfoByDaikaiIndex(kInfo.dwIndex);
			if (pTableInfo == nullptr)
			{
				AutoCreateUnionRoom(kInfo);
			}
		}
		break;
	}
	case DBO_GR_AUTO_CREATE:
	{
		OnEventCreateAuto(wRequestID, pData, wDataSize, "");
		break;
	}
	case DBO_GR_ADD_AUTO_SUCC:
	{
		OnEventAddAutoRoomSucc(pIServerUserItem, pData, wDataSize);
		break;
	}
	case DBO_GR_ADD_AUTO_ERR:
	{
		//发送错误
		DBO_GR_AutoFailure * pLogonFailure = (DBO_GR_AutoFailure *)pData;
		SendAddAutoResult(pIServerUserItem, pLogonFailure->szDescribeString, pLogonFailure->lResultCode);
		break;
	}
	case DBO_GR_DEL_AUTO_RESULTE:
	{
		//发送错误
		DBO_GR_AutoFailure * pLogonFailure = (DBO_GR_AutoFailure *)pData;
		SendAddAutoResult(pIServerUserItem, pLogonFailure->szDescribeString, pLogonFailure->lResultCode);
		break;
	}
	}
	return true;
}

//自动创建房间;
void PriaveteGame::AutoCreateUnionRoom(CMD_GR_AutoCreatePrivate &CreatePrivate)
{
	if (CreatePrivate.cbGameType == Type_Private)
	{
		DBR_GR_Create_Private kDBRInfo;
		kDBRInfo.dwUserID = INVALID_CHAIR;
		kDBRInfo.dwDaikaiIndex = CreatePrivate.dwIndex;
		kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
		kDBRInfo.dwUnionCode = CreatePrivate.dwUnionCode;
		kDBRInfo.cbUnionGoldOpen = CreatePrivate.cbUnionGoldOpen;
		kDBRInfo.cbRoomType = Type_Private;
		kDBRInfo.dwCostType = Type_Private;
		kDBRInfo.dwAgaginTable = INVALID_DWORD;
		ASSERT(CreatePrivate.bPlayCoutIdex < 4);
		ASSERT(m_kPrivateInfo.lPlayCost[CreatePrivate.bPlayCoutIdex] != 0);
		kDBRInfo.dwCost = (DWORD)m_kPrivateInfo.lPlayCost[CreatePrivate.bPlayCoutIdex];
		kDBRInfo.bPlayCoutIdex = CreatePrivate.bPlayCoutIdex;
		kDBRInfo.bGameRuleIdex = CreatePrivate.bGameRuleIdex;
		kDBRInfo.bGameTypeIdex = CreatePrivate.bGameTypeIdex;

		kDBRInfo.cbEnterRoomScoreType = CreatePrivate.cbEnterRoomScoreType;
		kDBRInfo.lInitEnterRoomScore = CreatePrivate.lInitEnterRoomScore;
		kDBRInfo.cbBaseScore = CreatePrivate.cbBaseScore;

		if ((kDBRInfo.bGameRuleIdex & ePrivateTableCommonRule_CardAA) == ePrivateTableCommonRule_CardAA)
		{
			if (m_pGameServiceAttrib->wChairCount > 0)
			{
				kDBRInfo.dwCost = kDBRInfo.dwCost / m_pGameServiceAttrib->wChairCount;
			}
		}

		CString strDebugInfo;
		strDebugInfo.Format(_T("dwUserID[%d], bPlayCoutIdex[%d], dwCost[%d], bPlayCoutIdex[%d], bGameRuleIdex[%d], bGameTypeIdex[%d]"),
			kDBRInfo.dwUserID, CreatePrivate.bPlayCoutIdex, kDBRInfo.dwCost, kDBRInfo.bPlayCoutIdex, kDBRInfo.bGameRuleIdex, kDBRInfo.bGameTypeIdex);
		::OutputDebugString(strDebugInfo.GetBuffer());

		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_AUTO_UNION_ROOM, 0L, &kDBRInfo, sizeof(DBR_GR_Create_Private));
	}

}

//自动创建房间
bool PriaveteGame::OnEventCreateAuto(WORD wRequestID, VOID * pData, WORD wDataSize, std::string kChannel)
{
	//参数效验
	if (wDataSize > sizeof(DBO_GR_CreatePrivateResoult)) return false;

	//提取数据
	DBO_GR_CreatePrivateResoult* pPrivate = (DBO_GR_CreatePrivateResoult*)pData;
	DWORD dwAgaginTable = pPrivate->dwAgaginTable;

	//报名失败
	if (pPrivate->bSucess == false)
	{
		CTraceService::TraceString(pPrivate->szDescribeString, TraceLevel_Normal);
		return true;
	}

	if (pPrivate->bPlayCoutIdex >= 4)
	{
		return false;
	}

	//寻找位置
	ITableFrame * pICurrTableFrame = NULL;
	PrivateTableInfo* pCurrTableInfo = NULL;
	
	//WORD wTableID = 0;
	for (WORD wTableID = 0; wTableID < m_pGameServiceOption->wTableCount; wTableID++)
	{
		//获取对象
		ASSERT(m_pTableInfo[wTableID].pITableFrame != NULL);

		ITableFrame * pITableFrame = m_pTableInfo[wTableID].pITableFrame;
		if (m_pTableInfo[wTableID].bInEnd) continue;

		// 代开房间;
		if (m_pTableInfo[wTableID].m_dwDaikaiIndex == 0)
		{
			if (pITableFrame->GetNullChairCount() == pITableFrame->GetChairCount())
			{
				pICurrTableFrame = pITableFrame;
				pCurrTableInfo = &m_pTableInfo[wTableID];
				pCurrTableInfo->restValue();
				break;
			}
		}
	}

	//桌子判断
	if (pICurrTableFrame == NULL)
	{
		return true;
	}

	if (m_pGameServiceOption->wServerID >= 90)
	{
		ASSERT(false);
		return true;
	}
	int iRandNum = m_allocationID.PopValue();
	iRandNum = (m_pGameServiceOption->wServerID + 10) * 10000 + iRandNum;
	pCurrTableInfo->dwPlayCout = (DWORD)m_kPrivateInfo.bPlayCout[pPrivate->bPlayCoutIdex];
	if (pPrivate->cbRoomType == Type_Private)
	{
		pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lPlayCost[pPrivate->bPlayCoutIdex];
	}
	else
	{
		pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lCostGold;
	}

	pCurrTableInfo->setRoomNum(iRandNum);
	pCurrTableInfo->dwCreaterUserID = INVALID_CHAIR;
	pCurrTableInfo->dwUnionCode = pPrivate->dwUnionCode;
	pCurrTableInfo->m_dwDaikaiIndex = pPrivate->dwDaikaiIndex;
	pCurrTableInfo->kHttpChannel = kChannel;
	pCurrTableInfo->cbRoomType = pPrivate->cbRoomType;

	pCurrTableInfo->dwGameRuleIdex = pPrivate->bGameRuleIdex;
	pCurrTableInfo->bGameTypeIdex = pPrivate->bGameTypeIdex;
	pCurrTableInfo->bPlayCoutIdex = pPrivate->bPlayCoutIdex;
	GetLocalTime(&pCurrTableInfo->kTotalRecord.kPlayTime);

	pCurrTableInfo->cbEnterRoomScoreType = pPrivate->cbEnterRoomScoreType;
	pCurrTableInfo->lInitEnterRoomScore = pPrivate->lInitEnterRoomScore;
	pCurrTableInfo->cbBaseScore = pPrivate->cbBaseScore;

	pCurrTableInfo->cbUnionGoldOpen = pPrivate->cbUnionGoldOpen;
	pCurrTableInfo->lScoreMultiple = pPrivate->lScoreMultiple;
	pCurrTableInfo->lGameGold = pPrivate->lGameGold;

	if (pPrivate->dwAgaginTable == INVALID_DWORD)
	{
		pCurrTableInfo->kTotalRecord.iRecordID = pPrivate->dwRecordID;
	}

	tagPrivateFrameParameter PriavateFrame;
	PriavateFrame.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
	PriavateFrame.dwRoomNum = pCurrTableInfo->dwRoomNum;
	PriavateFrame.dwPlayCost = pCurrTableInfo->dwPlayCost;
	PriavateFrame.cbGameTypeIdex = (BYTE)pCurrTableInfo->dwGameRuleIdex;
	PriavateFrame.cbGameCout = (BYTE)pCurrTableInfo->dwPlayCout;
	PriavateFrame.dwGameRule = pCurrTableInfo->dwGameRuleIdex;
	PriavateFrame.cbEnterRoomScoreType = pCurrTableInfo->cbEnterRoomScoreType;			//进房间时的分数类型;
	PriavateFrame.lInitEnterRoomScore = pCurrTableInfo->lInitEnterRoomScore;			//进入房间时的分数;
	PriavateFrame.cbUnionGoldOpen = pCurrTableInfo->cbUnionGoldOpen;
	PriavateFrame.lScoreMultiple = pCurrTableInfo->lScoreMultiple;
	PriavateFrame.lGameGold = pCurrTableInfo->lGameGold;
	PriavateFrame.cbBaseScore = pCurrTableInfo->cbBaseScore;

	pICurrTableFrame->SetPrivateInfo(PriavateFrame);

	CString strTmp;
	strTmp.Format(_T("创建代开房间: %d, %d，%d"), iRandNum, pPrivate->bPlayCoutIdex, pPrivate->cbBaseScore);
	CTraceService::TraceString(strTmp, TraceLevel_Normal);

	sendPrivateRoomInfo(NULL, pCurrTableInfo);

	// 通知数据库扣费;
	if (pPrivate->dwUnionCode != 0)
	{
		DBR_GR_Create_UnionRoom CreateUnionRoom;
		ZeroMemory(&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));

		CreateUnionRoom.wServerID = m_pGameServiceOption->wServerID;
		CreateUnionRoom.dwUnionCode = pPrivate->dwUnionCode;
		CreateUnionRoom.dwRoomID = pCurrTableInfo->dwRoomNum;
		CreateUnionRoom.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
		CreateUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
		CreateUnionRoom.dwCost = pCurrTableInfo->dwPlayCost;
		CreateUnionRoom.dwCostType = pCurrTableInfo->cbRoomType;
		CreateUnionRoom.dwGameRuleIdex = pCurrTableInfo->dwGameRuleIdex;
		CreateUnionRoom.bPlayCoutIdex = (BYTE)pCurrTableInfo->dwPlayCout;
		CreateUnionRoom.dwRecordID = pPrivate->dwRecordID;
		CreateUnionRoom.cbBaseScore = pPrivate->cbBaseScore;

		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_CREATE_UNION_ROOM, 0L, (BYTE*)&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
	}
	else
	{
		DataStream kDataStream;
		pCurrTableInfo->kTotalRecord.StreamValue(kDataStream, true);
		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_PRIVATE_GAME_RECORD, 0, &kDataStream[0], kDataStream.size());
	}

	//// 设置房主积分;
	//PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	//if (NULL == pTableInfo) return true;
	//if (pTableInfo->bInEnd) return true;

	//if (pTableInfo->IsSetOneTimeRoomScoreType())
	//{	//进入房间时赋值为初始积分;
	//	SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
	//	pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
	//}

	return true;
}

//bool PriaveteGame::joinPrivateRoom(IServerUserItem * pIServerUserItem, ITableFrame * pICurrTableFrame)
bool PriaveteGame::joinPrivateRoom(IServerUserItem * pIServerUserItem, PrivateTableInfo* pTableInfo, SCORE lUnionScore)
{
	WORD wChairID = INVALID_CHAIR;
	
	ITableFrame * pICurrTableFrame = pTableInfo->pITableFrame;

	//椅子搜索
	for (WORD i=0;i<pICurrTableFrame->GetChairCount();i++)
	{
		if (pICurrTableFrame->GetTableUserItem(i)==NULL)
		{
			wChairID = i;
			break;
		}
	}

	//分配用户
	if (wChairID!=INVALID_CHAIR)
	{
		//用户起立
		if (pIServerUserItem->GetTableID()!=INVALID_TABLE)
		{
			return pIServerUserItem->GetTableID() == pICurrTableFrame->GetTableID();
		}

		//用户坐下
		if(pICurrTableFrame->PerformSitDownAction(wChairID,pIServerUserItem)==false)
		{
			return false;
		}
		
		// 记录欢乐积分
		pTableInfo->lScoreInfoArray[wChairID] = lUnionScore;

		// 通知数据库写座位号;
		DBR_GR_WriteUnionRoomChairID JoinRoomUser;
		ZeroMemory(&JoinRoomUser, sizeof(JoinRoomUser));
		JoinRoomUser.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
		JoinRoomUser.wChairID = wChairID;
		JoinRoomUser.dwUserID = pIServerUserItem->GetUserID();
		m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_WRITE_UNION_CHAIRID, 0L, (BYTE*)&JoinRoomUser, sizeof(DBR_GR_WriteUnionRoomChairID));

		return true;
	}

	return false;
}
//创建房间
bool PriaveteGame::OnEventCreatePrivate(WORD wRequestID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize,std::string kChannel)
{
	//参数效验
	if(pIServerUserItem==NULL) return true;
	if(wDataSize>sizeof(DBO_GR_CreatePrivateResoult)) return false;

	//提取数据
	DBO_GR_CreatePrivateResoult* pPrivate = (DBO_GR_CreatePrivateResoult*)pData;	
	DWORD dwAgaginTable = pPrivate->dwAgaginTable;

	//报名失败
	if(pPrivate->bSucess==false)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,pPrivate->szDescribeString,SMT_EJECT);
		CTraceService::TraceString(pPrivate->szDescribeString, TraceLevel_Normal);
		
		return true;
	}

	if (pPrivate->bPlayCoutIdex >= 4)
	{
		return false;
	}

	//寻找位置
	ITableFrame * pICurrTableFrame=NULL;
	PrivateTableInfo* pCurrTableInfo=NULL;
	if (dwAgaginTable != INVALID_DWORD)
	{
		pCurrTableInfo = getTableInfoByTableID(dwAgaginTable);
		if (!pCurrTableInfo)
		{
			return false;
		}
		pICurrTableFrame = pCurrTableInfo->pITableFrame;
		if (pCurrTableInfo->bInEnd == false)
		{
			//joinPrivateRoom(pIServerUserItem,pICurrTableFrame);
			joinPrivateRoom(pIServerUserItem, pCurrTableInfo, pPrivate->lUnionScore);
			return true;
		}
		else
		{
			pCurrTableInfo->restAgainValue();
			sendPrivateRoomInfo(NULL,pCurrTableInfo);
		}
	}
	else
	{
		//WORD wTableID = 0;
		for (WORD wTableID = 0; wTableID < m_pGameServiceOption->wTableCount; wTableID++)
		{
			//获取对象
			ASSERT(m_pTableInfo[wTableID].pITableFrame!=NULL);

			ITableFrame * pITableFrame=m_pTableInfo[wTableID].pITableFrame;
			if (m_pTableInfo[wTableID].bInEnd) continue;

			// 代开房间;
			if (m_pTableInfo[wTableID].m_dwDaikaiIndex == 0)
			{
				if (pITableFrame->GetNullChairCount() == pITableFrame->GetChairCount())
				{
					pICurrTableFrame = pITableFrame;
					pCurrTableInfo = &m_pTableInfo[wTableID];
					pCurrTableInfo->restValue();
					break;
				}
			}
		}

		if (getTableInfoByCreaterID(pIServerUserItem->GetUserID()))
		{
			return true;
		}
	}

	//桌子判断
	if(pICurrTableFrame==NULL)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("房间已满，创建房间失败。"),SMT_EJECT);
		return true;
	}

	if (m_pGameServiceOption->wServerID >= 90)
	{
		ASSERT(false);
		return true;
	}
	int iRandNum = m_allocationID.PopValue();
	iRandNum = (m_pGameServiceOption->wServerID+10)*10000+iRandNum;
	pCurrTableInfo->dwPlayCout = (DWORD)m_kPrivateInfo.bPlayCout[pPrivate->bPlayCoutIdex];
	if (pPrivate->cbRoomType == Type_Private)
	{
		pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lPlayCost[pPrivate->bPlayCoutIdex];
	}
	else
	{
		pCurrTableInfo->dwPlayCost = (DWORD)m_kPrivateInfo.lCostGold;
	}

	pCurrTableInfo->setRoomNum(iRandNum);
	pCurrTableInfo->dwCreaterUserID = pIServerUserItem->GetUserID();
	pCurrTableInfo->dwUnionCode = pPrivate->dwUnionCode;
	pCurrTableInfo->kHttpChannel = kChannel;
	pCurrTableInfo->cbRoomType = pPrivate->cbRoomType;
	pCurrTableInfo->lCreateScore = pPrivate->lUnionScore;

	pCurrTableInfo->dwGameRuleIdex = pPrivate->bGameRuleIdex;
	pCurrTableInfo->bGameTypeIdex = pPrivate->bGameTypeIdex;
	pCurrTableInfo->bPlayCoutIdex = pPrivate->bPlayCoutIdex;
	GetLocalTime(&pCurrTableInfo->kTotalRecord.kPlayTime);

	pCurrTableInfo->cbEnterRoomScoreType = pPrivate->cbEnterRoomScoreType;
	pCurrTableInfo->lInitEnterRoomScore	= pPrivate->lInitEnterRoomScore;
	pCurrTableInfo->cbBaseScore = pPrivate->cbBaseScore;

	pCurrTableInfo->cbUnionGoldOpen = pPrivate->cbUnionGoldOpen;
	pCurrTableInfo->lScoreMultiple = pPrivate->lScoreMultiple;
	pCurrTableInfo->lGameGold = pPrivate->lGameGold;

	if (pPrivate->dwAgaginTable == INVALID_DWORD)
	{
		pCurrTableInfo->kTotalRecord.iRecordID = pPrivate->dwRecordID;
	}

	tagPrivateFrameParameter PriavateFrame;
	PriavateFrame.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
	PriavateFrame.dwRoomNum = pCurrTableInfo->dwRoomNum;
	PriavateFrame.dwPlayCost = pCurrTableInfo->dwPlayCost;
	PriavateFrame.cbGameTypeIdex = (BYTE)pCurrTableInfo->dwGameRuleIdex;
	PriavateFrame.cbGameCout = (BYTE)pCurrTableInfo->dwPlayCout;
	PriavateFrame.dwGameRule = pCurrTableInfo->dwGameRuleIdex;
	PriavateFrame.cbEnterRoomScoreType = pCurrTableInfo->cbEnterRoomScoreType;			//进房间时的分数类型;
	PriavateFrame.lInitEnterRoomScore = pCurrTableInfo->lInitEnterRoomScore;			//进入房间时的分数;
	PriavateFrame.cbBaseScore = pCurrTableInfo->cbBaseScore;

	PriavateFrame.cbUnionGoldOpen = pCurrTableInfo->cbUnionGoldOpen;
	PriavateFrame.lScoreMultiple = pCurrTableInfo->lScoreMultiple;
	PriavateFrame.lGameGold = pCurrTableInfo->lGameGold;

	pICurrTableFrame->SetPrivateInfo(PriavateFrame);

	//pICurrTableFrame->SetPrivateInfo(pCurrTableInfo->bGameTypeIdex,pCurrTableInfo->bGameRuleIdex);

	CMD_GF_Create_Private_Sucess kSucessInfo;
	kSucessInfo.lCurSocre = pPrivate->bSucess;
	kSucessInfo.dwRoomNum = pCurrTableInfo->dwRoomNum;
	SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GR_CREATE_PRIVATE_SUCESS,&kSucessInfo,sizeof(kSucessInfo));

	CString strTmp;
	strTmp.Format(_T("创建房间: %d, %d"), iRandNum, pPrivate->bPlayCoutIdex);
	CTraceService::TraceString(strTmp, TraceLevel_Normal);

	sendPrivateRoomInfo(NULL,pCurrTableInfo);

	// 通知数据库扣费;
	if (pPrivate->dwUnionCode != 0)
	{
		DBR_GR_Create_UnionRoom CreateUnionRoom;
		ZeroMemory(&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
		
		CreateUnionRoom.wServerID = m_pGameServiceOption->wServerID;
		CreateUnionRoom.dwUnionCode = pPrivate->dwUnionCode;
		CreateUnionRoom.dwRoomID = pCurrTableInfo->dwRoomNum;
		CreateUnionRoom.dwCreaterUserID = pCurrTableInfo->dwCreaterUserID;
		CreateUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
		CreateUnionRoom.dwCost = pCurrTableInfo->dwPlayCost;
		CreateUnionRoom.dwCostType = pCurrTableInfo->cbRoomType;
		CreateUnionRoom.dwGameRuleIdex = pCurrTableInfo->dwGameRuleIdex;
		CreateUnionRoom.bPlayCoutIdex = (BYTE)pCurrTableInfo->dwPlayCout;
		CreateUnionRoom.dwRecordID = pPrivate->dwRecordID;
		CreateUnionRoom.cbBaseScore = pPrivate->cbBaseScore;

		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_CREATE_UNION_ROOM, 0L, (BYTE*)&CreateUnionRoom, sizeof(DBR_GR_Create_UnionRoom));
	}
	else
	{
		DataStream kDataStream;
		pCurrTableInfo->kTotalRecord.StreamValue(kDataStream, true);
		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_PRIVATE_GAME_RECORD, 0, &kDataStream[0], kDataStream.size());
	}

	// 设置房主积分;
	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (NULL == pTableInfo) return true;
	if (pTableInfo->bInEnd) return true;

	if (pTableInfo->IsSetOneTimeRoomScoreType())
	{	//进入房间时赋值为初始积分;
		SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
		pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
	}

	return true;
}

//创建私人场
bool PriaveteGame::OnTCPNetworkSubCreatePrivate(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//参数效验
	ASSERT(wDataSize==sizeof(CMD_GR_Create_Private));
	if(wDataSize!=sizeof(CMD_GR_Create_Private)) return false;

	// 判断服务器维护;
	if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("服务器即将维护，请关注微信群通知。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
		return true;
	}

	CMD_GR_Create_Private* pCMDInfo = (CMD_GR_Create_Private*)pData;

	if (pIServerUserItem->GetTableID() != INVALID_TABLE)
	{
		SendData(pIServerUserItem, MDM_GR_PRIVATE, SUB_GR_PRIVATE_HAS_CREATED, NULL, 0);
		return true;
	}

	if(pCMDInfo->cbGameType == Type_Private)
	{
		DBR_GR_Create_Private kDBRInfo;
		kDBRInfo.dwUserID = pIServerUserItem->GetUserID();
		kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
		kDBRInfo.dwDaikaiIndex = 0;
		kDBRInfo.dwUnionCode = pCMDInfo->dwUnionCode;
		kDBRInfo.cbUnionGoldOpen = pCMDInfo->cbUnionGoldOpen;
		kDBRInfo.cbRoomType = Type_Private;
		kDBRInfo.dwCostType = Type_Private;
		kDBRInfo.dwAgaginTable = INVALID_DWORD;
		ASSERT(pCMDInfo->bPlayCoutIdex < 4);
		ASSERT(m_kPrivateInfo.lPlayCost[pCMDInfo->bPlayCoutIdex] != 0);
		kDBRInfo.dwCost = (DWORD)m_kPrivateInfo.lPlayCost[pCMDInfo->bPlayCoutIdex];
		kDBRInfo.bPlayCoutIdex = pCMDInfo->bPlayCoutIdex;
		kDBRInfo.bGameRuleIdex = pCMDInfo->bGameRuleIdex;
		kDBRInfo.bGameTypeIdex = pCMDInfo->bGameTypeIdex;

		kDBRInfo.cbEnterRoomScoreType	= pCMDInfo->cbEnterRoomScoreType;
		kDBRInfo.lInitEnterRoomScore	= pCMDInfo->lInitEnterRoomScore;
		kDBRInfo.cbBaseScore = pCMDInfo->cbBaseScore;

		if ((kDBRInfo.bGameRuleIdex & ePrivateTableCommonRule_CardAA) == ePrivateTableCommonRule_CardAA)
		{
			if (m_pGameServiceAttrib->wChairCount > 0)
			{
				kDBRInfo.dwCost = kDBRInfo.dwCost / m_pGameServiceAttrib->wChairCount;
			}
		}

		CString strDebugInfo;
		strDebugInfo.Format(_T("dwUserID[%d], bPlayCoutIdex[%d], dwCost[%d], bPlayCoutIdex[%d], bGameRuleIdex[%d], bGameTypeIdex[%d]"), 
			kDBRInfo.dwUserID, pCMDInfo->bPlayCoutIdex, kDBRInfo.dwCost, kDBRInfo.bPlayCoutIdex, kDBRInfo.bGameRuleIdex, kDBRInfo.bGameTypeIdex);
		::OutputDebugString(strDebugInfo.GetBuffer());

		m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_CREATE_PRIVAT, dwSocketID, &kDBRInfo, sizeof(DBR_GR_Create_Private));
	}

	return true;
}

//创建代开信息
bool PriaveteGame::OnTCPNetworkSubAutoRoomInfo(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//参数效验
	ASSERT(wDataSize == sizeof(CMD_GR_AutoRoomInfo));
	if (wDataSize != sizeof(CMD_GR_AutoRoomInfo)) return false;

	// 判断服务器维护;
	if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("服务器即将维护，请关注微信群通知。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
		return true;
	}

	CMD_GR_AutoRoomInfo* pCMDInfo = (CMD_GR_AutoRoomInfo*)pData;
	ASSERT(pCMDInfo->dwUserID == pIServerUserItem->GetUserID());

	if (pCMDInfo->cbGameType == Type_Private)
	{
		DBR_GR_AutoRoomInfo kDBRInfo;
		kDBRInfo.dwUserID = pCMDInfo->dwUserID;
		kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
		kDBRInfo.wServerID = m_pGameServiceOption->wServerID;
		kDBRInfo.cbGameType = pCMDInfo->cbGameType;

		ASSERT(pCMDInfo->bPlayCoutIdex < 4);
		ASSERT(m_kPrivateInfo.lPlayCost[pCMDInfo->bPlayCoutIdex] != 0);
		
		kDBRInfo.bPlayCoutIdex = pCMDInfo->bPlayCoutIdex;
		kDBRInfo.bPlayCout = m_kPrivateInfo.bPlayCout[pCMDInfo->bPlayCoutIdex];
		kDBRInfo.bGameRuleIdex = pCMDInfo->bGameRuleIdex;
		kDBRInfo.bGameTypeIdex = pCMDInfo->bGameTypeIdex;

		kDBRInfo.cbEnterRoomScoreType = pCMDInfo->cbEnterRoomScoreType;
		kDBRInfo.lInitEnterRoomScore = pCMDInfo->lInitEnterRoomScore;
		kDBRInfo.cbBaseScore = pCMDInfo->cbBaseScore;

		m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_ADD_AUTO_ROOM_INFO, dwSocketID, &kDBRInfo, sizeof(DBR_GR_AutoRoomInfo));
	}

	return true;
}

//增加自动开房信息成功;
bool PriaveteGame::OnEventAddAutoRoomSucc(IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
	ASSERT(wDataSize == sizeof(CMD_GR_AutoCreatePrivate));
	if (pIServerUserItem == nullptr) return false;
	if (wDataSize != sizeof(CMD_GR_AutoCreatePrivate)) return false;

	CMD_GR_AutoCreatePrivate AutoCreate;
	memcpy(&AutoCreate, pData, wDataSize);

	// 查找列表中是否存在该记录;m_UnionRoomList
	for (int i = 0; i < (int)m_UnionRoomList.kList.size(); i++)
	{
		CMD_GR_AutoCreatePrivate& kInfo = m_UnionRoomList.kList[i];
		if (kInfo.dwIndex == AutoCreate.dwIndex)
		{
			return false;
		}
	}

	// 不存在加入列表，然后创建房间;
	AutoCreateUnionRoom(AutoCreate);
	m_UnionRoomList.kList.push_back(AutoCreate);

	// 通知客户端增加成功;
	SendAddAutoResult(pIServerUserItem, TEXT("添加代开信息成功！"), 0);

	return true;
}

//发送增加自动开房结果;
bool PriaveteGame::SendAddAutoResult(IServerUserItem * pIServerUserItem, LPCTSTR pszString, LONG lErrorCode)
{
	//变量定义
	CMD_GR_AutoResulte autoFailure;
	ZeroMemory(&autoFailure, sizeof(autoFailure));

	//构造数据
	autoFailure.lErrorCode = lErrorCode;
	lstrcpyn(autoFailure.szDescribeString, pszString, CountArray(autoFailure.szDescribeString));

	//数据属性
	WORD wDataSize = CountStringBuffer(autoFailure.szDescribeString);
	WORD wHeadSize = sizeof(autoFailure) - sizeof(autoFailure.szDescribeString);

	//发送数据
	return SendData(pIServerUserItem, MDM_GR_PRIVATE, SUB_GR_CREATE_AUTO_RESULTE, &autoFailure, wHeadSize + wDataSize);
}

//删除代开信息
bool PriaveteGame::OnTCPNetworkSubDelAutoRoomInfo(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//参数效验
	ASSERT(wDataSize == sizeof(CMD_GP_DelAutoRoomInfo));
	if (wDataSize != sizeof(CMD_GP_DelAutoRoomInfo)) return false;

	CMD_GP_DelAutoRoomInfo* pDelAutoInfo = (CMD_GP_DelAutoRoomInfo*)pData;
	
	if (pDelAutoInfo->wServerID != m_pGameServiceOption->wServerID) return false;

	// 删除内存数据;
	bool bHasAutoRoomInfo = false;
	for (std::vector<CMD_GR_AutoCreatePrivate>::iterator iter = m_UnionRoomList.kList.begin(); iter != m_UnionRoomList.kList.end(); iter++)
	{
		if ((*iter).dwIndex == pDelAutoInfo->dwIndex)
		{
			iter = m_UnionRoomList.kList.erase(iter);
			bHasAutoRoomInfo = true;
			break;
		}
	}

	if (bHasAutoRoomInfo)
	{
		// 解散内存房间;
		for (int i = 0; i < m_pGameServiceOption->wTableCount; i++)
		{
			PrivateTableInfo* pTableInfo = &m_pTableInfo[i];

			//已经创建并且没有开始的桌子
			if (pTableInfo->dwCreaterUserID > 0 && !pTableInfo->bStart)
			{
				if ((pTableInfo->dwGameRuleIdex&ePrivateTableCommonRule_DaiKaiFang) == ePrivateTableCommonRule_DaiKaiFang)
				{
					if (pTableInfo->m_dwDaikaiIndex == pDelAutoInfo->dwIndex)
					{
						DismissRoom(pTableInfo);
						break;
					}
				}
			}
		}

		// 删除数据库数据;
		DBO_GR_DelAutoRoomInfo DelAutoRoomInfo;
		DelAutoRoomInfo.dwUserID = pIServerUserItem->GetUserID();
		DelAutoRoomInfo.dwIndex = pDelAutoInfo->dwIndex;
		DelAutoRoomInfo.wServerID = pDelAutoInfo->wServerID;
		m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_DEL_AUTO_ROOM_INFO, dwSocketID, &DelAutoRoomInfo, sizeof(DelAutoRoomInfo));
		
		//SendAddAutoResult(pIServerUserItem, TEXT("删除代开信息完成！"), 0);
	}
	else
	{
		SendAddAutoResult(pIServerUserItem, TEXT("抱歉，未找到代开信息！"), 1);
	}

	return true;
}

//自由人数玩家状态，玩家可以准备;
bool PriaveteGame::OnTCPNetworkSubAutoUserStatus(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	//if (!pTableInfo)
	//{
	//	return false;
	//}

	//// 结束了或者已经开始了，就不处理该消息;
	//if (pTableInfo->bInEnd || pTableInfo->bStart)
	//{
	//	return true;
	//}

	//WORD wChairID = pIServerUserItem->GetChairID();
	//if (wChairID == INVALID_CHAIR) return false;

	//pTableInfo->bAutoStart[wChairID] = true;

	//// 发送状态;
	//SendAutoUserStatus(pTableInfo);

	return true;
}

//自由人数准备状态
bool PriaveteGame::OnTCPNetworkSubAutoUserReady(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//参数效验
	ASSERT(wDataSize == sizeof(CMD_GR_Private_Ready));
	if (wDataSize != sizeof(CMD_GR_Private_Ready)) return false;

	CMD_GR_Private_Ready* pCMDInfo = (CMD_GR_Private_Ready*)pData;

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return false;
	}

	// 结束了或者已经开始了，就不处理该消息;
	if (pTableInfo->bInEnd || pTableInfo->bStart)
	{
		return true;
	}

	WORD wChairID = pIServerUserItem->GetChairID();
	WORD wTableID = pIServerUserItem->GetTableID();
	if (wChairID == INVALID_CHAIR || wTableID == INVALID_CHAIR) return false;
	
	// 第一个申请开始人;
	if (pCMDInfo->bStart && pTableInfo->mReadyInfo.wChairID == INVALID_CHAIR)
	{
		pTableInfo->mReadyInfo.wChairID = wChairID;
	}

	// 准备;
	if (pCMDInfo->bReady && pIServerUserItem->GetUserStatus()== US_SIT)
	{
		// 玩家准备;
		pIServerUserItem->SetUserStatus(US_READY, wTableID, wChairID);
		pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_READY;

		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
	}
	else
	{
		// 玩家准备;
		//pIServerUserItem->SetUserStatus(US_READY, wTableID, wChairID);
		ITableFrame* pITableFrame = pTableInfo->pITableFrame;
		if (pTableInfo == nullptr) return true;

		WORD wChairCount = pITableFrame->GetChairCount();
		for (int i = 0; i < wChairCount; i++)
		{
			IServerUserItem * pServerItem = pITableFrame->GetTableUserItem(i);
			if (pServerItem == nullptr) continue;
			
			if (pServerItem->GetUserStatus() == US_READY)
			{
				pIServerUserItem->SetUserStatus(US_SIT, wTableID, i);
			}
		}


		pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_REFUSED;

		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
	}

	return true;
}

//重新加入私人场
bool PriaveteGame::OnTCPNetworkSubAgainEnter(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//参数效验
	ASSERT(wDataSize==sizeof(CMD_GR_Again_Private));
	if(wDataSize!=sizeof(CMD_GR_Again_Private)) return false;

	CMD_GR_Again_Private* pCMDInfo = (CMD_GR_Again_Private*)pData;

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return true;
	}
	if (!pTableInfo->bInEnd && pTableInfo->dwRoomNum != 0)
	{
		//joinPrivateRoom(pIServerUserItem,pTableInfo->pITableFrame);
		joinPrivateRoom(pIServerUserItem, pTableInfo, 0);
		return true;
	}
	DBR_GR_Create_Private kDBRInfo;
	ZeroMemory(&kDBRInfo,sizeof(kDBRInfo));
	kDBRInfo.cbRoomType = pTableInfo->cbRoomType;
	kDBRInfo.dwUserID = pIServerUserItem->GetUserID();
	kDBRInfo.wKindID = m_pGameServiceAttrib->wKindID;
	kDBRInfo.dwCost = (DWORD)m_kPrivateInfo.lPlayCost[pTableInfo->bPlayCoutIdex];
	kDBRInfo.dwAgaginTable = pIServerUserItem->GetTableID();

	m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_CREATE_PRIVAT, dwSocketID, &kDBRInfo, sizeof(DBR_GR_Create_Private));

	return true;
}

//加入私人场
bool PriaveteGame::OnTCPNetworkSubJoinPrivate(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//参数效验
	ASSERT(wDataSize==sizeof(CMD_GR_Join_Private));
	if(wDataSize!=sizeof(CMD_GR_Join_Private)) return false;

	// 判断服务器维护;
	if (CServerRule::IsForfendGameStart(m_pGameServiceOption->dwServerRule) == true)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("服务器即将维护，请关注微信群通知。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
		return true;
	}

	bool bRet = true;
	CString strMessage;

	CMD_GR_Join_Private* pCMDInfo = (CMD_GR_Join_Private*)pData;
	PrivateTableInfo* pTableInfo = getTableInfoByRoomID(pCMDInfo->dwRoomNum);
	do 
	{
		if (!pTableInfo)
		{
			bRet = false;
			strMessage = TEXT("对不起，没有找到该房间，可能房主已经退出。");
			break;
		}
		if (pTableInfo->pITableFrame->GetNullChairCount() <= 0)
		{
			bRet = false;
			strMessage = TEXT("对不起，游戏人数已满，无法加入。");
			break;
		}
		if (pTableInfo->bStart || pTableInfo->bInEnd)
		{
			bRet = false;
			strMessage = TEXT("对不起，游戏已经开始，无法加入。");
			break;
		}
		BYTE cbStartMode = pTableInfo->GetStartMode();
		if ((cbStartMode == START_MODE_FULL_READY) && (pTableInfo->bStart || pTableInfo->bInEnd))
		{
			bRet = false;
			strMessage = TEXT("对不起，游戏已经开始，无法加入。");
			break;
		}
		if (!pTableInfo->IsCanJoinTable(pIServerUserItem, strMessage))
		{
			bRet = false;
			break;
		}
	} while (0);

	if (!bRet)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, strMessage, SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
		return true;
	}

	// 是工会房;
	if (pTableInfo->dwUnionCode != 0)
	{
		if (pIServerUserItem->GetUserID() == pTableInfo->dwCreaterUserID)
		{
			joinPrivateRoom(pIServerUserItem, pTableInfo, pTableInfo->lCreateScore);
		}
		else
		{
			DBR_GR_JoinUnionRoom JoinUnionRoom;
			ZeroMemory(&JoinUnionRoom, sizeof(JoinUnionRoom));
			JoinUnionRoom.dwUnionCode = pTableInfo->dwUnionCode;
			JoinUnionRoom.dwUserID = pIServerUserItem->GetUserID();
			JoinUnionRoom.dwRoomID = pTableInfo->dwRoomNum;
			JoinUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
			JoinUnionRoom.cbUnionGoldOpen = pTableInfo->cbUnionGoldOpen;

			m_pIDataBaseEngine->PostDataBaseRequest(pIServerUserItem->GetUserID(), DBR_GR_JOIN_UNION_ROOM, dwSocketID, &JoinUnionRoom, sizeof(DBR_GR_JoinUnionRoom));
		}
	}
	else
	{
		//joinPrivateRoom(pIServerUserItem, pTableInfo->pITableFrame);
		joinPrivateRoom(pIServerUserItem, pTableInfo, 0);
	}

	//if (!joinPrivateRoom(pIServerUserItem,pTableInfo->pITableFrame))
	//{
	//	//m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("加入房间失败。"), SMT_EJECT | SMT_CHAT | SMT_CLOSE_LINK);
	//}

	return true;
}
bool PriaveteGame::OnTCPNetworkSubDismissPrivate(VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	//CTraceService::TraceString(TEXT("SUB_GR_PRIVATE_DISMISS"),TraceLevel_Normal);

	//参数效验
	ASSERT(wDataSize==sizeof(CMD_GR_Dismiss_Private));
	if(wDataSize!=sizeof(CMD_GR_Dismiss_Private)) return false;

	CMD_GR_Dismiss_Private* pCMDInfo = (CMD_GR_Dismiss_Private*)pData;

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return false;
	}
	if (!pTableInfo->bStart && pTableInfo->dwCreaterUserID != pIServerUserItem->GetUserID())
	{
		return true;
	}
	if (pTableInfo->bInEnd)
	{
		return true;
	}

#if _DEBUG

#else
	// 游戏开始不到2分钟不可以解散;
	if (pTableInfo->bStart && !pTableInfo->IsDismissRoom())
	{
		//变量定义
		CMD_GR_RequestFailure RequestFailure;
		ZeroMemory(&RequestFailure, sizeof(RequestFailure));

		//构造数据
		RequestFailure.lErrorCode = SMT_EJECT;
		lstrcpyn(RequestFailure.szDescribeString, TEXT("无离线玩家或玩家离线不足2分钟，无法解散房间！"), CountArray(RequestFailure.szDescribeString));

		//发送数据
		WORD wDataSize = CountStringBuffer(RequestFailure.szDescribeString);
		WORD wHeadSize = sizeof(RequestFailure)-sizeof(RequestFailure.szDescribeString);
		SendData(pIServerUserItem, MDM_GR_USER, SUB_GR_REQUEST_FAILURE, &RequestFailure, wHeadSize + wDataSize);

		return true;
	}
#endif

	// 没人申请解散，不需要拒绝解散;
	if (pTableInfo->kDismissChairID.size() == 0 && !pCMDInfo->bDismiss)
	{
		return true;
	}

	// 解散房间;
	if(pCMDInfo->bDismiss)
	{
		for (int i = 0;i<(int)pTableInfo->kDismissChairID.size();i++)
		{
			if (pTableInfo->kDismissChairID[i] == pIServerUserItem->GetChairID())
			{
				return true;
			}
		}
		pTableInfo->kDismissChairID.push_back(pIServerUserItem->GetChairID());
	}
	else
	{
		// 拒绝解散;
		for (int i = 0;i<(int)pTableInfo->kNotAgreeChairID.size();i++)
		{
			if (pTableInfo->kNotAgreeChairID[i] == pIServerUserItem->GetChairID())
			{
				return true;
			}
		}
		pTableInfo->kNotAgreeChairID.push_back(pIServerUserItem->GetChairID());
	}

	// 解散信息发生给客户端;
	CMD_GF_Private_Dismiss_Info kNetInfo;
	kNetInfo.dwDissUserCout = pTableInfo->kDismissChairID.size();
	kNetInfo.dwNotAgreeUserCout = pTableInfo->kNotAgreeChairID.size();
	for (int i = 0;i<(int)pTableInfo->kDismissChairID.size();i++)
	{
		kNetInfo.dwDissChairID[i] = pTableInfo->kDismissChairID[i];
	}
	for (int i = 0;i<(int)pTableInfo->kNotAgreeChairID.size();i++)
	{
		kNetInfo.dwNotAgreeChairID[i] = pTableInfo->kNotAgreeChairID[i];
	}
	SendTableData(pTableInfo->pITableFrame,MDM_GR_PRIVATE,SUB_GR_PRIVATE_DISMISS,&kNetInfo,sizeof(kNetInfo));

	// 有人拒绝解散;
	//if (pTableInfo->kNotAgreeChairID.size() >= 2)
	if (pTableInfo->kNotAgreeChairID.size() > 0)
	{
		pTableInfo->kNotAgreeChairID.clear();
		pTableInfo->kDismissChairID.clear();
		pTableInfo->fDismissPastTime = 0;

		CMD_GF_Private_Dismiss_Result mResult;
		mResult.bSuccess = false;
		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_PRIVATE_DISMISS_RESULT, &mResult, sizeof(mResult));
	}

	// 解散游戏;
	if (!pTableInfo->bStart || (int)kNetInfo.dwDissUserCout >= (int)pTableInfo->pITableFrame->GetSitUserCount()-1)
	{
		CMD_GF_Private_Dismiss_Result mResult;
		mResult.bSuccess = true;
		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_PRIVATE_DISMISS_RESULT, &mResult, sizeof(mResult));

		//pTableInfo->pITableFrame->SendGameMessage(TEXT("房间已被解散！"),SMT_EJECT);

		DismissRoom(pTableInfo);

		ClearRoom(pTableInfo);
	}


	return true;
}
//比赛事件
bool PriaveteGame::OnEventSocketPrivate(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
	case SUB_GR_PRIVATE_INFO:	//私人场信息
		{
			SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GR_PRIVATE_INFO,&m_kPrivateInfo,sizeof(m_kPrivateInfo));
			return true;
		}
	case SUB_GR_CREATE_PRIVATE:	//创建私人场
		{
			return OnTCPNetworkSubCreatePrivate(pData,wDataSize,pIServerUserItem,dwSocketID);
		}
	case SUB_GR_RIVATE_AGAIN:	//重新加入私人场
		{
			return OnTCPNetworkSubAgainEnter(pData,wDataSize,pIServerUserItem,dwSocketID);
		}
	case SUB_GR_JOIN_PRIVATE:	//加入私人场
		{
			return OnTCPNetworkSubJoinPrivate(pData,wDataSize,pIServerUserItem,dwSocketID);	
		}
	case SUB_GR_PRIVATE_DISMISS:	//解散
		{
			return OnTCPNetworkSubDismissPrivate(pData,wDataSize,pIServerUserItem,dwSocketID);	
		}
	case SUB_GR_CREATE_AUTO_ROOM:
	{
		return OnTCPNetworkSubAutoRoomInfo(pData, wDataSize, pIServerUserItem, dwSocketID);
	}
	case SUB_GR_DEL_AUTO_ROOM_INFO:
	{
		return OnTCPNetworkSubDelAutoRoomInfo(pData, wDataSize, pIServerUserItem, dwSocketID);
	}
	case SUB_GR_AUTO_USER_STATUS:
	{
		return OnTCPNetworkSubAutoUserStatus(pData, wDataSize, pIServerUserItem, dwSocketID);
	}
	case SUB_GR_AUTO_USER_READY:
	{
		return OnTCPNetworkSubAutoUserReady(pData, wDataSize, pIServerUserItem, dwSocketID);
	}
	}
	return true;
}

//重置桌位
void PriaveteGame::DismissRoom(PrivateTableInfo* pTableInfo)
{
	ASSERT(pTableInfo!=NULL);
	if (pTableInfo==NULL) return;

	ITableFrame* pTableFrame=pTableInfo->pITableFrame;
	ASSERT(pTableFrame!=NULL);
	if (pTableFrame==NULL) return;

	//强制解散游戏
	if (pTableFrame->IsGameStarted()==true)
	{
		bool bSuccess=pTableFrame->DismissGame();
		if (bSuccess==false)
		{
			CTraceService::TraceString(TEXT("PriaveteGame 解散游戏 失败！"),TraceLevel_Exception);
			return;
		}
	}

	m_allocationID.PushValue(pTableInfo->dwRoomNum % 10000);

	// 如果是第一局没结束就解散，需要到数据库返还工会房卡;
	if (!pTableInfo->bStart || (pTableInfo->dwStartPlayCout < 1))
	{
		DBR_GR_DismissUnionRoom DismissUnionRoom;
		ZeroMemory(&DismissUnionRoom, sizeof(DismissUnionRoom));

		DismissUnionRoom.dwUnionCode = pTableInfo->dwUnionCode;
		DismissUnionRoom.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
		DismissUnionRoom.dwCost = pTableInfo->dwPlayCost;

		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_DISMISS_UNION_ROOM, 0L, (BYTE*)&DismissUnionRoom, sizeof(DismissUnionRoom));
	}

	pTableInfo->bInEnd = true;

	if (pTableInfo->bStart)
	{
		SendGamePrivateEndInfo(pTableInfo);

		CalcUnionScore(pTableInfo);

		pTableInfo->bInEnd = true;
		pTableInfo->dwCreaterUserID = 0;
		pTableInfo->dwUnionCode = 0;			// 工会ID
		pTableInfo->dwUnionConsumerID = 0;		// 消耗记录ID

		//清除每局的记录只向0.数据库记录总的记录;
		pTableInfo->kTotalRecord.kRecordChild.clear();

		DataStream kDataStream;
		pTableInfo->kTotalRecord.StreamValue(kDataStream,true);

		m_pIDataBaseEngine->PostDataBaseRequest(0,DBR_GR_PRIVATE_GAME_RECORD,0,&kDataStream[0],kDataStream.size());	

		pTableInfo->bStart = false;
		sendPrivateRoomInfo(NULL,pTableInfo);

		gameEnd(pTableInfo);
	}
	else
	{
		ClearRoom(pTableInfo);
	}
	
	CString strTmp;
	strTmp.Format(_T("解散房间: %d"), pTableInfo->dwRoomNum);
	CTraceService::TraceString(strTmp, TraceLevel_Normal);

	return;
}
void PriaveteGame::ClearRoom(PrivateTableInfo* pTableInfo)
{
	ASSERT(pTableInfo!=NULL);
	if (pTableInfo==NULL) return;

	ITableFrame* pTableFrame=pTableInfo->pITableFrame;
	ASSERT(pTableFrame!=NULL);
	if (pTableFrame==NULL) return;

	//该桌用户全部离开
	for (int i=0;i<pTableFrame->GetChairCount();i++)
	{
		IServerUserItem* pUserItem=pTableFrame->GetTableUserItem(i);
		if(pUserItem&&pUserItem->GetTableID()!=INVALID_TABLE)
		{
			pTableFrame->PerformStandUpActionEx(pUserItem);
		}
	}
	pTableInfo->restValue();
}

//发送私人场结束消息,结算信息来自每个游戏内部;
void PriaveteGame::SendGamePrivateEndInfo(PrivateTableInfo* pTableInfo)
{
	ITableFrame* pTableFrame = pTableInfo->pITableFrame;
	ASSERT(pTableFrame != NULL);
	if (pTableFrame == NULL) return;

	DataStream kDataStream;
	pTableFrame->GetPrivateEndInfo(kDataStream, true);
	if (kDataStream.size() > 0)
	{
		SendTableData(pTableFrame, MDM_GR_PRIVATE, SUB_GF_GM_PRIVATE_END, &kDataStream[0], kDataStream.size());
	}
}

//用户积分
bool PriaveteGame::OnEventUserItemScore(IServerUserItem * pIServerUserItem, BYTE cbReason)
{
	//效验参数
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	m_pIServerUserItemSink->OnEventUserItemScore(pIServerUserItem,cbReason);
	return true;
}

//用户状态
bool PriaveteGame::OnEventUserItemStatus(IServerUserItem * pIServerUserItem, WORD wOldTableID, WORD wOldChairID)
{
	if(m_pIServerUserItemSink!=NULL)
	{
		return m_pIServerUserItemSink->OnEventUserItemStatus(pIServerUserItem,wOldTableID,wOldChairID);
	}

	return true;
}

//用户权限
bool PriaveteGame::OnEventUserItemRight(IServerUserItem *pIServerUserItem, DWORD dwAddRight, DWORD dwRemoveRight,bool bGameRight)
{
	if(m_pIServerUserItemSink!=NULL)
	{
		return m_pIServerUserItemSink->OnEventUserItemRight(pIServerUserItem,dwAddRight,dwRemoveRight,bGameRight);
	}

	return true;
}

//用户登录
bool PriaveteGame::OnEventUserLogon(IServerUserItem * pIServerUserItem)
{
	return true;
}

//用户登出
bool PriaveteGame::OnEventUserLogout(IServerUserItem * pIServerUserItem)
{
	return true;
}

//进入事件
bool PriaveteGame::OnEventEnterPrivate(DWORD dwSocketID ,VOID* pData,DWORD dwUserIP, bool bIsMobile)
{
	//手机用户
	if(bIsMobile == true)
	{
		//处理消息
		CMD_GR_LogonMobile * pLogonMobile=(CMD_GR_LogonMobile *)pData;
		pLogonMobile->szPassword[CountArray(pLogonMobile->szPassword)-1]=0;
		pLogonMobile->szMachineID[CountArray(pLogonMobile->szMachineID)-1]=0;

		//变量定义
		DBR_GR_LogonMobile LogonMobile;
		ZeroMemory(&LogonMobile,sizeof(LogonMobile));

		//构造数据
		LogonMobile.dwUserID=pLogonMobile->dwUserID;
		LogonMobile.dwClientAddr=dwUserIP;		
		LogonMobile.cbDeviceType=pLogonMobile->cbDeviceType;
		LogonMobile.wBehaviorFlags=pLogonMobile->wBehaviorFlags;
		LogonMobile.wPageTableCount=pLogonMobile->wPageTableCount;		
		lstrcpyn(LogonMobile.szPassword,pLogonMobile->szPassword,CountArray(LogonMobile.szPassword));
		lstrcpyn(LogonMobile.szMachineID,pLogonMobile->szMachineID,CountArray(LogonMobile.szMachineID));

		//投递请求
		m_pIDataBaseEngine->PostDataBaseRequest(LogonMobile.dwUserID,DBR_GR_LOGON_MOBILE,dwSocketID,&LogonMobile,sizeof(LogonMobile));		
	}
	else
	{
		//处理消息
		CMD_GR_LogonUserID * pLogonUserID=(CMD_GR_LogonUserID *)pData;
		pLogonUserID->szPassword[CountArray(pLogonUserID->szPassword)-1]=0;
		pLogonUserID->szMachineID[CountArray(pLogonUserID->szMachineID)-1]=0;

		//变量定义
		DBR_GR_LogonUserID LogonUserID;
		ZeroMemory(&LogonUserID,sizeof(LogonUserID));

		//构造数据
		LogonUserID.dwClientAddr=dwUserIP;
		LogonUserID.dwUserID=pLogonUserID->dwUserID;
		lstrcpyn(LogonUserID.szPassword,pLogonUserID->szPassword,CountArray(LogonUserID.szPassword));
		lstrcpyn(LogonUserID.szMachineID,pLogonUserID->szMachineID,CountArray(LogonUserID.szMachineID));

		//投递请求
		m_pIDataBaseEngine->PostDataBaseRequest(LogonUserID.dwUserID,DBR_GR_LOGON_USERID,dwSocketID,&LogonUserID,sizeof(LogonUserID));
	}
	return true;
}
bool PriaveteGame::AddPrivateAction(ITableFrame* pTbableFrame,DWORD dwChairID, BYTE	bActionIdex)
{
	//PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pTbableFrame);
	//ASSERT(pTableInfo);
	//if (!pTableInfo)
	//{
	//	return true;
	//}
	//if (dwChairID >= 100 || bActionIdex >= MAX_PRIVATE_ACTION)
	//{
	//	return true;
	//}
	//pTableInfo->lPlayerAction[dwChairID][bActionIdex] ++;
	return true;
}

//是不是自由人数场
bool PriaveteGame::IsAutoUserCountRule(ITableFrame* pTbableFrame, bool bReal)
{
	PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pTbableFrame);
	ASSERT(pTableInfo);
	if (!pTableInfo)
	{
		return false;
	}

	if (bReal == false)
	{
		if (pTableInfo->bStart || pTableInfo->bInEnd)
		{
			return false;
		}
	}

	return pTableInfo->IsAutoUserCountRule();
}

bool PriaveteGame::addPrivatePlayCout(ITableFrame* pTbableFrame, WORD wCout)
{
	PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pTbableFrame);
	ASSERT(pTableInfo);
	if (!pTableInfo)
	{
		return true;
	}

	pTableInfo->dwFinishPlayCout += wCout;
	return true;
}
//用户
bool PriaveteGame::OnEventUserJoinPrivate(IServerUserItem * pIServerUserItem, BYTE cbReason,DWORD dwSocketID)
{
	//参数校验
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem == NULL) return false;

	SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GR_PRIVATE_INFO,&m_kPrivateInfo,sizeof(m_kPrivateInfo));

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	//判断状态
	if(pIServerUserItem->GetTableID()!=INVALID_TABLE)
	{
		sendPrivateRoomInfo(pIServerUserItem,getTableInfoByTableID(pIServerUserItem->GetTableID()));
	}
	return true;
}

//用户退赛
bool PriaveteGame::OnEventUserQuitPrivate(IServerUserItem * pIServerUserItem, BYTE cbReason, WORD *pBestRank, DWORD dwContextID)
{
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	return true;
}

//游戏开始
bool PriaveteGame::OnEventGameStart(ITableFrame *pITableFrame, WORD wChairCount)
{
	PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pITableFrame);
	ASSERT(pTableInfo);
	if (!pTableInfo) return true;

	// 是工会房间通知数据库扣费;
	if ((pTableInfo->dwUnionCode != 0) && !pTableInfo->bStart)
	{
		ITableFrame* pTableFrame = pTableInfo->pITableFrame;
		if (NULL != pTableFrame)
		{
			DBR_GR_UnionRoomUser UnionRoomUser;
			ZeroMemory(&UnionRoomUser, sizeof(DBR_GR_UnionRoomUser));
			UnionRoomUser.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;

			UnionRoomUser.CreateUnionRoom.dwUnionCode = pTableInfo->dwUnionCode;
			UnionRoomUser.CreateUnionRoom.dwRoomID = pTableInfo->dwRoomNum;
			UnionRoomUser.CreateUnionRoom.dwCreaterUserID = pTableInfo->dwCreaterUserID;
			UnionRoomUser.CreateUnionRoom.wKindID = m_pGameServiceAttrib->wKindID;
			UnionRoomUser.CreateUnionRoom.dwCost = pTableInfo->dwPlayCost;
			UnionRoomUser.CreateUnionRoom.dwCostType = pTableInfo->cbRoomType;
			UnionRoomUser.CreateUnionRoom.dwGameRuleIdex = pTableInfo->dwGameRuleIdex;

			WORD nUserCount = pTableFrame->GetChairCount();

			for (int i = 0; i < nUserCount; i++)
			{
				IServerUserItem* pServerUserItem = pTableFrame->GetTableUserItem(i);
				if (NULL == pServerUserItem) continue;
				//if (pTableInfo->dwCreaterUserID != INVALID_TABLE && pTableInfo->dwCreaterUserID == pServerUserItem->GetUserID()) continue;
				UnionRoomUser.dwUserID[UnionRoomUser.cbUserCount++] = pServerUserItem->GetUserID();
			}

			m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_UNION_ROOM_USER, 0L, (BYTE*)&UnionRoomUser, sizeof(UnionRoomUser));
		}

		// 自动代开;
		if ((pTableInfo->dwGameRuleIdex&ePrivateTableCommonRule_DaiKaiFang) > 0)
		{
			CMD_GR_AutoCreatePrivate CreatePrivate;

			CreatePrivate.dwIndex = pTableInfo->m_dwDaikaiIndex;
			CreatePrivate.dwUnionCode = pTableInfo->dwUnionCode;							//工会ID
			CreatePrivate.cbUnionGoldOpen = pTableInfo->cbUnionGoldOpen;					// 1 欢乐场, 0普通;
			CreatePrivate.cbGameType = pTableInfo->cbRoomType;								//游戏类型
			CreatePrivate.bPlayCoutIdex = pTableInfo->bPlayCoutIdex;						//游戏局数
			CreatePrivate.bGameTypeIdex = pTableInfo->bGameTypeIdex;						//游戏类型
			CreatePrivate.bGameRuleIdex = pTableInfo->dwGameRuleIdex;						//游戏规则
			CreatePrivate.cbEnterRoomScoreType = pTableInfo->cbEnterRoomScoreType;			//进房间时的分数类型;
			CreatePrivate.lInitEnterRoomScore = pTableInfo->lInitEnterRoomScore;			//进入房间时的分数;
			CreatePrivate.cbBaseScore = pTableInfo->cbBaseScore;

			AutoCreateUnionRoom(CreatePrivate);
		}
	}

	pTableInfo->dwStartPlayCout ++;
	pTableInfo->bStart = true;
	pTableInfo->newRandChild();

	sendPrivateRoomInfo(NULL,pTableInfo);

	// 显示游戏开始;
	CString strDebugInfo = _T("");
	strDebugInfo.Format("EventGameStart RoomID = %d, TableID = %d", pTableInfo->dwRoomNum, pITableFrame->GetTableID());
	::OutputDebugString(strDebugInfo.GetBuffer());

	return true;
}

//游戏结束
bool PriaveteGame::OnEventGameEnd(ITableFrame *pITableFrame,WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
{
	ASSERT(pITableFrame!=NULL);
	if (pITableFrame==NULL) return false;

	PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pITableFrame);
	if (!pTableInfo)
	{
		return true;
	}

	if (pTableInfo->cbRoomType == Type_Private)
	{
		// 显示游戏开始;
		CString strDebugInfo = _T("");
		strDebugInfo.Format("EventGameEnd RoomID = %d, TableID = %d", pTableInfo->dwRoomNum, pITableFrame->GetTableID());
		::OutputDebugString(strDebugInfo.GetBuffer());

		// 一局没结束提前解散不扣房卡;
		if ((cbReason != GER_DISMISS) && (pTableInfo->dwStartPlayCout == 1))
		{
			CreatePrivateCost(pTableInfo);
		}

		if (pITableFrame->IsPrivateEnd())
		{
			DismissRoom(pTableInfo);
			return true;
		}

		sendPrivateRoomInfo(NULL, pTableInfo);
	}
	else if (pTableInfo->cbRoomType == Type_Public)
	{
		CreatePrivateCost(pTableInfo);
		DismissRoom(pTableInfo);
		ClearRoom(pTableInfo);
	}
	return true;
}

//记录游戏积分
bool PriaveteGame::WriteTableScore(ITableFrame* pITableFrame,tagScoreInfo ScoreInfoArray[], WORD wScoreCount,DataStream& kData)
{
	PrivateTableInfo* pTableInfo = getTableInfoByTableFrame(pITableFrame);
	if (!pTableInfo)
	{
		return true;
	}

	// 插入私人场信息;
	tagGameRecord gameRecord;
	gameRecord.StreamValue(kData, false);
	gameRecord.roomInfo.cbRoomType = pTableInfo->cbRoomType;
	gameRecord.roomInfo.bStartGame = pTableInfo->bStart;
	gameRecord.roomInfo.dwRoomNum = pTableInfo->dwRoomNum;
	gameRecord.roomInfo.dwPlayCout = pTableInfo->dwFinishPlayCout - 1;		// 减去当局的局数;
	gameRecord.roomInfo.dwCreateUserID = pTableInfo->dwCreaterUserID;
	gameRecord.roomInfo.bGameRuleIdex = pTableInfo->dwGameRuleIdex;
	gameRecord.roomInfo.bGameTypeIdex = pTableInfo->bGameTypeIdex;
	gameRecord.roomInfo.bPlayCoutIdex = pTableInfo->bPlayCoutIdex;
	gameRecord.roomInfo.dwPlayTotal = pTableInfo->dwPlayCout;

	DataStream tmpGameRecord;
	gameRecord.StreamValue(tmpGameRecord, true);
	pTableInfo->writeSocre(ScoreInfoArray, wScoreCount, tmpGameRecord);

	//写入单一一场数据到数据库;
	std::vector<tagPrivateRandRecordChild>& refkRecordChild = pTableInfo->kTotalRecord.kRecordChild;
	if (refkRecordChild.size() > 0)
	{
		tagPrivateRandRecordChild& refkSingleRecord = refkRecordChild.back();
		refkSingleRecord.iRecordID = pTableInfo->kTotalRecord.iRecordID;

		// 玩家ID;
		CString strUserIDs = "";
		WORD nUserCount = pITableFrame->GetChairCount();
		for (int i = 0; i < nUserCount; i++)
		{
			IServerUserItem* pServerUserItem = pITableFrame->GetTableUserItem(i);
			if (NULL == pServerUserItem) continue;

			CString strTmp = "";

			if (!strUserIDs.IsEmpty())
			{
				strTmp.Format(",%d", pServerUserItem->GetUserID());
			}
			else
			{
				strTmp.Format("%d", pServerUserItem->GetUserID());
			}

			strUserIDs += strTmp;
		}
		refkSingleRecord.kUserDefine = strUserIDs;

		DataStream singleGameRecordData;
		refkSingleRecord.StreamValue(singleGameRecordData, true);

		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_SINGLE_PRIVATE_RECORD, 0L, (BYTE*)&singleGameRecordData[0], singleGameRecordData.size());
	}

	return true;
}

//发送房间信息;
void PriaveteGame::sendPrivateRoomInfo(IServerUserItem * pIServerUserItem,PrivateTableInfo* pTableInfo)
{
	ASSERT(pTableInfo);
	if (!pTableInfo)
	{
		return;
	}

	CMD_GF_Private_Room_Info kNetInfo;
	kNetInfo.cbRoomType = pTableInfo->cbRoomType;
	kNetInfo.bStartGame = pTableInfo->bStart;
	kNetInfo.dwRoomNum = pTableInfo->dwRoomNum;
	//kNetInfo.dwPlayCout = pTableInfo->dwStartPlayCout;
	kNetInfo.dwPlayCout = pTableInfo->dwFinishPlayCout;
	kNetInfo.dwCreateUserID = pTableInfo->dwCreaterUserID;
	kNetInfo.dwUnionCode = pTableInfo->dwUnionCode;
	kNetInfo.bGameRuleIdex = pTableInfo->dwGameRuleIdex;
	kNetInfo.bGameTypeIdex = pTableInfo->bGameTypeIdex;
	kNetInfo.bPlayCoutIdex = pTableInfo->bPlayCoutIdex;
	kNetInfo.dwPlayTotal = pTableInfo->dwPlayCout;
	kNetInfo.dwPlayCost = pTableInfo->dwPlayCost;
	kNetInfo.cbUnionGoldOpen = pTableInfo->cbUnionGoldOpen;
	kNetInfo.lScoreMultiple = pTableInfo->lScoreMultiple;
	kNetInfo.lGameGold = pTableInfo->lGameGold;
	kNetInfo.cbBaseScore = pTableInfo->cbBaseScore;

	kNetInfo.kWinLoseScore.resize(pTableInfo->pITableFrame->GetChairCount());
	//kNetInfo.kScoreInfoArray.resize(pTableInfo->pITableFrame->GetChairCount());
	for (WORD i = 0;i<pTableInfo->pITableFrame->GetChairCount();i++)
	{
		kNetInfo.kWinLoseScore[i] =  (int)pTableInfo->lPlayerWinLose[i];
		//kNetInfo.kScoreInfoArray[i] = pTableInfo->lScoreInfoArray[i];
	}

	DataStream kDataStream;
	kNetInfo.StreamValue(kDataStream,true);
	
	if (pIServerUserItem)
	{
		SendData(pIServerUserItem,MDM_GR_PRIVATE,SUB_GF_PRIVATE_ROOM_INFO,&kDataStream[0],kDataStream.size());
	}
	else
	{
		SendTableData(pTableInfo->pITableFrame,MDM_GR_PRIVATE,SUB_GF_PRIVATE_ROOM_INFO,&kDataStream[0],kDataStream.size());
	}

	// 发生欢乐积分
	if (1 == pTableInfo->cbUnionGoldOpen)
	{
		CMD_GF_Private_Score_Info kScoreInfo;
		kScoreInfo.kScoreInfoArray.resize(pTableInfo->pITableFrame->GetChairCount());
		for (WORD i = 0; i < pTableInfo->pITableFrame->GetChairCount(); i++)
		{
			kScoreInfo.kScoreInfoArray[i] = pTableInfo->lScoreInfoArray[i];
		}

		DataStream kSocreStream;
		kScoreInfo.StreamValue(kSocreStream, true);
		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GF_PRIVATE_SCORE_INFO, &kSocreStream[0], kSocreStream.size());
	}
}

//断线
bool PriaveteGame::OnActionUserOffLine(WORD wChairID, IServerUserItem * pIServerUserItem)
{
	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return false;
	}
	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return false;
	}
	if (pTableInfo->dwCreaterUserID == pIServerUserItem->GetUserID() && !pTableInfo->bInEnd)
	{
		return true;
	}
	if (pTableInfo->bInEnd)
	{
		pTableInfo->pITableFrame->PerformStandUpActionEx(pIServerUserItem);
	}
	else
	{
		// 离线时间;
		WORD wOfflineChairID = pIServerUserItem->GetChairID();
		if (wOfflineChairID != INVALID_CHAIR)
		{
			pTableInfo->fOfflineTimes[wOfflineChairID] = 0;
		}

		//// 是不是自由场;
		//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
		//{
		//	// 可以准备清空;
		//	pTableInfo->bAutoStart[wChairID] = false;
		//}
	}
	return true;
}

//用户坐下
bool PriaveteGame::OnActionUserSitDown(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{ 
	ASSERT(pIServerUserItem);
	if (NULL == pIServerUserItem) return true;


	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (NULL == pTableInfo) return true;
	if (pTableInfo->bInEnd) return false;

	if (pTableInfo->IsSetOneTimeRoomScoreType())
	{	
		//进入房间时赋值为初始积分;
		SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
		pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
	}

	// 是不是自由场;
	if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	{
		// 可以准备清空;
		pTableInfo->mReadyInfo.reset();

		tagAutoUserStatus autoUserStatus;
		autoUserStatus.bStartGame = false;
		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
	}

	return true; 
}

//用户起立
bool PriaveteGame::OnActionUserStandUp(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return true;
	}
	if (pTableInfo->bInEnd)
	{
		return false;
	}

	// 是不是自由场;
	if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	{
		// 可以准备清空;
		pTableInfo->mReadyInfo.reset();

		tagAutoUserStatus autoUserStatus;
		autoUserStatus.bStartGame = false;
		SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
	}

	return true;
}

//随机空位
WORD PriaveteGame::GetNullChairID(ITableFrame * pTableFrame)
{
	//椅子搜索
	for (WORD i = 0; i < pTableFrame->GetChairCount(); i++)
	{
		if (pTableFrame->GetTableUserItem(i) == NULL)
		{
			return i;
		}
	}

	return INVALID_CHAIR;
}

 //用户同意
bool PriaveteGame::OnActionUserOnReady(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{ 
	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return true;
	}
	if (pTableInfo->bInEnd)
	{
		return false;
	}

	if ( pTableInfo->IsEveryTimeRoomScoreType() )
	{	
		//每局重新赋值为初始积分;
		SCORE lScore = pTableInfo->lInitEnterRoomScore - pIServerUserItem->GetUserScore();
		pIServerUserItem->WriteUserScore(lScore, 0, 0, 0, SCORE_TYPE_PRESENT, 1, 0);
	}

	//// 自由人数，通知客户端玩家准备情况;
	//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	//{
	//	//变量定义
	//	bool bReady = *(bool *)pData;

	//	// 第一个准备的人为申请人;
	//	if (pTableInfo->mReadyInfo.wChairID == INVALID_CHAIR)
	//	{
	//		pTableInfo->mReadyInfo.wChairID = wChairID;
	//	}

	//	if (bReady)
	//	{
	//		pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_READY;
	//	}
	//	else
	//	{
	//		pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_REFUSED;
	//	}
	//	

	//	SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));
	//}

	return true; 
}

//判断房卡是否够
bool PriaveteGame::OnActionUserFangKaCheck(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, SCORE lUserInsure)
{
	ASSERT(pIServerUserItem);
	if (NULL == pIServerUserItem) return true;

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(wTableID);
	if (NULL == pTableInfo) return true;
	if (pTableInfo->bInEnd) return false;

	if (pTableInfo->IsCardAARule())
	{
		ASSERT((pTableInfo->dwPlayCost / pTableInfo->pITableFrame->GetChairCount())>0);

		// AA 情况下判断房卡数量;
		if (lUserInsure < (pTableInfo->dwPlayCost / pTableInfo->pITableFrame->GetChairCount()))
		{
			return false;
		}
	}

	return true;
}

//用户可以开始
bool PriaveteGame::OnActionUserOnStart(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
	//效验参数
	ASSERT(wDataSize == sizeof(tagAutoUserStatus));
	if (wDataSize != sizeof(tagAutoUserStatus)) return false;
	if (pData == nullptr) return false;

	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(wTableID);;

	if (pIServerUserItem->GetTableID() != INVALID_TABLE)
	{
		ASSERT(pIServerUserItem->GetTableID() == wTableID);
	}

	if (!pTableInfo)
	{
		return true;
	}

	if (pTableInfo->bInEnd)
	{
		return false;
	}

	// 是不是自由场;
	if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	{
		// 断线重连;
		if (pTableInfo->mReadyInfo.wChairID != INVALID_CHAIR)
		{
			//SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));

			if (pTableInfo->bInEnd || pTableInfo->bStart) return true;

			pTableInfo->mReadyInfo.reset();

			// 通知客户端可以重新准备;
			tagAutoUserStatus autoUserStatus;
			autoUserStatus.bStartGame = true;
			SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
		}
		else
		{
			tagAutoUserStatus autoUserStatus;
			CopyMemory(&autoUserStatus, pData, sizeof(tagAutoUserStatus));
			SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
		}
	}

	return true;
}

//用户开始游戏
bool PriaveteGame::OnActionUserStartGame(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
	//效验参数
	ASSERT(wDataSize == sizeof(bool));
	if (wDataSize != sizeof(bool)) return false;
	if (pData == nullptr) return false;

	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}

	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return true;
	}
	if (pTableInfo->bInEnd || pTableInfo->bStart)
	{
		return false;
	}

	ITableFrame* pTableFrame = pTableInfo->pITableFrame;
	ASSERT(pTableFrame != NULL);
	if (pTableFrame == NULL) return false;

	// 自由人数，通知客户端玩家准备情况;
	if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	{
		//变量定义
		bool bReady = *(bool *)pData;

		// 判断是否可以开始游戏
		if (bReady && EfficacyStartGame(pTableInfo, wChairID))
		{
			if (!pTableFrame->IsGameStarted())
			{
				bool bSuccess = pTableFrame->StartGame();
				if (bSuccess == false)
				{
					CTraceService::TraceString(TEXT("PriaveteGame 开始游戏失败！"), TraceLevel_Exception);
					return false;
				}
			}

			return true;
		}
		else
		{
			// 第一个准备的人为申请人;
			if (pTableInfo->mReadyInfo.wChairID == INVALID_CHAIR)
			{
				pTableInfo->mReadyInfo.wChairID = wChairID;
			}

			if (bReady)
			{
				pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_READY;
			}
			else
			{
				pTableInfo->mReadyInfo.cbReady[wChairID] = RIT_REFUSED;
			}
			
			SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_READY, &pTableInfo->mReadyInfo, sizeof(pTableInfo->mReadyInfo));

			// 一个人拒绝之后就要重新开始;
			if (!bReady)
			{
				//pTableInfo->mReadyInfo.reset();
				m_pITimerEngine->SetTimer(IDI_AUTO_USER_RESET + pTableFrame->GetTableID(), NOT_AUTO_USER_TIME*1000L, 1, 0);
			}
		}
	}

	return true;
}

//开始效验
bool PriaveteGame::EfficacyStartGame(PrivateTableInfo* pTableInfo, WORD wReadyChairID)
{
	//状态判断
	if (!pTableInfo) return true;
	if (pTableInfo->bInEnd || pTableInfo->bStart) return false;

	ITableFrame* pTableFrame = pTableInfo->pITableFrame;
	ASSERT(pTableFrame != NULL);
	if (pTableFrame == NULL) return false;

	WORD  wChairCount = pTableInfo->getChairCout();

	//准备人数
	WORD wReadyUserCount = 0;
	for (WORD i = 0; i < wChairCount; i++)
	{
		//获取用户
		IServerUserItem * pITableUserItem = pTableFrame->GetTableUserItem(i);
		if (pITableUserItem == NULL) continue;

		//用户统计
		if (pITableUserItem != NULL)
		{
			//状态判断(离线前的状态如果是准备状态)
			if (pITableUserItem->IsClientReady() == false) return false;

			BYTE cbReady = pTableInfo->mReadyInfo.cbReady[i];
			if ((wReadyChairID != i) && (cbReady != RIT_READY)) return false;

			//用户计数
			wReadyUserCount++;
		}
	}

	// 自由人数场;
	if (pTableInfo->IsAutoUserCountRule())
	{
		//数目判断
		if (wReadyUserCount >= 2L) return true;
		return false;
	}

	return false;
}


bool PriaveteGame::OnEventReqStandUP(IServerUserItem * pIServerUserItem)
{
	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}
	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	ASSERT(pTableInfo);
	if (!pTableInfo)
	{
		return true;
	}
	if (pTableInfo->bStart && !pTableInfo->bInEnd)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("游戏已经开始，无法退出。"),SMT_EJECT);
		return true;
	}
	if (getTableInfoByCreaterID(pIServerUserItem->GetUserID()) && !pTableInfo->bInEnd)
	{
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("您已返回大厅,房间将会继续保留。"),SMT_CLOSE_GAME);
		return true;
	}

	// 如果是工会房间，去数据库离开桌子;
	DBR_GR_WriteUnionRoomChairID JoinRoomUser;
	ZeroMemory(&JoinRoomUser, sizeof(JoinRoomUser));
	JoinRoomUser.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
	JoinRoomUser.wChairID = pIServerUserItem->GetChairID();
	JoinRoomUser.dwUserID = 0;
	m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_WRITE_UNION_CHAIRID, 0L, (BYTE*)&JoinRoomUser, sizeof(DBR_GR_WriteUnionRoomChairID));


	pTableInfo->pITableFrame->PerformStandUpActionEx(pIServerUserItem);
	
	//// 是不是自由场;
	//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	//{
	//	// 可以准备清空;
	//	pTableInfo->bAutoStart[pIServerUserItem->GetChairID()] = false;

	//	// 发送状态;
	//	SendAutoUserStatus(pTableInfo);
	//}

	return true;
}
bool PriaveteGame::OnEventClientReady(WORD wChairID,IServerUserItem * pIServerUserItem)
{
	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}
	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return true;
	}
	//sendPrivateRoomInfo(pIServerUserItem,pTableInfo);

	//if (pTableInfo->pITableFrame->GetGameStatus() == GAME_STATUS_FREE)
	//{
	//	pIServerUserItem->SetUserStatus(US_READY,
	//		pTableInfo->pITableFrame->GetTableID(),wChairID);
	//}

	if (pTableInfo->kDismissChairID.size())
	{
		CMD_GF_Private_Dismiss_Info kNetInfo;
		kNetInfo.dwDissUserCout = pTableInfo->kDismissChairID.size();
		kNetInfo.dwNotAgreeUserCout = pTableInfo->kNotAgreeChairID.size();
		for (int i = 0;i<(int)pTableInfo->kDismissChairID.size();i++)
		{
			kNetInfo.dwDissChairID[i] = pTableInfo->kDismissChairID[i];
		}
		for (int i = 0;i<(int)pTableInfo->kNotAgreeChairID.size();i++)
		{
			kNetInfo.dwNotAgreeChairID[i] = pTableInfo->kNotAgreeChairID[i];
		}
		SendTableData(pTableInfo->pITableFrame,MDM_GR_PRIVATE,SUB_GR_PRIVATE_DISMISS,&kNetInfo,sizeof(kNetInfo));
	}

	//// 是不是自由场;
	//if (pTableInfo->IsAutoUserCountRule() && !pTableInfo->bStart)
	//{
	//	// 发送状态;
	//	SendAutoUserStatus(pTableInfo);
	//}

	return true;
}

//同步私人场信息
bool PriaveteGame::OnEventPrivateRoomInfo(WORD wChairID, IServerUserItem * pIServerUserItem)
{
	ASSERT(pIServerUserItem);
	if (!pIServerUserItem)
	{
		return true;
	}
	PrivateTableInfo* pTableInfo = getTableInfoByTableID(pIServerUserItem->GetTableID());
	if (!pTableInfo)
	{
		return true;
	}
	sendPrivateRoomInfo(pIServerUserItem, pTableInfo);

}

void PriaveteGame::CreaterPlayerPrivateCost(PrivateTableInfo* pTableInfo)
{
	DBR_GR_Create_Private_Cost kNetInfo;
	kNetInfo.dwUserID = pTableInfo->dwCreaterUserID;
	kNetInfo.wKindID = m_pGameServiceOption->wKindID;
	kNetInfo.dwRoomID = pTableInfo->dwRoomNum;
	kNetInfo.dwCost = pTableInfo->dwPlayCost;
	kNetInfo.dwCostType = pTableInfo->cbRoomType;
	kNetInfo.dwGameRuleIdex = pTableInfo->dwGameRuleIdex;
	m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_CREATE_PRIVAT_COST, 0L, &kNetInfo, sizeof(kNetInfo));
}

void PriaveteGame::EveryOnePrivateCost(PrivateTableInfo* pTableInfo, bool bDivideCost)
{
	if (NULL == pTableInfo) return;

	ITableFrame* pTableFrame = pTableInfo->pITableFrame;
	if ( NULL == pTableFrame) return;

	WORD nUserCount = pTableFrame->GetChairCount();
	DWORD dwCost	= pTableInfo->dwPlayCost;
	if (bDivideCost && nUserCount!=0)
	{
		dwCost = (dwCost / nUserCount);
	}
	for (int i = 0; i < nUserCount; i++)
	{
		IServerUserItem* pServerUserItem = pTableFrame->GetTableUserItem(i);
		if (NULL == pServerUserItem) continue;

		DBR_GR_Create_Private_Cost kNetInfo;
		kNetInfo.dwUserID = pServerUserItem->GetUserID();
		kNetInfo.wKindID = m_pGameServiceOption->wKindID;
		kNetInfo.dwRoomID = pTableInfo->dwRoomNum;
		kNetInfo.dwCost = dwCost;
		kNetInfo.dwCostType = pTableInfo->cbRoomType;
		kNetInfo.dwGameRuleIdex = pTableInfo->dwGameRuleIdex;
		m_pIDataBaseEngine->PostDataBaseRequest(0L, DBR_GR_CREATE_PRIVAT_COST, 0L, &kNetInfo, sizeof(kNetInfo));
	}
}

void PriaveteGame::gameEnd(PrivateTableInfo* pTableInfo)
{
	ASSERT(pTableInfo != nullptr);

	ITableFrame* pITableFrame = pTableInfo->pITableFrame;
	ASSERT(pITableFrame != nullptr);
	if (nullptr == pITableFrame) return;

	DBO_GR_PrivateGameEnd mGameEnd;
	mGameEnd.wKindID = m_pGameServiceOption->wKindID;
	mGameEnd.wServerID = m_pGameServiceOption->wServerID;
	mGameEnd.wPlayCount = (WORD)pTableInfo->dwFinishPlayCout;

	WORD wChairCount = pITableFrame->GetChairCount();
	for (WORD i = 0; i < wChairCount; i++)
	{
		IServerUserItem * pServerItem = pITableFrame->GetTableUserItem(i);
		if (pServerItem == nullptr)
		{
			continue;
		}

		mGameEnd.dwUserID = pServerItem->GetUserID();
		mGameEnd.lScore = pServerItem->GetUserScore();
		mGameEnd.dwCardLibIndex = pServerItem->getCardLibIndex();
		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_PRIVATE_GAME_END, 0, &mGameEnd, sizeof(DBO_GR_PrivateGameEnd));
	}
}

void PriaveteGame::CalcUnionScore(PrivateTableInfo* pTableInfo)
{
	if (NULL == pTableInfo) return;

	ITableFrame* pTableFrame = pTableInfo->pITableFrame;
	if (NULL == pTableFrame) return;

	// 通知数据库操作;
	DBR_GR_UnionRoomEnd UnionRoomEnd;
	ZeroMemory(&UnionRoomEnd, sizeof(DBR_GR_UnionRoomEnd));

	UnionRoomEnd.dwUnionConsumerID = pTableInfo->dwUnionConsumerID;
	UnionRoomEnd.dwUnionCode = pTableInfo->dwUnionCode;
	UnionRoomEnd.cbUserCount = (BYTE)pTableInfo->getChairCout();

	// 积分场才去处理;
	if (1 != pTableInfo->cbUnionGoldOpen)
	{
		for (int i = 0; i < UnionRoomEnd.cbUserCount; i++)
		{
			IServerUserItem * pServerItem = pTableFrame->GetTableUserItem(i);
			if (pServerItem == nullptr)
			{
				continue;
			}

			UnionRoomEnd.dwUserID[i] = pServerItem->GetUserID();
			UnionRoomEnd.lUserScore[i] = pTableInfo->lPlayerWinLose[i];
		}

		m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_UNION_ROOM_END, 0L, (BYTE*)&UnionRoomEnd, sizeof(UnionRoomEnd));
		return;
	}
	
	// 计算积分，找到大赢家分数;
	SCORE lMaxScore = 0;
	for (int i = 0; i < UnionRoomEnd.cbUserCount; i++)
	{
		IServerUserItem * pServerItem = pTableFrame->GetTableUserItem(i);
		if (pServerItem == nullptr)
		{
			continue;
		}

		UnionRoomEnd.dwUserID[i] = pServerItem->GetUserID();
		/*UnionRoomEnd.lUserScore[i] = pTableInfo->lPlayerWinLose[i] * pTableInfo->lScoreMultiple * pTableInfo->cbBaseScore;*/
		UnionRoomEnd.lUserScore[i] = pTableInfo->lPlayerWinLose[i] * pTableInfo->cbBaseScore;

		if (UnionRoomEnd.lUserScore[i] > lMaxScore)
		{
			lMaxScore = UnionRoomEnd.lUserScore[i];
		}
	}

	// 统计大赢家数量;
	int iMaxScoreCount = 0;
	for (int j = 0; j < UnionRoomEnd.cbUserCount; j++)
	{
		if ((lMaxScore > 0) && (UnionRoomEnd.lUserScore[j] == lMaxScore))
		{
			iMaxScoreCount++;
		}
	}

	if (iMaxScoreCount > 0)
	{
		// 佣金
		SCORE lGameGold = pTableInfo->lGameGold * pTableInfo->dwPlayCost;

		// 计算玩家积分;
		SCORE lRevenue = floor(lGameGold / iMaxScoreCount);

		// 重新计算积分, 统计扣税;
		for (int k = 0; k < UnionRoomEnd.cbUserCount; k++)
		{
			if ((lMaxScore > 0) && (UnionRoomEnd.lUserScore[k] == lMaxScore))
			{
				if (UnionRoomEnd.lUserScore[k] > lRevenue)
				{
					UnionRoomEnd.lUserScore[k] -= lRevenue;
					UnionRoomEnd.lRevenue += lRevenue;
				}
				else
				{
					UnionRoomEnd.lRevenue += UnionRoomEnd.lUserScore[k];
					UnionRoomEnd.lUserScore[k] = 0;
				}
			}
		}
	}

	m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_UNION_ROOM_END, 0L, (BYTE*)&UnionRoomEnd, sizeof(UnionRoomEnd));

	// 写每个玩家积分;
	for (int i = 0; i < UnionRoomEnd.cbUserCount; i++)
	{
		IServerUserItem* pServerUserItem = pTableFrame->GetTableUserItem(i);
		if (NULL == pServerUserItem) continue;
		
		// 有输赢才写数据库;
		if (UnionRoomEnd.lUserScore[i] != 0)
		{
			DBR_GR_UnionScore unionScore;
			ZeroMemory(&unionScore, sizeof(DBR_GR_UnionScore));

			unionScore.dwUserID = pServerUserItem->GetUserID();
			unionScore.dwUnoinCode = pTableInfo->dwUnionCode;
			unionScore.lUserScore = UnionRoomEnd.lUserScore[i];

			m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_WRITE_UNION_SCORE, 0L, (BYTE*)&unionScore, sizeof(unionScore));
		}
	}
}

////发送自由人数玩家状态
//void PriaveteGame::SendAutoUserStatus(PrivateTableInfo* pTableInfo)
//{
//	if (pTableInfo == nullptr) return;
//
//	// 结束了或者已经开始了，就不处理该消息;
//	if (pTableInfo->bInEnd || pTableInfo->bStart)return;
//
//	// 不是自由人数场;
//	if (!pTableInfo->IsAutoUserCountRule()) return;
//
//	// 通知客户端可以开始游戏了;
//	tagAutoUserStatus autoUserStatus;
//	ZeroMemory(&autoUserStatus, sizeof(tagAutoUserStatus));
//	
//	autoUserStatus.wChairCount = pTableInfo->pITableFrame->GetChairCount();
//	CopyMemory(autoUserStatus.bAutoUserStatus, pTableInfo->bAutoStart, sizeof(bool)*autoUserStatus.wChairCount);
//	
//	SendTableData(pTableInfo->pITableFrame, MDM_GR_PRIVATE, SUB_GR_AUTO_USER_STATUS, &autoUserStatus, sizeof(autoUserStatus));
//
//}