//-------------------------------------------------------------------------------------
void Entity::backupCellData()
{
AUTO_SCOPED_PROFILE("backup");
if(baseMailbox_ != NULL)
{
// 将当前的cell部分数据打包 一起发送给base部分备份
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
(*pBundle).newMessage(BaseappInterface::onBackupEntityCellData);
(*pBundle) << id_;
MemoryStream* s = MemoryStream::ObjPool().createObject();
addPositionAndDirectionToStream(*s);
(*pBundle).append(s);
MemoryStream::ObjPool().reclaimObject(s);
s = MemoryStream::ObjPool().createObject();
addCellDataToStream(ENTITY_CELL_DATA_FLAGS, s);
(*pBundle).append(s);
MemoryStream::ObjPool().reclaimObject(s);
baseMailbox_->postMail((*pBundle));
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
else
{
WARNING_MSG(boost::format("Entity::backupCellData(): %1% %2% has no base!\n") %
this->getScriptName() % this->getID());
}
}
//-------------------------------------------------------------------------------------
void Bots::handleGameTick()
{
// time_t t = ::time(NULL);
// DEBUG_MSG("EntityApp::handleGameTick[%"PRTime"]:%u\n", t, time_);
ClientApp::handleGameTick();
pEventPoller_->processPendingEvents(0.0);
{
AUTO_SCOPED_PROFILE("updateBots");
CLIENTS::iterator iter = clients().begin();
for(;iter != clients().end();)
{
Network::Channel* pChannel = iter->first;
ClientObject* pClientObject = iter->second;
++iter;
if(pClientObject->isDestroyed())
{
delClient(pChannel);
continue;
}
pClientObject->gameTick();
}
}
}
//-------------------------------------------------------------------------------------
void ServerApp::queryWatcher(Network::Channel* pChannel, MemoryStream& s)
{
AUTO_SCOPED_PROFILE("watchers");
std::string path;
s >> path;
MemoryStream::SmartPoolObjectPtr readStreamPtr = MemoryStream::createSmartPoolObj();
WatcherPaths::root().readWatchers(path, readStreamPtr.get()->get());
MemoryStream::SmartPoolObjectPtr readStreamPtr1 = MemoryStream::createSmartPoolObj();
WatcherPaths::root().readChildPaths(path, path, readStreamPtr1.get()->get());
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
ConsoleInterface::ConsoleWatcherCBMessageHandler msgHandler;
(*pBundle).newMessage(msgHandler);
uint8 type = 0;
(*pBundle) << type;
(*pBundle).append(readStreamPtr.get()->get());
pChannel->send(pBundle);
Network::Bundle* pBundle1 = Network::Bundle::ObjPool().createObject();
(*pBundle1).newMessage(msgHandler);
type = 1;
(*pBundle1) << type;
(*pBundle1).append(readStreamPtr1.get()->get());
pChannel->send(pBundle1);
}
//-------------------------------------------------------------------------------------
bool PendingLoginMgr::process()
{
AUTO_SCOPED_PROFILE("PendingMgr_process");
if(pPLMap_.size() <= 0)
{
start_ = false;
return false;
}
PTINFO_MAP::iterator iter = pPLMap_.begin();
while (iter != pPLMap_.end())
{
PLInfos* infos = iter->second;
TimeStamp curr = timestamp();
if(curr - infos->lastProcessTime >= OP_TIME_OUT_MAX)
{
iter = pPLMap_.erase(iter);
DEBUG_MSG(fmt::format("PendingLoginMgr::process: [{1}] is timeout, currsize={0}.\n",
pPLMap_.size(), infos->accountName));
SAFE_RELEASE(infos);
}
else
{
++iter;
}
}
return true;
}
//-------------------------------------------------------------------------------------
void ServerApp::queryWatcher(Mercury::Channel* pChannel, MemoryStream& s)
{
AUTO_SCOPED_PROFILE("watchers");
std::string path;
s >> path;
MemoryStream::SmartPoolObjectPtr readStreamPtr = MemoryStream::createSmartPoolObj();
WatcherPaths::root().readWatchers(path, readStreamPtr.get()->get());
MemoryStream::SmartPoolObjectPtr readStreamPtr1 = MemoryStream::createSmartPoolObj();
WatcherPaths::root().readChildPaths(path, path, readStreamPtr1.get()->get());
Mercury::Bundle bundle;
ConsoleInterface::ConsoleWatcherCBMessageHandler msgHandler;
bundle.newMessage(msgHandler);
uint8 type = 0;
bundle << type;
bundle.append(readStreamPtr.get()->get());
bundle.send(getNetworkInterface(), pChannel);
Mercury::Bundle bundle1;
bundle1.newMessage(msgHandler);
type = 1;
bundle1 << type;
bundle1.append(readStreamPtr1.get()->get());
bundle1.send(getNetworkInterface(), pChannel);
}
//-------------------------------------------------------------------------------------
bool Proxy::sendToClient(bool expectData)
{
if(!clientMailbox())
return false;
Network::Channel* pChannel = clientMailbox()->getChannel();
if(!pChannel)
return false;
if(expectData)
{
if(pChannel->bundles().size() == 0)
{
WARNING_MSG("Proxy::sendToClient: no data!\n");
return false;
}
}
{
// 如果数据大量阻塞发不出去将会报警
AUTO_SCOPED_PROFILE("sendToClient");
pChannel->send();
}
return true;
}
//-------------------------------------------------------------------------------------
void Cellapp::handleGameTick()
{
AUTO_SCOPED_PROFILE("gameTick");
updateLoad();
EntityApp<Entity>::handleGameTick();
updatables_.update();
}
//-------------------------------------------------------------------------------------
void Loginapp::reqAccountResetPassword(Network::Channel* pChannel, std::string& accountName)
{
AUTO_SCOPED_PROFILE("reqAccountResetPassword");
accountName = KBEngine::strutil::kbe_trim(accountName);
INFO_MSG(fmt::format("Loginapp::reqAccountResetPassword: accountName({})\n",
accountName));
if (!g_kbeSrvConfig.getDBMgr().account_registration_enable)
{
ERROR_MSG(fmt::format("Loginapp::reqAccountResetPassword({}): not available! modify kbengine[_defs].xml->dbmgr->account_resetPassword.\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_ERR_ACCOUNT_RESET_PASSWORD_NOT_AVAILABLE;
(*pBundle) << retcode;
pChannel->send(pBundle);
return;
}
Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY;
(*pBundle) << retcode;
pChannel->send(pBundle);
return;
}
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(DbmgrInterface::accountReqResetPassword);
(*pBundle) << accountName;
dbmgrinfos->pChannel->send(pBundle);
}
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_SUCCESS;
(*pBundle) << retcode;
pChannel->send(pBundle);
}
}
//-------------------------------------------------------------------------------------
void Bots::handleGameTick()
{
// time_t t = ::time(NULL);
// DEBUG_MSG("EntityApp::handleGameTick[%"PRTime"]:%u\n", t, time_);
ClientApp::handleGameTick();
pEventPoller_->processPendingEvents(0.0);
{
AUTO_SCOPED_PROFILE("updateBots");
CLIENTS::iterator iter = clients().begin();
for(;iter != clients().end(); iter++)
iter->second.get()->gameTick();
}
}
//-------------------------------------------------------------------------------------
PyObject* Pickler::unpickle(const std::string& str)
{
AUTO_SCOPED_PROFILE("unpickle");
PyObject* pyRet = PyObject_CallFunction(unPicklerMethod_,
const_cast<char*>("(y#)"), str.data(), str.length());
if (!pyRet)
{
ERROR_MSG(fmt::format("Pickler::unpickle: failed to unpickle[{}] len={}.\n",
str.c_str(), str.length()));
}
SCRIPT_ERROR_CHECK();
return pyRet;
}
//-------------------------------------------------------------------------------------
void ScriptCallbackHandler::handleTimeout( TimerHandle handle, void * pUser )
{
AUTO_SCOPED_PROFILE("callCallbacks");
//int id = scriptCallbacks_.getIDForHandle(handle);
PyObject * pObject = pObject_;
Py_INCREF( pObject );
PyObject * pResult =
PyObject_CallFunction( pObject, const_cast<char*>(""));
Py_XDECREF( pResult );
Py_DECREF( pObject );
SCRIPT_ERROR_CHECK();
}
//-------------------------------------------------------------------------------------
std::string Pickler::pickle(PyObject* pyobj, int8 protocol)
{
AUTO_SCOPED_PROFILE("pickleEx");
PyObject* pyRet = PyObject_CallFunction(picklerMethod_,
const_cast<char*>("(Oi)"), pyobj, protocol);
SCRIPT_ERROR_CHECK();
if(pyRet)
{
std::string str;
str.assign(PyBytes_AsString(pyRet), PyBytes_Size(pyRet));
S_RELEASE(pyRet);
return str;
}
return "";
}
//-------------------------------------------------------------------------------------
void Loginapp::reqAccountResetPassword(Mercury::Channel* pChannel, std::string& accountName)
{
AUTO_SCOPED_PROFILE("reqAccountResetPassword");
accountName = KBEngine::strutil::kbe_trim(accountName);
INFO_MSG(boost::format("Loginapp::reqAccountResetPassword: accountName(%1%)\n") %
accountName);
Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG(boost::format("Loginapp::_createAccount: create(%1%), not found dbmgr!\n") %
accountName);
Mercury::Bundle bundle;
bundle.newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY;
bundle << retcode;
bundle.send(this->getNetworkInterface(), pChannel);
return;
}
{
Mercury::Bundle bundle;
bundle.newMessage(DbmgrInterface::accountReqResetPassword);
bundle << accountName;
bundle.send(this->getNetworkInterface(), dbmgrinfos->pChannel);
}
{
Mercury::Bundle bundle;
bundle.newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_SUCCESS;
bundle << retcode;
bundle.send(this->getNetworkInterface(), pChannel);
}
}
//-------------------------------------------------------------------------------------
void Loginapp::reqAccountResetPassword(Network::Channel* pChannel, std::string& accountName)
{
AUTO_SCOPED_PROFILE("reqAccountResetPassword");
accountName = KBEngine::strutil::kbe_trim(accountName);
INFO_MSG(fmt::format("Loginapp::reqAccountResetPassword: accountName({})\n",
accountName));
Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY;
(*pBundle) << retcode;
pChannel->send(pBundle);
return;
}
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(DbmgrInterface::accountReqResetPassword);
(*pBundle) << accountName;
dbmgrinfos->pChannel->send(pBundle);
}
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onReqAccountResetPasswordCB);
SERVER_ERROR_CODE retcode = SERVER_SUCCESS;
(*pBundle) << retcode;
pChannel->send(pBundle);
}
}
//-------------------------------------------------------------------------------------
void Witness::update()
{
SCOPED_PROFILE(CLIENT_UPDATE_PROFILE);
if(pEntity_ == NULL)
return;
if(!pEntity_->getClientMailbox())
return;
Mercury::Channel* pChannel = pEntity_->getClientMailbox()->getChannel();
if(!pChannel)
return;
{
// 如果数据大量阻塞发不出去将会报警
AUTO_SCOPED_PROFILE("updateClientSend");
pChannel->send();
}
}
//-------------------------------------------------------------------------------------
bool Loginapp::_createAccount(Network::Channel* pChannel, std::string& accountName,
std::string& password, std::string& datas, ACCOUNT_TYPE type)
{
AUTO_SCOPED_PROFILE("createAccount");
ACCOUNT_TYPE oldType = type;
if(!g_kbeSrvConfig.getDBMgr().account_registration_enable)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount({}): not available!\n", accountName));
std::string retdatas = "";
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_ACCOUNT_REGISTER_NOT_AVAILABLE;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
accountName = KBEngine::strutil::kbe_trim(accountName);
password = KBEngine::strutil::kbe_trim(password);
if(accountName.size() > ACCOUNT_NAME_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName too big, size={}, limit={}.\n",
accountName.size(), ACCOUNT_NAME_MAX_LENGTH));
return false;
}
if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: password too big, size={}, limit={}.\n",
password.size(), ACCOUNT_PASSWD_MAX_LENGTH));
return false;
}
if(datas.size() > ACCOUNT_DATA_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: bindatas too big, size={}, limit={}.\n",
datas.size(), ACCOUNT_DATA_MAX_LENGTH));
return false;
}
std::string retdatas = "";
if(shuttingdown_ != SHUTDOWN_STATE_STOP)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount: shutting down, create {} failed!\n", accountName));
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_IN_SHUTTINGDOWN;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.find(const_cast<std::string&>(accountName));
if(ptinfos != NULL)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount: pendingCreateMgr has {}, request create failed!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_BUSY;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
if(type == ACCOUNT_TYPE_SMART)
{
if (email_isvalid(accountName.c_str()))
{
type = ACCOUNT_TYPE_MAIL;
}
else
{
if(!validName(accountName))
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
type = ACCOUNT_TYPE_NORMAL;
}
}
else if(type == ACCOUNT_TYPE_NORMAL)
{
if(!validName(accountName))
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
}
else if (!email_isvalid(accountName.c_str()))
{
/*
std::string user_name, domain_name;
user_name = regex_replace(accountName, _g_mail_pattern, std::string("$1") );
domain_name = regex_replace(accountName, _g_mail_pattern, std::string("$2") );
*/
WARNING_MSG(fmt::format("Loginapp::_createAccount: invalid mail={}\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME_MAIL;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
DEBUG_MSG(fmt::format("Loginapp::_createAccount: accountName={}, passwordsize={}, type={}, oldType={}.\n",
accountName.c_str(), password.size(), type, oldType));
ptinfos = new PendingLoginMgr::PLInfos;
ptinfos->accountName = accountName;
ptinfos->password = password;
ptinfos->datas = datas;
ptinfos->addr = pChannel->addr();
pendingCreateMgr_.add(ptinfos);
Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
pChannel->extra(accountName);
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(DbmgrInterface::reqCreateAccount);
uint8 uatype = uint8(type);
(*pBundle) << accountName << password << uatype;
(*pBundle).appendBlob(datas);
dbmgrinfos->pChannel->send(pBundle);
return true;
}
E* EntityApp<E>::findEntity(ENTITY_ID entityID)
{
AUTO_SCOPED_PROFILE("findEntity");
return pEntities_->find(entityID);
}
//-------------------------------------------------------------------------------------
void CoordinateSystem::update(CoordinateNode* pNode)
{
AUTO_SCOPED_PROFILE("coordinateSystemUpdates");
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update enter:[{:p}]: ({} {} {})\n", (void*)pNode, pNode->xx(), pNode->yy(), pNode->zz()));
#endif
// 没有计数器支持，这个标记很可能中途被update子分支取消，因此没有意义
//pNode->addFlags(COORDINATE_NODE_FLAG_PENDING);
++updating_;
if(pNode->xx() != pNode->old_xx())
{
while(true)
{
CoordinateNode* pCurrNode = pNode->pPrevX();
while(pCurrNode && pCurrNode != pNode && pCurrNode->x() > pNode->xx())
{
pNode->x(pCurrNode->x());
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update start: [-X] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
// 先把节点移动过去
moveNodeX(pNode, pNode->xx(), pCurrNode);
if (!pNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update1: [-X] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pCurrNode->onNodePassX(pNode, true);
}
if (!pCurrNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update2: [-X] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pNode->onNodePassX(pCurrNode, false);
}
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update end: [-X] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
if (pNode->pPrevX() == NULL)
break;
pCurrNode = pNode->pPrevX();
}
pCurrNode = pNode->pNextX();
while(pCurrNode && pCurrNode != pNode && pCurrNode->x() < pNode->xx())
{
pNode->x(pCurrNode->x());
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update start: [+X] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
// 先把节点移动过去
moveNodeX(pNode, pNode->xx(), pCurrNode);
if (!pNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update1: [+X] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pCurrNode->onNodePassX(pNode, true);
}
if (!pCurrNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update2: [+X] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pNode->onNodePassX(pCurrNode, false);
}
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update end: [+X] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
if (pNode->pNextX() == NULL)
break;
pCurrNode = pNode->pNextX();
}
if((pNode->pPrevX() == NULL || (pNode->xx() >= pNode->pPrevX()->x())) &&
(pNode->pNextX() == NULL || (pNode->xx() <= pNode->pNextX()->x())))
{
pNode->x(pNode->xx());
break;
}
}
}
if(CoordinateSystem::hasY && pNode->yy() != pNode->old_yy())
{
while(true)
{
CoordinateNode* pCurrNode = pNode->pPrevY();
while(pCurrNode && pCurrNode != pNode && pCurrNode->y() > pNode->yy())
{
pNode->y(pCurrNode->y());
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update start: [-Y] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
// 先把节点移动过去
moveNodeY(pNode, pNode->yy(), pCurrNode);
if (!pNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update1: [-Y] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pCurrNode->onNodePassY(pNode, true);
}
if (!pCurrNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update2: [-Y] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pNode->onNodePassY(pCurrNode, false);
}
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update end: [-Y] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
if (pNode->pPrevY() == NULL)
break;
pCurrNode = pNode->pPrevY();
}
pCurrNode = pNode->pNextY();
while(pCurrNode && pCurrNode != pNode && pCurrNode->y() < pNode->yy())
{
pNode->y(pCurrNode->y());
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update start: [+Y] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
// 先把节点移动过去
moveNodeY(pNode, pNode->yy(), pCurrNode);
if (!pNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update1: [+Y] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pCurrNode->onNodePassY(pNode, true);
}
if (!pCurrNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update2: [+Y] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pNode->onNodePassY(pCurrNode, false);
}
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update end: [+Y] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
if (pNode->pNextY() == NULL)
break;
pCurrNode = pNode->pNextY();
}
if((pNode->pPrevY() == NULL || (pNode->yy() >= pNode->pPrevY()->y())) &&
(pNode->pNextY() == NULL || (pNode->yy() <= pNode->pNextY()->y())))
{
pNode->y(pNode->yy());
break;
}
}
}
if(pNode->zz() != pNode->old_zz())
{
while(true)
{
CoordinateNode* pCurrNode = pNode->pPrevZ();
while(pCurrNode && pCurrNode != pNode && pCurrNode->z() > pNode->zz())
{
pNode->z(pCurrNode->z());
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update start: [-Z] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
// 先把节点移动过去
moveNodeZ(pNode, pNode->zz(), pCurrNode);
if (!pNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update1: [-Z] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pCurrNode->onNodePassZ(pNode, true);
}
if (!pCurrNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update2: [-Z] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pNode->onNodePassZ(pCurrNode, false);
}
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update end: [-Z] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
if (pNode->pPrevZ() == NULL)
break;
pCurrNode = pNode->pPrevZ();
}
pCurrNode = pNode->pNextZ();
while(pCurrNode && pCurrNode != pNode && pCurrNode->z() < pNode->zz())
{
pNode->z(pCurrNode->z());
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update start: [+Z] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
// 先把节点移动过去
moveNodeZ(pNode, pNode->zz(), pCurrNode);
if (!pNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update:1 [+Z] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pCurrNode->onNodePassZ(pNode, true);
}
if (!pCurrNode->hasFlags(COORDINATE_NODE_FLAG_HIDE_OR_REMOVED))
{
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update:2 [+Z] ({}), passNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
pNode->onNodePassZ(pCurrNode, false);
}
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::update end: [+Z] ({}), pCurrNode=>({})\n", pNode->c_str(), pCurrNode->c_str()));
#endif
if (pNode->pNextZ() == NULL)
break;
pCurrNode = pNode->pNextZ();
}
if((pNode->pPrevZ() == NULL || (pNode->zz() >= pNode->pPrevZ()->z())) &&
(pNode->pNextZ() == NULL || (pNode->zz() <= pNode->pNextZ()->z())))
{
pNode->z(pNode->zz());
break;
}
}
}
pNode->resetOld();
//pNode->removeFlags(COORDINATE_NODE_FLAG_PENDING);
--updating_;
//if (updating_ == 0)
// releaseNodes();
#ifdef DEBUG_COORDINATE_SYSTEM
DEBUG_MSG(fmt::format("CoordinateSystem::debugX[ x ]:[{:p}]\n", (void*)pNode));
first_x_coordinateNode_->debugX();
DEBUG_MSG(fmt::format("CoordinateSystem::debugY[ y ]:[{:p}]\n", (void*)pNode));
if (first_y_coordinateNode_)first_y_coordinateNode_->debugY();
DEBUG_MSG(fmt::format("CoordinateSystem::debugZ[ z ]:[{:p}]\n", (void*)pNode));
first_z_coordinateNode_->debugZ();
#endif
}
//-------------------------------------------------------------------------------------
void Loginapp::login(Network::Channel* pChannel, MemoryStream& s)
{
AUTO_SCOPED_PROFILE("login");
COMPONENT_CLIENT_TYPE ctype;
CLIENT_CTYPE tctype = UNKNOWN_CLIENT_COMPONENT_TYPE;
std::string loginName;
std::string password;
std::string datas;
// 前端类别
s >> tctype;
ctype = static_cast<COMPONENT_CLIENT_TYPE>(tctype);
// 附带数据
s.readBlob(datas);
// 帐号登录名
s >> loginName;
// 密码
s >> password;
loginName = KBEngine::strutil::kbe_trim(loginName);
if(loginName.size() == 0)
{
INFO_MSG("Loginapp::login: loginName is NULL.\n");
_loginFailed(pChannel, loginName, SERVER_ERR_NAME, datas, true);
s.done();
return;
}
if(loginName.size() > ACCOUNT_NAME_MAX_LENGTH)
{
INFO_MSG(fmt::format("Loginapp::login: loginName is too long, size={}, limit={}.\n",
loginName.size(), ACCOUNT_NAME_MAX_LENGTH));
_loginFailed(pChannel, loginName, SERVER_ERR_NAME, datas, true);
s.done();
return;
}
if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH)
{
INFO_MSG(fmt::format("Loginapp::login: password is too long, size={}, limit={}.\n",
password.size(), ACCOUNT_PASSWD_MAX_LENGTH));
_loginFailed(pChannel, loginName, SERVER_ERR_PASSWORD, datas, true);
s.done();
return;
}
if(datas.size() > ACCOUNT_DATA_MAX_LENGTH)
{
INFO_MSG(fmt::format("Loginapp::login: bindatas is too long, size={}, limit={}.\n",
datas.size(), ACCOUNT_DATA_MAX_LENGTH));
_loginFailed(pChannel, loginName, SERVER_ERR_OP_FAILED, datas, true);
s.done();
return;
}
// 首先必须baseappmgr和dbmgr都已经准备完毕了。
Components::ComponentInfos* baseappmgrinfos = Components::getSingleton().getBaseappmgr();
if(baseappmgrinfos == NULL || baseappmgrinfos->pChannel == NULL || baseappmgrinfos->cid == 0)
{
datas = "";
_loginFailed(pChannel, loginName, SERVER_ERR_SRV_NO_READY, datas, true);
s.done();
return;
}
Components::ComponentInfos* dbmgrinfos = Components::getSingleton().getDbmgr();
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
datas = "";
_loginFailed(pChannel, loginName, SERVER_ERR_SRV_NO_READY, datas, true);
s.done();
return;
}
if(!g_kbeSrvConfig.getDBMgr().allowEmptyDigest)
{
std::string clientDigest;
if(s.length() > 0)
s >> clientDigest;
if(clientDigest.size() > 0)
{
if(clientDigest != digest_)
{
INFO_MSG(fmt::format("Loginapp::login: loginName({}), digest not match. curr({}) != dbmgr({})\n",
loginName, clientDigest, digest_));
datas = "";
_loginFailed(pChannel, loginName, SERVER_ERR_ENTITYDEFS_NOT_MATCH, datas, true);
return;
}
}
else
{
//WARNING_MSG(fmt::format("Loginapp::login: loginName={} no check entitydefs!\n", loginName));
}
}
//-------------------------------------------------------------------------------------
void Loginapp::login(Mercury::Channel* pChannel, MemoryStream& s)
{
AUTO_SCOPED_PROFILE("login");
COMPONENT_CLIENT_TYPE ctype;
CLIENT_CTYPE tctype = UNKNOWN_CLIENT_COMPONENT_TYPE;
std::string loginName;
std::string password;
std::string datas;
// 前端类别
s >> tctype;
ctype = static_cast<COMPONENT_CLIENT_TYPE>(tctype);
// 附带数据
s.readBlob(datas);
// 帐号登录名
s >> loginName;
// 密码
s >> password;
loginName = KBEngine::strutil::kbe_trim(loginName);
if(loginName.size() == 0)
{
ERROR_MSG("Loginapp::login: loginName is NULL.\n");
return;
}
if(loginName.size() > ACCOUNT_NAME_MAX_LENGTH)
{
ERROR_MSG(boost::format("Loginapp::login: loginName too big, size=%1%, limit=%2%.\n") %
loginName.size() % ACCOUNT_NAME_MAX_LENGTH);
return;
}
if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH)
{
ERROR_MSG(boost::format("Loginapp::login: password too big, size=%1%, limit=%2%.\n") %
password.size() % ACCOUNT_PASSWD_MAX_LENGTH);
return;
}
if(datas.size() > ACCOUNT_DATA_MAX_LENGTH)
{
ERROR_MSG(boost::format("Loginapp::login: bindatas too big, size=%1%, limit=%2%.\n") %
datas.size() % ACCOUNT_DATA_MAX_LENGTH);
return;
}
if(!g_kbeSrvConfig.getDBMgr().allowEmptyDigest && (ctype != CLIENT_TYPE_BROWSER && ctype != CLIENT_TYPE_MINI))
{
std::string clientDigest;
if(s.opsize() > 0)
s >> clientDigest;
if(clientDigest != digest_)
{
ERROR_MSG(boost::format("Loginapp::login: loginName(%1%), digest not match. curr(%2%) != dbmgr(%3%)\n") %
loginName % clientDigest % digest_);
datas = "";
_loginFailed(pChannel, loginName, SERVER_ERR_ENTITYDEFS_NOT_MATCH, datas, true);
return;
}
}
//-------------------------------------------------------------------------------------
void ServerApp::handleTimers()
{
AUTO_SCOPED_PROFILE("callTimers");
timers().process(g_kbetime);
}
//-------------------------------------------------------------------------------------
bool Loginapp::_createAccount(Network::Channel* pChannel, std::string& accountName,
std::string& password, std::string& datas, ACCOUNT_TYPE type)
{
AUTO_SCOPED_PROFILE("createAccount");
ACCOUNT_TYPE oldType = type;
if(!g_kbeSrvConfig.getDBMgr().account_registration_enable)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount({}): not available!\n", accountName));
std::string retdatas = "";
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_ACCOUNT_REGISTER_NOT_AVAILABLE;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
accountName = KBEngine::strutil::kbe_trim(accountName);
password = KBEngine::strutil::kbe_trim(password);
if(accountName.size() > ACCOUNT_NAME_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName too big, size={}, limit={}.\n",
accountName.size(), ACCOUNT_NAME_MAX_LENGTH));
return false;
}
if(password.size() > ACCOUNT_PASSWD_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: password too big, size={}, limit={}.\n",
password.size(), ACCOUNT_PASSWD_MAX_LENGTH));
return false;
}
if(datas.size() > ACCOUNT_DATA_MAX_LENGTH)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: bindatas too big, size={}, limit={}.\n",
datas.size(), ACCOUNT_DATA_MAX_LENGTH));
return false;
}
std::string retdatas = "";
if(shuttingdown_ != SHUTDOWN_STATE_STOP)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount: shutting down, create {} failed!\n", accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_IN_SHUTTINGDOWN;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.find(const_cast<std::string&>(accountName));
if(ptinfos != NULL)
{
WARNING_MSG(fmt::format("Loginapp::_createAccount: pendingCreateMgr has {}, request create failed!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_BUSY;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
{
// 把请求交由脚本处理
SERVER_ERROR_CODE retcode = SERVER_SUCCESS;
SCOPED_PROFILE(SCRIPTCALL_PROFILE);
PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(),
const_cast<char*>("onRequestCreateAccount"),
const_cast<char*>("ssy#"),
accountName.c_str(),
password.c_str(),
datas.c_str(), datas.length());
if(pyResult != NULL)
{
if(PySequence_Check(pyResult) && PySequence_Size(pyResult) == 4)
{
char* sname;
char* spassword;
char *extraDatas;
Py_ssize_t extraDatas_size = 0;
if(PyArg_ParseTuple(pyResult, "H|s|s|y#", &retcode, &sname, &spassword, &extraDatas, &extraDatas_size) == -1)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: {}.onReuqestLogin, Return value error! accountName={}\n",
g_kbeSrvConfig.getLoginApp().entryScriptFile, accountName));
retcode = SERVER_ERR_OP_FAILED;
}
else
{
accountName = sname;
password = spassword;
if (extraDatas && extraDatas_size > 0)
datas.assign(extraDatas, extraDatas_size);
else
SCRIPT_ERROR_CHECK();
}
}
else
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: {}.onReuqestLogin, Return value error, must be errorcode or tuple! accountName={}\n",
g_kbeSrvConfig.getLoginApp().entryScriptFile, accountName));
retcode = SERVER_ERR_OP_FAILED;
}
Py_DECREF(pyResult);
}
else
{
SCRIPT_ERROR_CHECK();
retcode = SERVER_ERR_OP_FAILED;
}
if(retcode != SERVER_SUCCESS)
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
else
{
if(accountName.size() == 0)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: accountName is empty!\n"));
retcode = SERVER_ERR_NAME;
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
}
}
if(type == ACCOUNT_TYPE_SMART)
{
if (email_isvalid(accountName.c_str()))
{
type = ACCOUNT_TYPE_MAIL;
}
else
{
if(!validName(accountName))
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
type = ACCOUNT_TYPE_NORMAL;
}
}
else if(type == ACCOUNT_TYPE_NORMAL)
{
if(!validName(accountName))
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: invalid accountName({})\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
}
else if (!email_isvalid(accountName.c_str()))
{
/*
std::string user_name, domain_name;
user_name = regex_replace(accountName, _g_mail_pattern, std::string("$1") );
domain_name = regex_replace(accountName, _g_mail_pattern, std::string("$2") );
*/
WARNING_MSG(fmt::format("Loginapp::_createAccount: invalid mail={}\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_NAME_MAIL;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
DEBUG_MSG(fmt::format("Loginapp::_createAccount: accountName={}, passwordsize={}, type={}, oldType={}.\n",
accountName.c_str(), password.size(), type, oldType));
ptinfos = new PendingLoginMgr::PLInfos;
ptinfos->accountName = accountName;
ptinfos->password = password;
ptinfos->datas = datas;
ptinfos->addr = pChannel->addr();
pendingCreateMgr_.add(ptinfos);
Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
ERROR_MSG(fmt::format("Loginapp::_createAccount: create({}), not found dbmgr!\n",
accountName));
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(ClientInterface::onCreateAccountResult);
SERVER_ERROR_CODE retcode = SERVER_ERR_SRV_NO_READY;
(*pBundle) << retcode;
(*pBundle).appendBlob(retdatas);
pChannel->send(pBundle);
return false;
}
pChannel->extra(accountName);
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
(*pBundle).newMessage(DbmgrInterface::reqCreateAccount);
uint8 uatype = uint8(type);
(*pBundle) << accountName << password << uatype;
(*pBundle).appendBlob(datas);
dbmgrinfos->pChannel->send(pBundle);
return true;
}