zhujimajiang_redis/俱乐部/Source/ServerControl/CorrespondServer/AttemperEngineSink.cpp

#include "StdAfx.h"
#include "AttemperEngineSink.h"
#include "GetRandom.h"
#include "CorrespondServer.h"
#include "CorrespondServerDlg.h"

extern   CCorrespondServerApp theApp;
//////////////////////////////////////////////////////////////////////////////////
//定时器定义

#define IDI_LOAD_PLATFORM_PARAMETER		1							//加载参数
#define IDI_CHK_GAME_SERVER				2							//心跳
#define IDI_LOAD_SEND_LIST				3							//轮训数据库
#define TIME_LOAD_PLATFORM_PARAMETER	600000						//时间间隔

#define IDI_ROOM						4							//检查清楚超时房间
#define TIME_ROOM_PARAMETER				60*1000						//时间间隔1分钟


///[---add by yd
#define TIMER_ID_CHK_LOGON_SERVER	   6							  //检查LogonServer的定时器id
#define TIMES_CHECK_LOGONSERVER        2*TIMES_LOGONSERVER_HEARTBEAT  //检查LogonServer的定时器的时间间隔
///---]
//////////////////////////////////////////////////////////////////////////////////

//构造函数
CAttemperEngineSink::CAttemperEngineSink()
{
	//状态变量
	m_wCollectItem = INVALID_WORD;

	//设置变量
	m_pInitParameter = NULL;
	m_pBindParameter = NULL;

	//组件变量
	m_pITimerEngine = NULL;
	m_pITCPNetworkEngine = NULL;
	m_GlobalInfoManager.SetFromP(this);
	return;
}

//析构函数
CAttemperEngineSink::~CAttemperEngineSink()
{
}

//接口查询
VOID * CAttemperEngineSink::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(IAttemperEngineSink, Guid, dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(IAttemperEngineSink, Guid, dwQueryVer);
	return NULL;
}

//启动事件
bool CAttemperEngineSink::OnAttemperEngineStart(IUnknownEx * pIUnknownEx)
{
	//绑定参数
	m_pBindParameter = new tagBindParameter[m_pInitParameter->m_wMaxConnect];
	ZeroMemory(m_pBindParameter, sizeof(tagBindParameter)*m_pInitParameter->m_wMaxConnect);
	
	//设置定时器
#ifndef _DEBUG
	m_pITimerEngine->SetTimer(IDI_LOAD_PLATFORM_PARAMETER, TIME_LOAD_PLATFORM_PARAMETER, TIMES_INFINITY, 0);
#else
	m_pITimerEngine->SetTimer(IDI_LOAD_PLATFORM_PARAMETER, 10*60*1000, TIMES_INFINITY, 0);
#endif

#ifdef _DEBUG
	m_pITimerEngine->SetTimer(IDI_CHK_GAME_SERVER, 3500, TIMES_INFINITY, 0);
#else
	m_pITimerEngine->SetTimer(IDI_CHK_GAME_SERVER, 3500, TIMES_INFINITY, 0);
#endif
	//m_pITimerEngine->SetTimer(IDI_CHK_GAME_SERVER, 3500, TIMES_INFINITY, 0);

	m_pITimerEngine->SetTimer(IDI_ROOM, TIME_ROOM_PARAMETER, TIMES_INFINITY, 0);

	///[---add by yd   检查登录服务器
	m_pITimerEngine->SetTimer(TIMER_ID_CHK_LOGON_SERVER, TIMES_CHECK_LOGONSERVER, TIMES_INFINITY, 0);
	///---]
	return true;
}

//停止事件
bool CAttemperEngineSink::OnAttemperEngineConclude(IUnknownEx * pIUnknownEx)
{
	//状态变量
	m_wCollectItem = INVALID_WORD;
	m_WaitCollectItemArray.RemoveAll();

	//设置变量
	m_pITimerEngine = NULL;
	m_pITCPNetworkEngine = NULL;

	//删除数据
	SafeDeleteArray(m_pBindParameter);

	//设置组件
	m_GlobalInfoManager.ResetData();
	m_GlobalInfoManager.SetFromP(this);

	///+++2017-9-18清理下界面
	CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
	if (p)
	{
		while (true)
		{
			if (p->bbb.ItemHasChildren(p->hbbRoot))
			{
				HTREEITEM hChildItem = p->bbb.GetChildItem(p->hbbRoot);
				p->bbb.DeleteItem(hChildItem);
			}
			else
			{
				break;
			}
		}

		while (true)
		{
			if (p->ServiceTree.ItemHasChildren(p->hRoot))
			{
				HTREEITEM hChildItem = p->ServiceTree.GetChildItem(p->hRoot);
				p->ServiceTree.DeleteItem(hChildItem);
			}
			else
			{
				break;
			}
		}

		m_ServiceIDMap.RemoveAll();				
		m_LoginServiceIDMap.RemoveAll();
	}

	

	return true;
}

//控制事件
bool CAttemperEngineSink::OnEventControl(WORD wIdentifier, VOID * pData, WORD wDataSize)
{
	return false;
}

//调度事件
bool CAttemperEngineSink::OnEventAttemperData(WORD wRequestID, VOID * pData, WORD wDataSize)
{
	return false;
}

//同步事件
bool CAttemperEngineSink::OnTongBu(int Command, DWORD dwContextID, VOID * pData, WORD wDataSize)
{
	return true;
}
//时间事件
bool CAttemperEngineSink::OnEventTimer(DWORD dwTimerID, WPARAM wBindParam)
{
	//加载参数
	if (IDI_LOAD_PLATFORM_PARAMETER == dwTimerID)
	{
		//发送通知
		m_pITCPNetworkEngine->SendDataBatch(MDM_CS_MANAGER_SERVICE, SUB_CS_S_PLATFORM_PARAMETER, 0, 0, 0L);

		return true;
	}
	else if (IDI_ROOM == dwTimerID)
	{
		CTime tm; tm = CTime::GetCurrentTime();

		if (tm.GetHour() == 4
			&& (tm.GetMinute() == 0 
			|| tm.GetMinute() == 1))
		{
			//检测超时房间
			CMapRoomList* pCMapRoomList = m_GlobalInfoManager.GetRoomData();

			pCMapRoomList->RemoveAll();
			m_GlobalInfoManager.GetPrivateRoom()->RemoveAll();
		/*look3:
			POSITION pos = pCMapRoomList->GetStartPosition();

			while (pos)
			{
				DWORD dTest;
				JN_GR_RoomListGroup temp;
				ZeroMemory(&temp, sizeof(temp));

				pCMapRoomList->GetNextAssoc(pos, dTest, temp);

				int iNum = 0;
				if (temp.Num > 10) temp.Num = 10;

			look2:
				for (size_t i = 0; i <temp.Num; i++)
				{
					if (temp.jgrDate[i].dwRoomNumber != 0)
					{
						DWORD dTime = GetTickCount();

						if ((dTime - temp.jgrDate[i].InsertTime) > 1000 * 60 * 60 * 23)
						{
							//超过一天则清楚
							if (temp.Num == 0)
							{
								//清除这个人的信息
								pCMapRoomList->RemoveKey(dTest);

								CString csTest;
								csTest.Format(_T("超时清除 用户ID:%d"), dTest);
								CTraceService::TraceString(csTest, TraceLevel_Normal);
								goto look3;
							}
							else
							{
								DWORD dRoomID = 0;
								dRoomID = temp.jgrDate[i].dwRoomNumber;
								temp.jgrDate[i] = temp.jgrDate[temp.Num - 1];
								ZeroMemory(&(temp.jgrDate[temp.Num - 1]), sizeof(temp.jgrDate[temp.Num - 1]));

								CString csTest;
								csTest.Format(_T("超时清除 房间ID:%d"), dRoomID);
								CTraceService::TraceString(csTest, TraceLevel_Normal);

								if (temp.Num > 0) temp.Num--;
							}
							goto  look2;
						}
					}
				}

				pCMapRoomList->SetAt(dTest, temp);
			}*/
		}

		return true;
	}
	else if (IDI_CHK_GAME_SERVER == dwTimerID)
	{
		POSITION Position = NULL;
		DWORD dwCurrentTime = (DWORD)time(NULL);
		bool bDel = false;
		do
		{
			//获取对象
			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.EnumServerItem(Position);

			//设置数据
			if (pGlobalServerItem != NULL)
			{
				if (dwCurrentTime - pGlobalServerItem->m_GameServer.dwLiveTime > SEVERTIMEOUT)
				{
					DWORD dTime = dwCurrentTime - pGlobalServerItem->m_GameServer.dwLiveTime;
					CString str;
					str.Format(TEXT("通讯失败超时断开，注销GameServer [%d]%s:%d, 超时时间%d 当前时间%d"), pGlobalServerItem->GetServerID(), pGlobalServerItem->m_GameServer.szServerAddr, pGlobalServerItem->m_GameServer.wServerPort, dTime, dwCurrentTime);
					CTraceService::TraceString(str, TraceLevel_Warning);

					//变量定义
					CMD_CS_S_ServerRemove ServerRemove;
					ZeroMemory(&ServerRemove, sizeof(ServerRemove));

					//删除通知
					ServerRemove.wServerID = pGlobalServerItem->GetServerID();
					m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_REMOVE, &ServerRemove, sizeof(ServerRemove), 0L);

					//注销房间
					m_GlobalInfoManager.DeleteServerItem(pGlobalServerItem->GetServerID());

					bDel = true;
				}
			}

		} while (Position != NULL);

		if (bDel)
		{
			Position = NULL;
			CTraceService::TraceString(TEXT("当前的GameServer列表："), TraceLevel_Normal);
			do
			{
				//获取对象
				CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.EnumServerItem(Position);

				if (pGlobalServerItem != NULL)
				{
					CString str;
					str.Format(TEXT("[%d] %s : %d"), pGlobalServerItem->GetServerID(), pGlobalServerItem->m_GameServer.szServerAddr, pGlobalServerItem->m_GameServer.wServerPort);
					CTraceService::TraceString(str, TraceLevel_Normal);
				}

			} while (Position != NULL);
		}

		return true;
	}
	///[--- add by yd  检查登录服务器是否掉线
	else if (TIMER_ID_CHK_LOGON_SERVER == dwTimerID)
	{
		//static int iCount = 0;
		//iCount++;

		POSITION Position = NULL;
		DWORD dwCurrentTime = GetTickCount(); ///--(DWORD)time(NULL);
		bool bDel = false;
		do
		{
			//获取对象
			CGlobalPlazaItem * pGlobalServerItem = m_GlobalInfoManager.EnumPlazaItem(Position);

			//设置数据
			if (pGlobalServerItem != NULL)
			{
				///---超过上报时间的3倍时长（即3次都没有收到心跳）
				if ((dwCurrentTime - pGlobalServerItem->m_GamePlaza.dwLiveTime) > 5 * TIMES_LOGONSERVER_HEARTBEAT)
				{
					DWORD dTime = dwCurrentTime - pGlobalServerItem->m_GamePlaza.dwLiveTime;
					CString str;
					str.Format(TEXT("**登录通讯失败超时断开，注销LogonServer [%d]%s, 超时时间%d 当前时间%d"),
						pGlobalServerItem->GetPlazaServerID(), 
						pGlobalServerItem->m_GamePlaza.szServerAddr, 
						dTime, dwCurrentTime);

					CTraceService::TraceString(str, TraceLevel_Warning);

					
					HTREEITEM hTemp;
					if (m_LoginServiceIDMap.Lookup(pGlobalServerItem->m_GamePlaza.wPlazaID, hTemp))
					{
						CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
						if (p)
						{
							p->bbb.DeleteItem(hTemp);
						}
						m_LoginServiceIDMap.RemoveKey(pGlobalServerItem->m_GamePlaza.wPlazaID);
					}	
					else
					{
						//提示消息
						CString cstr = L"";
						cstr.Format(L"超过上报m_LoginServiceIDMap hTemp不存在：%d", pGlobalServerItem->m_GamePlaza.wPlazaID);
						CTraceService::TraceString(cstr, TraceLevel_Warning);
						//CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
						//if (p)
						//{
						//	CString csIpPort;
						//	csIpPort.Format(L"%s:%s 编号[%d]", CString(pGlobalServerItem->m_GamePlaza.szServerAddr), pGlobalServerItem->m_GamePlaza.szServerName, pGlobalServerItem->m_GamePlaza.wPlazaID);
						//	HTREEITEM aa = p->bbb.InsertItem(csIpPort, 1, 1, p->hbbRoot, TVI_LAST);
						//	p->bbb.SetItemData(aa, 0);
						//	m_LoginServiceIDMap[pGlobalServerItem->m_GamePlaza.wPlazaID] = aa;
						//}
					}

					//删除登录服务器
					m_GlobalInfoManager.DeletePlazaItem(pGlobalServerItem->m_GamePlaza.wPlazaID);

					bDel = true;
				}
			}

		} while (Position != NULL);

		if (bDel)
		{
			Position = NULL;
			CTraceService::TraceString(TEXT("当前的LogonServer列表："), TraceLevel_Normal);
			do
			{
				//获取对象
				CGlobalPlazaItem * pGlobalServerItem = m_GlobalInfoManager.EnumPlazaItem(Position);

				if (pGlobalServerItem != NULL)
				{
					CString str;
					str.Format(TEXT("[%d]-%s"), pGlobalServerItem->GetPlazaServerID(), pGlobalServerItem->m_GamePlaza.szServerAddr);
					CTraceService::TraceString(str, TraceLevel_Normal);
				}

			} while (Position != NULL);
		}

		return true;
	}

	return false;
}

