2489 lines
76 KiB
C++
2489 lines
76 KiB
C++
#include "StdAfx.h"
|
||
#include "ServiceUnits.h"
|
||
#include "ControlPacket.h"
|
||
#include "AttemperEngineSink.h"
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////
|
||
|
||
//时间标识
|
||
#define IDI_LOAD_GAME_LIST 1 //加载列表
|
||
#define IDI_CONNECT_CORRESPOND 2 //重连标识
|
||
#define IDI_COLLECT_ONLINE_INFO 3 //统计在线
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////
|
||
|
||
void ConvertUtf8ToGBK(CString &strUtf8)
|
||
{
|
||
int len=MultiByteToWideChar(CP_UTF8, 0, (LPCTSTR)strUtf8, -1, NULL,0);
|
||
wchar_t * wszGBK = new wchar_t[len];
|
||
memset(wszGBK,0,len);
|
||
MultiByteToWideChar(CP_UTF8, 0, (LPCTSTR)strUtf8, -1, wszGBK, len);
|
||
|
||
len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
|
||
char *szGBK=new char[len + 1];
|
||
memset(szGBK, 0, len + 1);
|
||
WideCharToMultiByte (CP_ACP, 0, wszGBK, -1, szGBK, len, NULL,NULL);
|
||
|
||
strUtf8 = szGBK;
|
||
delete[] szGBK;
|
||
delete[] wszGBK;
|
||
}
|
||
void ConvertUtf8ToGBK(char* pChar,int iLen)
|
||
{
|
||
CString kString(pChar);
|
||
ConvertUtf8ToGBK(kString);
|
||
strncpy(pChar,kString.GetString(),iLen);
|
||
}
|
||
//构造函数
|
||
CAttemperEngineSink::CAttemperEngineSink()
|
||
{
|
||
//状态变量
|
||
m_bNeekCorrespond=true;
|
||
m_bShowServerStatus=false;
|
||
|
||
//状态变量
|
||
m_pInitParameter=NULL;
|
||
m_pBindParameter=NULL;
|
||
|
||
//组件变量
|
||
m_pITimerEngine=NULL;
|
||
m_pIDataBaseEngine=NULL;
|
||
m_pITCPNetworkEngine=NULL;
|
||
m_pITCPSocketService=NULL;
|
||
|
||
//视频配置
|
||
m_wAVServerPort=0;
|
||
m_dwAVServerAddr=0;
|
||
|
||
ZeroMemory((void*)&m_kCheckInInfo,sizeof(m_kCheckInInfo));
|
||
ZeroMemory(&m_BaseEnsureParameter,sizeof(m_BaseEnsureParameter));
|
||
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);
|
||
|
||
//设置时间
|
||
ASSERT(m_pITimerEngine!=NULL);
|
||
m_pITimerEngine->SetTimer(IDI_COLLECT_ONLINE_INFO,m_pInitParameter->m_wCollectTime*1000L,TIMES_INFINITY,0);
|
||
|
||
//获取目录
|
||
TCHAR szPath[MAX_PATH]=TEXT("");
|
||
CString szFileName;
|
||
GetModuleFileName(AfxGetInstanceHandle(),szPath,sizeof(szPath));
|
||
szFileName=szPath;
|
||
int nIndex = szFileName.ReverseFind(TEXT('\\'));
|
||
szFileName = szFileName.Left(nIndex);
|
||
szFileName += TEXT("\\PlazaOptionConfig.ini");
|
||
|
||
//读取配置
|
||
m_bShowServerStatus = (GetPrivateProfileInt(TEXT("ServerStatus"),TEXT("ShowServerStatus"),0,szFileName) != 0);
|
||
|
||
//获取目录
|
||
TCHAR szServerAddr[LEN_SERVER]=TEXT("");
|
||
GetCurrentDirectory(sizeof(szPath),szPath);
|
||
|
||
//读取配置
|
||
TCHAR szVideoFileName[MAX_PATH]=TEXT("");
|
||
_sntprintf_s(szVideoFileName,CountArray(szVideoFileName),TEXT("%s\\VideoOption.ini"),szPath);
|
||
m_wAVServerPort=GetPrivateProfileInt(TEXT("VideoOption"),TEXT("ServerPort"), 0,szVideoFileName);
|
||
DWORD dwAddrLen=GetPrivateProfileString(TEXT("VideoOption"),TEXT("ServerAddr"), TEXT(""), szServerAddr,LEN_SERVER,szVideoFileName);
|
||
if(dwAddrLen>0)
|
||
{
|
||
CT2CA strServerDomain(szServerAddr);
|
||
m_dwAVServerAddr=inet_addr(strServerDomain);
|
||
}
|
||
else
|
||
{
|
||
m_dwAVServerAddr=0;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//停止事件
|
||
bool CAttemperEngineSink::OnAttemperEngineConclude(IUnknownEx * pIUnknownEx)
|
||
{
|
||
//状态变量
|
||
m_bNeekCorrespond=true;
|
||
|
||
//组件变量
|
||
m_pITimerEngine=NULL;
|
||
m_pIDataBaseEngine=NULL;
|
||
m_pITCPNetworkEngine=NULL;
|
||
m_pITCPSocketService=NULL;
|
||
|
||
//删除数据
|
||
SafeDeleteArray(m_pBindParameter);
|
||
|
||
//列表组件
|
||
m_ServerListManager.ResetServerList();
|
||
|
||
return true;
|
||
}
|
||
|
||
//控制事件
|
||
bool CAttemperEngineSink::OnEventControl(WORD wIdentifier, VOID * pData, WORD wDataSize)
|
||
{
|
||
switch (wIdentifier)
|
||
{
|
||
case CT_LOAD_DB_GAME_LIST: //加载列表
|
||
{
|
||
//加载列表
|
||
m_ServerListManager.DisuseKernelItem();
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_GAME_LIST,0,NULL,0);
|
||
|
||
////加载奖励
|
||
//m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_CHECKIN_REWARD,0,NULL,0);
|
||
|
||
////加载低保
|
||
//m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_BASEENSURE,0,NULL,0);
|
||
|
||
////加载新手引导
|
||
//m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_BEGINNER,0,NULL,0);
|
||
|
||
//DBR_GP_GetAddBankConfig kGetAddBankConfig;
|
||
//kGetAddBankConfig.iIdex = 0;
|
||
//m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_ADDRANK_CONFIG,0,&kGetAddBankConfig,sizeof(kGetAddBankConfig));
|
||
|
||
//kGetAddBankConfig.iIdex = 1;
|
||
//m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_ADDRANK_CONFIG,0,&kGetAddBankConfig,sizeof(kGetAddBankConfig));
|
||
|
||
//kGetAddBankConfig.iIdex = 2;
|
||
//m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_ADDRANK_CONFIG,0,&kGetAddBankConfig,sizeof(kGetAddBankConfig));
|
||
return true;
|
||
}
|
||
case CT_CONNECT_CORRESPOND: //连接协调
|
||
{
|
||
//发起连接
|
||
tagAddressInfo * pCorrespondAddress=&m_pInitParameter->m_CorrespondAddress;
|
||
m_pITCPSocketService->Connect(pCorrespondAddress->szAddress,m_pInitParameter->m_wCorrespondPort);
|
||
|
||
//构造提示
|
||
TCHAR szString[512]=TEXT("");
|
||
_sntprintf_s(szString,CountArray(szString),TEXT("正在连接协调服务器 [ %s:%d ]"),pCorrespondAddress->szAddress,m_pInitParameter->m_wCorrespondPort);
|
||
|
||
//提示消息
|
||
CTraceService::TraceString(szString,TraceLevel_Normal);
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//调度事件
|
||
bool CAttemperEngineSink::OnEventAttemperData(WORD wRequestID, VOID * pData, WORD wDataSize)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
//时间事件
|
||
bool CAttemperEngineSink::OnEventTimer(DWORD dwTimerID, WPARAM wBindParam)
|
||
{
|
||
switch (dwTimerID)
|
||
{
|
||
case IDI_LOAD_GAME_LIST: //加载列表
|
||
{
|
||
//加载列表
|
||
m_ServerListManager.DisuseKernelItem();
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOAD_GAME_LIST,0,NULL,0);
|
||
|
||
return true;
|
||
}
|
||
case IDI_CONNECT_CORRESPOND: //连接协调
|
||
{
|
||
//发起连接
|
||
tagAddressInfo * pCorrespondAddress=&m_pInitParameter->m_CorrespondAddress;
|
||
m_pITCPSocketService->Connect(pCorrespondAddress->szAddress,m_pInitParameter->m_wCorrespondPort);
|
||
|
||
//构造提示
|
||
TCHAR szString[512]=TEXT("");
|
||
_sntprintf_s(szString,CountArray(szString),TEXT("正在连接协调服务器 [ %s:%d ]"),pCorrespondAddress->szAddress,m_pInitParameter->m_wCorrespondPort);
|
||
|
||
//提示消息
|
||
CTraceService::TraceString(szString,TraceLevel_Normal);
|
||
|
||
return true;
|
||
}
|
||
case IDI_COLLECT_ONLINE_INFO: //统计在线
|
||
{
|
||
//变量定义
|
||
DBR_GP_OnLineCountInfo OnLineCountInfo;
|
||
ZeroMemory(&OnLineCountInfo,sizeof(OnLineCountInfo));
|
||
|
||
//获取总数
|
||
OnLineCountInfo.dwOnLineCountSum=m_ServerListManager.CollectOnlineInfo();
|
||
|
||
//获取类型
|
||
POSITION KindPosition=NULL;
|
||
do
|
||
{
|
||
//获取类型
|
||
CGameKindItem * pGameKindItem=m_ServerListManager.EmunGameKindItem(KindPosition);
|
||
|
||
//设置变量
|
||
if (pGameKindItem!=NULL)
|
||
{
|
||
WORD wKindIndex=OnLineCountInfo.wKindCount++;
|
||
OnLineCountInfo.OnLineCountKind[wKindIndex].wKindID=pGameKindItem->m_GameKind.wKindID;
|
||
OnLineCountInfo.OnLineCountKind[wKindIndex].dwOnLineCount=pGameKindItem->m_GameKind.dwOnLineCount;
|
||
}
|
||
|
||
//溢出判断
|
||
if (OnLineCountInfo.wKindCount>=CountArray(OnLineCountInfo.OnLineCountKind))
|
||
{
|
||
ASSERT(FALSE);
|
||
break;
|
||
}
|
||
|
||
} while (KindPosition!=NULL);
|
||
|
||
//发送请求
|
||
WORD wHeadSize=sizeof(OnLineCountInfo)-sizeof(OnLineCountInfo.OnLineCountKind);
|
||
WORD wSendSize=wHeadSize+OnLineCountInfo.wKindCount*sizeof(OnLineCountInfo.OnLineCountKind[0]);
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_ONLINE_COUNT_INFO,0,&OnLineCountInfo,wSendSize);
|
||
|
||
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::OnEventTCPNetworkShut(DWORD dwClientAddr, DWORD dwActiveTime, DWORD dwSocketID)
|
||
{
|
||
//清除信息
|
||
WORD wBindIndex=LOWORD(dwSocketID);
|
||
ZeroMemory((m_pBindParameter+wBindIndex),sizeof(tagBindParameter));
|
||
|
||
return false;
|
||
}
|
||
|
||
//读取事件
|
||
bool CAttemperEngineSink::OnEventTCPNetworkRead(TCP_Command Command, VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
switch (Command.wMainCmdID)
|
||
{
|
||
case MDM_GP_LOGON: //登录命令
|
||
{
|
||
return OnTCPNetworkMainPCLogon(Command.wSubCmdID,pData,wDataSize,dwSocketID);
|
||
}
|
||
case MDM_GP_SERVER_LIST: //列表命令
|
||
{
|
||
return OnTCPNetworkMainPCServerList(Command.wSubCmdID,pData,wDataSize,dwSocketID);
|
||
}
|
||
case MDM_GP_USER_SERVICE: //服务命令
|
||
{
|
||
return OnTCPNetworkMainPCUserService(Command.wSubCmdID,pData,wDataSize,dwSocketID);
|
||
}
|
||
case MDM_GP_REMOTE_SERVICE: //远程服务
|
||
{
|
||
return OnTCPNetworkMainPCRemoteService(Command.wSubCmdID,pData,wDataSize,dwSocketID);
|
||
}
|
||
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//数据库事件
|
||
bool CAttemperEngineSink::OnEventDataBase(WORD wRequestID, DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
switch (wRequestID)
|
||
{
|
||
case DBO_GP_LOGON_SUCCESS: //登录成功
|
||
{
|
||
return OnDBPCLogonSuccess(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_LOGON_FAILURE: //登录失败
|
||
{
|
||
return OnDBPCLogonFailure(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_USER_INDIVIDUAL: //用户信息
|
||
{
|
||
return OnDBPCUserIndividual(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_USER_ACCOUNTINFO: //用户个人信息
|
||
{
|
||
return OnDBPCUserAccountInfo(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_USER_INGAME_SERVER_ID: //玩家是否在游戏中
|
||
{
|
||
return OnDBPCInGameSevrerID(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_USER_WXSHARE_REWARD: //微信分享成功
|
||
{
|
||
return OnDBPCUserWXShareReward(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_OPERATE_SUCCESS: //操作成功
|
||
{
|
||
return OnDBPCOperateSuccess(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_OPERATE_FAILURE: //操作失败
|
||
{
|
||
return OnDBPCOperateFailure(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_TYPE_ITEM: //类型子项
|
||
{
|
||
return OnDBPCGameTypeItem(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_KIND_ITEM: //类型子项
|
||
{
|
||
return OnDBPCGameKindItem(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_NODE_ITEM: //节点子项
|
||
{
|
||
return OnDBPCGameNodeItem(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_PAGE_ITEM: //定制子项
|
||
{
|
||
return OnDBPCGamePageItem(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_LIST_RESULT: //加载结果
|
||
{
|
||
return OnDBPCGameListResult(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_RECORD_LIST: //战绩回放列表
|
||
{
|
||
return OnDBPCGameRecordList(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_RECORD_TOTAL: //战绩列表
|
||
{
|
||
return OnDBPCGameRecordTotal(dwContextID,pData,wDataSize);
|
||
}
|
||
case DBO_GP_GAME_RECORD_CHILD:
|
||
{
|
||
return OnDBPCGameRecordChild(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_QueryInMatch:
|
||
{
|
||
return OnDBPCQueryInMatch(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_QueryInUnion:
|
||
{
|
||
return OnDBPCQueryInUnion(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_UnionList:
|
||
{
|
||
return OnDBPCUnionList(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_UnionGameList:
|
||
{
|
||
return OnDBPCUnionGameList(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_UnionRoomList:
|
||
{
|
||
return OnDBPCUnionRoomList(dwContextID, pData, wDataSize);
|
||
}
|
||
case DBO_GP_AutoRoomList:
|
||
{
|
||
return OnDBPCAutoRoomList(dwContextID, pData, wDataSize);
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//关闭事件
|
||
bool CAttemperEngineSink::OnEventTCPSocketShut(WORD wServiceID, BYTE cbShutReason)
|
||
{
|
||
//协调连接
|
||
if (wServiceID==NETWORK_CORRESPOND)
|
||
{
|
||
//重连判断
|
||
if (m_bNeekCorrespond==true)
|
||
{
|
||
//构造提示
|
||
TCHAR szDescribe[128]=TEXT("");
|
||
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("与协调服务器的连接关闭了，%ld 秒后将重新连接"),m_pInitParameter->m_wConnectTime);
|
||
|
||
//提示消息
|
||
CTraceService::TraceString(szDescribe,TraceLevel_Warning);
|
||
|
||
//设置时间
|
||
ASSERT(m_pITimerEngine!=NULL);
|
||
m_pITimerEngine->SetTimer(IDI_CONNECT_CORRESPOND,m_pInitParameter->m_wConnectTime*1000L,1,0);
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//连接事件
|
||
bool CAttemperEngineSink::OnEventTCPSocketLink(WORD wServiceID, INT nErrorCode)
|
||
{
|
||
//协调连接
|
||
if (wServiceID==NETWORK_CORRESPOND)
|
||
{
|
||
//错误判断
|
||
if (nErrorCode!=0)
|
||
{
|
||
//构造提示
|
||
TCHAR szDescribe[128]=TEXT("");
|
||
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("协调服务器连接失败 [ %ld ]，%ld 秒后将重新连接"),
|
||
nErrorCode,m_pInitParameter->m_wConnectTime);
|
||
|
||
//提示消息
|
||
CTraceService::TraceString(szDescribe,TraceLevel_Warning);
|
||
|
||
//设置时间
|
||
ASSERT(m_pITimerEngine!=NULL);
|
||
m_pITimerEngine->SetTimer(IDI_CONNECT_CORRESPOND,m_pInitParameter->m_wConnectTime*1000L,1,0);
|
||
|
||
return false;
|
||
}
|
||
|
||
//提示消息
|
||
CTraceService::TraceString(TEXT("正在注册游戏登录服务器..."),TraceLevel_Normal);
|
||
|
||
//变量定义
|
||
CMD_CS_C_RegisterPlaza RegisterPlaza;
|
||
ZeroMemory(&RegisterPlaza,sizeof(RegisterPlaza));
|
||
|
||
//设置变量
|
||
lstrcpyn(RegisterPlaza.szServerName,m_pInitParameter->m_szServerName,CountArray(RegisterPlaza.szServerName));
|
||
lstrcpyn(RegisterPlaza.szServerAddr,m_pInitParameter->m_ServiceAddress.szAddress,CountArray(RegisterPlaza.szServerAddr));
|
||
|
||
//发送数据
|
||
m_pITCPSocketService->SendData(MDM_CS_REGISTER,SUB_CS_C_REGISTER_PLAZA,&RegisterPlaza,sizeof(RegisterPlaza));
|
||
|
||
return true;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//读取事件
|
||
bool CAttemperEngineSink::OnEventTCPSocketRead(WORD wServiceID, TCP_Command Command, VOID * pData, WORD wDataSize)
|
||
{
|
||
//协调连接
|
||
if (wServiceID==NETWORK_CORRESPOND)
|
||
{
|
||
switch (Command.wMainCmdID)
|
||
{
|
||
case MDM_CS_REGISTER: //注册服务
|
||
{
|
||
return OnTCPSocketMainRegister(Command.wSubCmdID,pData,wDataSize);
|
||
}
|
||
case MDM_CS_SERVICE_INFO: //服务信息
|
||
{
|
||
return OnTCPSocketMainServiceInfo(Command.wSubCmdID,pData,wDataSize);
|
||
}
|
||
case MDM_CS_REMOTE_SERVICE: //远程服务
|
||
{
|
||
return OnTCPSocketMainRemoteService(Command.wSubCmdID,pData,wDataSize);
|
||
}
|
||
case MDM_CS_MANAGER_SERVICE: //管理服务
|
||
{
|
||
return true;
|
||
}
|
||
case MDM_CS_WEB_SERVICE:
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
//错误断言
|
||
ASSERT(FALSE);
|
||
|
||
return false;
|
||
}
|
||
|
||
//注册事件
|
||
bool CAttemperEngineSink::OnTCPSocketMainRegister(WORD wSubCmdID, VOID * pData, WORD wDataSize)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_CS_S_REGISTER_FAILURE: //注册失败
|
||
{
|
||
//变量定义
|
||
CMD_CS_S_RegisterFailure * pRegisterFailure=(CMD_CS_S_RegisterFailure *)pData;
|
||
|
||
//效验参数
|
||
ASSERT(wDataSize>=(sizeof(CMD_CS_S_RegisterFailure)-sizeof(pRegisterFailure->szDescribeString)));
|
||
if (wDataSize<(sizeof(CMD_CS_S_RegisterFailure)-sizeof(pRegisterFailure->szDescribeString))) return false;
|
||
|
||
//关闭处理
|
||
m_bNeekCorrespond=false;
|
||
m_pITCPSocketService->CloseSocket();
|
||
|
||
//显示消息
|
||
LPCTSTR pszDescribeString=pRegisterFailure->szDescribeString;
|
||
if (lstrlen(pszDescribeString)>0) CTraceService::TraceString(pszDescribeString,TraceLevel_Exception);
|
||
|
||
//事件通知
|
||
CP_ControlResult ControlResult;
|
||
ControlResult.cbSuccess=ER_FAILURE;
|
||
SendUIControlPacket(UI_CORRESPOND_RESULT,&ControlResult,sizeof(ControlResult));
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//列表事件
|
||
bool CAttemperEngineSink::OnTCPSocketMainServiceInfo(WORD wSubCmdID, VOID * pData, WORD wDataSize)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_CS_S_SERVER_INFO: //房间信息
|
||
{
|
||
//废弃列表
|
||
m_ServerListManager.DisuseServerItem();
|
||
|
||
return true;
|
||
}
|
||
case SUB_CS_S_SERVER_ONLINE: //房间人数
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_CS_S_ServerOnLine));
|
||
if (wDataSize!=sizeof(CMD_CS_S_ServerOnLine)) return false;
|
||
|
||
//变量定义
|
||
CMD_CS_S_ServerOnLine * pServerOnLine=(CMD_CS_S_ServerOnLine *)pData;
|
||
|
||
//查找房间
|
||
CGameServerItem * pGameServerItem=m_ServerListManager.SearchGameServer(pServerOnLine->wServerID);
|
||
if(pGameServerItem == NULL) return true;
|
||
|
||
//设置人数
|
||
DWORD dwOldOnlineCount=0;
|
||
dwOldOnlineCount = pGameServerItem->m_GameServer.dwOnLineCount;
|
||
pGameServerItem->m_GameServer.dwOnLineCount=pServerOnLine->dwOnLineCount;
|
||
|
||
//目录人数
|
||
CGameKindItem * pGameKindItem=m_ServerListManager.SearchGameKind(pGameServerItem->m_GameServer.wKindID);
|
||
if (pGameKindItem!=NULL)
|
||
{
|
||
tagGameServer * pGameServer=&pGameServerItem->m_GameServer;
|
||
pGameKindItem->m_GameKind.dwOnLineCount -= dwOldOnlineCount;
|
||
pGameKindItem->m_GameKind.dwOnLineCount += pGameServer->dwOnLineCount;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
case SUB_CS_S_SERVER_INSERT: //房间插入
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize%sizeof(tagGameServer)==0);
|
||
if (wDataSize%sizeof(tagGameServer)!=0) return false;
|
||
|
||
//变量定义
|
||
WORD wItemCount=wDataSize/sizeof(tagGameServer);
|
||
tagGameServer * pGameServer=(tagGameServer *)pData;
|
||
|
||
//更新数据
|
||
for (WORD i=0;i<wItemCount;i++)
|
||
{
|
||
m_ServerListManager.InsertGameServer(pGameServer++);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
case SUB_CS_S_SERVER_MODIFY: //房间修改
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_CS_S_ServerModify));
|
||
if (wDataSize!=sizeof(CMD_CS_S_ServerModify)) return false;
|
||
|
||
//变量定义
|
||
CMD_CS_S_ServerModify * pServerModify=(CMD_CS_S_ServerModify *)pData;
|
||
|
||
//查找房间
|
||
ASSERT(m_ServerListManager.SearchGameServer(pServerModify->wServerID));
|
||
CGameServerItem * pGameServerItem=m_ServerListManager.SearchGameServer(pServerModify->wServerID);
|
||
|
||
//设置房间
|
||
if (pGameServerItem!=NULL)
|
||
{
|
||
//设置人数
|
||
DWORD dwOldOnlineCount=0, dwOldFullCount=0;
|
||
dwOldOnlineCount = pGameServerItem->m_GameServer.dwOnLineCount;
|
||
dwOldFullCount = pGameServerItem->m_GameServer.dwFullCount;
|
||
|
||
//修改房间信息
|
||
pGameServerItem->m_GameServer.wKindID=pServerModify->wKindID;
|
||
pGameServerItem->m_GameServer.wNodeID=pServerModify->wNodeID;
|
||
pGameServerItem->m_GameServer.wSortID=pServerModify->wSortID;
|
||
pGameServerItem->m_GameServer.wServerPort=pServerModify->wServerPort;
|
||
pGameServerItem->m_GameServer.dwOnLineCount=pServerModify->dwOnLineCount;
|
||
pGameServerItem->m_GameServer.dwFullCount=pServerModify->dwFullCount;
|
||
lstrcpyn(pGameServerItem->m_GameServer.szServerName,pServerModify->szServerName,CountArray(pGameServerItem->m_GameServer.szServerName));
|
||
lstrcpyn(pGameServerItem->m_GameServer.szServerAddr,pServerModify->szServerAddr,CountArray(pGameServerItem->m_GameServer.szServerAddr));
|
||
|
||
//目录人数
|
||
CGameKindItem * pGameKindItem=m_ServerListManager.SearchGameKind(pGameServerItem->m_GameServer.wKindID);
|
||
if (pGameKindItem!=NULL)
|
||
{
|
||
tagGameServer * pGameServer=&pGameServerItem->m_GameServer;
|
||
pGameKindItem->m_GameKind.dwOnLineCount -= dwOldOnlineCount;
|
||
pGameKindItem->m_GameKind.dwOnLineCount += pGameServer->dwOnLineCount;
|
||
|
||
pGameKindItem->m_GameKind.dwFullCount -= dwOldFullCount;
|
||
pGameKindItem->m_GameKind.dwFullCount += pGameServer->dwFullCount;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
case SUB_CS_S_SERVER_REMOVE: //房间删除
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_CS_S_ServerRemove));
|
||
if (wDataSize!=sizeof(CMD_CS_S_ServerRemove)) return false;
|
||
|
||
//变量定义
|
||
CMD_CS_S_ServerRemove * pServerRemove=(CMD_CS_S_ServerRemove *)pData;
|
||
|
||
//变量定义
|
||
m_ServerListManager.DeleteGameServer(pServerRemove->wServerID);
|
||
|
||
return true;
|
||
}
|
||
case SUB_CS_S_SERVER_FINISH: //房间完成
|
||
{
|
||
//清理列表
|
||
m_ServerListManager.CleanServerItem();
|
||
|
||
//事件处理
|
||
CP_ControlResult ControlResult;
|
||
ControlResult.cbSuccess=ER_SUCCESS;
|
||
SendUIControlPacket(UI_CORRESPOND_RESULT,&ControlResult,sizeof(ControlResult));
|
||
|
||
return true;
|
||
}
|
||
case SUB_CS_S_MATCH_INSERT: //比赛插入
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize%sizeof(tagGameMatch)==0);
|
||
if (wDataSize%sizeof(tagGameMatch)!=0) return false;
|
||
|
||
//变量定义
|
||
WORD wItemCount=wDataSize/sizeof(tagGameMatch);
|
||
tagGameMatch * pGameMatch=(tagGameMatch *)pData;
|
||
|
||
//更新数据
|
||
for (WORD i=0;i<wItemCount;i++)
|
||
{
|
||
CGameServerItem * pGameServerItem = m_ServerListManager.SearchGameServer(pGameMatch->wServerID);
|
||
if(pGameServerItem!=NULL)
|
||
{
|
||
CopyMemory(&pGameServerItem->m_GameMatch,pGameMatch++,sizeof(pGameServerItem->m_GameMatch));
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//远程服务
|
||
bool CAttemperEngineSink::OnTCPSocketMainRemoteService(WORD wSubCmdID, VOID * pData, WORD wDataSize)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_CS_S_SEARCH_CORRESPOND: //协调查找
|
||
{
|
||
//变量定义
|
||
CMD_CS_S_SearchCorrespond * pSearchCorrespond=(CMD_CS_S_SearchCorrespond *)pData;
|
||
|
||
//效验参数
|
||
ASSERT(wDataSize<=sizeof(CMD_CS_S_SearchCorrespond));
|
||
ASSERT(wDataSize>=(sizeof(CMD_CS_S_SearchCorrespond)-sizeof(pSearchCorrespond->UserRemoteInfo)));
|
||
ASSERT(wDataSize==(sizeof(CMD_CS_S_SearchCorrespond)-sizeof(pSearchCorrespond->UserRemoteInfo)+pSearchCorrespond->wUserCount*sizeof(pSearchCorrespond->UserRemoteInfo[0])));
|
||
|
||
//效验参数
|
||
if (wDataSize>sizeof(CMD_CS_S_SearchCorrespond)) return false;
|
||
if (wDataSize<(sizeof(CMD_CS_S_SearchCorrespond)-sizeof(pSearchCorrespond->UserRemoteInfo))) return false;
|
||
if (wDataSize!=(sizeof(CMD_CS_S_SearchCorrespond)-sizeof(pSearchCorrespond->UserRemoteInfo)+pSearchCorrespond->wUserCount*sizeof(pSearchCorrespond->UserRemoteInfo[0]))) return false;
|
||
|
||
//判断在线
|
||
ASSERT(LOWORD(pSearchCorrespond->dwSocketID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(pSearchCorrespond->dwSocketID))->dwSocketID!=pSearchCorrespond->dwSocketID) return true;
|
||
|
||
//变量定义
|
||
CMD_GP_S_SearchCorrespond SearchCorrespond;
|
||
ZeroMemory(&SearchCorrespond,sizeof(SearchCorrespond));
|
||
|
||
//设置变量
|
||
for (WORD i=0;i<pSearchCorrespond->wUserCount;i++)
|
||
{
|
||
//数据效验
|
||
ASSERT(SearchCorrespond.wUserCount<CountArray(SearchCorrespond.UserRemoteInfo));
|
||
if (SearchCorrespond.wUserCount>=CountArray(SearchCorrespond.UserRemoteInfo)) break;
|
||
|
||
//设置变量
|
||
WORD wIndex=SearchCorrespond.wUserCount++;
|
||
CopyMemory(&SearchCorrespond.UserRemoteInfo[wIndex],&pSearchCorrespond->UserRemoteInfo[i],sizeof(SearchCorrespond.UserRemoteInfo[wIndex]));
|
||
}
|
||
|
||
//发送数据
|
||
WORD wHeadSize=sizeof(SearchCorrespond)-sizeof(SearchCorrespond.UserRemoteInfo);
|
||
WORD wItemSize=sizeof(SearchCorrespond.UserRemoteInfo[0])*SearchCorrespond.wUserCount;
|
||
m_pITCPNetworkEngine->SendData(pSearchCorrespond->dwSocketID,MDM_GP_REMOTE_SERVICE,SUB_GP_S_SEARCH_CORRESPOND,&SearchCorrespond,wHeadSize+wItemSize);
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//登录处理
|
||
bool CAttemperEngineSink::OnTCPNetworkMainPCLogon(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_GP_LOGON_ACCOUNTS: //帐号登录
|
||
{
|
||
return OnTCPNetworkSubPCLogonAccounts(pData,wDataSize,dwSocketID);
|
||
}
|
||
case SUB_GP_REGISTER_ACCOUNTS: //帐号注册
|
||
{
|
||
return OnTCPNetworkSubPCRegisterAccounts(pData,wDataSize,dwSocketID);
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//列表处理
|
||
bool CAttemperEngineSink::OnTCPNetworkMainPCServerList(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_GP_GET_LIST: //获取列表
|
||
{
|
||
//发送列表
|
||
SendGameTypeInfo(dwSocketID);
|
||
SendGameKindInfo(dwSocketID);
|
||
|
||
//发送列表
|
||
if (m_pInitParameter->m_cbDelayList==TRUE)
|
||
{
|
||
//发送列表
|
||
SendGamePageInfo(dwSocketID,INVALID_WORD);
|
||
SendGameNodeInfo(dwSocketID,INVALID_WORD);
|
||
SendGameServerInfo(dwSocketID,INVALID_WORD);
|
||
}
|
||
else
|
||
{
|
||
//发送页面
|
||
SendGamePageInfo(dwSocketID,0);
|
||
}
|
||
|
||
//发送完成
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_FINISH);
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GET_SERVER: //获取房间
|
||
{
|
||
//效验数据
|
||
ASSERT(wDataSize%sizeof(WORD)==0);
|
||
if (wDataSize%sizeof(WORD)!=0) return false;
|
||
|
||
//发送列表
|
||
UINT nKindCount=wDataSize/sizeof(WORD);
|
||
for (UINT i=0;i<nKindCount;i++)
|
||
{
|
||
SendGameNodeInfo(dwSocketID,((WORD *)pData)[i]);
|
||
SendGamePageInfo(dwSocketID,((WORD *)pData)[i]);
|
||
SendGameServerInfo(dwSocketID,((WORD *)pData)[i]);
|
||
}
|
||
|
||
//发送完成
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_SERVER_FINISH,pData,wDataSize);
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GET_ONLINE: //获取在线
|
||
{
|
||
//变量定义
|
||
CMD_GP_GetOnline * pGetOnline=(CMD_GP_GetOnline *)pData;
|
||
WORD wHeadSize=(sizeof(CMD_GP_GetOnline)-sizeof(pGetOnline->wOnLineServerID));
|
||
|
||
//效验数据
|
||
ASSERT((wDataSize>=wHeadSize)&&(wDataSize==(wHeadSize+pGetOnline->wServerCount*sizeof(WORD))));
|
||
if ((wDataSize<wHeadSize)||(wDataSize!=(wHeadSize+pGetOnline->wServerCount*sizeof(WORD)))) return false;
|
||
|
||
//变量定义
|
||
CMD_GP_KindOnline KindOnline;
|
||
CMD_GP_ServerOnline ServerOnline;
|
||
ZeroMemory(&KindOnline,sizeof(KindOnline));
|
||
ZeroMemory(&ServerOnline,sizeof(ServerOnline));
|
||
|
||
//获取类型
|
||
POSITION KindPosition=NULL;
|
||
do
|
||
{
|
||
//获取类型
|
||
CGameKindItem * pGameKindItem=m_ServerListManager.EmunGameKindItem(KindPosition);
|
||
|
||
//设置变量
|
||
if (pGameKindItem!=NULL)
|
||
{
|
||
WORD wKindIndex=KindOnline.wKindCount++;
|
||
KindOnline.OnLineInfoKind[wKindIndex].wKindID=pGameKindItem->m_GameKind.wKindID;
|
||
KindOnline.OnLineInfoKind[wKindIndex].dwOnLineCount=pGameKindItem->m_GameKind.dwOnLineCount;
|
||
}
|
||
|
||
//溢出判断
|
||
if (KindOnline.wKindCount>=CountArray(KindOnline.OnLineInfoKind))
|
||
{
|
||
ASSERT(FALSE);
|
||
break;
|
||
}
|
||
|
||
} while (KindPosition!=NULL);
|
||
|
||
//获取房间
|
||
for (WORD i=0;i<pGetOnline->wServerCount;i++)
|
||
{
|
||
//获取房间
|
||
WORD wServerID=pGetOnline->wOnLineServerID[i];
|
||
CGameServerItem * pGameServerItem=m_ServerListManager.SearchGameServer(wServerID);
|
||
|
||
//设置变量
|
||
if (pGameServerItem!=NULL)
|
||
{
|
||
WORD wServerIndex=ServerOnline.wServerCount++;
|
||
ServerOnline.OnLineInfoServer[wServerIndex].wServerID=wServerID;
|
||
ServerOnline.OnLineInfoServer[wServerIndex].dwOnLineCount=pGameServerItem->m_GameServer.dwOnLineCount;
|
||
}
|
||
|
||
//溢出判断
|
||
if (ServerOnline.wServerCount>=CountArray(ServerOnline.OnLineInfoServer))
|
||
{
|
||
ASSERT(FALSE);
|
||
break;
|
||
}
|
||
}
|
||
|
||
//类型在线
|
||
if (KindOnline.wKindCount>0)
|
||
{
|
||
WORD wHeadSize=sizeof(KindOnline)-sizeof(KindOnline.OnLineInfoKind);
|
||
WORD wSendSize=wHeadSize+KindOnline.wKindCount*sizeof(KindOnline.OnLineInfoKind[0]);
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GR_KINE_ONLINE,&KindOnline,wSendSize);
|
||
}
|
||
|
||
//房间在线
|
||
if (ServerOnline.wServerCount>0)
|
||
{
|
||
WORD wHeadSize=sizeof(ServerOnline)-sizeof(ServerOnline.OnLineInfoServer);
|
||
WORD wSendSize=wHeadSize+ServerOnline.wServerCount*sizeof(ServerOnline.OnLineInfoServer[0]);
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GR_SERVER_ONLINE,&ServerOnline,wSendSize);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GET_COLLECTION: //获取收藏
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//服务处理
|
||
bool CAttemperEngineSink::OnTCPNetworkMainPCUserService(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_GP_GAME_RECORD_LIST://游戏记录
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_GetGameRecord_List));
|
||
if (wDataSize!=sizeof(CMD_GP_GetGameRecord_List)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_GetGameRecord_List * pNetInfo=(CMD_GP_GetGameRecord_List *)pData;
|
||
|
||
//变量定义
|
||
DBR_GP_GameRecordList kDBInfo;
|
||
ZeroMemory(&kDBInfo,sizeof(kDBInfo));
|
||
|
||
//构造数据
|
||
kDBInfo.dwUserID = pNetInfo->dwUserID;
|
||
kDBInfo.wKindID = pNetInfo->wKindID;
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_GAME_RECORD_LIST,dwSocketID,&kDBInfo,sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GAME_RECORD_TOTAL://游戏记录
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_GetGameTotalRecord));
|
||
if (wDataSize!=sizeof(CMD_GP_GetGameTotalRecord)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_GetGameTotalRecord * pNetInfo=(CMD_GP_GetGameTotalRecord *)pData;
|
||
//变量定义
|
||
DBR_GP_GetGameTotalRecord kDBInfo;
|
||
ZeroMemory(&kDBInfo,sizeof(kDBInfo));
|
||
|
||
//构造数据
|
||
kDBInfo.dwUserID = pNetInfo->dwUserID;
|
||
kDBInfo.dwRecordID = pNetInfo->dwRecordID;
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_GAME_TOTAL_RECORD,dwSocketID,&kDBInfo,sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GAME_RECORD_CHILD: //根据分享码查询
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GP_GetGameTotalRecord));
|
||
if (wDataSize != sizeof(CMD_GP_GetGameTotalRecord)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_GetGameTotalRecord * pNetInfo = (CMD_GP_GetGameTotalRecord *)pData;
|
||
|
||
//变量定义
|
||
DBR_GP_GetGameTotalRecord kDBInfo;
|
||
ZeroMemory(&kDBInfo, sizeof(kDBInfo));
|
||
|
||
//构造数据
|
||
kDBInfo.dwUserID = pNetInfo->dwUserID;
|
||
kDBInfo.dwRecordID = pNetInfo->dwRecordID;
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_GAME_CHILD_RECORD, dwSocketID, &kDBInfo, sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_PUBLIC_NOTICE://自定义字段查询
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_QueryNotice));
|
||
if (wDataSize!=sizeof(CMD_GP_QueryNotice)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_QueryNotice * pNetInfo=(CMD_GP_QueryNotice *)pData;
|
||
//变量定义
|
||
DBR_GP_PublicNotic kDBInfo;
|
||
ZeroMemory(&kDBInfo,sizeof(kDBInfo));
|
||
|
||
//构造数据
|
||
lstrcpyn(kDBInfo.szKeyName,pNetInfo->szKeyName,CountArray(kDBInfo.szKeyName));
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_PUBLIC_NOTIC,dwSocketID,&kDBInfo,sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_MODIFY_MACHINE: //绑定机器
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_ModifyMachine));
|
||
if (wDataSize!=sizeof(CMD_GP_ModifyMachine)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_ModifyMachine * pModifyMachine=(CMD_GP_ModifyMachine *)pData;
|
||
pModifyMachine->szPassword[CountArray(pModifyMachine->szPassword)-1]=0;
|
||
|
||
//变量定义
|
||
DBR_GP_ModifyMachine ModifyMachine;
|
||
ZeroMemory(&ModifyMachine,sizeof(ModifyMachine));
|
||
|
||
//构造数据
|
||
ModifyMachine.cbBind=pModifyMachine->cbBind;
|
||
ModifyMachine.dwUserID=pModifyMachine->dwUserID;
|
||
ModifyMachine.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
lstrcpyn(ModifyMachine.szPassword,pModifyMachine->szPassword,CountArray(ModifyMachine.szPassword));
|
||
lstrcpyn(ModifyMachine.szMachineID,pModifyMachine->szMachineID,CountArray(ModifyMachine.szMachineID));
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_MODIFY_MACHINE,dwSocketID,&ModifyMachine,sizeof(ModifyMachine));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_MODIFY_LOGON_PASS: //修改密码
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_ModifyLogonPass));
|
||
if (wDataSize!=sizeof(CMD_GP_ModifyLogonPass)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_ModifyLogonPass * pModifyLogonPass=(CMD_GP_ModifyLogonPass *)pData;
|
||
pModifyLogonPass->szDesPassword[CountArray(pModifyLogonPass->szDesPassword)-1]=0;
|
||
pModifyLogonPass->szScrPassword[CountArray(pModifyLogonPass->szScrPassword)-1]=0;
|
||
|
||
//变量定义
|
||
DBR_GP_ModifyLogonPass ModifyLogonPass;
|
||
ZeroMemory(&ModifyLogonPass,sizeof(ModifyLogonPass));
|
||
|
||
//构造数据
|
||
ModifyLogonPass.dwUserID=pModifyLogonPass->dwUserID;
|
||
ModifyLogonPass.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
lstrcpyn(ModifyLogonPass.szDesPassword,pModifyLogonPass->szDesPassword,CountArray(ModifyLogonPass.szDesPassword));
|
||
lstrcpyn(ModifyLogonPass.szScrPassword,pModifyLogonPass->szScrPassword,CountArray(ModifyLogonPass.szScrPassword));
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_MODIFY_LOGON_PASS,dwSocketID,&ModifyLogonPass,sizeof(ModifyLogonPass));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_INDIVIDUAL: //查询信息
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_QueryIndividual));
|
||
if (wDataSize!=sizeof(CMD_GP_QueryIndividual)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_QueryIndividual * pQueryIndividual=(CMD_GP_QueryIndividual *)pData;
|
||
|
||
//变量定义
|
||
DBR_GP_QueryIndividual QueryIndividual;
|
||
ZeroMemory(&QueryIndividual,sizeof(QueryIndividual));
|
||
|
||
//构造数据
|
||
QueryIndividual.dwUserID=pQueryIndividual->dwUserID;
|
||
QueryIndividual.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_QUERY_INDIVIDUAL,dwSocketID,&QueryIndividual,sizeof(QueryIndividual));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_ACCOUNTINFO: //查询个人信息
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_QueryAccountInfo));
|
||
if (wDataSize!=sizeof(CMD_GP_QueryAccountInfo)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_QueryAccountInfo * pQueryIndividual=(CMD_GP_QueryAccountInfo *)pData;
|
||
|
||
//变量定义
|
||
DBR_GP_QueryAccountInfo QueryIndividual;
|
||
ZeroMemory(&QueryIndividual,sizeof(QueryIndividual));
|
||
|
||
//构造数据
|
||
QueryIndividual.dwUserID=pQueryIndividual->dwUserID;
|
||
QueryIndividual.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_QUERY_ACCOUNTINFO,dwSocketID,&QueryIndividual,sizeof(QueryIndividual));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_INGAME_SEVERID: //查询游戏状态
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_UserInGameServerID));
|
||
if (wDataSize!=sizeof(CMD_GP_UserInGameServerID)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_UserInGameServerID * pNetInfo=(CMD_GP_UserInGameServerID *)pData;
|
||
|
||
//变量定义
|
||
DBR_GP_QueryUserInGameServerID kDBInfo;
|
||
ZeroMemory(&kDBInfo,sizeof(kDBInfo));
|
||
kDBInfo.dwUserID=pNetInfo->dwUserID;
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_USER_INGAME_SERVERID,dwSocketID,&kDBInfo,sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_MODIFY_INDIVIDUAL: //修改资料
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize>=sizeof(CMD_GP_ModifyIndividual));
|
||
if (wDataSize<sizeof(CMD_GP_ModifyIndividual)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_ModifyIndividual * pModifyIndividual=(CMD_GP_ModifyIndividual *)pData;
|
||
pModifyIndividual->szPassword[CountArray(pModifyIndividual->szPassword)-1]=0;
|
||
|
||
//变量定义
|
||
DBR_GP_ModifyIndividual ModifyIndividual;
|
||
ZeroMemory(&ModifyIndividual,sizeof(ModifyIndividual));
|
||
|
||
//设置变量
|
||
ModifyIndividual.dwUserID=pModifyIndividual->dwUserID;
|
||
ModifyIndividual.cbGender=pModifyIndividual->cbGender;
|
||
ModifyIndividual.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
lstrcpyn(ModifyIndividual.szPassword,pModifyIndividual->szPassword,CountArray(ModifyIndividual.szPassword));
|
||
|
||
//变量定义
|
||
VOID * pDataBuffer=NULL;
|
||
tagDataDescribe DataDescribe;
|
||
CRecvPacketHelper RecvPacket(pModifyIndividual+1,wDataSize-sizeof(CMD_GP_ModifyIndividual));
|
||
|
||
//扩展信息
|
||
while (true)
|
||
{
|
||
pDataBuffer=RecvPacket.GetData(DataDescribe);
|
||
if (DataDescribe.wDataDescribe==DTP_NULL) break;
|
||
switch (DataDescribe.wDataDescribe)
|
||
{
|
||
case DTP_GP_UI_NICKNAME: //用户昵称
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szNickName));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szNickName))
|
||
{
|
||
CopyMemory(&ModifyIndividual.szNickName,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szNickName[CountArray(ModifyIndividual.szNickName)-1]=0;
|
||
//ConvertUtf8ToGBK(ModifyIndividual.szNickName, LEN_NICKNAME);
|
||
}
|
||
break;
|
||
}
|
||
case DTP_GP_UI_USER_NOTE: //用户备注
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szUserNote));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szUserNote))
|
||
{
|
||
CopyMemory(&ModifyIndividual.szUserNote,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szUserNote[CountArray(ModifyIndividual.szUserNote)-1]=0;
|
||
}
|
||
break;
|
||
}
|
||
case DTP_GP_UI_COMPELLATION: //真实名字
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szCompellation));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szCompellation))
|
||
{
|
||
CopyMemory(&ModifyIndividual.szCompellation,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szCompellation[CountArray(ModifyIndividual.szCompellation)-1]=0;
|
||
}
|
||
break;
|
||
}
|
||
case DTP_GP_UI_MOBILE_PHONE: //移动电话
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szMobilePhone));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szMobilePhone))
|
||
{
|
||
CopyMemory(ModifyIndividual.szMobilePhone,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szMobilePhone[CountArray(ModifyIndividual.szMobilePhone)-1]=0;
|
||
}
|
||
break;
|
||
}
|
||
case DTP_GP_UI_DWELLING_PLACE: //联系地址
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szDwellingPlace));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szDwellingPlace))
|
||
{
|
||
CopyMemory(ModifyIndividual.szDwellingPlace,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szDwellingPlace[CountArray(ModifyIndividual.szDwellingPlace)-1]=0;
|
||
}
|
||
break;
|
||
}
|
||
case DTP_GP_UI_HEAD_HTTP: //头像地址
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szHeadHttp));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szHeadHttp))
|
||
{
|
||
CopyMemory(ModifyIndividual.szHeadHttp,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szHeadHttp[CountArray(ModifyIndividual.szHeadHttp)-1]=0;
|
||
}
|
||
break;
|
||
}
|
||
case DTP_GP_UI_CHANNEL: //渠道号
|
||
{
|
||
ASSERT(pDataBuffer!=NULL);
|
||
ASSERT(DataDescribe.wDataSize<=sizeof(ModifyIndividual.szUserChannel));
|
||
if (DataDescribe.wDataSize<=sizeof(ModifyIndividual.szUserChannel))
|
||
{
|
||
CopyMemory(ModifyIndividual.szUserChannel,pDataBuffer,DataDescribe.wDataSize);
|
||
ModifyIndividual.szUserChannel[CountArray(ModifyIndividual.szUserChannel)-1]=0;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_MODIFY_INDIVIDUAL,dwSocketID,&ModifyIndividual,sizeof(ModifyIndividual));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_MXSHARE_SUCCESS:
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GP_WXShareSuccess));
|
||
if (wDataSize != sizeof(CMD_GP_WXShareSuccess)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_WXShareSuccess * pWXShare = (CMD_GP_WXShareSuccess *)pData;
|
||
pWXShare->szPassword[CountArray(pWXShare->szPassword) - 1] = 0;
|
||
|
||
//变量定义
|
||
DBR_GP_WXShareSuccess mSuccess;
|
||
ZeroMemory(&mSuccess, sizeof(mSuccess));
|
||
|
||
//构造数据
|
||
mSuccess.dwUserID = pWXShare->dwUserID;
|
||
lstrcpyn(mSuccess.szPassword, pWXShare->szPassword, CountArray(mSuccess.szPassword));
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_USER_WXSHARE_SUCCESS, dwSocketID, &mSuccess, sizeof(mSuccess));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_USER_INFO_REQUEST: //查询用户
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_QueryUserInfoRequest));
|
||
if (wDataSize!=sizeof(CMD_GP_QueryUserInfoRequest)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_QueryUserInfoRequest * pQueryUserInfoRequest=(CMD_GP_QueryUserInfoRequest *)pData;
|
||
|
||
//变量定义
|
||
DBR_GP_QueryInsureUserInfo QueryInsureUserInfo;
|
||
ZeroMemory(&QueryInsureUserInfo,sizeof(QueryInsureUserInfo));
|
||
|
||
//构造数据
|
||
QueryInsureUserInfo.cbByNickName=pQueryUserInfoRequest->cbByNickName;
|
||
lstrcpyn(QueryInsureUserInfo.szNickName,pQueryUserInfoRequest->szNickName,CountArray(QueryInsureUserInfo.szNickName));
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_QUERY_USER_INFO,dwSocketID,&QueryInsureUserInfo,sizeof(QueryInsureUserInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_IN_MATCH:
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GP_QUERY_IN_MATCH));
|
||
if (wDataSize != sizeof(CMD_GP_QUERY_IN_MATCH)) return false;
|
||
|
||
//处理消息;
|
||
CMD_GP_QUERY_IN_MATCH * pNetInfo = (CMD_GP_QUERY_IN_MATCH *)pData;
|
||
|
||
//变量定义;
|
||
DBR_GP_QueryInMatch kDBInfo;
|
||
ZeroMemory(&kDBInfo, sizeof(kDBInfo));
|
||
|
||
//构造数据
|
||
kDBInfo.dwUserID = pNetInfo->dwUserID;
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_QUERY_IN_MATCH, dwSocketID, &kDBInfo, sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_QUERY_IN_UNION:
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GP_UserInUnion));
|
||
if (wDataSize != sizeof(CMD_GP_UserInUnion)) return false;
|
||
|
||
//处理消息;
|
||
CMD_GP_UserInUnion * pNetInfo = (CMD_GP_UserInUnion *)pData;
|
||
|
||
//变量定义;
|
||
DBR_GP_UserInUnion kDBInfo;
|
||
ZeroMemory(&kDBInfo, sizeof(kDBInfo));
|
||
kDBInfo.dwUserID = pNetInfo->dwUserID;
|
||
kDBInfo.dwUnionCode = pNetInfo->dwUnionCode;
|
||
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_QUERY_IN_UNION, dwSocketID, &kDBInfo, sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GET_UNION_LIST:
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GP_GetUnionList));
|
||
if (wDataSize != sizeof(CMD_GP_GetUnionList)) return false;
|
||
|
||
//处理消息;
|
||
CMD_GP_GetUnionList* pGetUnionList = (CMD_GP_GetUnionList *)pData;
|
||
|
||
//变量定义;
|
||
DBR_GP_GetUnionList kDBInfo;
|
||
ZeroMemory(&kDBInfo, sizeof(kDBInfo));
|
||
kDBInfo.dwUserID = pGetUnionList->dwUserID;
|
||
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_GET_UNION_LIST, dwSocketID, &kDBInfo, sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GET_UNION_ROOM_LIST:
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GR_GetUnionRoomInfo));
|
||
if (wDataSize != sizeof(CMD_GR_GetUnionRoomInfo)) return false;
|
||
|
||
//处理消息;
|
||
CMD_GR_GetUnionRoomInfo* pGetUnionList = (CMD_GR_GetUnionRoomInfo *)pData;
|
||
|
||
//变量定义;
|
||
DBR_GP_GetUnionRoomList kDBInfo;
|
||
ZeroMemory(&kDBInfo, sizeof(kDBInfo));
|
||
kDBInfo.dwUserID = pGetUnionList->dwUserID;
|
||
kDBInfo.dwUnionCode = pGetUnionList->dwUnionCode;
|
||
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_GET_UNION_ROOM_LIST, dwSocketID, &kDBInfo, sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
case SUB_GP_GET_AUTO_ROOM_LIST:
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize == sizeof(CMD_GP_GetUnionList));
|
||
if (wDataSize != sizeof(CMD_GP_GetUnionList)) return false;
|
||
|
||
//处理消息;
|
||
CMD_GP_GetAutoRoomList* pGetAutoList = (CMD_GP_GetAutoRoomList *)pData;
|
||
|
||
//变量定义;
|
||
DBR_GP_GetAutoRoomList kDBInfo;
|
||
ZeroMemory(&kDBInfo, sizeof(kDBInfo));
|
||
kDBInfo.dwUserID = pGetAutoList->dwUserID;
|
||
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_GET_AUTO_ROOM_LIST, dwSocketID, &kDBInfo, sizeof(kDBInfo));
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//操作失败
|
||
VOID CAttemperEngineSink::SendOperateFailure(DWORD dwContextID, LONG lResultCode, LPCTSTR pszDescribe)
|
||
{
|
||
//效验参数
|
||
ASSERT(pszDescribe != NULL);
|
||
if(pszDescribe == NULL) return;
|
||
|
||
//变量定义
|
||
CMD_GP_OperateFailure OperateFailure;
|
||
ZeroMemory(&OperateFailure,sizeof(OperateFailure));
|
||
|
||
//构造数据
|
||
OperateFailure.lResultCode=lResultCode;
|
||
lstrcpyn(OperateFailure.szDescribeString,pszDescribe,CountArray(OperateFailure.szDescribeString));
|
||
|
||
//发送数据
|
||
WORD wDescribe=CountStringBuffer(OperateFailure.szDescribeString);
|
||
WORD wHeadSize=sizeof(OperateFailure)-sizeof(OperateFailure.szDescribeString);
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_OPERATE_FAILURE,&OperateFailure,wHeadSize+wDescribe);
|
||
|
||
//关闭连接
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
|
||
return;
|
||
}
|
||
|
||
//远程处理
|
||
bool CAttemperEngineSink::OnTCPNetworkMainPCRemoteService(WORD wSubCmdID, VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
switch (wSubCmdID)
|
||
{
|
||
case SUB_GP_C_SEARCH_CORRESPOND: //协调查找
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(CMD_GP_C_SearchCorrespond));
|
||
if (wDataSize!=sizeof(CMD_GP_C_SearchCorrespond)) return false;
|
||
|
||
//处理消息
|
||
CMD_GP_C_SearchCorrespond * pSearchCorrespond=(CMD_GP_C_SearchCorrespond *)pData;
|
||
pSearchCorrespond->szNickName[CountArray(pSearchCorrespond->szNickName)-1]=0;
|
||
|
||
//变量定义
|
||
CMD_CS_C_SearchCorrespond SearchCorrespond;
|
||
ZeroMemory(&SearchCorrespond,sizeof(SearchCorrespond));
|
||
|
||
//连接变量
|
||
SearchCorrespond.dwSocketID=dwSocketID;
|
||
SearchCorrespond.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
|
||
//查找变量
|
||
SearchCorrespond.dwGameID=pSearchCorrespond->dwGameID;
|
||
lstrcpyn(SearchCorrespond.szNickName,pSearchCorrespond->szNickName,CountArray(SearchCorrespond.szNickName));
|
||
|
||
//发送数据
|
||
m_pITCPSocketService->SendData(MDM_CS_REMOTE_SERVICE,SUB_CS_C_SEARCH_CORRESPOND,&SearchCorrespond,sizeof(SearchCorrespond));
|
||
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
//帐号登录
|
||
bool CAttemperEngineSink::OnTCPNetworkSubPCLogonAccounts(VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize>=sizeof(CMD_GP_LogonAccounts));
|
||
if (wDataSize<sizeof(CMD_GP_LogonAccounts))
|
||
{
|
||
if (wDataSize<sizeof(CMD_GP_LogonAccounts)-sizeof(BYTE))
|
||
return false;
|
||
}
|
||
|
||
//变量定义
|
||
WORD wBindIndex=LOWORD(dwSocketID);
|
||
tagBindParameter * pBindParameter=(m_pBindParameter+wBindIndex);
|
||
|
||
//处理消息
|
||
CMD_GP_LogonAccounts * pLogonAccounts=(CMD_GP_LogonAccounts *)pData;
|
||
pLogonAccounts->szAccounts[CountArray(pLogonAccounts->szAccounts)-1]=0;
|
||
pLogonAccounts->szPassword[CountArray(pLogonAccounts->szPassword)-1]=0;
|
||
pLogonAccounts->szMachineID[CountArray(pLogonAccounts->szMachineID)-1]=0;
|
||
pLogonAccounts->szOpenId[CountArray(pLogonAccounts->szOpenId) - 1] = 0;
|
||
pLogonAccounts->szUnionid[CountArray(pLogonAccounts->szUnionid) - 1] = 0;
|
||
|
||
//设置连接
|
||
pBindParameter->cbClientKind=CLIENT_KIND_COMPUTER;
|
||
pBindParameter->dwPlazaVersion=pLogonAccounts->dwPlazaVersion;
|
||
|
||
//版本判断
|
||
if (CheckPlazaVersion(DEVICE_TYPE_PC,pLogonAccounts->dwPlazaVersion,dwSocketID,((pLogonAccounts->cbValidateFlags&LOW_VER_VALIDATE_FLAGS)!=0))==false)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
//变量定义
|
||
DBR_GP_LogonAccounts LogonAccounts;
|
||
ZeroMemory(&LogonAccounts,sizeof(LogonAccounts));
|
||
|
||
//附加信息
|
||
LogonAccounts.pBindParameter=(m_pBindParameter+LOWORD(dwSocketID));
|
||
|
||
//构造数据
|
||
LogonAccounts.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
lstrcpyn(LogonAccounts.szAccounts,pLogonAccounts->szAccounts,CountArray(LogonAccounts.szAccounts));
|
||
lstrcpyn(LogonAccounts.szPassword,pLogonAccounts->szPassword,CountArray(LogonAccounts.szPassword));
|
||
lstrcpyn(LogonAccounts.szMachineID,pLogonAccounts->szMachineID,CountArray(LogonAccounts.szMachineID));
|
||
lstrcpyn(LogonAccounts.szOpenId, pLogonAccounts->szOpenId, CountArray(LogonAccounts.szOpenId));
|
||
lstrcpyn(LogonAccounts.szUnionid, pLogonAccounts->szUnionid, CountArray(LogonAccounts.szUnionid));
|
||
LogonAccounts.cbNeeValidateMBCard=(pLogonAccounts->cbValidateFlags&MB_VALIDATE_FLAGS);
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_LOGON_ACCOUNTS,dwSocketID,&LogonAccounts,sizeof(LogonAccounts));
|
||
|
||
return true;
|
||
}
|
||
|
||
//帐号注册
|
||
bool CAttemperEngineSink::OnTCPNetworkSubPCRegisterAccounts(VOID * pData, WORD wDataSize, DWORD dwSocketID)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize>=sizeof(CMD_GP_RegisterAccounts));
|
||
if (wDataSize<sizeof(CMD_GP_RegisterAccounts))
|
||
{
|
||
if (wDataSize<sizeof(CMD_GP_RegisterAccounts)-sizeof(BYTE))
|
||
return false;
|
||
}
|
||
|
||
//变量定义
|
||
WORD wBindIndex=LOWORD(dwSocketID);
|
||
tagBindParameter * pBindParameter=(m_pBindParameter+wBindIndex);
|
||
|
||
//处理消息
|
||
CMD_GP_RegisterAccounts * pRegisterAccounts=(CMD_GP_RegisterAccounts *)pData;
|
||
//ConvertUtf8ToGBK(pRegisterAccounts->szNickName,LEN_NICKNAME);
|
||
pRegisterAccounts->szOpenId[CountArray(pRegisterAccounts->szOpenId) - 1] = 0;
|
||
pRegisterAccounts->szUnionid[CountArray(pRegisterAccounts->szUnionid) - 1] = 0;
|
||
pRegisterAccounts->szAccounts[CountArray(pRegisterAccounts->szAccounts)-1]=0;
|
||
pRegisterAccounts->szNickName[CountArray(pRegisterAccounts->szNickName)-1]=0;
|
||
pRegisterAccounts->szSpreader[CountArray(pRegisterAccounts->szSpreader)-1]=0;
|
||
pRegisterAccounts->szMachineID[CountArray(pRegisterAccounts->szMachineID)-1]=0;
|
||
pRegisterAccounts->szLogonPass[CountArray(pRegisterAccounts->szLogonPass)-1]=0;
|
||
pRegisterAccounts->szInsurePass[CountArray(pRegisterAccounts->szInsurePass)-1]=0;
|
||
pRegisterAccounts->szPassPortID[CountArray(pRegisterAccounts->szPassPortID)-1]=0;
|
||
pRegisterAccounts->szCompellation[CountArray(pRegisterAccounts->szCompellation)-1]=0;
|
||
|
||
//设置连接
|
||
pBindParameter->cbClientKind=CLIENT_KIND_COMPUTER;
|
||
pBindParameter->dwPlazaVersion=pRegisterAccounts->dwPlazaVersion;
|
||
|
||
//效验版本
|
||
if (CheckPlazaVersion(DEVICE_TYPE_PC,pRegisterAccounts->dwPlazaVersion,dwSocketID,((pRegisterAccounts->cbValidateFlags&LOW_VER_VALIDATE_FLAGS)!=0))==false)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
//变量定义
|
||
DBR_GP_RegisterAccounts RegisterAccounts;
|
||
ZeroMemory(&RegisterAccounts,sizeof(RegisterAccounts));
|
||
|
||
//附加信息
|
||
RegisterAccounts.pBindParameter=(m_pBindParameter+LOWORD(dwSocketID));
|
||
|
||
//构造数据
|
||
RegisterAccounts.wFaceID=pRegisterAccounts->wFaceID;
|
||
RegisterAccounts.cbGender=pRegisterAccounts->cbGender;
|
||
RegisterAccounts.dwClientAddr=(m_pBindParameter+LOWORD(dwSocketID))->dwClientAddr;
|
||
lstrcpyn(RegisterAccounts.szOpenId, pRegisterAccounts->szOpenId, CountArray(RegisterAccounts.szOpenId));
|
||
lstrcpyn(RegisterAccounts.szUnionid, pRegisterAccounts->szUnionid, CountArray(RegisterAccounts.szUnionid));
|
||
lstrcpyn(RegisterAccounts.szAccounts,pRegisterAccounts->szAccounts,CountArray(RegisterAccounts.szAccounts));
|
||
lstrcpyn(RegisterAccounts.szNickName,pRegisterAccounts->szNickName,CountArray(RegisterAccounts.szNickName));
|
||
lstrcpyn(RegisterAccounts.szSpreader,pRegisterAccounts->szSpreader,CountArray(RegisterAccounts.szSpreader));
|
||
lstrcpyn(RegisterAccounts.szMachineID,pRegisterAccounts->szMachineID,CountArray(RegisterAccounts.szMachineID));
|
||
lstrcpyn(RegisterAccounts.szLogonPass,pRegisterAccounts->szLogonPass,CountArray(RegisterAccounts.szLogonPass));
|
||
lstrcpyn(RegisterAccounts.szInsurePass,pRegisterAccounts->szInsurePass,CountArray(RegisterAccounts.szInsurePass));
|
||
lstrcpyn(RegisterAccounts.szPassPortID,pRegisterAccounts->szPassPortID,CountArray(RegisterAccounts.szPassPortID));
|
||
lstrcpyn(RegisterAccounts.szCompellation,pRegisterAccounts->szCompellation,CountArray(RegisterAccounts.szCompellation));
|
||
|
||
//投递请求
|
||
m_pIDataBaseEngine->PostDataBaseRequest(DBR_GP_REGISTER_ACCOUNTS,dwSocketID,&RegisterAccounts,sizeof(RegisterAccounts));
|
||
|
||
return true;
|
||
}
|
||
|
||
//登录成功
|
||
bool CAttemperEngineSink::OnDBPCLogonSuccess(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//变量定义
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
DBO_GP_LogonSuccess * pDBOLogonSuccess=(DBO_GP_LogonSuccess *)pData;
|
||
CMD_GP_LogonSuccess * pCMDLogonSuccess=(CMD_GP_LogonSuccess *)cbDataBuffer;
|
||
|
||
//发送定义
|
||
WORD wHeadSize=sizeof(CMD_GP_LogonSuccess);
|
||
CSendPacketHelper SendPacket(cbDataBuffer+wHeadSize,sizeof(cbDataBuffer)-wHeadSize);
|
||
|
||
//设置变量
|
||
ZeroMemory(pCMDLogonSuccess,sizeof(CMD_GP_LogonSuccess));
|
||
|
||
//构造数据
|
||
pCMDLogonSuccess->wFaceID=pDBOLogonSuccess->wFaceID;
|
||
pCMDLogonSuccess->cbGender=pDBOLogonSuccess->cbGender;
|
||
pCMDLogonSuccess->dwGameID=pDBOLogonSuccess->dwGameID;
|
||
pCMDLogonSuccess->dwUserID=pDBOLogonSuccess->dwUserID;
|
||
pCMDLogonSuccess->dwCustomID=pDBOLogonSuccess->dwCustomID;
|
||
pCMDLogonSuccess->dwUserMedal=pDBOLogonSuccess->dwUserMedal;
|
||
pCMDLogonSuccess->dwExperience=pDBOLogonSuccess->dwExperience;
|
||
pCMDLogonSuccess->dwLoveLiness=pDBOLogonSuccess->dwLoveLiness;
|
||
pCMDLogonSuccess->cbWXShareTimes = pDBOLogonSuccess->cbWXShareTimes;
|
||
pCMDLogonSuccess->dwSpreaderID=pDBOLogonSuccess->dwSpreaderID;
|
||
pCMDLogonSuccess->cbMoorMachine=pDBOLogonSuccess->cbMoorMachine;
|
||
pCMDLogonSuccess->cbInsureEnabled=pDBOLogonSuccess->cbInsureEnabled;
|
||
lstrcpyn(pCMDLogonSuccess->szAccounts,pDBOLogonSuccess->szAccounts,CountArray(pCMDLogonSuccess->szAccounts));
|
||
lstrcpyn(pCMDLogonSuccess->szNickName,pDBOLogonSuccess->szNickName,CountArray(pCMDLogonSuccess->szNickName));
|
||
|
||
//用户成绩
|
||
pCMDLogonSuccess->lUserScore=pDBOLogonSuccess->lUserScore;
|
||
pCMDLogonSuccess->lUserInsure=pDBOLogonSuccess->lUserInsure;
|
||
pCMDLogonSuccess->lGrade = pDBOLogonSuccess->lGrade;
|
||
pCMDLogonSuccess->isLottery = pDBOLogonSuccess->isLottery;
|
||
|
||
//配置信息
|
||
pCMDLogonSuccess->cbShowServerStatus=m_bShowServerStatus?1:0;
|
||
|
||
////会员信息
|
||
//if (pDBOLogonSuccess->cbMemberOrder!=0)
|
||
//{
|
||
// DTP_GP_MemberInfo MemberInfo;
|
||
// ZeroMemory(&MemberInfo,sizeof(MemberInfo));
|
||
// MemberInfo.cbMemberOrder=pDBOLogonSuccess->cbMemberOrder;
|
||
// MemberInfo.MemberOverDate=pDBOLogonSuccess->MemberOverDate;
|
||
// SendPacket.AddPacket(&MemberInfo,sizeof(MemberInfo),DTP_GP_MEMBER_INFO);
|
||
//}
|
||
|
||
////个性签名
|
||
//if (pDBOLogonSuccess->szUnderWrite[0]!=0)
|
||
//{
|
||
// SendPacket.AddPacket(pDBOLogonSuccess->szUnderWrite,CountStringBuffer(pDBOLogonSuccess->szUnderWrite),DTP_GP_UNDER_WRITE);
|
||
//}
|
||
|
||
//登录成功
|
||
WORD wSendSize=SendPacket.GetDataSize()+sizeof(CMD_GP_LogonSuccess);
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_LOGON,SUB_GP_LOGON_SUCCESS,cbDataBuffer,wSendSize);
|
||
|
||
//发送列表
|
||
if (m_pInitParameter->m_cbDelayList==TRUE)
|
||
{
|
||
//发送列表
|
||
SendGameTypeInfo(dwContextID);
|
||
SendGameKindInfo(dwContextID);
|
||
SendGamePageInfo(dwContextID,INVALID_WORD);
|
||
SendGameNodeInfo(dwContextID,INVALID_WORD);
|
||
SendGameServerInfo(dwContextID,INVALID_WORD);
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_SERVER_LIST,SUB_GP_LIST_FINISH);
|
||
}
|
||
else
|
||
{
|
||
SendGameTypeInfo(dwContextID);
|
||
SendGameKindInfo(dwContextID);
|
||
SendGamePageInfo(dwContextID,0);
|
||
SendGameServerInfo(dwContextID,INVALID_WORD);
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_SERVER_LIST,SUB_GP_LIST_FINISH);
|
||
}
|
||
|
||
////报名列表
|
||
//SendUserSignupInfo(dwContextID,pDBOLogonSuccess->wSignupCount,pDBOLogonSuccess->SignupMatchInfo);
|
||
|
||
//登录完成
|
||
CMD_GP_LogonFinish LogonFinish;
|
||
ZeroMemory(&LogonFinish,sizeof(LogonFinish));
|
||
LogonFinish.wIntermitTime=m_pInitParameter->m_wIntermitTime;
|
||
LogonFinish.wOnLineCountTime=m_pInitParameter->m_wOnLineCountTime;
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_LOGON,SUB_GP_LOGON_FINISH,&LogonFinish,sizeof(LogonFinish));
|
||
|
||
return true;
|
||
}
|
||
|
||
//登录失败
|
||
bool CAttemperEngineSink::OnDBPCLogonFailure(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//变量定义
|
||
CMD_GP_LogonFailure LogonFailure;
|
||
ZeroMemory(&LogonFailure,sizeof(LogonFailure));
|
||
DBO_GP_LogonFailure * pLogonFailure=(DBO_GP_LogonFailure *)pData;
|
||
|
||
//构造数据
|
||
LogonFailure.lResultCode=pLogonFailure->lResultCode;
|
||
lstrcpyn(LogonFailure.szDescribeString,pLogonFailure->szDescribeString,CountArray(LogonFailure.szDescribeString));
|
||
|
||
//发送数据
|
||
WORD wStringSize=CountStringBuffer(LogonFailure.szDescribeString);
|
||
WORD wSendSize=sizeof(LogonFailure)-sizeof(LogonFailure.szDescribeString)+wStringSize;
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_LOGON,SUB_GP_LOGON_FAILURE,&LogonFailure,wSendSize);
|
||
|
||
//关闭连接
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//用户信息
|
||
bool CAttemperEngineSink::OnDBPCUserIndividual(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//变量定义
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
DBO_GP_UserIndividual * pDBOUserIndividual=(DBO_GP_UserIndividual *)pData;
|
||
CMD_GP_UserIndividual * pCMDUserIndividual=(CMD_GP_UserIndividual *)cbDataBuffer;
|
||
CSendPacketHelper SendPacket(cbDataBuffer+sizeof(CMD_GP_UserIndividual),sizeof(cbDataBuffer)-sizeof(CMD_GP_UserIndividual));
|
||
|
||
//设置变量
|
||
ZeroMemory(pCMDUserIndividual,sizeof(CMD_GP_UserIndividual));
|
||
|
||
//构造数据
|
||
pCMDUserIndividual->dwUserID=pDBOUserIndividual->dwUserID;
|
||
|
||
//用户信息
|
||
if (pDBOUserIndividual->szUserNote[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szUserNote);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szUserNote,wBufferSize,DTP_GP_UI_USER_NOTE);
|
||
}
|
||
|
||
//真实姓名
|
||
if (pDBOUserIndividual->szCompellation[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szCompellation);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szCompellation,wBufferSize,DTP_GP_UI_COMPELLATION);
|
||
}
|
||
|
||
//电话号码
|
||
if (pDBOUserIndividual->szSeatPhone[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szSeatPhone);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szSeatPhone,wBufferSize,DTP_GP_UI_SEAT_PHONE);
|
||
}
|
||
|
||
//移动电话
|
||
if (pDBOUserIndividual->szMobilePhone[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szMobilePhone);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szMobilePhone,wBufferSize,DTP_GP_UI_MOBILE_PHONE);
|
||
}
|
||
|
||
//联系资料
|
||
if (pDBOUserIndividual->szQQ[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szQQ);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szQQ,wBufferSize,DTP_GP_UI_QQ);
|
||
}
|
||
|
||
//电子邮件
|
||
if (pDBOUserIndividual->szEMail[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szEMail);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szEMail,wBufferSize,DTP_GP_UI_EMAIL);
|
||
}
|
||
|
||
//联系地址
|
||
if (pDBOUserIndividual->szDwellingPlace[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szDwellingPlace);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szDwellingPlace,wBufferSize,DTP_GP_UI_DWELLING_PLACE);
|
||
}
|
||
//头像http
|
||
if (pDBOUserIndividual->szHeadHttp[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szHeadHttp);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szHeadHttp,wBufferSize,DTP_GP_UI_HEAD_HTTP);
|
||
}
|
||
//IP
|
||
if (pDBOUserIndividual->szLogonIP[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szLogonIP);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szLogonIP,wBufferSize,DTP_GP_UI_IP);
|
||
}
|
||
//渠道号
|
||
if (pDBOUserIndividual->szUserChannel[0]!=0)
|
||
{
|
||
WORD wBufferSize=CountStringBuffer(pDBOUserIndividual->szUserChannel);
|
||
SendPacket.AddPacket(pDBOUserIndividual->szUserChannel,wBufferSize,DTP_GP_UI_CHANNEL);
|
||
}
|
||
|
||
//发送消息
|
||
WORD wSendSize=sizeof(CMD_GP_UserIndividual)+SendPacket.GetDataSize();
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_USER_INDIVIDUAL,cbDataBuffer,wSendSize);
|
||
|
||
return true;
|
||
}
|
||
//用户个人信息
|
||
bool CAttemperEngineSink::OnDBPCUserAccountInfo(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//变量定义
|
||
DBO_GP_UserAccountInfo * pDBOUserIndividual=(DBO_GP_UserAccountInfo *)pData;
|
||
CMD_GP_UserAccountInfo kCMDUserIndividual;
|
||
CopyMemory(&kCMDUserIndividual,pDBOUserIndividual,sizeof(kCMDUserIndividual));
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_QUERY_ACCOUNTINFO,&kCMDUserIndividual,sizeof(kCMDUserIndividual));
|
||
return true;
|
||
}
|
||
|
||
bool CAttemperEngineSink::OnDBPCInGameSevrerID(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
DBO_GP_UserInGameServerID * pDBInfo=(DBO_GP_UserInGameServerID *)pData;
|
||
//变量定义
|
||
CMD_GP_InGameSeverID kNetInfo;
|
||
ZeroMemory(&kNetInfo,sizeof(kNetInfo));
|
||
|
||
kNetInfo.LockKindID=pDBInfo->LockKindID;
|
||
kNetInfo.LockServerID=pDBInfo->LockServerID;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_QUERY_INGAME_SEVERID,&kNetInfo,sizeof(kNetInfo));
|
||
|
||
//关闭连接
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//微信分享成功
|
||
bool CAttemperEngineSink::OnDBPCUserWXShareReward(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
DBO_GP_WXShareReward * pDBInfo = (DBO_GP_WXShareReward *)pData;
|
||
|
||
if (pDBInfo->cbFKCount>0)
|
||
{
|
||
//变量定义
|
||
CMD_GP_WXShareReward mReward;
|
||
ZeroMemory(&mReward, sizeof(mReward));
|
||
|
||
mReward.cbFKCount = pDBInfo->cbFKCount;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_MXSHARE_REWARD, &mReward, sizeof(mReward));
|
||
}
|
||
|
||
//关闭连接
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//操作成功
|
||
bool CAttemperEngineSink::OnDBPCOperateSuccess(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//变量定义
|
||
CMD_GP_OperateSuccess OperateSuccess;
|
||
ZeroMemory(&OperateSuccess,sizeof(OperateSuccess));
|
||
|
||
//变量定义
|
||
DBO_GP_OperateSuccess * pOperateSuccess=(DBO_GP_OperateSuccess *)pData;
|
||
|
||
//构造数据
|
||
OperateSuccess.lResultCode=pOperateSuccess->lResultCode;
|
||
lstrcpyn(OperateSuccess.szDescribeString,pOperateSuccess->szDescribeString,CountArray(OperateSuccess.szDescribeString));
|
||
|
||
//发送数据
|
||
WORD wDescribe=CountStringBuffer(OperateSuccess.szDescribeString);
|
||
WORD wHeadSize=sizeof(OperateSuccess)-sizeof(OperateSuccess.szDescribeString);
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_OPERATE_SUCCESS,&OperateSuccess,wHeadSize+wDescribe);
|
||
|
||
//关闭连接
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//操作失败
|
||
bool CAttemperEngineSink::OnDBPCOperateFailure(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//变量定义
|
||
CMD_GP_OperateFailure OperateFailure;
|
||
ZeroMemory(&OperateFailure,sizeof(OperateFailure));
|
||
|
||
//变量定义
|
||
DBO_GP_OperateFailure * pOperateFailure=(DBO_GP_OperateFailure *)pData;
|
||
|
||
//构造数据
|
||
OperateFailure.lResultCode=pOperateFailure->lResultCode;
|
||
lstrcpyn(OperateFailure.szDescribeString,pOperateFailure->szDescribeString,CountArray(OperateFailure.szDescribeString));
|
||
|
||
//发送数据
|
||
WORD wDescribe=CountStringBuffer(OperateFailure.szDescribeString);
|
||
WORD wHeadSize=sizeof(OperateFailure)-sizeof(OperateFailure.szDescribeString);
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_OPERATE_FAILURE,&OperateFailure,wHeadSize+wDescribe);
|
||
|
||
//关闭连接
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
|
||
return true;
|
||
}
|
||
|
||
//游戏种类
|
||
bool CAttemperEngineSink::OnDBPCGameTypeItem(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize%sizeof(DBO_GP_GameType)==0);
|
||
if (wDataSize%sizeof(DBO_GP_GameType)!=0) return false;
|
||
|
||
//变量定义
|
||
WORD wItemCount=wDataSize/sizeof(DBO_GP_GameType);
|
||
DBO_GP_GameType * pGameType=(DBO_GP_GameType *)pData;
|
||
|
||
//更新数据
|
||
for (WORD i=0;i<wItemCount;i++)
|
||
{
|
||
//变量定义
|
||
tagGameType GameType;
|
||
ZeroMemory(&GameType,sizeof(GameType));
|
||
|
||
//构造数据
|
||
GameType.wTypeID=(pGameType+i)->wTypeID;
|
||
GameType.wJoinID=(pGameType+i)->wJoinID;
|
||
GameType.wSortID=(pGameType+i)->wSortID;
|
||
lstrcpyn(GameType.szTypeName,(pGameType+i)->szTypeName,CountArray(GameType.szTypeName));
|
||
|
||
//插入列表
|
||
m_ServerListManager.InsertGameType(&GameType);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//游戏类型
|
||
bool CAttemperEngineSink::OnDBPCGameKindItem(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize%sizeof(DBO_GP_GameKind)==0);
|
||
if (wDataSize%sizeof(DBO_GP_GameKind)!=0) return false;
|
||
|
||
//变量定义
|
||
WORD wItemCount=wDataSize/sizeof(DBO_GP_GameKind);
|
||
DBO_GP_GameKind * pGameKind=(DBO_GP_GameKind *)pData;
|
||
|
||
//更新数据
|
||
for (WORD i=0;i<wItemCount;i++)
|
||
{
|
||
//变量定义
|
||
tagGameKind GameKind;
|
||
ZeroMemory(&GameKind,sizeof(GameKind));
|
||
|
||
//构造数据
|
||
GameKind.wTypeID=(pGameKind+i)->wTypeID;
|
||
GameKind.wJoinID=(pGameKind+i)->wJoinID;
|
||
GameKind.wSortID=(pGameKind+i)->wSortID;
|
||
GameKind.wKindID=(pGameKind+i)->wKindID;
|
||
GameKind.wGameID=(pGameKind+i)->wGameID;
|
||
GameKind.dwOnLineCount=m_ServerListManager.CollectOnlineInfo((pGameKind+i)->wKindID);
|
||
lstrcpyn(GameKind.szKindName,(pGameKind+i)->szKindName,CountArray(GameKind.szKindName));
|
||
lstrcpyn(GameKind.szProcessName,(pGameKind+i)->szProcessName,CountArray(GameKind.szProcessName));
|
||
|
||
//插入列表
|
||
m_ServerListManager.InsertGameKind(&GameKind);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//游戏节点
|
||
bool CAttemperEngineSink::OnDBPCGameNodeItem(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize%sizeof(DBO_GP_GameNode)==0);
|
||
if (wDataSize%sizeof(DBO_GP_GameNode)!=0) return false;
|
||
|
||
//变量定义
|
||
WORD wItemCount=wDataSize/sizeof(DBO_GP_GameNode);
|
||
DBO_GP_GameNode * pGameNode=(DBO_GP_GameNode *)pData;
|
||
|
||
//更新数据
|
||
for (WORD i=0;i<wItemCount;i++)
|
||
{
|
||
//变量定义
|
||
tagGameNode GameNode;
|
||
ZeroMemory(&GameNode,sizeof(GameNode));
|
||
|
||
//构造数据
|
||
GameNode.wKindID=(pGameNode+i)->wKindID;
|
||
GameNode.wJoinID=(pGameNode+i)->wJoinID;
|
||
GameNode.wSortID=(pGameNode+i)->wSortID;
|
||
GameNode.wNodeID=(pGameNode+i)->wNodeID;
|
||
lstrcpyn(GameNode.szNodeName,(pGameNode+i)->szNodeName,CountArray(GameNode.szNodeName));
|
||
|
||
//插入列表
|
||
m_ServerListManager.InsertGameNode(&GameNode);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//游戏定制
|
||
bool CAttemperEngineSink::OnDBPCGamePageItem(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize%sizeof(DBO_GP_GamePage)==0);
|
||
if (wDataSize%sizeof(DBO_GP_GamePage)!=0) return false;
|
||
|
||
//变量定义
|
||
WORD wItemCount=wDataSize/sizeof(DBO_GP_GamePage);
|
||
DBO_GP_GamePage * pGamePage=(DBO_GP_GamePage *)pData;
|
||
|
||
//更新数据
|
||
for (WORD i=0;i<wItemCount;i++)
|
||
{
|
||
//变量定义
|
||
tagGamePage GamePage;
|
||
ZeroMemory(&GamePage,sizeof(GamePage));
|
||
|
||
//构造数据
|
||
GamePage.wKindID=(pGamePage+i)->wKindID;
|
||
GamePage.wNodeID=(pGamePage+i)->wNodeID;
|
||
GamePage.wSortID=(pGamePage+i)->wSortID;
|
||
GamePage.wPageID=(pGamePage+i)->wPageID;
|
||
GamePage.wOperateType=(pGamePage+i)->wOperateType;
|
||
lstrcpyn(GamePage.szDisplayName,(pGamePage+i)->szDisplayName,CountArray(GamePage.szDisplayName));
|
||
|
||
//插入列表
|
||
m_ServerListManager.InsertGamePage(&GamePage);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//游戏列表
|
||
bool CAttemperEngineSink::OnDBPCGameListResult(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//效验参数
|
||
ASSERT(wDataSize==sizeof(DBO_GP_GameListResult));
|
||
if (wDataSize!=sizeof(DBO_GP_GameListResult)) return false;
|
||
|
||
//变量定义
|
||
DBO_GP_GameListResult * pGameListResult=(DBO_GP_GameListResult *)pData;
|
||
|
||
//消息处理
|
||
if (pGameListResult->cbSuccess==TRUE)
|
||
{
|
||
//清理列表
|
||
m_ServerListManager.CleanKernelItem();
|
||
|
||
//事件通知
|
||
CP_ControlResult ControlResult;
|
||
ControlResult.cbSuccess=ER_SUCCESS;
|
||
SendUIControlPacket(UI_LOAD_DB_LIST_RESULT,&ControlResult,sizeof(ControlResult));
|
||
|
||
//设置时间
|
||
ASSERT(m_pITimerEngine!=NULL);
|
||
m_pITimerEngine->SetTimer(IDI_LOAD_GAME_LIST,m_pInitParameter->m_wLoadListTime*1000L,1,0);
|
||
}
|
||
else
|
||
{
|
||
//构造提示
|
||
TCHAR szDescribe[128]=TEXT("");
|
||
_sntprintf_s(szDescribe,CountArray(szDescribe),TEXT("服务器列表加载失败，%ld 秒后将重新加载"),m_pInitParameter->m_wReLoadListTime);
|
||
|
||
//提示消息
|
||
CTraceService::TraceString(szDescribe,TraceLevel_Warning);
|
||
|
||
//设置时间
|
||
ASSERT(m_pITimerEngine!=NULL);
|
||
m_pITimerEngine->SetTimer(IDI_LOAD_GAME_LIST,m_pInitParameter->m_wReLoadListTime*1000L,1,0);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//版本检测
|
||
bool CAttemperEngineSink::CheckPlazaVersion(BYTE cbDeviceType, DWORD dwPlazaVersion, DWORD dwSocketID, bool bCheckLowVer)
|
||
{
|
||
//变量定义
|
||
bool bMustUpdate=false;
|
||
bool bAdviceUpdate=false;
|
||
DWORD dwVersion=VERSION_PLAZA;
|
||
|
||
//手机版本
|
||
if(cbDeviceType >= DEVICE_TYPE_IPAD) dwVersion=VERSION_MOBILE_IOS;
|
||
else if(cbDeviceType >= DEVICE_TYPE_IPHONE) dwVersion=VERSION_MOBILE_IOS;
|
||
else if(cbDeviceType >= DEVICE_TYPE_ITOUCH) dwVersion=VERSION_MOBILE_IOS;
|
||
else if(cbDeviceType >= DEVICE_TYPE_ANDROID) dwVersion=VERSION_MOBILE_ANDROID;
|
||
else if(cbDeviceType == DEVICE_TYPE_PC) dwVersion=VERSION_PLAZA;
|
||
|
||
//版本判断
|
||
if (bCheckLowVer && GetSubVer(dwPlazaVersion)<GetSubVer(dwVersion)) bAdviceUpdate=true;
|
||
if (GetMainVer(dwPlazaVersion)!=GetMainVer(dwVersion)) bMustUpdate=true;
|
||
if (GetProductVer(dwPlazaVersion)!=GetProductVer(dwVersion)) bMustUpdate=true;
|
||
|
||
//升级判断
|
||
if ((bMustUpdate==true)||(bAdviceUpdate==true))
|
||
{
|
||
//变量定义
|
||
CMD_GP_UpdateNotify UpdateNotify;
|
||
ZeroMemory(&UpdateNotify,sizeof(UpdateNotify));
|
||
|
||
//变量定义
|
||
UpdateNotify.cbMustUpdate=bMustUpdate;
|
||
UpdateNotify.cbAdviceUpdate=bAdviceUpdate;
|
||
UpdateNotify.dwCurrentVersion=dwVersion;
|
||
|
||
//发送消息
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_LOGON,SUB_GP_UPDATE_NOTIFY,&UpdateNotify,sizeof(UpdateNotify));
|
||
|
||
//中断判断
|
||
if (bMustUpdate==true)
|
||
{
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwSocketID);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
//发送请求
|
||
bool CAttemperEngineSink::SendUIControlPacket(WORD wRequestID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//发送数据
|
||
CServiceUnits * pServiceUnits=CServiceUnits::g_pServiceUnits;
|
||
pServiceUnits->PostControlRequest(wRequestID,pData,wDataSize);
|
||
|
||
return true;
|
||
}
|
||
|
||
//发送类型
|
||
VOID CAttemperEngineSink::SendGameTypeInfo(DWORD dwSocketID)
|
||
{
|
||
//网络数据
|
||
WORD wSendSize=0;
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
|
||
//枚举数据
|
||
POSITION Position=NULL;
|
||
CGameTypeItem * pGameTypeItem=NULL;
|
||
|
||
//枚举数据
|
||
for (DWORD i=0;i<m_ServerListManager.GetGameTypeCount();i++)
|
||
{
|
||
//发送数据
|
||
if ((wSendSize+sizeof(tagGameType))>sizeof(cbDataBuffer))
|
||
{
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_TYPE,cbDataBuffer,wSendSize);
|
||
wSendSize=0;
|
||
}
|
||
|
||
//获取数据
|
||
pGameTypeItem=m_ServerListManager.EmunGameTypeItem(Position);
|
||
if (pGameTypeItem==NULL) break;
|
||
|
||
//拷贝数据
|
||
CopyMemory(cbDataBuffer+wSendSize,&pGameTypeItem->m_GameType,sizeof(tagGameType));
|
||
wSendSize+=sizeof(tagGameType);
|
||
}
|
||
|
||
//发送剩余
|
||
if (wSendSize>0) m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_TYPE,cbDataBuffer,wSendSize);
|
||
|
||
return;
|
||
}
|
||
|
||
//发送种类
|
||
VOID CAttemperEngineSink::SendGameKindInfo(DWORD dwSocketID)
|
||
{
|
||
//网络数据
|
||
WORD wSendSize=0;
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
|
||
//枚举数据
|
||
POSITION Position=NULL;
|
||
CGameKindItem * pGameKindItem=NULL;
|
||
|
||
//枚举数据
|
||
for (DWORD i=0;i<m_ServerListManager.GetGameKindCount();i++)
|
||
{
|
||
//发送数据
|
||
if ((wSendSize+sizeof(tagGameKind))>sizeof(cbDataBuffer))
|
||
{
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_KIND,cbDataBuffer,wSendSize);
|
||
wSendSize=0;
|
||
}
|
||
|
||
//获取数据
|
||
pGameKindItem=m_ServerListManager.EmunGameKindItem(Position);
|
||
if (pGameKindItem==NULL) break;
|
||
|
||
//拷贝数据
|
||
CopyMemory(cbDataBuffer+wSendSize,&pGameKindItem->m_GameKind,sizeof(tagGameKind));
|
||
wSendSize+=sizeof(tagGameKind);
|
||
}
|
||
|
||
//发送剩余
|
||
if (wSendSize>0) m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_KIND,cbDataBuffer,wSendSize);
|
||
|
||
return;
|
||
}
|
||
|
||
//发送节点
|
||
VOID CAttemperEngineSink::SendGameNodeInfo(DWORD dwSocketID, WORD wKindID)
|
||
{
|
||
//网络数据
|
||
WORD wSendSize=0;
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
|
||
//枚举数据
|
||
POSITION Position=NULL;
|
||
CGameNodeItem * pGameNodeItem=NULL;
|
||
|
||
//枚举数据
|
||
for (DWORD i=0;i<m_ServerListManager.GetGameNodeCount();i++)
|
||
{
|
||
//发送数据
|
||
if ((wSendSize+sizeof(tagGameNode))>sizeof(cbDataBuffer))
|
||
{
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_NODE,cbDataBuffer,wSendSize);
|
||
wSendSize=0;
|
||
}
|
||
|
||
//获取数据
|
||
pGameNodeItem=m_ServerListManager.EmunGameNodeItem(Position);
|
||
if (pGameNodeItem==NULL) break;
|
||
|
||
//拷贝数据
|
||
if ((wKindID==INVALID_WORD)||(pGameNodeItem->m_GameNode.wKindID==wKindID))
|
||
{
|
||
CopyMemory(cbDataBuffer+wSendSize,&pGameNodeItem->m_GameNode,sizeof(tagGameNode));
|
||
wSendSize+=sizeof(tagGameNode);
|
||
}
|
||
}
|
||
|
||
//发送剩余
|
||
if (wSendSize>0) m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_NODE,cbDataBuffer,wSendSize);
|
||
|
||
return;
|
||
}
|
||
|
||
//发送定制
|
||
VOID CAttemperEngineSink::SendGamePageInfo(DWORD dwSocketID, WORD wKindID)
|
||
{
|
||
//网络数据
|
||
WORD wSendSize=0;
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
|
||
//枚举数据
|
||
POSITION Position=NULL;
|
||
CGamePageItem * pGamePageItem=NULL;
|
||
|
||
//枚举数据
|
||
for (DWORD i=0;i<m_ServerListManager.GetGamePageCount();i++)
|
||
{
|
||
//发送数据
|
||
if ((wSendSize+sizeof(tagGamePage))>sizeof(cbDataBuffer))
|
||
{
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_PAGE,cbDataBuffer,wSendSize);
|
||
wSendSize=0;
|
||
}
|
||
|
||
//获取数据
|
||
pGamePageItem=m_ServerListManager.EmunGamePageItem(Position);
|
||
if (pGamePageItem==NULL) break;
|
||
|
||
//拷贝数据
|
||
if ((wKindID==INVALID_WORD)||(pGamePageItem->m_GamePage.wKindID==wKindID))
|
||
{
|
||
CopyMemory(cbDataBuffer+wSendSize,&pGamePageItem->m_GamePage,sizeof(tagGamePage));
|
||
wSendSize+=sizeof(tagGamePage);
|
||
}
|
||
}
|
||
|
||
//发送剩余
|
||
if (wSendSize>0) m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_PAGE,cbDataBuffer,wSendSize);
|
||
|
||
return;
|
||
}
|
||
|
||
//发送房间
|
||
VOID CAttemperEngineSink::SendGameServerInfo(DWORD dwSocketID, WORD wKindID)
|
||
{
|
||
//网络数据
|
||
WORD wSendSize=0;
|
||
BYTE cbDataBuffer[SOCKET_TCP_PACKET];
|
||
|
||
//枚举数据
|
||
POSITION Position=NULL;
|
||
CGameServerItem * pGameServerItem=NULL;
|
||
|
||
//枚举数据
|
||
for (DWORD i=0;i<m_ServerListManager.GetGameServerCount();i++)
|
||
{
|
||
//发送数据
|
||
if ((wSendSize+sizeof(tagGameServer))>sizeof(cbDataBuffer))
|
||
{
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_SERVER,cbDataBuffer,wSendSize);
|
||
wSendSize=0;
|
||
}
|
||
|
||
//获取数据
|
||
pGameServerItem=m_ServerListManager.EmunGameServerItem(Position);
|
||
if (pGameServerItem==NULL) break;
|
||
|
||
//拷贝数据
|
||
if ((wKindID==INVALID_WORD)||(pGameServerItem->m_GameServer.wKindID==wKindID))
|
||
{
|
||
CopyMemory(cbDataBuffer+wSendSize,&pGameServerItem->m_GameServer,sizeof(tagGameServer));
|
||
wSendSize+=sizeof(tagGameServer);
|
||
}
|
||
}
|
||
|
||
//发送剩余
|
||
if (wSendSize>0) m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_SERVER,cbDataBuffer,wSendSize);
|
||
|
||
//设置变量
|
||
wSendSize=0;
|
||
ZeroMemory(cbDataBuffer,sizeof(cbDataBuffer));
|
||
|
||
//枚举数据
|
||
for (DWORD i=0;i<m_ServerListManager.GetGameServerCount();i++)
|
||
{
|
||
//发送数据
|
||
if ((wSendSize+sizeof(tagGameMatch))>sizeof(cbDataBuffer))
|
||
{
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_MATCH,cbDataBuffer,wSendSize);
|
||
wSendSize=0;
|
||
}
|
||
|
||
//获取数据
|
||
pGameServerItem=m_ServerListManager.EmunGameServerItem(Position);
|
||
if (pGameServerItem==NULL) break;
|
||
if (pGameServerItem->IsMatchServer()==false) continue;
|
||
|
||
//拷贝数据
|
||
if ((wKindID==INVALID_WORD)||(pGameServerItem->m_GameServer.wKindID==wKindID))
|
||
{
|
||
CopyMemory(cbDataBuffer+wSendSize,&pGameServerItem->m_GameMatch,sizeof(tagGameMatch));
|
||
wSendSize+=sizeof(tagGameMatch);
|
||
}
|
||
}
|
||
|
||
//发送剩余
|
||
if (wSendSize>0) m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_LIST_MATCH,cbDataBuffer,wSendSize);
|
||
|
||
if(m_wAVServerPort!=0 && m_dwAVServerAddr!=0)
|
||
{
|
||
//变量定义
|
||
tagAVServerOption AVServerOption;
|
||
AVServerOption.wAVServerPort=m_wAVServerPort;
|
||
AVServerOption.dwAVServerAddr=m_dwAVServerAddr;
|
||
|
||
//发送配置
|
||
m_pITCPNetworkEngine->SendData(dwSocketID,MDM_GP_SERVER_LIST,SUB_GP_VIDEO_OPTION,&AVServerOption,sizeof(AVServerOption));
|
||
};
|
||
|
||
return;
|
||
}
|
||
|
||
//游戏记录
|
||
bool CAttemperEngineSink::OnDBPCGameRecordList(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_GAME_RECORD_LIST,pData,wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
//游戏记录
|
||
bool CAttemperEngineSink::OnDBPCGameRecordTotal(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID)<m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter+LOWORD(dwContextID))->dwSocketID!=dwContextID) return true;
|
||
|
||
//DBO_GP_GameRecord_Video
|
||
//CMD_GP_BackGameRecord_Video
|
||
m_pITCPNetworkEngine->SendData(dwContextID,MDM_GP_USER_SERVICE,SUB_GP_GAME_RECORD_TOTAL,pData,wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
//分享回放
|
||
bool CAttemperEngineSink::OnDBPCGameRecordChild(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_GAME_RECORD_CHILD, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
bool CAttemperEngineSink::OnDBPCQueryInMatch(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_QUERY_IN_MATCH, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
bool CAttemperEngineSink::OnDBPCQueryInUnion(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_QUERY_IN_UNION, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
bool CAttemperEngineSink::OnDBPCUnionList(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_GET_UNION_LIST, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
bool CAttemperEngineSink::OnDBPCUnionGameList(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_UNION_GAME_LIST, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
//工会房间列表;
|
||
bool CAttemperEngineSink::OnDBPCUnionRoomList(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_GET_UNION_ROOM_LIST, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
|
||
//自动创建房间列表;
|
||
bool CAttemperEngineSink::OnDBPCAutoRoomList(DWORD dwContextID, VOID * pData, WORD wDataSize)
|
||
{
|
||
//判断在线
|
||
ASSERT(LOWORD(dwContextID) < m_pInitParameter->m_wMaxConnect);
|
||
if ((m_pBindParameter + LOWORD(dwContextID))->dwSocketID != dwContextID) return true;
|
||
|
||
m_pITCPNetworkEngine->SendData(dwContextID, MDM_GP_USER_SERVICE, SUB_GP_GET_AUTO_ROOM_LIST, pData, wDataSize);
|
||
m_pITCPNetworkEngine->ShutDownSocket(dwContextID);
|
||
return true;
|
||
}
|
||
//////////////////////////////////////////////////////////////////////////////////
|