void NFCWorldToMasterModule::ServerReport()
{
if (mLastReportTime + 10 > pPluginManager->GetNowTime())
{
return;
}
mLastReportTime = pPluginManager->GetNowTime();
std::shared_ptr<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
NFList<std::string>& strIdList = xLogicClass->GetIdList();
std::string strId;
for (bool bRet = strIdList.First(strId); bRet; bRet = strIdList.Next(strId))
{
const int nServerType = m_pElementModule->GetPropertyInt(strId, NFrame::Server::Type());
const int nServerID = m_pElementModule->GetPropertyInt(strId, NFrame::Server::ServerID());
if (pPluginManager->GetAppID() == nServerID)
{
const int nPort = m_pElementModule->GetPropertyInt(strId, NFrame::Server::Port());
const int nMaxConnect = m_pElementModule->GetPropertyInt(strId, NFrame::Server::MaxOnline());
const std::string& strName = m_pElementModule->GetPropertyString(strId, NFrame::Server::Name());
const std::string& strIP = m_pElementModule->GetPropertyString(strId, NFrame::Server::IP());
NFMsg::ServerInfoReport reqMsg;
reqMsg.set_server_id(nServerID);
reqMsg.set_server_name(strName);
reqMsg.set_server_cur_count(0);
reqMsg.set_server_ip(strIP);
reqMsg.set_server_port(nPort);
reqMsg.set_server_max_online(nMaxConnect);
reqMsg.set_server_state(NFMsg::EST_NARMAL);
reqMsg.set_server_type(nServerType);
for (int n = 0;n < 10;n++)
{
AddServerInfoExt("key" + lexical_cast<std::string>(n), "value" + lexical_cast<std::string>(n));
}
NFMsg::ServerInfoExt pb_ServerInfoExt;
for (auto it = m_mServerInfoExt.begin(); it != m_mServerInfoExt.end(); it++)
{
*pb_ServerInfoExt.add_key() = it->first;
*pb_ServerInfoExt.add_value() = it->second;
}
reqMsg.mutable_server_info_list_ext()->CopyFrom(pb_ServerInfoExt);
std::shared_ptr<ConnectData> pServerData = m_pNetClientModule->GetServerList().First();
if (pServerData)
{
m_pNetClientModule->SendToServerByPB(pServerData->nGameID, NFMsg::EGMI_STS_SERVER_REPORT, reqMsg);
}
}
}
}
}
void NFCWorldToMasterModule::Register(NFINet* pNet)
{
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
NFList<std::string>& strIdList = xLogicClass->GetIdList();
std::string strId;
for (bool bRet = strIdList.First(strId); bRet; bRet = strIdList.Next(strId))
{
const int nServerType = m_pElementModule->GetPropertyInt(strId, NFrame::Server::Type());
const int nServerID = m_pElementModule->GetPropertyInt(strId, NFrame::Server::ServerID());
if (nServerType == NF_SERVER_TYPES::NF_ST_WORLD && pPluginManager->GetAppID() == nServerID)
{
const int nPort = m_pElementModule->GetPropertyInt(strId, NFrame::Server::Port());
const int nMaxConnect = m_pElementModule->GetPropertyInt(strId, NFrame::Server::MaxOnline());
const int nCpus = m_pElementModule->GetPropertyInt(strId, NFrame::Server::CpuCount());
const std::string& strName = m_pElementModule->GetPropertyString(strId, NFrame::Server::Name());
const std::string& strIP = m_pElementModule->GetPropertyString(strId, NFrame::Server::IP());
NFMsg::ServerInfoReportList xMsg;
NFMsg::ServerInfoReport* pData = xMsg.add_server_list();
pData->set_server_id(nServerID);
pData->set_server_name(strName);
pData->set_server_cur_count(0);
pData->set_server_ip(strIP);
pData->set_server_port(nPort);
pData->set_server_max_online(nMaxConnect);
pData->set_server_state(NFMsg::EST_NARMAL);
pData->set_server_type(nServerType);
NFMsg::ServerInfoExt pb_ServerInfoExt;
pData->mutable_server_info_list_ext()->CopyFrom(pb_ServerInfoExt);
NF_SHARE_PTR<ConnectData> pServerData = m_pNetClientModule->GetServerNetInfo(pNet);
if (pServerData)
{
int nTargetID = pServerData->nGameID;
m_pNetClientModule->SendToServerByPB(nTargetID, NFMsg::EGameMsgID::EGMI_MTL_WORLD_REGISTERED, xMsg);
m_pLogModule->LogNormal(NFILogModule::NLL_INFO_NORMAL, NFGUID(0, pData->server_id()), pData->server_name(), "Register");
}
}
}
}
}
void NFCGameServerToWorldModule::Register(NFINet* pNet)
{
//成功就注册
NF_SHARE_PTR<NFILogicClass> xLogicClass = m_pLogicClassModule->GetElement("Server");
if (xLogicClass.get())
{
NFList<std::string>& xNameList = xLogicClass->GetConfigNameList();
std::string strConfigName;
for (bool bRet = xNameList.First(strConfigName); bRet; bRet = xNameList.Next(strConfigName))
{
const int nServerType = m_pElementInfoModule->GetPropertyInt(strConfigName, "Type");
const int nServerID = m_pElementInfoModule->GetPropertyInt(strConfigName, "ServerID");
if (nServerType == NF_SERVER_TYPES::NF_ST_GAME && pPluginManager->AppID() == nServerID)
{
const int nPort = m_pElementInfoModule->GetPropertyInt(strConfigName, "Port");
const int nMaxConnect = m_pElementInfoModule->GetPropertyInt(strConfigName, "MaxOnline");
const int nCpus = m_pElementInfoModule->GetPropertyInt(strConfigName, "CpuCount");
const std::string& strName = m_pElementInfoModule->GetPropertyString(strConfigName, "Name");
const std::string& strIP = m_pElementInfoModule->GetPropertyString(strConfigName, "IP");
NFMsg::ServerInfoReportList xMsg;
NFMsg::ServerInfoReport* pData = xMsg.add_server_list();
pData->set_server_id(nServerID);
pData->set_server_name(strName);
pData->set_server_cur_count(0);
pData->set_server_ip(strIP);
pData->set_server_port(nPort);
pData->set_server_max_online(nMaxConnect);
pData->set_server_state(NFMsg::EST_NARMAL);
pData->set_server_type(nServerType);
NF_SHARE_PTR<ServerData> pServerData = GetServerNetInfo(pNet);
if (pServerData)
{
int nTargetID = pServerData->nGameID;
SendToServerByPB(nTargetID, NFMsg::EGameMsgID::EGMI_GTW_GAME_REGISTERED, xMsg);
m_pLogModule->LogNormal(NFILogModule::NLL_INFO_NORMAL, NFIDENTID(0, pData->server_id()), pData->server_name(), "Register");
}
}
}
}
}
void NFCProxyServerToWorldModule::ServerReport()
{
if (mLastReportTime + 10 > pPluginManager->GetNowTime())
{
return;
}
mLastReportTime = pPluginManager->GetNowTime();
std::shared_ptr<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
for (int i = 0; i < strIdList.size(); ++i)
{
const std::string& strId = strIdList[i];
const int nServerType = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Type());
const int nServerID = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::ServerID());
if ( pPluginManager->GetAppID() == nServerID)
{
const int nPort = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Port());
const int nMaxConnect = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::MaxOnline());
const std::string& strName = m_pElementModule->GetPropertyString(strId, NFrame::Server::Name());
const std::string& strIP = m_pElementModule->GetPropertyString(strId, NFrame::Server::IP());
NFMsg::ServerInfoReport reqMsg;
reqMsg.set_server_id(nServerID);
reqMsg.set_server_name(strName);
reqMsg.set_server_cur_count(0);
reqMsg.set_server_ip(strIP);
reqMsg.set_server_port(nPort);
reqMsg.set_server_max_online(nMaxConnect);
reqMsg.set_server_state(NFMsg::EST_NARMAL);
reqMsg.set_server_type(nServerType);
std::shared_ptr<ConnectData> pServerData = m_pNetClientModule->GetServerNetInfo(NF_SERVER_TYPES::NF_ST_WORLD);
if (pServerData)
{
m_pNetClientModule->SendToServerByPB(pServerData->nGameID, NFMsg::EGMI_STS_SERVER_REPORT, reqMsg);
}
}
}
}
}
void NFCProxyServerToWorldModule::Register(NFINet* pNet)
{
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
for (int i = 0; i < strIdList.size(); ++i)
{
const std::string& strId = strIdList[i];
const int nServerType = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Type());
const int nServerID = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::ServerID());
if (nServerType == NF_SERVER_TYPES::NF_ST_PROXY && pPluginManager->GetAppID() == nServerID)
{
const int nPort = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Port());
const int nMaxConnect = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::MaxOnline());
const int nCpus = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::CpuCount());
const std::string& strName = m_pElementModule->GetPropertyString(strId, NFrame::Server::Name());
const std::string& strIP = m_pElementModule->GetPropertyString(strId, NFrame::Server::IP());
NFMsg::ServerInfoReportList xMsg;
NFMsg::ServerInfoReport* pData = xMsg.add_server_list();
pData->set_server_id(nServerID);
pData->set_server_name(strName);
pData->set_server_cur_count(0);
pData->set_server_ip(strIP);
pData->set_server_port(nPort);
pData->set_server_max_online(nMaxConnect);
pData->set_server_state(NFMsg::EST_NARMAL);
pData->set_server_type(nServerType);
NF_SHARE_PTR<ConnectData> pServerData = GetClusterModule()->GetServerNetInfo(pNet);
if (pServerData)
{
int nTargetID = pServerData->nGameID;
GetClusterModule()->SendToServerByPB(nTargetID, NFMsg::EGameMsgID::EGMI_PTWG_PROXY_REGISTERED, xMsg);
m_pLogModule->LogNormal(NFILogModule::NLL_INFO_NORMAL, NFGUID(0, pData->server_id()), pData->server_name(), "Register");
}
}
}
}
}
void NFCWorldNet_ServerModule::ServerReport(int reportServerId, NFMsg::EServerState serverStatus)
{
std::shared_ptr<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
for (int i = 0; i < strIdList.size(); ++i)
{
const std::string& strId = strIdList[i];
const int nServerType = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Type());
const int nServerID = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::ServerID());
if (reportServerId == nServerID)
{
const int nPort = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Port());
const int nMaxConnect = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::MaxOnline());
const std::string& strName = m_pElementModule->GetPropertyString(strId, NFrame::Server::Name());
const std::string& strIP = m_pElementModule->GetPropertyString(strId, NFrame::Server::IP());
NFMsg::ServerInfoReport reqMsg;
reqMsg.set_server_id(nServerID);
reqMsg.set_server_name(strName);
reqMsg.set_server_cur_count(0);
reqMsg.set_server_ip(strIP);
reqMsg.set_server_port(nPort);
reqMsg.set_server_max_online(nMaxConnect);
reqMsg.set_server_state(serverStatus);
reqMsg.set_server_type(nServerType);
m_pNetClientModule->SendToAllServerByPB(NF_SERVER_TYPES::NF_ST_MASTER, NFMsg::EGMI_STS_SERVER_REPORT, reqMsg);
}
}
}
}
bool NFCMasterNet_ServerModule::AfterInit()
{
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_STS_HEART_BEAT, this, &NFCMasterNet_ServerModule::OnHeartBeat);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_WTM_WORLD_REGISTERED, this, &NFCMasterNet_ServerModule::OnWorldRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_WTM_WORLD_UNREGISTERED, this, &NFCMasterNet_ServerModule::OnWorldUnRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_WTM_WORLD_REFRESH, this, &NFCMasterNet_ServerModule::OnRefreshWorldInfoProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_LTM_LOGIN_REGISTERED, this, &NFCMasterNet_ServerModule::OnLoginRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_LTM_LOGIN_UNREGISTERED, this, &NFCMasterNet_ServerModule::OnLoginUnRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_LTM_LOGIN_REFRESH, this, &NFCMasterNet_ServerModule::OnRefreshLoginInfoProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQ_CONNECT_WORLD, this, &NFCMasterNet_ServerModule::OnSelectWorldProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_ACK_CONNECT_WORLD, this, &NFCMasterNet_ServerModule::OnSelectServerResultProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_STS_SERVER_REPORT, this, &NFCMasterNet_ServerModule::OnServerReport);
m_pNetModule->AddReceiveCallBack(this, &NFCMasterNet_ServerModule::InvalidMessage);
m_pNetModule->AddEventCallBack(this, &NFCMasterNet_ServerModule::OnSocketEvent);
m_pNetModule->ExpandBufferSize();
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
for (int i = 0; i < strIdList.size(); ++i)
{
const std::string& strId = strIdList[i];
const int nServerType = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Type());
const int nServerID = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::ServerID());
if (nServerType == NF_SERVER_TYPES::NF_ST_MASTER && pPluginManager->GetAppID() == nServerID)
{
const int nPort = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Port());
const int nMaxConnect = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::MaxOnline());
const int nCpus = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::CpuCount());
const std::string& strName = m_pElementModule->GetPropertyString(strId, NFrame::Server::Name());
const std::string& strIP = m_pElementModule->GetPropertyString(strId, NFrame::Server::IP());
int nRet = m_pNetModule->Initialization(nMaxConnect, nPort, nCpus);
if (nRet < 0)
{
std::ostringstream strLog;
strLog << "Cannot init server net, Port = " << nPort;
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, NULL_OBJECT, strLog, __FUNCTION__, __LINE__);
NFASSERT(nRet, "Cannot init server net", __FILE__, __FUNCTION__);
exit(0);
}
NFMsg::ServerInfoReport reqMsg;
reqMsg.set_server_id(nServerID);
reqMsg.set_server_name(strName);
reqMsg.set_server_cur_count(0);
reqMsg.set_server_ip(strIP);
reqMsg.set_server_port(nPort);
reqMsg.set_server_max_online(nMaxConnect);
reqMsg.set_server_state(NFMsg::EST_NARMAL);
reqMsg.set_server_type(nServerType);
auto pServerData = NF_SHARE_PTR<ServerData>(NF_NEW ServerData());
*(pServerData->pData) = reqMsg;
mMasterMap.AddElement(nServerID, pServerData);
}
}
}
return true;
}