//应答事件
bool CAttemperEngineSink::OnEventTCPNetworkBind(DWORD dwClientAddr, DWORD dwSocketID)
{
	//获取索引
	ASSERT(LOWORD(dwSocketID) < m_pInitParameter->m_wMaxConnect);
	if (LOWORD(dwSocketID) >= m_pInitParameter->m_wMaxConnect) return false;

	//变量定义
	WORD wBindIndex = LOWORD(dwSocketID);
	tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

	//设置变量
	pBindParameter->dwSocketID = dwSocketID;
	pBindParameter->dwClientAddr = dwClientAddr;
	pBindParameter->dwActiveTime = (DWORD)time(NULL);

	return true;
}

//读取事件
bool CAttemperEngineSink::OnEventTCPNetworkRead(TCP_Command Command, VOID * pData, WORD wDataSize, DWORD dwSocketID)
{
	switch (Command.wMainCmdID)
	{
	case MDM_CS_REGISTER:		//服务注册
	{
		return OnTCPNetworkMainRegister(Command.wSubCmdID, pData, wDataSize, dwSocketID);
	}
	case MDM_CS_SERVICE_INFO:	//服务信息
	{
		return OnTCPNetworkMainServiceInfo(Command.wSubCmdID, pData, wDataSize, dwSocketID);
	}
	case MDM_CS_USER_COLLECT:	//用户命令
	{
		return OnTCPNetworkMainUserCollect(Command.wSubCmdID, pData, wDataSize, dwSocketID);
	}
	case MDM_CS_REMOTE_SERVICE:	//远程服务
	{
		return OnTCPNetworkMainRemoteService(Command.wSubCmdID, pData, wDataSize, dwSocketID);
	}
	case MDM_CS_MANAGER_SERVICE: //管理服务
	{
		return OnTCPNetworkMainManagerService(Command.wSubCmdID, pData, wDataSize, dwSocketID);
	}
	//case MDM_CS_ANDROID_SERVICE: //机器服务
	//{
	//	return OnTCPNetworkMainAndroidService(Command.wSubCmdID, pData, wDataSize, dwSocketID);
	//}
	default: break;
	}

	return false;
}

//关闭事件  ---会话Socket断开
bool CAttemperEngineSink::OnEventTCPNetworkShut(DWORD dwClientAddr, DWORD dwActiveTime, DWORD dwSocketID)
{
	//获取信息
	WORD wBindIndex = LOWORD(dwSocketID);
	tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

	//游戏服务 ---GameServer断开
	if (pBindParameter->ServiceKind == ServiceKind_Game)
	{
		//变量定义
		WORD wBindIndexTemp = LOWORD(dwSocketID);

		//汇总处理
		if (wBindIndexTemp == m_wCollectItem)
		{
			//设置变量
			m_wCollectItem = INVALID_WORD;

			//汇总切换
			if (m_WaitCollectItemArray.GetCount() > 0)
			{
				//提取变量
				INT_PTR nWaitCount = m_WaitCollectItemArray.GetCount();
				m_wCollectItem = m_WaitCollectItemArray[nWaitCount - 1];

				//删除数组
				m_WaitCollectItemArray.RemoveAt(nWaitCount - 1);

				//发送消息
				DWORD dwSocketIDTemp = (m_pBindParameter + m_wCollectItem)->dwSocketID;
				m_pITCPNetworkEngine->SendData(dwSocketIDTemp, MDM_CS_USER_COLLECT, SUB_CS_S_COLLECT_REQUEST);
			}
		}
		else
		{
			//删除等待
			for (INT_PTR i = 0; i < m_WaitCollectItemArray.GetCount(); i++)
			{
				if (wBindIndexTemp == m_WaitCollectItemArray[i])
				{
					m_WaitCollectItemArray.RemoveAt(i);
					break;
				}
			}
		}

		//变量定义
		CMD_CS_S_ServerRemove ServerRemove;
		ZeroMemory(&ServerRemove, sizeof(ServerRemove));

		//删除通知
		ServerRemove.wServerID = pBindParameter->wServiceID;
		m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_REMOVE, &ServerRemove, sizeof(ServerRemove), 0L);

		//注销房间
		m_GlobalInfoManager.DeleteServerItem(pBindParameter->wServiceID);
		
		HTREEITEM hTemp;
		if (m_ServiceIDMap.Lookup(pBindParameter->wServiceID, hTemp))
		{
			CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
			if (p)
			{
				p->ServiceTree.DeleteItem(hTemp);
			}

			m_ServiceIDMap.RemoveKey(pBindParameter->wServiceID);
		}

		POSITION Position = NULL;
		
		CTraceService::TraceString(TEXT("GameServer被动断开断开，当前的GameServer列表："), TraceLevel_Normal);

		do
		{
			//获取对象
			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.EnumServerItem(Position);

			if (pGlobalServerItem != NULL)
			{
				CString str;
				str.Format(TEXT("[%d] %s : %d"), pGlobalServerItem->GetServerID(), pGlobalServerItem->m_GameServer.szServerAddr, pGlobalServerItem->m_GameServer.wServerPort);
				CTraceService::TraceString(str, TraceLevel_Normal);
			}

		} while (Position != NULL);
	}
	else if (pBindParameter->ServiceKind == ServiceKind_Plaza)  //广场服务  ---LogonServer断开
	{
		//变量定义
		//WORD wBindIndex = LOWORD(dwSocketID);
		//tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

		//提示消息
		CString cstr = L"";
		cstr.Format(L"关闭事件  ---会话Socket断开 pBindParameter->ServiceKind LogonServer断开：%d", pBindParameter->wServiceID);
		CTraceService::TraceString(cstr, TraceLevel_Normal);
		//注销房间
		m_GlobalInfoManager.DeletePlazaItem(pBindParameter->wServiceID);

		HTREEITEM hTemp;
		if (m_LoginServiceIDMap.Lookup(pBindParameter->wServiceID, hTemp))
		{
			CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
			if (p)
			{
				p->bbb.DeleteItem(hTemp);
			}
			//提示消息
			CString cstrTemp = L"";
			cstrTemp.Format(L"关闭事件  m_LoginServiceIDMap删除key：%d", pBindParameter->wServiceID);
			CTraceService::TraceString(cstrTemp, TraceLevel_Warning);
			///---add by yd 201-8-4
			m_LoginServiceIDMap.RemoveKey(pBindParameter->wServiceID);
		}
	}

	//清除信息
	ZeroMemory(pBindParameter, sizeof(tagBindParameter));

	return false;
}

