void NFDBNet_ServerModule::InitAllHomeScene()
{
//Tile
//mxTileSceneIDList
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Scene::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 nSceneType = m_pElementModule->GetPropertyInt32(strId, NFrame::Scene::Tile());
if (nSceneType == 1 && strId != "1")
{
int nSceneID = lexical_cast<int>(strId);
std::vector<int>::iterator it = std::find(mxTileSceneIDList.begin(), mxTileSceneIDList.end(), nSceneID);
if (it == mxTileSceneIDList.end())
{
mxTileSceneIDList.push_back(nSceneID);
}
}
}
}
}
bool NFCLoginNet_HttpServerModule::AfterInit()
{
m_pHttpNetModule->AddRequestHandler("/login", NFHttpType::NF_HTTP_REQ_POST, this, &NFCLoginNet_HttpServerModule::OnLogin);
m_pHttpNetModule->AddRequestHandler("/world", NFHttpType::NF_HTTP_REQ_GET, this, &NFCLoginNet_HttpServerModule::OnWorldView);
m_pHttpNetModule->AddRequestHandler("/world", NFHttpType::NF_HTTP_REQ_CONNECT, this, &NFCLoginNet_HttpServerModule::OnWorldSelect);
m_pHttpNetModule->AddNetFilter("/world", this, &NFCLoginNet_HttpServerModule::OnFilter);
NF_SHARE_PTR<NFIClass> xLogicClass = m_pLogicClassModule->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];
int nJsonPort = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::WebPort());
int nWebServerAppID = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::ServerID());
//webserver only run one instance in each server
if (pPluginManager->GetAppID() == nWebServerAppID)
{
m_pHttpNetModule->InitServer(nJsonPort);
break;
}
}
}
return true;
}
bool NFCSceneAOIModule::Init()
{
m_pKernelModule = pPluginManager->FindModule<NFIKernelModule>();
m_pClassModule = pPluginManager->FindModule<NFIClassModule>();
m_pElementModule = pPluginManager->FindModule<NFIElementModule>();
m_pLogModule = pPluginManager->FindModule<NFILogModule>();
m_pEventModule = pPluginManager->FindModule<NFIEventModule>();
m_pKernelModule->RegisterCommonClassEvent(this, &NFCSceneAOIModule::OnClassCommonEvent);
m_pKernelModule->RegisterCommonPropertyEvent(this, &NFCSceneAOIModule::OnPropertyCommonEvent);
m_pKernelModule->RegisterCommonRecordEvent(this, &NFCSceneAOIModule::OnRecordCommonEvent);
//init all scene
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Scene::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];
int nSceneID = lexical_cast<int>(strId);
m_pKernelModule->CreateScene(nSceneID);
}
}
return true;
}
void NFCPropertyConfigModule::Load()
{
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::InitProperty::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];
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pElementModule->GetPropertyManager(strId);
if (pPropertyManager)
{
int nJob = m_pElementModule->GetPropertyInt32(strId, NFrame::InitProperty::Job());
int nLevel = m_pElementModule->GetPropertyInt32(strId, NFrame::InitProperty::Level());
std::string strEffectData = m_pElementModule->GetPropertyString(strId, NFrame::InitProperty::EffectData());
NF_SHARE_PTR <NFMapEx<int, std::string> > xPropertyMap = mhtCoefficienData.GetElement(nJob);
if (!xPropertyMap)
{
xPropertyMap = NF_SHARE_PTR<NFMapEx<int, std::string>>(NF_NEW NFMapEx<int, std::string>());
mhtCoefficienData.AddElement(nJob, xPropertyMap);
}
NF_SHARE_PTR<std::string> xRefPropertyIDName = xPropertyMap->GetElement(nLevel);
if (!xRefPropertyIDName)
{
xRefPropertyIDName = NF_SHARE_PTR<std::string>(NF_NEW std::string(strEffectData));
}
xPropertyMap->AddElement(nLevel, xRefPropertyIDName);
}
}
}
}
bool NFCMasterNet_HttpJsonModule::AfterInit()
{
m_pHttpNetModule->AddReceiveCallBack("json", this, &NFCMasterNet_HttpJsonModule::OnCommandQuery);
m_pHttpNetModule->AddNetCommonReceiveCallBack(this, &NFCMasterNet_HttpJsonModule::OnCommonQuery);
int nJsonPort = 80;
int nWebServerAppID = 0;
NF_SHARE_PTR<NFIClass> xLogicClass = m_pLogicClassModule->GetElement(NFrame::HttpServer::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];
nJsonPort = m_pElementModule->GetPropertyInt(strId, NFrame::HttpServer::WebPort());
nWebServerAppID = m_pElementModule->GetPropertyInt(strId, NFrame::HttpServer::ServerID());
m_strWebRootPath = m_pElementModule->GetPropertyString(strId, NFrame::HttpServer::WebRootPath());
}
}
//webserver only run one instance for NF
if (pPluginManager->GetAppID() != nWebServerAppID)
{
return true;
}
m_pHttpNetModule->InitServer(nJsonPort);
return true;
}
bool NFCWorldNet_ServerModule::AfterInit()
{
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_PTWG_PROXY_REGISTERED, this, &NFCWorldNet_ServerModule::OnProxyServerRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_PTWG_PROXY_UNREGISTERED, this, &NFCWorldNet_ServerModule::OnProxyServerUnRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_PTWG_PROXY_REFRESH, this, &NFCWorldNet_ServerModule::OnRefreshProxyServerInfoProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_GTW_GAME_REGISTERED, this, &NFCWorldNet_ServerModule::OnGameServerRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_GTW_GAME_UNREGISTERED, this, &NFCWorldNet_ServerModule::OnGameServerUnRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_GTW_GAME_REFRESH, this, &NFCWorldNet_ServerModule::OnRefreshGameServerInfoProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_DTW_DB_REGISTERED, this, &NFCWorldNet_ServerModule::OnDBServerRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_DTW_DB_UNREGISTERED, this, &NFCWorldNet_ServerModule::OnDBServerUnRegisteredProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_DTW_DB_REFRESH, this, &NFCWorldNet_ServerModule::OnRefreshDBServerInfoProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_ACK_ONLINE_NOTIFY, this, &NFCWorldNet_ServerModule::OnOnlineProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_ACK_OFFLINE_NOTIFY, this, &NFCWorldNet_ServerModule::OnOfflineProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_STS_SERVER_REPORT, this, &NFCWorldNet_ServerModule::OnTransmitServerReport);
if (!m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQSWICHSERVER, this, &NFCWorldNet_ServerModule::OnReqSwitchServer)) { return false; }
if (!m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_ACKSWICHSERVER, this, &NFCWorldNet_ServerModule::OnAckSwitchServer)) { return false; }
m_pNetModule->AddEventCallBack(this, &NFCWorldNet_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_WORLD && 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);
}
}
}
}
return true;
}
bool NFCBigMapRedisModule::GetGridBaseInfo(std::vector<NFMsg::BigMapGridBaseInfo>& xBaseInfo)
{
NF_SHARE_PTR<NFIClass> xLogicClass = m_pLogicClassModule->GetElement(NFrame::Map::ThisName());
const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
std::vector<std::string> vFields;
for (int i = 0; i < strIdList.size(); ++i)
{
const std::string& strId = strIdList[i];
vFields.push_back(strId);
}
return GetGridBaseInfo(vFields, xBaseInfo);
}
bool NFCSecurityModule::AfterInit()
{
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Security::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 std::string& strSecurityData = m_pElementModule->GetPropertyString(strId, NFrame::Security::SecurityData());
}
}
return true;
}
bool NFDBNet_ServerModule::AfterInit()
{
InitAllHomeScene();
m_pNetModule->AddEventCallBack(this, &NFDBNet_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_DB && 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::ID());
//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);
}
}
}
}
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQ_ROLE_LIST, this, &NFDBNet_ServerModule::OnRequireRoleListProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQ_CREATE_ROLE, this, &NFDBNet_ServerModule::OnCreateRoleGameProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQ_DELETE_ROLE, this, &NFDBNet_ServerModule::OnDeleteRoleGameProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQ_LOAD_ROLE_DATA, this, &NFDBNet_ServerModule::OnLoadRoleDataProcess);
m_pNetModule->AddReceiveCallBack(NFMsg::EGMI_REQ_SAVE_ROLE_DATA, this, &NFDBNet_ServerModule::OnSaveRoleDataProcess);
return true;
}
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");
}
}
}
}
}
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;
}
bool NFCProxyServerToWorldModule::AfterInit()
{
m_pNetClientModule->AddReceiveCallBack(NF_SERVER_TYPES::NF_ST_WORLD, NFMsg::EGMI_ACK_CONNECT_WORLD, this, &NFCProxyServerToWorldModule::OnSelectServerResultProcess);
m_pNetClientModule->AddReceiveCallBack(NF_SERVER_TYPES::NF_ST_WORLD, NFMsg::EGMI_STS_NET_INFO, this, &NFCProxyServerToWorldModule::OnServerInfoProcess);
m_pNetClientModule->AddReceiveCallBack(NF_SERVER_TYPES::NF_ST_WORLD, this, &NFCProxyServerToWorldModule::OnOtherMessage);
m_pNetClientModule->AddEventCallBack(NF_SERVER_TYPES::NF_ST_WORLD, this, &NFCProxyServerToWorldModule::OnSocketWSEvent);
m_pNetClientModule->ExpandBufferSize();
NF_SHARE_PTR<NFIClass> xLogicClass = m_pClassModule->GetElement(NFrame::Server::ThisName());
if (xLogicClass)
{
const std::vector<std::string>& strIdList = xLogicClass->GetIDList();
const int nCurAppID = pPluginManager->GetAppID();
std::vector<std::string>::const_iterator itr =
std::find_if(strIdList.begin(), strIdList.end(), [&](const std::string& strConfigId)
{
return nCurAppID == m_pElementModule->GetPropertyInt32(strConfigId, NFrame::Server::ServerID());
});
if (strIdList.end() == itr)
{
std::ostringstream strLog;
strLog << "Cannot find current server, AppID = " << nCurAppID;
m_pLogModule->LogNormal(NFILogModule::NLL_ERROR_NORMAL, NULL_OBJECT, strLog, __FUNCTION__, __LINE__);
NFASSERT(-1, "Cannot find current server", __FILE__, __FUNCTION__);
exit(0);
}
const int nCurArea = m_pElementModule->GetPropertyInt32(*itr, NFrame::Server::Area());
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());
const int nServerArea = m_pElementModule->GetPropertyInt32(strId, NFrame::Server::Area());
if (nServerType == NF_SERVER_TYPES::NF_ST_WORLD && nCurArea == nServerArea)
{
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());
ConnectData xServerData;
xServerData.nGameID = nServerID;
xServerData.eServerType = (NF_SERVER_TYPES)nServerType;
xServerData.strIP = strIP;
xServerData.nPort = nPort;
xServerData.strName = strName;
m_pNetClientModule->AddServer(xServerData);
}
}
}
return true;
}
bool NFCItemModule::CheckConfig()
{
NF_SHARE_PTR<NFIClass> pLogicCLass = m_pLogicClassModule->GetElement(NFrame::Item::ThisName());
if (nullptr == pLogicCLass)
{
assert(0);
}
const std::vector<std::string>& strIdList = pLogicCLass->GetIDList();
for (int i = 0; i < strIdList.size(); ++i)
{
const std::string& strConfigID = strIdList[i];
NF_SHARE_PTR<NFIPropertyManager> pPropertyManager = m_pElementModule->GetPropertyManager(strConfigID);
if (!pPropertyManager)
{
assert(0);
}
int nType = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::ItemType());
if (nType < 0)
{
assert(0);
}
int nSubType = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::ItemSubType());
if (nSubType < 0)
{
assert(0);
}
int nLevel = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::Level());
if (nLevel < 0)
{
assert(0);
}
int nQuality = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::Quality());
if (nQuality < 0)
{
assert(0);
}
//int nCoolDown = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::CoolDownTime());
//if (nCoolDown <= 0)
//{
// assert(0);
//}
int nOverlayCount = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::OverlayCount());
if (nOverlayCount <= 0)
{
assert(0);
}
int nBuyPrice = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::BuyPrice());
int nSalePrice = m_pElementModule->GetPropertyInt32(strConfigID, NFrame::Item::SalePrice());
//if (nSalePrice <= 0 || nBuyPrice <= 0)
if (nSalePrice < 0 || nBuyPrice < 0)
{
assert(0);
}
}
return true;
}