//数据库事件
bool CAttemperEngineSink::OnEventDataBase(WORD wRequestID, DWORD dwContextID, VOID * pData, WORD wDataSize)
{
	return false;
}

//关闭事件
bool CAttemperEngineSink::OnEventTCPSocketShut(WORD wServiceID, BYTE cbShutReason)
{
	return false;
}

//连接事件
bool CAttemperEngineSink::OnEventTCPSocketLink(WORD wServiceID, INT nErrorCode)
{
	return false;
}

//读取事件
bool CAttemperEngineSink::OnEventTCPSocketRead(WORD wServiceID, TCP_Command Command, VOID * pData, WORD wDataSize)
{
	return true;
}

//注册服务
bool CAttemperEngineSink::OnTCPNetworkMainRegister(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
	case SUB_CS_C_REGISTER_PLAZA:	//注册登陆服务器
	{
		//效验数据
		ASSERT(wDataSize == sizeof(CMD_CS_C_RegisterPlaza));
		if (wDataSize != sizeof(CMD_CS_C_RegisterPlaza)) return false;

		//消息定义
		CMD_CS_C_RegisterPlaza * pRegisterPlaza = (CMD_CS_C_RegisterPlaza *)pData;

		//有效判断
		if ((pRegisterPlaza->szServerName[0] == 0) || (pRegisterPlaza->szServerAddr[0] == 0))
		{
			//变量定义
			CMD_CS_S_RegisterFailure RegisterFailure;
			ZeroMemory(&RegisterFailure, sizeof(RegisterFailure));

			//设置变量
			RegisterFailure.lErrorCode = 0L;
			lstrcpyn(RegisterFailure.szDescribeString, TEXT("服务器注册失败，“服务地址”与“服务器名”不合法！"), CountArray(RegisterFailure.szDescribeString));

			//发送消息
			WORD wStringSize = CountStringBuffer(RegisterFailure.szDescribeString);
			WORD wSendSize = sizeof(RegisterFailure) - sizeof(RegisterFailure.szDescribeString) + wStringSize;
			m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_REGISTER, SUB_CS_S_REGISTER_FAILURE, &RegisterFailure, wSendSize);

			//中断网络
			m_pITCPNetworkEngine->ShutDownSocket(dwSocketID);

			return true;
		}

		//设置绑定
		WORD wBindIndex = LOWORD(dwSocketID);
		(m_pBindParameter + wBindIndex)->wServiceID = pRegisterPlaza->wServerID;
		(m_pBindParameter + wBindIndex)->ServiceKind = ServiceKind_Plaza;

		//变量定义
		tagGamePlaza GamePlaza;
		ZeroMemory(&GamePlaza, sizeof(GamePlaza));

		//构造数据
		GamePlaza.wPlazaID = pRegisterPlaza->wServerID;//wBindIndex;
		lstrcpyn(GamePlaza.szServerName, pRegisterPlaza->szServerName, CountArray(GamePlaza.szServerName));
		lstrcpyn(GamePlaza.szServerAddr, pRegisterPlaza->szServerAddr, CountArray(GamePlaza.szServerAddr));
		
		///[---add by yd 初始化当前时间
		GamePlaza.wServerID = pRegisterPlaza->wServerID;
		GamePlaza.dwLiveTime = GetTickCount();///(DWORD)time(NULL);
		///---]
		//注册房间
		m_GlobalInfoManager.ActivePlazaItem(wBindIndex, GamePlaza);

		HTREEITEM hTemp;
		if (m_LoginServiceIDMap.Lookup(GamePlaza.wPlazaID/*(m_pBindParameter + wBindIndex)->wServiceID*/, hTemp))
		{
			CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
			if (p)
			{
				p->bbb.DeleteItem(hTemp);
			}
			//提示消息
			CString cstr = L"";
			cstr.Format(L"m_LoginServiceIDMap能找到：%d，hTemp存在先删除了，再加入", GamePlaza.wPlazaID);
			CTraceService::TraceString(cstr, TraceLevel_Warning);
			CString csIpPort;
			csIpPort.Format(L"%s:%s 编号[%d]", CString(pRegisterPlaza->szServerAddr), pRegisterPlaza->szServerName, GamePlaza.wPlazaID/* (m_pBindParameter + wBindIndex)->wServiceID*/);
			HTREEITEM aa = p->bbb.InsertItem(csIpPort, 1, 1, p->hbbRoot, TVI_LAST);
			p->bbb.SetItemData(aa, 0);

			m_LoginServiceIDMap[GamePlaza.wPlazaID/*(m_pBindParameter + wBindIndex)->wServiceID*/] = aa;
		}
		else
		{
			CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
			if (p)
			{
				CString csIpPort;
				csIpPort.Format(L"%s:%s 编号[%d]", CString(pRegisterPlaza->szServerAddr), CString(pRegisterPlaza->szServerName), GamePlaza.wPlazaID/*(m_pBindParameter + wBindIndex)->wServiceID*/);
				HTREEITEM aa = p->bbb.InsertItem(csIpPort, 1, 1, p->hbbRoot, TVI_LAST);
				p->bbb.SetItemData(aa, 0);

				m_LoginServiceIDMap[GamePlaza.wPlazaID/*(m_pBindParameter + wBindIndex)->wServiceID*/] = aa;
			}
		}

		POSITION Position = NULL;

		CTraceService::TraceString(TEXT("一个登陆服务器加入,当前的登陆服务器列表："), TraceLevel_Normal);
		
		do
		{
			//获取对象
			CGlobalPlazaItem * pGlobalServerItem = m_GlobalInfoManager.EnumPlazaItem(Position);

			if (pGlobalServerItem != NULL)
			{
				CString str;
				str.Format(TEXT("[%s] %s : %d"), pGlobalServerItem->m_GamePlaza.szServerName, pGlobalServerItem->m_GamePlaza.szServerAddr, pGlobalServerItem->m_GamePlaza.wPlazaID);
				CTraceService::TraceString(str, TraceLevel_Normal);
			}

		} while (Position != NULL);


		//发送列表
		SendServerListItem(dwSocketID);
		SendMatchListItem(dwSocketID);

		//群发设置
		m_pITCPNetworkEngine->AllowBatchSend(dwSocketID, true, 0L);

		return true;
	}
	case SUB_CS_C_REGISTER_SERVER:	//注册游戏中心服务器
	{
		//效验数据
		ASSERT(wDataSize == sizeof(CMD_CS_C_RegisterServer));
		if (wDataSize != sizeof(CMD_CS_C_RegisterServer)) return false;

		//消息定义
		CMD_CS_C_RegisterServer * pRegisterServer = (CMD_CS_C_RegisterServer *)pData;

		//查找房间
		if (m_GlobalInfoManager.SearchServerItem(pRegisterServer->wServerID) != NULL)
		{
			//存在的话先注销旧的
			//变量定义
			CMD_CS_S_ServerRemove ServerRemove;
			ZeroMemory(&ServerRemove, sizeof(ServerRemove));

			//删除通知
			ServerRemove.wServerID = pRegisterServer->wServerID;
			m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_REMOVE, &ServerRemove, sizeof(ServerRemove), 0L);

			//注销房间
			m_GlobalInfoManager.DeleteServerItem(pRegisterServer->wServerID);

			////变量定义
			//CMD_CS_S_RegisterFailure RegisterFailure;
			//ZeroMemory(&RegisterFailure, sizeof(RegisterFailure));

			////设置变量
			//RegisterFailure.lErrorCode = 0L;
			//lstrcpyn(RegisterFailure.szDescribeString, TEXT("已经存在相同标识的游戏房间服务，房间服务注册失败"), CountArray(RegisterFailure.szDescribeString));

			////发送消息
			//WORD wStringSize = CountStringBuffer(RegisterFailure.szDescribeString);
			//WORD wSendSize = sizeof(RegisterFailure) - sizeof(RegisterFailure.szDescribeString) + wStringSize;
			//m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_REGISTER, SUB_CS_S_REGISTER_FAILURE, &RegisterFailure, wSendSize);

			////中断网络
			//m_pITCPNetworkEngine->ShutDownSocket(dwSocketID);

			//return true;
		}

		//设置绑定
		WORD wBindIndex = LOWORD(dwSocketID);
		(m_pBindParameter + wBindIndex)->ServiceKind = ServiceKind_Game;
		(m_pBindParameter + wBindIndex)->wServiceID = pRegisterServer->wServerID;

		//变量定义
		tagGameServer GameServer;
		ZeroMemory(&GameServer, sizeof(GameServer));

		//构造数据
		GameServer.wKindID = pRegisterServer->wKindID;
		GameServer.wNodeID = pRegisterServer->wNodeID;
		GameServer.wSortID = pRegisterServer->wSortID;
		GameServer.wServerID = pRegisterServer->wServerID;
		GameServer.wServerKind = pRegisterServer->wServerKind;
		GameServer.wServerType = pRegisterServer->wServerType;
		GameServer.wServerPort = pRegisterServer->wServerPort;
		GameServer.lCellScore = pRegisterServer->lCellScore;
		GameServer.lEnterScore = pRegisterServer->lEnterScore;
		GameServer.dwServerRule = pRegisterServer->dwServerRule;
		GameServer.dwOnLineCount = pRegisterServer->dwOnLineCount;
		GameServer.dwFullCount = pRegisterServer->dwFullCount;
		GameServer.wTableFullCount = pRegisterServer->dwFullTable;
		GameServer.wServerLevel = pRegisterServer->wServerLevel;
		GameServer.bService = pRegisterServer->bService;
		GameServer.dwLiveTime = (DWORD)time(NULL);
		lstrcpyn(GameServer.szServerName, pRegisterServer->szServerName, CountArray(GameServer.szServerName));
		lstrcpyn(GameServer.szServerAddr, pRegisterServer->szServerAddr, CountArray(GameServer.szServerAddr));

		TCHAR szClientAddr[16] = TEXT("");
		BYTE * pClientAddr = (BYTE *)&(m_pBindParameter + wBindIndex)->dwClientAddr;
		_sntprintf(szClientAddr, CountArray(szClientAddr), TEXT("%d.%d.%d.%d"), pClientAddr[0], pClientAddr[1], pClientAddr[2], pClientAddr[3]);


		//注册房间
		m_GlobalInfoManager.ActiveServerItem(wBindIndex, GameServer);

		HTREEITEM hTemp;
		if (m_ServiceIDMap.Lookup(pRegisterServer->wServerID, hTemp))
		{
			CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
			if (p)
			{
				p->ServiceTree.DeleteItem(hTemp);
			}

			CString csIpPort;
			csIpPort.Format(L"%s:%d level->%d stat->%s:%d", GameServer.szServerAddr, GameServer.wServerPort, GameServer.wServerLevel, GameServer.bService == 1 ? _T("run") : (GameServer.bService == 0 ? _T("stop") : _T("by ddos")), GameServer.bService);
			HTREEITEM aa = p->ServiceTree.InsertItem(csIpPort, 1, 1, p->hRoot, TVI_LAST);
			p->ServiceTree.SetItemData(aa, GameServer.wServerID);

			m_ServiceIDMap[pRegisterServer->wServerID] = aa;
		}
		else
		{
			CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
			if (p)
			{
				CString csIpPort;
				csIpPort.Format(L"%s:%d level->%d stat->%s:%d", GameServer.szServerAddr, GameServer.wServerPort, GameServer.wServerLevel, GameServer.bService == 1 ? _T("run") : (GameServer.bService == 0 ? _T("stop") : _T("by ddos")), GameServer.bService);
				HTREEITEM aa = p->ServiceTree.InsertItem(csIpPort, 1, 1, p->hRoot, TVI_LAST);
				p->ServiceTree.SetItemData(aa, GameServer.wServerID);

				m_ServiceIDMap[pRegisterServer->wServerID] = aa;
			}
		}

		//群发房间
		m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_INSERT, &GameServer, sizeof(GameServer), 0L);

		//发送列表
		SendServerListItem(dwSocketID);
		SendMatchListItem(dwSocketID);

		//发送所有私人房间列表
		SendPrivateListItem(dwSocketID);

		//群发设置
		m_pITCPNetworkEngine->AllowBatchSend(dwSocketID, true, 0L);

		//汇总通知
		if (m_wCollectItem == INVALID_WORD)
		{
			m_wCollectItem = wBindIndex;
			m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_USER_COLLECT, SUB_CS_S_COLLECT_REQUEST);
		}
		else m_WaitCollectItemArray.Add(wBindIndex);

		POSITION Position = NULL;

		CString csTest;
		csTest.Format(L"GameServer加入[%s][%d]", szClientAddr, (m_pBindParameter + wBindIndex)->wServiceID);
		CTraceService::TraceString(csTest, TraceLevel_Normal);

		do
		{
			//获取对象
			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.EnumServerItem(Position);

			if (pGlobalServerItem != NULL)
			{
				CString str;
				str.Format(TEXT("[%d] %s : %d"), pGlobalServerItem->GetServerID(), pGlobalServerItem->m_GameServer.szServerAddr, pGlobalServerItem->m_GameServer.wServerPort);
				CTraceService::TraceString(str, TraceLevel_Normal);
			}

		} while (Position != NULL);

		return true;
	}
	case SUB_CS_C_REGISTER_MATCH:	//注册比赛
	{
		//效验数据
		ASSERT(wDataSize == sizeof(CMD_CS_C_RegisterMatch));
		if (wDataSize != sizeof(CMD_CS_C_RegisterMatch)) return false;

		//消息定义
		CMD_CS_C_RegisterMatch * pRegisterMatch = (CMD_CS_C_RegisterMatch *)pData;

		//查找房间
		CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.SearchServerItem(pRegisterMatch->wServerID);
		if (pGlobalServerItem == NULL) return true;

		//变量定义
		tagGameMatch GameMatch;
		ZeroMemory(&GameMatch, sizeof(GameMatch));

		//构造数据
		GameMatch.wServerID = pRegisterMatch->wServerID;
		GameMatch.dwMatchID = pRegisterMatch->dwMatchID;
		GameMatch.dwMatchNO = pRegisterMatch->dwMatchNO;
		GameMatch.cbMatchType = pRegisterMatch->cbMatchType;
		GameMatch.lMatchFee = pRegisterMatch->lMatchFee;
		GameMatch.cbMatchFeeType = pRegisterMatch->cbMatchFeeType;
		GameMatch.cbMemberOrder = pRegisterMatch->cbMemberOrder;
		GameMatch.wRewardCount = pRegisterMatch->wRewardCount;
		GameMatch.MatchEndTime = pRegisterMatch->MatchEndTime;
		GameMatch.MatchStartTime = pRegisterMatch->MatchStartTime;
		GameMatch.wStartUserCount = pRegisterMatch->wStartUserCount;
		GameMatch.wMatchPlayCount = pRegisterMatch->wMatchPlayCount;
		lstrcpyn(GameMatch.szMatchName, pRegisterMatch->szMatchName, CountArray(GameMatch.szMatchName));

		//拷贝数据
		CopyMemory(&pGlobalServerItem->m_GameMatch, &GameMatch, sizeof(pGlobalServerItem->m_GameMatch));

		//群发房间
		m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_MATCH_INSERT, &GameMatch, sizeof(GameMatch), 0L);

		return true;
	}
	default: break;
	}

	return false;
}

//服务状态
bool CAttemperEngineSink::OnTCPNetworkMainServiceInfo(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
		case SUB_CS_UPDATASERVICE:	//服务器状态更新
		{
			ASSERT(wDataSize == sizeof(JN_GR_SERVICESTAT));
			if (wDataSize != sizeof(JN_GR_SERVICESTAT)) return false;

			//消息定义
			JN_GR_SERVICESTAT * pServerOnLine = (JN_GR_SERVICESTAT *)pData;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//查找房间
			WORD wServerID = pBindParameter->wServiceID;

			ASSERT(wServerID == pServerOnLine->dwServerID);
			if (wServerID != pServerOnLine->dwServerID) return false;

			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.SearchServerItem(wServerID);

			//设置人数
			if (pGlobalServerItem != NULL)
			{
				//变量定义
				JN_GR_SERVICESTAT ServerOnLine;
				ZeroMemory(&ServerOnLine, sizeof(ServerOnLine));

				ServerOnLine.bService = pServerOnLine->bService;
				ServerOnLine.dwServerID = pServerOnLine->dwServerID;

				CCorrespondServerDlg *p = (CCorrespondServerDlg *)theApp.m_pMainWnd;
				//查找房间

				//修改房间信息
				pGlobalServerItem->m_GameServer.bService = pServerOnLine->bService;

				if (p)
				{
					HTREEITEM startitem = p->ServiceTree.GetChildItem(p->hRoot);

					while (startitem)
					{
						CString strTemp = p->ServiceTree.GetItemText(startitem);
						DWORD dData = p->ServiceTree.GetItemData(startitem);

						if (dData == pServerOnLine->dwServerID)
						{
							if (pGlobalServerItem->m_GameServer.bService > 0)
							{
								//正常服务状态
								p->ServiceTree.SetItemImage(startitem, 1, 1);
								break;
							}
							else if (pGlobalServerItem->m_GameServer.bService == 0)
							{
								//主动不提供服务状态
								p->ServiceTree.SetItemImage(startitem, 2, 2);
								break;
							}
							else
							{
								//被攻击无法服务状态
								p->ServiceTree.SetItemImage(startitem, 3, 3);
								break;
							}
						}
						startitem = p->ServiceTree.GetNextSiblingItem(startitem);
					}
				}

				//发送通知
				m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_STAT, &ServerOnLine, sizeof(ServerOnLine), 0L);
			}

			return true;
		}
		case SUB_CS_C_SERVER_ONLINE:	//房间人数
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_C_ServerOnLine));
			if (wDataSize != sizeof(CMD_CS_C_ServerOnLine)) return false;

			//消息定义
			CMD_CS_C_ServerOnLine * pServerOnLine = (CMD_CS_C_ServerOnLine *)pData;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//查找房间
			WORD wServerID = pBindParameter->wServiceID;
			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.SearchServerItem(wServerID);

			//设置人数
			if (pGlobalServerItem != NULL)
			{
				//变量定义
				CMD_CS_S_ServerOnLine ServerOnLine;
				ZeroMemory(&ServerOnLine, sizeof(ServerOnLine));

				//设置变量
				pGlobalServerItem->m_GameServer.dwOnLineCount = pServerOnLine->dwOnLineCount;

				//设置变量
				ServerOnLine.wServerID = wServerID;
				ServerOnLine.dwOnLineCount = pServerOnLine->dwOnLineCount;
				ServerOnLine.wTableOnlineCount = pServerOnLine->wTableOnlineCount;//在线桌子数
				ServerOnLine.wTableFullCount = pServerOnLine->wTableFullCount; 	  //满员桌子数


				pGlobalServerItem->m_GameServer.wTableOnlineCount = pServerOnLine->wTableOnlineCount;
				pGlobalServerItem->m_GameServer.dwOnLineCount = pServerOnLine->dwOnLineCount;
				pGlobalServerItem->m_GameServer.wTableFullCount = pServerOnLine->wTableFullCount;


				m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_ONLINE, &ServerOnLine, sizeof(ServerOnLine), 0L);
				//存储信息到redis
				std::vector<std::pair<std::string, std::string>> field_val;
				field_val.push_back({ "wServerID", string_format("%d",ServerOnLine.wServerID) });
				field_val.push_back({ "dwOnLineCount", string_format("%d",ServerOnLine.dwOnLineCount) });
				field_val.push_back({ "wTableOnlineCount", string_format("%d",ServerOnLine.wTableOnlineCount) });
				field_val.push_back({ "wTableFullCount", string_format("%d",ServerOnLine.wTableFullCount) });
				m_RedisClient->GetRedisClient()->hmset(string_format("Server_Info:%d", ServerOnLine.wServerID), field_val, [](const cpp_redis::reply& reply) {
					std::cout << "hmset: " << reply << std::endl;
					});
				m_RedisClient->GetRedisClient()->sync_commit();
			}

			return true;
		}
		case SUB_CS_C_SERVER_ONLINE_ACK: //房间人数应答   ///---是GameServer实例个数
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_S_ServerAllOnLine));
			if (wDataSize != sizeof(CMD_CS_S_ServerAllOnLine)) return false;

			//消息定义
			CMD_CS_S_ServerAllOnLine * pServerOnLine = (CMD_CS_S_ServerAllOnLine *)pData;

			DWORD dNum = m_GlobalInfoManager.GetServerItemCount();

			if (dNum != pServerOnLine->dwServerNum)
			{
				m_pITCPNetworkEngine->CloseSocket(dwSocketID);
				//主动断开通讯,清理工作交给超时检测。
			}
			return true;
		}
		case SUB_CS_C_SERVER_MODIFY:	//房间修改
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_C_ServerModify));
			if (wDataSize != sizeof(CMD_CS_C_ServerModify)) return false;

			//消息定义
			CMD_CS_C_ServerModify * pServerModify = (CMD_CS_C_ServerModify *)pData;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//查找房间
			ASSERT(m_GlobalInfoManager.SearchServerItem(pBindParameter->wServiceID) != NULL);
			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.SearchServerItem(pBindParameter->wServiceID);

			//房间修改
			if (pGlobalServerItem != NULL)
			{
				//设置变量
				pGlobalServerItem->m_GameServer.wSortID = pServerModify->wSortID;
				pGlobalServerItem->m_GameServer.wKindID = pServerModify->wKindID;
				pGlobalServerItem->m_GameServer.wNodeID = pServerModify->wNodeID;
				pGlobalServerItem->m_GameServer.wServerPort = pServerModify->wServerPort;
				pGlobalServerItem->m_GameServer.dwOnLineCount = pServerModify->dwOnLineCount;
				pGlobalServerItem->m_GameServer.wTableFullCount = pServerModify->wTableFullCount;				//满员桌子数
				pGlobalServerItem->m_GameServer.wTableOnlineCount = pServerModify->wTableOnlineCount;		//在线桌子数
				pGlobalServerItem->m_GameServer.dwFullCount = pServerModify->dwFullCount;
				lstrcpyn(pGlobalServerItem->m_GameServer.szServerName, pServerModify->szServerName, CountArray(pGlobalServerItem->m_GameServer.szServerName));
				lstrcpyn(pGlobalServerItem->m_GameServer.szServerAddr, pServerModify->szServerAddr, CountArray(pGlobalServerItem->m_GameServer.szServerAddr));

				//变量定义
				CMD_CS_S_ServerModify ServerModify;
				ZeroMemory(&ServerModify, sizeof(ServerModify));

				//设置变量
				ServerModify.wKindID = pServerModify->wKindID;
				ServerModify.wSortID = pServerModify->wSortID;
				ServerModify.wNodeID = pServerModify->wNodeID;
				ServerModify.wServerID = pBindParameter->wServiceID;
				ServerModify.wServerPort = pServerModify->wServerPort;
				ServerModify.dwFullCount = pServerModify->dwFullCount;
				lstrcpyn(ServerModify.szServerAddr, pServerModify->szServerAddr, CountArray(ServerModify.szServerAddr));
				lstrcpyn(ServerModify.szServerName, pServerModify->szServerName, CountArray(ServerModify.szServerName));

				//发送通知
				m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_MODIFY, &ServerModify, sizeof(ServerModify), 0L);
			}
			return true;
		}
		case SUB_CS_C_SERVER_JULI:
		{
			//发送通知
			m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_C_SERVER_JULI_ACK, pData, wDataSize, 0L);
			return true;
		}
		default: break;
	}

	return false;
}

//登录失败
bool CAttemperEngineSink::SendLogonFailure(LPCTSTR pszString, LONG lErrorCode, DWORD dwSocketID)
{
	CTraceService::TraceString(TEXT("登录失败 SendLogonFailure"), TraceLevel_Exception);
	//变量定义
	CMD_GR_LogonFailureEx LogonFailure;
	ZeroMemory(&LogonFailure, sizeof(LogonFailure));

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

	//数据属性
	WORD wDataSize = CountStringBuffer(LogonFailure.szDescribeString);
	WORD wHeadSize = sizeof(LogonFailure) - sizeof(LogonFailure.szDescribeString);
	m_pITCPNetworkEngine->SendData(dwSocketID, MDM_GR_LOGON, SUB_GR_LOGON_FAILURE, &LogonFailure, wHeadSize + wDataSize);

	return true;
}
//用户处理
bool CAttemperEngineSink::OnTCPNetworkMainUserCollect(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
	case SUB_CS_DISSOLVEROOM:
	{
		//群主解散俱乐部房间
		ASSERT(wDataSize == sizeof(DWORD));
		if (wDataSize != sizeof(DWORD)) return false;
		//DWORD *dwRoomID = (DWORD *)pData;

		//广播给特定服务器
		POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

		while (Position != NULL)
		{
			CGlobalServerItem *pCGlobalServerItem = NULL;
			WORD wID = 0;
			m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
			if (pCGlobalServerItem != NULL)
			{
				SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_DISSOLVEROOM, pData, wDataSize);
			}
		}
		return true;
	}
		case SUB_CS_ChangServer:
		{

			//向协调申请换服务器开房
			ASSERT(wDataSize == sizeof(CMD_GR_ClubAction2_XT));
			if (wDataSize != sizeof(CMD_GR_ClubAction2_XT)) return false;
			CMD_GR_ClubAction2_XT *pClubAction = (CMD_GR_ClubAction2_XT *)pData;
			
			//广播给特定服务器
			POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

			while (Position != NULL)
			{
				CGlobalServerItem *pCGlobalServerItem = NULL;
				WORD wID = 0;
				m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
				if (pCGlobalServerItem != NULL && pCGlobalServerItem->GetServerID() == pClubAction->dwServerID)
				{
					SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_ChangServer, pData, wDataSize);
				}
			}
			return true;
		}
	    case SUB_CS_C_USER_SendMessage:
		{
			ASSERT(wDataSize == sizeof(CMD_GR_Club_NotifyEX_ACK));
			if (wDataSize != sizeof(CMD_GR_Club_NotifyEX_ACK)) return false;

			CMD_GR_Club_NotifyEX_ACK* pInfo = (CMD_GR_Club_NotifyEX_ACK*)pData;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//向所有服务器广播该信息
			POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

			while (Position != NULL)
			{
				CGlobalServerItem *pCGlobalServerItem = NULL;
				WORD wID = 0;
				m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
				if (pCGlobalServerItem != NULL)
				{
					SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_C_USER_SendMessage, pInfo, sizeof(CMD_GR_Club_NotifyEX_ACK));
				}
			}
			return true;

		}
		case SUB_CS_C_GET_ROOMID:    ///---??用户创建房间时返回的房间ID(由协调统一生成唯一ID)
		{
			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			DWORD dRet = GetRandom::GetRandomValue();

			CMD_CS_UserSitDownEx * pUserSitDown = (CMD_CS_UserSitDownEx *)pData;
			pUserSitDown->RoomID = dRet;

			SendDataToGame(pBindParameter->wServiceID, MDM_CS_USER_COLLECT, SUB_CS_C_GET_ROOMID, pData, wDataSize);
			return true;
		}
		case SUB_CS_UPDATAOWNBEANS_UNLOCK:
		{
			ASSERT(wDataSize == sizeof(DBO_GR_UserReduceResultEX));
			if (wDataSize != sizeof(DBO_GR_UserReduceResultEX)) return false;

			DBO_GR_UserReduceResultEX* pInfo = (DBO_GR_UserReduceResultEX*)pData;
		
			CGlobalUserItem *pCGlobalUserItem = m_GlobalInfoManager.SearchUserItemByUserID(pInfo->dwUserID);

			if (pCGlobalUserItem && pCGlobalUserItem->m_ServerID!=0)
			{
				int i = 0;
				CGlobalServerItem * p = pCGlobalUserItem->EnumServerItem(i);
				while (p)
				{
					if (p->GetServerID() == pCGlobalUserItem->m_ServerID)
					{
						//向最近登录的服务器，发送。
						SendDataToGame(p->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOWNBEANS_UNLOCK, pData, wDataSize);
						break;
					}
					i++;
					p = pCGlobalUserItem->EnumServerItem(i);
				}
			}
			return true;
		}
		case SUB_CS_UPDATAOWNBEANS_LOCK:
		{
			ASSERT(wDataSize == sizeof(DBO_GR_UserReduceResultEX));
			if (wDataSize != sizeof(DBO_GR_UserReduceResultEX)) return false;

			DBO_GR_UserReduceResultEX* pInfo = (DBO_GR_UserReduceResultEX*)pData;

			CGlobalUserItem *pCGlobalUserItem = m_GlobalInfoManager.SearchUserItemByUserID(pInfo->dwUserID);

			if (pCGlobalUserItem && pCGlobalUserItem->m_ServerID != 0)
			{
				int i = 0;
				CGlobalServerItem * p = pCGlobalUserItem->EnumServerItem(i);
				while (p)
				{
					if (p->GetServerID() == pCGlobalUserItem->m_ServerID)
					{
						//向最近登录的服务器，发送。
						SendDataToGame(p->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOWNBEANS_LOCK, pData, wDataSize);
						break;
					}
					i++;
					p = pCGlobalUserItem->EnumServerItem(i);
				}
			}

			return true;
		}
		case SUB_CS_C_USER_ENTER:		//用户进入
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_C_UserEnter));
			if (wDataSize != sizeof(CMD_CS_C_UserEnter)) return false;

			//消息处理
			CMD_CS_C_UserEnter * pUserEnter = (CMD_CS_C_UserEnter *)pData;
			//pUserEnter->szNickName[CountArray(pUserEnter->szNickName) - 1] = 0;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//变量定义
			tagGlobalUserInfo GlobalUserInfo;
			ZeroMemory(&GlobalUserInfo, sizeof(GlobalUserInfo));

			//设置变量
			GlobalUserInfo.dwUserID = pUserEnter->dwUserID;
			GlobalUserInfo.dwGameID = pUserEnter->dwGameID;
			//lstrcpyn(GlobalUserInfo.szNickName, pUserEnter->szNickName, CountArray(GlobalUserInfo.szNickName));

			//辅助信息
			GlobalUserInfo.cbGender = pUserEnter->cbGender;
			GlobalUserInfo.cbMemberOrder = pUserEnter->cbMemberOrder;
			GlobalUserInfo.cbMasterOrder = pUserEnter->cbMasterOrder;

			//激活用户
			int result = m_GlobalInfoManager.ActiveUserItem(GlobalUserInfo, pBindParameter->wServiceID);
			if (result > 0)
			{
				//遍历节点
				POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();
				while (Position != NULL)
				{
					CGlobalServerItem *pCGlobalServerItem = NULL;
					WORD wID = 0;
					m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
					if (pCGlobalServerItem != NULL && pCGlobalServerItem->GetServerID() == result)
					{
						SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_C_USER_DisCONN, &(GlobalUserInfo.dwUserID), sizeof(DWORD));
					}
				}
			}

			//返回这个用户的创建房间列表
			CMapRoomList* pCMapRoomList = m_GlobalInfoManager.GetRoomData();
			JN_GR_RoomListGroup jnTemp;
			ZeroMemory(&jnTemp, sizeof(jnTemp));

			if (pCMapRoomList->Lookup(GlobalUserInfo.dwUserID, jnTemp))
			{
				JN_GR_RoomListGroupSend jnTempSend;
				ZeroMemory(&jnTempSend, sizeof(jnTempSend));
				jnTempSend.Num = jnTemp.Num;
				for (int i = 0; i < (jnTemp.Num > 30 ? 30 : jnTemp.Num); i++)
				{
					CopyMemory(&(jnTempSend.jgrDate[i]), &(jnTemp.jgrDate[i]), sizeof(JN_GR_RoomList));
					jnTempSend.jgrDate[i].tmp1 = jnTemp.jgrDate[i].bRoomCreatePay;
					jnTempSend.jgrDate[i].tmp2 = jnTemp.jgrDate[i].tmp1;
					jnTempSend.jgrDate[i].tmp3 = jnTemp.jgrDate[i].tmp2;
				}
				//拥有
				if (jnTempSend.Num > 0) m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_USER_COLLECT, SUB_CS_UPDATAOWNROOMLIST, &jnTempSend, sizeof(JN_GR_RoomListGroupSend));
			}

			//向所有服务器广播该玩家上线信息
			POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

			while (Position != NULL)
			{
				CGlobalServerItem *pCGlobalServerItem = NULL;
				WORD wID = 0;
				m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
				if (pCGlobalServerItem != NULL)
				{
					 SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_C_USER_ONLINE, pUserEnter, sizeof(CMD_CS_C_UserEnter));
				}
			}
			return true;
		}
		case SUB_CS_C_USER_LEAVE:		//用户离开
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_C_UserLeave));
			if (wDataSize != sizeof(CMD_CS_C_UserLeave)) return false;

			//消息处理
			CMD_CS_C_UserLeave * pUserLeave = (CMD_CS_C_UserLeave *)pData;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//删除用户
			m_GlobalInfoManager.DeleteUserItem(pUserLeave->dwUserID, pBindParameter->wServiceID);

			//向所有服务器广播该玩家离线信息
			POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

			while (Position != NULL)
			{
				CGlobalServerItem *pCGlobalServerItem = NULL;
				WORD wID = 0;
				m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
				if (pCGlobalServerItem != NULL)
				{
					 SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_C_USER_OFFLINE, pUserLeave, sizeof(CMD_CS_C_UserLeave));
				}
			}

			return true;
		}
		case SUB_CS_C_USER_FINISH:		//用户完成
		{
			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT((m_wCollectItem == wBindIndex) && (pBindParameter->ServiceKind == ServiceKind_Game));
			if ((m_wCollectItem != wBindIndex) || (pBindParameter->ServiceKind != ServiceKind_Game)) return false;

			//设置变量
			m_wCollectItem = INVALID_WORD;

			//汇总切换
			if (m_WaitCollectItemArray.GetCount() > 0)
			{
				//切换汇总
				INT_PTR nWaitCount = m_WaitCollectItemArray.GetCount();
				m_wCollectItem = m_WaitCollectItemArray[nWaitCount - 1];

				//删除数组
				m_WaitCollectItemArray.RemoveAt(nWaitCount - 1);

				//发送消息
				DWORD dwSocketIDTemp = (m_pBindParameter + m_wCollectItem)->dwSocketID;
				m_pITCPNetworkEngine->SendData(dwSocketIDTemp, MDM_CS_USER_COLLECT, SUB_CS_S_COLLECT_REQUEST);
			}

			return true;
		}
		case SUB_CS_C_USER_SERVER:  ///---用户是否在游戏牌桌上的状态汇总
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_C_UserServer));
			if (wDataSize != sizeof(CMD_CS_C_UserServer)) return false;

			//消息处理
			CMD_CS_C_UserServer * pUserServer = (CMD_CS_C_UserServer *)pData;

			//获取参数
			WORD wBindIndex = LOWORD(dwSocketID);
			tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

			//连接效验
			ASSERT(pBindParameter->ServiceKind == ServiceKind_Game);
			if (pBindParameter->ServiceKind != ServiceKind_Game) return false;

			//变量定义
			CMD_CS_S_ServerUserInfo ServerUserInfo;
			ZeroMemory(&ServerUserInfo, sizeof(ServerUserInfo));
			ServerUserInfo.dwUserID = pUserServer->dwUserID;
			if (pUserServer->cbFlag == 0)
			{
				ServerUserInfo.wServerID = 0;
			}
			else
			{
				ServerUserInfo.wServerID = pBindParameter->wServiceID;
			}

			m_pITCPNetworkEngine->SendDataBatch(MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_USER_INFO, &ServerUserInfo, sizeof(ServerUserInfo), 0L);
			return true;
		}
		case SUB_CS_UPDATAOWNROOM:	//私人桌子更新
		{
			//效验数据
			ASSERT(wDataSize == sizeof(JN_GR_RoomListBig));
			if (wDataSize != sizeof(JN_GR_RoomListBig)) return false;

			//消息处理
			JN_GR_RoomListBig * pUserServer = (JN_GR_RoomListBig *)pData;

 			int b = 0;

			if (pUserServer->dwInsert_UpData_Del == 0)   ///---添加更新删除  0 ， 1， 2
			{
				CPrivateRoomList* pCMapRoomListA = m_GlobalInfoManager.GetPrivateRoom();
				JN_GR_RoomListBig tempA;
				ZeroMemory(&tempA, sizeof(tempA));
				tempA.InsertTime = GetTickCount();
				pUserServer->InsertTime = GetTickCount();
				if (!pCMapRoomListA->Lookup(pUserServer->dwRoomNumber, tempA))
				{
					//CString csTest;
					//csTest.Format(_T("私有房间数目:%d,房间编号%d->新增"), pCMapRoomListA->GetSize() + 1, pUserServer->dwRoomNumber);
					//CTraceService::TraceString(csTest, TraceLevel_Normal);

					tempA = *pUserServer;
					pCMapRoomListA->SetAt(pUserServer->dwRoomNumber, tempA);
					//更新私有房间广播
					POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

					while (Position != NULL)
					{
						CGlobalServerItem *pCGlobalServerItem = NULL;
						WORD wID = 0;
						m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
						if (pCGlobalServerItem != NULL)
						{
							 SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOTHERROOM, pData, wDataSize);
						}
					}
				}

				//添加
				CMapRoomList* pCMapRoomList = m_GlobalInfoManager.GetRoomData();
				JN_GR_RoomListGroup temp;
				ZeroMemory(&temp, sizeof(temp));
				pCMapRoomList->Lookup(pUserServer->dwUserID, temp);

				if (temp.Num < 10)
				{
					bool bFind = false;
					for (size_t i = 0; i <( temp.Num < 10 ? temp.Num: 10); i++)
					{
						if (temp.jgrDate[i].dwRoomNumber == pUserServer->dwRoomNumber)
						{
							bFind = true;
							b = i;
							break;
						}
					}

					if (bFind)
					{
						temp.jgrDate[b] = *pUserServer;
						(*pCMapRoomList)[pUserServer->dwUserID] = temp;
						pUserServer->dwInsert_UpData_Del = 1;
					}
					else
					{
						temp.jgrDate[temp.Num] = *pUserServer;
						temp.Num++;
						(*pCMapRoomList)[pUserServer->dwUserID] = temp;
					}
				}
			}
			else if (pUserServer->dwInsert_UpData_Del == 1)
			{
				//更新
				CMapRoomList* pCMapRoomList = m_GlobalInfoManager.GetRoomData();
				JN_GR_RoomListGroup temp;
				ZeroMemory(&temp, sizeof(temp));
				pCMapRoomList->Lookup(pUserServer->dwUserID, temp);

				for (size_t i = 0; i < (temp.Num < 10 ? temp.Num : 10); i++)
				{
					if (temp.jgrDate[i].dwRoomNumber == pUserServer->dwRoomNumber)
					{
						temp.jgrDate[i] = *pUserServer;
						(*pCMapRoomList)[pUserServer->dwUserID] = temp;
						break;
					}
				}

				//更新私有房间广播
				POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

				while (Position != NULL)
				{
					CGlobalServerItem *pCGlobalServerItem = NULL;
					WORD wID = 0;
					m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
					if (pCGlobalServerItem != NULL)
					{
						SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOTHERROOM, pData, wDataSize);
					}
				}
			}
			else
			{
				CPrivateRoomList* pCMapRoomListA = m_GlobalInfoManager.GetPrivateRoom();
				JN_GR_RoomListBig tempA;
				ZeroMemory(&tempA, sizeof(tempA));
				if (pCMapRoomListA->Lookup(pUserServer->dwRoomNumber, tempA))
				{
					pCMapRoomListA->RemoveKey(pUserServer->dwRoomNumber);

					//CString csTest;
					//csTest.Format(_T("私有房间数目:%d,房间编号%d->销毁"), pCMapRoomListA->GetSize(), pUserServer->dwRoomNumber);
					//CTraceService::TraceString(csTest, TraceLevel_Normal);
					//更新私有房间广播
					/*DWORD dPrivateRoom = 0;
					POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();

					while (Position != NULL)
					{
						CGlobalServerItem *pCGlobalServerItem = NULL;
						WORD wID = 0;
						m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
						if (pCGlobalServerItem != NULL)
						{
							SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOTHERROOM, pData, wDataSize);
						}
					}*/
				}

				//无条件广播
				POSITION Position = m_GlobalInfoManager.GetMapServerID()->GetStartPosition();
				while (Position != NULL)
				{
					CGlobalServerItem *pCGlobalServerItem = NULL;
					WORD wID = 0;
					m_GlobalInfoManager.GetMapServerID()->GetNextAssoc(Position, wID, pCGlobalServerItem);
					if (pCGlobalServerItem != NULL)
					{
						SendDataToGame(pCGlobalServerItem->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOTHERROOM, pData, wDataSize);
					}
				}

				//删除
				CMapRoomList* pCMapRoomList = m_GlobalInfoManager.GetRoomData();
				JN_GR_RoomListGroup temp;
				ZeroMemory(&temp, sizeof(temp));
				pCMapRoomList->Lookup(pUserServer->dwUserID, temp);

				for (size_t i = 0; i < (temp.Num < 10 ? temp.Num : 10); i++)
				{
					if (temp.jgrDate[i].dwRoomNumber == pUserServer->dwRoomNumber)
					{
						temp.jgrDate[i] = temp.jgrDate[(temp.Num < 10 ? temp.Num : 10) - 1];
						ZeroMemory(&(temp.jgrDate[temp.Num - 1]), sizeof(temp.jgrDate[temp.Num - 1]));
						if (temp.Num > 0) temp.Num--;
						if (temp.Num == 0)
						{
							//清除这个人的信息
							pCMapRoomList->RemoveKey(pUserServer->dwUserID);
						}
						else
						{
							(*pCMapRoomList)[pUserServer->dwUserID] = temp;
						}
						break;
					}
				}
			}

			CGlobalUserItem * pUser = m_GlobalInfoManager.SearchUserItemByUserID(pUserServer->dwUserID);
			if (pUser)
			{
				int a = 0;
				CGlobalServerItem * p = pUser->EnumServerItem(a);

				while (p)
				{
					if (p->GetServerID() == pUser->m_ServerID)
					{
						//最近登录的服务器，发送。
						SendDataToGame(p->GetServerID(), MDM_CS_USER_COLLECT, SUB_CS_UPDATAOWNROOM, pData, wDataSize);
						break;
					}
					a++;
					p = pUser->EnumServerItem(a);
				}
			}

			return true;
		}
		
	default: break;
	}

	return false;
}

//远程服务
bool CAttemperEngineSink::OnTCPNetworkMainRemoteService(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
	case SUB_CS_C_SEARCH_CORRESPOND:	//协调查找
	{
		//效验参数
		ASSERT(wDataSize == sizeof(CMD_CS_C_SearchCorrespond));
		if (wDataSize != sizeof(CMD_CS_C_SearchCorrespond)) return false;

		//处理消息
		CMD_CS_C_SearchCorrespond * pSearchCorrespond = (CMD_CS_C_SearchCorrespond *)pData;
		pSearchCorrespond->szNickName[CountArray(pSearchCorrespond->szNickName) - 1] = 0;

		//变量定义
		CMD_CS_S_SearchCorrespond SearchCorrespond;
		ZeroMemory(&SearchCorrespond, sizeof(SearchCorrespond));

		//结果用户
		CGlobalUserItem * ResultUserItem[2];
		ZeroMemory(ResultUserItem, sizeof(ResultUserItem));

		//设置变量
		SearchCorrespond.dwSocketID = pSearchCorrespond->dwSocketID;
		SearchCorrespond.dwClientAddr = pSearchCorrespond->dwClientAddr;

		//查找用户
		if (pSearchCorrespond->dwGameID != 0L)
		{
			ResultUserItem[0] = m_GlobalInfoManager.SearchUserItemByGameID(pSearchCorrespond->dwGameID);
		}

		//查找用户
		//if (pSearchCorrespond->szNickName[0] != 0)
		//{
		//	_tcslwr(pSearchCorrespond->szNickName);
			//ResultUserItem[1] = m_GlobalInfoManager.SearchUserItemByNickName(pSearchCorrespond->szNickName);
		//}

		//设置结果
		for (BYTE i = 0; i < CountArray(ResultUserItem); i++)
		{
			if (ResultUserItem[i] != NULL)
			{
				//变量定义
				WORD wServerIndex = 0;

				//查找房间
				do
				{
					//查找房间
					CGlobalServerItem * pGlobalServerItem = ResultUserItem[i]->EnumServerItem(wServerIndex++);

					//终止判断
					if (pGlobalServerItem == NULL) break;
					if (SearchCorrespond.wUserCount >= CountArray(SearchCorrespond.UserRemoteInfo)) break;

					//索引定义
					WORD wIndex = SearchCorrespond.wUserCount++;

					//辅助信息
					SearchCorrespond.UserRemoteInfo[wIndex].cbGender = ResultUserItem[i]->GetGender();
					SearchCorrespond.UserRemoteInfo[wIndex].cbMemberOrder = ResultUserItem[i]->GetMemberOrder();
					SearchCorrespond.UserRemoteInfo[wIndex].cbMasterOrder = ResultUserItem[i]->GetMasterOrder();

					//用户信息
					SearchCorrespond.UserRemoteInfo[wIndex].dwUserID = ResultUserItem[i]->GetUserID();
					SearchCorrespond.UserRemoteInfo[wIndex].dwGameID = ResultUserItem[i]->GetGameID();
					//lstrcpyn(SearchCorrespond.UserRemoteInfo[wIndex].szNickName, ResultUserItem[i]->GetNickName(), LEN_NICKNAME);

					//房间信息
					SearchCorrespond.UserRemoteInfo[wIndex].wKindID = pGlobalServerItem->GetKindID();
					SearchCorrespond.UserRemoteInfo[wIndex].wServerID = pGlobalServerItem->GetServerID();
					lstrcpyn(SearchCorrespond.UserRemoteInfo[wIndex].szGameServer, pGlobalServerItem->m_GameServer.szServerName, LEN_SERVER);

				} while (true);
			}
		}

		//发送数据
		WORD wHeadSize = sizeof(SearchCorrespond) - sizeof(SearchCorrespond.UserRemoteInfo);
		WORD wItemSize = sizeof(SearchCorrespond.UserRemoteInfo[0])*SearchCorrespond.wUserCount;
		m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_REMOTE_SERVICE, SUB_CS_S_SEARCH_CORRESPOND, &SearchCorrespond, wHeadSize + wItemSize);

		return true;
	}
	default: break;
	}

	return false;
}

//管理服务
bool CAttemperEngineSink::OnTCPNetworkMainManagerService(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
		case SUB_CS_C_SYSTEM_MESSAGE:	//系统消息
		{
			//发送通知
			m_pITCPNetworkEngine->SendDataBatch(MDM_CS_MANAGER_SERVICE, SUB_CS_S_SYSTEM_MESSAGE, pData, wDataSize, 0L);
			return true;
		}
		case SUB_CS_C_PROPERTY_TRUMPET:  //喇叭消息
		{
			//发送通知
			m_pITCPNetworkEngine->SendDataBatch(MDM_CS_MANAGER_SERVICE, SUB_CS_S_PROPERTY_TRUMPET, pData, wDataSize, 0L);

			return true;
		}
		case SUB_CS_C_TELL_CORRESPOND:	//服务器发来的心跳
		{
			//效验数据
			ASSERT(wDataSize == sizeof(CMD_CS_C_TellCorr));
			if (wDataSize != sizeof(CMD_CS_C_TellCorr)) return false;

			//消息定义
			CMD_CS_C_TellCorr * pTellCorr = (CMD_CS_C_TellCorr *)pData;

			//获取对象
			CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.SearchServerItem(pTellCorr->wServerID);

			if (pGlobalServerItem != NULL)
			{
				pGlobalServerItem->m_GameServer.dwLiveTime = (DWORD)time(NULL);

				CString str;
				str.Format(TEXT("服务器%d 心跳时间[%d]"), pGlobalServerItem->GetServerID(), pGlobalServerItem->m_GameServer.dwLiveTime);

				CCorrespondServerDlg* pCCorrespondServerDlg = (CCorrespondServerDlg*)theApp.m_pMainWnd;

				pCCorrespondServerDlg->aa.SetWindowTextW(str);;
				///CTraceService::TraceString(str, TraceLevel_Normal);
			}
			else
			{
				//为空则该服务器已经被清空。断开连接。回一个非法包
				m_pITCPNetworkEngine->CloseSocket(dwSocketID);
				//m_pITCPNetworkEngine->ShutDownSocket(dwSocketID);
				//WORD wPacketSize = pHead->TCPInfo.wPacketSize;
				//if (wPacketSize > SOCKET_TCP_BUFFER) throw TEXT("数据包超长");
				//if (wPacketSize < sizeof(TCP_Head)) throw TEXT("数据包非法");
				//if (m_wRecvSize < wPacketSize) break;
			}
			return true;
		}
			///[---add by yd
		case SUB_CS_C_LOGON_HEARTBEAT:	// 收到登录服务器的心跳包，更新LogonServer心跳时间
		{
			ASSERT(wDataSize == sizeof(CMD_CS_C_RegisterPlaza));
			if (wDataSize != sizeof(CMD_CS_C_RegisterPlaza))
			{
				return false;
			}

			//消息定义
			//WORD * pwServerID = (WORD *)pData;

			////获取对象
			//CGlobalPlazaItem * pGlobalServerItem = m_GlobalInfoManager.SearchPlazaItemByServerID(*pwServerID);

			CMD_CS_C_RegisterPlaza * pRegisterPlaza = (CMD_CS_C_RegisterPlaza *)pData;


			//变量定义
			tagGamePlaza GamePlaza;
			ZeroMemory(&GamePlaza, sizeof(GamePlaza));

			//构造数据
			//GamePlaza.wPlazaID = wBindIndex;
			//lstrcpyn(GamePlaza.szServerName, pRegisterPlaza->szServerName, CountArray(GamePlaza.szServerName));
			//lstrcpyn(GamePlaza.szServerAddr, pRegisterPlaza->szServerAddr, CountArray(GamePlaza.szServerAddr));
			//GamePlaza.wServerID = pRegisterPlaza->wServerID;
			//GamePlaza.dwLiveTime = GetTickCount();///(DWORD)time(NULL);
			//m_GlobalInfoManager.ActivePlazaItem(wBindIndex, GamePlaza);

			//获取对象
			//CGlobalPlazaItem * pGlobalServerItem = m_GlobalInfoManager.SearchPlazaItemByServerID(GamePlaza.wServerID);

			CGlobalPlazaItem * pGlobalServerItem = m_GlobalInfoManager.SearchPlazaItem(pRegisterPlaza->wServerID);

			if (pGlobalServerItem != NULL)
			{
				///---更新当前登录服务器的心跳时间
				pGlobalServerItem->m_GamePlaza.dwLiveTime = GetTickCount();///(DWORD)time(NULL);

				CString str;
				str.Format(TEXT("***登录服务器%d 心跳时间[%d]"), pGlobalServerItem->GetPlazaServerID(), pGlobalServerItem->m_GamePlaza.dwLiveTime);

				CCorrespondServerDlg* pCCorrespondServerDlg = (CCorrespondServerDlg*)theApp.m_pMainWnd;

				pCCorrespondServerDlg->aa.SetWindowTextW(str);

				//CTraceService::TraceString(str, TraceLevel_Normal);

				///---回一个心跳包
				m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_MANAGER_SERVICE, SUB_CS_C_LOGON_HEARTBEAT, pData, wDataSize);
			}
			else
			{
				ASSERT(FALSE);
				CString str;
				str.Format(TEXT("***未找到此登录服务器, wServerID=%d 心跳未发送"),  pRegisterPlaza->wServerID);

				CTraceService::TraceString(str, TraceLevel_Normal);
			}

			return true;
		}
		default: break;
			///---]
	}

	return false;
}

//机器服务
//bool CAttemperEngineSink::OnTCPNetworkMainAndroidService(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
//{
//	switch (wSubCmdID)
//	{
//	case SUB_CS_C_ADDPARAMETER:		//添加参数
//	{
//		//参数校验
//		ASSERT(sizeof(CMD_CS_C_AddParameter) == wDataSize);
//		if (sizeof(CMD_CS_C_AddParameter) != wDataSize) return false;
//
//		//提取数据
//		CMD_CS_C_AddParameter * pAddParameter = (CMD_CS_C_AddParameter *)pData;
//
//		//构造结构
//		CMD_CS_S_AddParameter AddParameter;
//		CopyMemory(&AddParameter.AndroidParameter, &pAddParameter->AndroidParameter, sizeof(tagAndroidParameter));
//
//		//发送消息
//		SendDataToGame(pAddParameter->wServerID, MDM_CS_ANDROID_SERVICE, SUB_CS_S_ADDPARAMETER, &AddParameter, sizeof(AddParameter));
//
//		return true;
//	}
//	case SUB_CS_C_MODIFYPARAMETER:  //修改参数
//	{
//		//参数校验
//		ASSERT(sizeof(CMD_CS_C_ModifyParameter) == wDataSize);
//		if (sizeof(CMD_CS_C_ModifyParameter) != wDataSize) return false;
//
//		//提取数据
//		CMD_CS_C_ModifyParameter * pModifyParameter = (CMD_CS_C_ModifyParameter *)pData;
//
//		//构造结构
//		CMD_CS_S_ModifyParameter ModifyParameter;
//		CopyMemory(&ModifyParameter.AndroidParameter, &pModifyParameter->AndroidParameter, sizeof(tagAndroidParameter));
//
//		//发送通知
//		SendDataToGame(pModifyParameter->wServerID, MDM_CS_ANDROID_SERVICE, SUB_CS_S_MODIFYPARAMETER, &ModifyParameter, sizeof(ModifyParameter));
//
//		return true;
//	}
//	case SUB_CS_C_DELETEPARAMETER:  //删除参数
//	{
//		//参数校验
//		ASSERT(sizeof(CMD_CS_C_DeleteParameter) == wDataSize);
//		if (sizeof(CMD_CS_C_DeleteParameter) != wDataSize) return false;
//
//		//提取数据
//		CMD_CS_C_DeleteParameter * pDeleteParameter = (CMD_CS_C_DeleteParameter *)pData;
//
//		//构造结构
//		CMD_CS_S_DeleteParameter DeleteParameter;
//		DeleteParameter.dwBatchID = pDeleteParameter->dwBatchID;
//
//		//发送通知
//		SendDataToGame(pDeleteParameter->wServerID, MDM_CS_ANDROID_SERVICE, SUB_CS_S_DELETEPARAMETER, &DeleteParameter, sizeof(DeleteParameter));
//
//		return true;
//	}
//	default: break;
//	}
//
//	return false;
//}

//发送私人房间列表总会
bool CAttemperEngineSink::SendPrivateListItem(DWORD dwSocketID)
{
	//变量定义
	CPrivateRoomList* pCMapRoomListA = m_GlobalInfoManager.GetPrivateRoom();
	///---JN_GR_RoomListBig tempA;
	///---ZeroMemory(&tempA, sizeof(tempA));

	POSITION Position = pCMapRoomListA->GetStartPosition();
	while (Position != NULL)
	{
		JN_GR_RoomListBig Temp;
		ZeroMemory(&Temp, sizeof(JN_GR_RoomListBig));

		DWORD dwRoomNumber = 0;
		pCMapRoomListA->GetNextAssoc(Position, dwRoomNumber, Temp);

		m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_USER_COLLECT, SUB_CS_UPDATAOTHERROOM, &Temp, sizeof(JN_GR_RoomListBig));
	}

	return true;
}

//发送列表
bool CAttemperEngineSink::SendServerListItem(DWORD dwSocketID)
{
	//变量定义
	WORD wPacketSize = 0L;
	POSITION Position = NULL;
	BYTE cbBuffer[SOCKET_TCP_PACKET];

	//发送信息
	m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_INFO);

	//收集数据
	do
	{
		//发送数据
		if ((wPacketSize + sizeof(tagGameServer)) > sizeof(cbBuffer))
		{
			m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_INSERT, cbBuffer, wPacketSize);
			wPacketSize = 0;
		}

		//获取对象
		tagGameServer * pGameServer = (tagGameServer *)(cbBuffer + wPacketSize);
		CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.EnumServerItem(Position);

		//设置数据
		if (pGlobalServerItem != NULL)
		{
			wPacketSize += sizeof(tagGameServer);
			CopyMemory(pGameServer, &pGlobalServerItem->m_GameServer, sizeof(tagGameServer));
		}

	} while (Position != NULL);

	//发送数据
	if (wPacketSize > 0) m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_INSERT, cbBuffer, wPacketSize);

	//发送完成
	m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_SERVICE_INFO, SUB_CS_S_SERVER_FINISH);

	return true;
}

//发送列表
bool CAttemperEngineSink::SendMatchListItem(DWORD dwSocketID)
{
	//变量定义
	WORD wPacketSize = 0L;
	POSITION Position = NULL;
	BYTE cbBuffer[SOCKET_TCP_PACKET];

	//收集数据
	do
	{
		//发送数据
		if ((wPacketSize + sizeof(tagGameServer)) > sizeof(cbBuffer))
		{
			m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_SERVICE_INFO, SUB_CS_S_MATCH_INSERT, cbBuffer, wPacketSize);
			wPacketSize = 0;
		}

		//获取对象
		tagGameMatch * pGameMatch = (tagGameMatch *)(cbBuffer + wPacketSize);
		CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.EnumServerItem(Position);

		//设置数据
		if (pGlobalServerItem != NULL && pGlobalServerItem->IsMatchServer())
		{
			wPacketSize += sizeof(tagGameMatch);
			CopyMemory(pGameMatch, &pGlobalServerItem->m_GameMatch, sizeof(tagGameMatch));
		}

	} while (Position != NULL);

	//发送数据
	if (wPacketSize > 0) m_pITCPNetworkEngine->SendData(dwSocketID, MDM_CS_SERVICE_INFO, SUB_CS_S_MATCH_INSERT, cbBuffer, wPacketSize);

	return true;
}

//房间发送
bool CAttemperEngineSink::SendDataToGame(WORD wServerID, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
	//查找房间
	CGlobalServerItem * pGlobalServerItem = m_GlobalInfoManager.SearchServerItem(wServerID);
	if (pGlobalServerItem == NULL) return false;

	//获取参数
	WORD wBindIndex = pGlobalServerItem->GetIndex();
	tagBindParameter * pBindParameter = (m_pBindParameter + wBindIndex);

	//发送数据
	DWORD dwSocketID = pBindParameter->dwSocketID;
	m_pITCPNetworkEngine->SendData(dwSocketID, wMainCmdID, wSubCmdID, pData, wDataSize);

	return true;
}


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