//------------------------------------------------------------------------------------- void Entity::onLeaveTrapID(ENTITY_ID entityID, float range, int controllerID) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS3(this, const_cast<char*>("onLeaveTrapID"), const_cast<char*>("kfi"), entityID, range, controllerID); }
//------------------------------------------------------------------------------------- bool Loginapp::initializeEnd() { PythonApp::initializeEnd(); // 添加一个timer, 每秒检查一些状态 mainProcessTimer_ = this->dispatcher().addTimer(1000000 / 50, this, reinterpret_cast<void *>(TIMEOUT_TICK)); SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 所有脚本都加载完毕 PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onLoginAppReady"), const_cast<char*>("")); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); pTelnetServer_ = new TelnetServer(&this->dispatcher(), &this->networkInterface()); pTelnetServer_->pScript(&this->getScript()); bool ret = pTelnetServer_->start(g_kbeSrvConfig.getLoginApp().telnet_passwd, g_kbeSrvConfig.getLoginApp().telnet_deflayer, g_kbeSrvConfig.getLoginApp().telnet_port); Components::getSingleton().extraData4(pTelnetServer_->port()); return ret; }
//------------------------------------------------------------------------------------- void Proxy::onStreamComplete(int16 id, bool success) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS2(this, const_cast<char*>("onStreamComplete"), const_cast<char*>("hO"), id, success ? Py_True : Py_False); }
//------------------------------------------------------------------------------------- void Entity::onTeleportSuccess(PyObject* nearbyEntity, SPACE_ID lastSpaceID) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS1(this, const_cast<char*>("onTeleportSuccess"), const_cast<char*>("O"), nearbyEntity); }
//------------------------------------------------------------------------------------- void Entity::onLeaveTrap(Entity* entity, float range, int controllerID) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS3(this, const_cast<char*>("onLeaveTrap"), const_cast<char*>("Ofi"), entity, range, controllerID); }
//------------------------------------------------------------------------------------- bool Interfaces::initializeEnd() { PythonApp::initializeEnd(); mainProcessTimer_ = this->dispatcher().addTimer(1000000 / g_kbeSrvConfig.gameUpdateHertz(), this, reinterpret_cast<void *>(TIMEOUT_TICK)); // 不做频道超时检查 CLOSE_CHANNEL_INACTIVITIY_DETECTION(); if (!initDB()) return false; SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 所有脚本都加载完毕 PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onInterfaceAppReady"), const_cast<char*>("")); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); pTelnetServer_ = new TelnetServer(&this->dispatcher(), &this->networkInterface()); pTelnetServer_->pScript(&this->getScript()); bool ret = pTelnetServer_->start(g_kbeSrvConfig.getInterfaces().telnet_passwd, g_kbeSrvConfig.getInterfaces().telnet_deflayer, g_kbeSrvConfig.getInterfaces().telnet_port); Components::getSingleton().extraData4(pTelnetServer_->port()); return ret; }
//------------------------------------------------------------------------------------- std::string Dbmgr::selectAccountDBInterfaceName(const std::string& name) { std::string dbInterfaceName = "default"; // 把请求交由脚本处理 SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onSelectAccountDBInterface"), const_cast<char*>("s"), name.c_str()); if (pyResult != NULL) { wchar_t* PyUnicode_AsWideCharStringRet0 = PyUnicode_AsWideCharString(pyResult, NULL); char* ccattr = strutil::wchar2char(PyUnicode_AsWideCharStringRet0); dbInterfaceName = ccattr; PyMem_Free(PyUnicode_AsWideCharStringRet0); Py_DECREF(pyResult); free(ccattr); } else { SCRIPT_ERROR_CHECK(); } if (dbInterfaceName == "" || g_kbeSrvConfig.dbInterface(dbInterfaceName) == NULL) { ERROR_MSG(fmt::format("Dbmgr::selectAccountDBInterfaceName: not found dbInterface({}), accountName={}.\n", dbInterfaceName, name)); return "default"; } return dbInterfaceName; }
//------------------------------------------------------------------------------------- void Entity::onWriteToDB() { SCOPED_PROFILE(SCRIPTCALL_PROFILE); DEBUG_MSG(boost::format("%1%::onWriteToDB(): %2%.\n") % this->getScriptName() % this->getID()); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onWriteToDB")); }
//------------------------------------------------------------------------------------- void Proxy::onClientGetCell(Network::Channel* pChannel, COMPONENT_ID componentID) { // 回调给脚本,获得了cell if(cellMailbox_ == NULL) cellMailbox_ = new EntityMailbox(pScriptModule_, NULL, componentID, id_, MAILBOX_TYPE_CELL); SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientGetCell")); }
//------------------------------------------------------------------------------------- void Dbmgr::onShutdownBegin() { PythonApp::onShutdownBegin(); // 通知脚本 SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(getEntryScript().get(), const_cast<char*>("onDBMgrShutDown")); scriptTimers_.cancelAll(); }
//------------------------------------------------------------------------------------- void Loginapp::onReqCreateAccountResult(Network::Channel* pChannel, MemoryStream& s) { SERVER_ERROR_CODE failedcode; std::string accountName; std::string password; std::string retdatas = ""; s >> failedcode >> accountName >> password; s.readBlob(retdatas); // 把请求交由脚本处理 SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onCreateAccountCallbackFromDB"), const_cast<char*>("sHy#"), accountName.c_str(), failedcode, retdatas.c_str(), retdatas.length()); if(pyResult != NULL) { Py_DECREF(pyResult); } else { SCRIPT_ERROR_CHECK(); } DEBUG_MSG(fmt::format("Loginapp::onReqCreateAccountResult: accountName={}, failedcode={}.\n", accountName.c_str(), failedcode)); PendingLoginMgr::PLInfos* ptinfos = pendingCreateMgr_.remove(accountName); if(ptinfos == NULL) return; Network::Channel* pClientChannel = this->networkInterface().findChannel(ptinfos->addr); if(pClientChannel == NULL) return; pClientChannel->extra(""); Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(ClientInterface::onCreateAccountResult); (*pBundle) << failedcode; (*pBundle).appendBlob(retdatas); pClientChannel->send(pBundle); SAFE_RELEASE(ptinfos); }
//------------------------------------------------------------------------------------- void Base::onDestroy(bool callScript) { if(callScript) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onDestroy")); } if(this->hasDB()) { onCellWriteToDBCompleted(0, -1); } eraseEntityLog(); }
//------------------------------------------------------------------------------------- void Entity::onRemoteMethodCall(Mercury::Channel* pChannel, MemoryStream& s) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); if(isDestroyed()) { ERROR_MSG(boost::format("%1%::onRemoteMethodCall: %2% is destroyed!\n") % getScriptName() % getID()); s.read_skip(s.opsize()); return; } ENTITY_METHOD_UID utype = 0; s >> utype; DEBUG_MSG(boost::format("Entity::onRemoteMethodCall: entityID %1%, methodType %2%.\n") % id_ % utype); MethodDescription* md = scriptModule_->findCellMethodDescription(utype); if(md == NULL) { ERROR_MSG(boost::format("Entity::onRemoteMethodCall: can't found method. utype=%1%, callerID:%2%.\n") % utype % id_); return; } md->currCallerID(this->getID()); PyObject* pyFunc = PyObject_GetAttrString(this, const_cast<char*> (md->getName())); if(md != NULL) { PyObject* pyargs = md->createFromStream(&s); if(pyargs) { md->call(pyFunc, pyargs); Py_XDECREF(pyargs); } else { SCRIPT_ERROR_CHECK(); } } Py_XDECREF(pyFunc); }
//------------------------------------------------------------------------------------- void Entity::onLoseWitness(Mercury::Channel* pChannel) { KBE_ASSERT(this->getClientMailbox() != NULL && this->hasWitness()); getClientMailbox()->addr(Mercury::Address::NONE); Py_DECREF(getClientMailbox()); setClientMailbox(NULL); pWitness_->detach(this); Witness::ObjPool().reclaimObject(pWitness_); pWitness_ = NULL; SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onLoseWitness")); }
//------------------------------------------------------------------------------------- void Interfaces::reqCreateAccount(Network::Channel* pChannel, KBEngine::MemoryStream& s) { std::string registerName, accountName, password, datas; COMPONENT_ID cid; uint8 accountType = 0; s >> cid >> registerName >> password >> accountType; s.readBlob(datas); if(accountType == (uint8)ACCOUNT_TYPE_MAIL) { } REQCREATE_MAP::iterator iter = reqCreateAccount_requests_.find(registerName); if(iter != reqCreateAccount_requests_.end()) { return; } CreateAccountTask* pinfo = new CreateAccountTask(); pinfo->commitName = registerName; pinfo->accountName = registerName; pinfo->getDatas = ""; pinfo->password = password; pinfo->postDatas = datas; pinfo->retcode = SERVER_ERR_OP_FAILED; pinfo->baseappID = cid; pinfo->dbmgrID = pChannel->componentID(); pinfo->address = pChannel->addr(); pinfo->enable = true; reqCreateAccount_requests_[pinfo->commitName] = pinfo; // 把请求交由脚本处理 SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onRequestCreateAccount"), const_cast<char*>("ssy#"), registerName.c_str(), password.c_str(), datas.c_str(), datas.length()); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); }
//------------------------------------------------------------------------------------- void Interfaces::charge(Network::Channel* pChannel, KBEngine::MemoryStream& s) { OrdersCharge* pOrdersCharge = new OrdersCharge(); pOrdersCharge->timeout = timestamp() + uint64(g_kbeSrvConfig.interfaces_orders_timeout_ * stampsPerSecond()); pOrdersCharge->dbmgrID = pChannel->componentID(); pOrdersCharge->address = pChannel->addr(); s >> pOrdersCharge->baseappID; s >> pOrdersCharge->ordersID; s >> pOrdersCharge->dbid; s.readBlob(pOrdersCharge->postDatas); s >> pOrdersCharge->cbid; INFO_MSG(fmt::format("Interfaces::charge: componentID={4}, chargeID={0}, dbid={1}, cbid={2}, datas={3}!\n", pOrdersCharge->ordersID, pOrdersCharge->dbid, pOrdersCharge->cbid, pOrdersCharge->postDatas, pOrdersCharge->baseappID)); ORDERS::iterator iter = orders_.find(pOrdersCharge->ordersID); if(iter != orders_.end()) { ERROR_MSG(fmt::format("Interfaces::charge: chargeID={} is exist!\n", pOrdersCharge->ordersID)); delete pOrdersCharge; return; } ChargeTask* pinfo = new ChargeTask(); pinfo->orders = *pOrdersCharge; pinfo->pOrders = pOrdersCharge; orders_[pOrdersCharge->ordersID].reset(pOrdersCharge); // 把请求交由脚本处理 SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onRequestCharge"), const_cast<char*>("sKy#"), pOrdersCharge->ordersID.c_str(), pOrdersCharge->dbid, pOrdersCharge->postDatas.c_str(), pOrdersCharge->postDatas.length()); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); }
int WINAPI WinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, LPSTR /*lpCmdLine*/, int /*nCmdShow*/ ) { redirect_io_to_console(); _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE ); _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR ); _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //::boost::unit_test::unit_test_main(init_unit_test_suite, 0, 0); boost::shared_ptr<System> system(new System()); system->init(); boost::shared_ptr<EffectManager> effect_manager(new EffectManager(system->handle_manager())); // Renderable* renderer = new SpringTest(system, effect_manager); //Renderable* renderer = new M2Renderer(system, effect_manager); Renderable *renderer = new MarchingCubes(system, effect_manager); SCOPED_PROFILE("Loading"); try { renderer->init(); } catch (std::exception& e) { LOG_ERROR_LN("%s", e.what()); return 0; } Profiler::instance().print(); Serializer::instance().load("codename_ch.dat"); system->run(); system->close(); Serializer::instance().save("codename_ch.dat"); SAFE_DELETE(renderer); effect_manager.reset(); system.reset(); Profiler::close(); StringIdTable::close(); LogMgr::close(); return 0; }
//------------------------------------------------------------------------------------- bool Dbmgr::initializeEnd() { // 添加一个timer, 每秒检查一些状态 loopCheckTimerHandle_ = this->dispatcher().addTimer(1000000, this, reinterpret_cast<void *>(TIMEOUT_CHECK_STATUS)); mainProcessTimer_ = this->dispatcher().addTimer(1000000 / 50, this, reinterpret_cast<void *>(TIMEOUT_TICK)); // 添加globalData, baseAppData, cellAppData支持 pGlobalData_ = new GlobalDataServer(GlobalDataServer::GLOBAL_DATA); pBaseAppData_ = new GlobalDataServer(GlobalDataServer::BASEAPP_DATA); pCellAppData_ = new GlobalDataServer(GlobalDataServer::CELLAPP_DATA); pGlobalData_->addConcernComponentType(CELLAPP_TYPE); pGlobalData_->addConcernComponentType(BASEAPP_TYPE); pBaseAppData_->addConcernComponentType(BASEAPP_TYPE); pCellAppData_->addConcernComponentType(CELLAPP_TYPE); INFO_MSG(fmt::format("Dbmgr::initializeEnd: digest({})\n", EntityDef::md5().getDigestStr())); SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 所有脚本都加载完毕 PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onDBMgrReady"), const_cast<char*>("")); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); pTelnetServer_ = new TelnetServer(&this->dispatcher(), &this->networkInterface()); pTelnetServer_->pScript(&this->getScript()); bool ret = pTelnetServer_->start(g_kbeSrvConfig.getDBMgr().telnet_passwd, g_kbeSrvConfig.getDBMgr().telnet_deflayer, g_kbeSrvConfig.getDBMgr().telnet_port); Components::getSingleton().extraData4(pTelnetServer_->port()); return ret && initInterfacesHandler() && initDB(); }
//------------------------------------------------------------------------------------- void Interfaces::onAccountLogin(Network::Channel* pChannel, KBEngine::MemoryStream& s) { std::string loginName, accountName, password, datas; COMPONENT_ID cid; s >> cid >> loginName >> password; s.readBlob(datas); REQLOGIN_MAP::iterator iter = reqAccountLogin_requests_.find(loginName); if(iter != reqAccountLogin_requests_.end()) { return; } LoginAccountTask* pinfo = new LoginAccountTask(); pinfo->commitName = loginName; pinfo->accountName = loginName; pinfo->getDatas = ""; pinfo->password = password; pinfo->postDatas = datas; pinfo->retcode = SERVER_ERR_OP_FAILED; pinfo->baseappID = cid; pinfo->dbmgrID = pChannel->componentID(); pinfo->address = pChannel->addr(); pinfo->enable = true; reqAccountLogin_requests_[pinfo->commitName] = pinfo; // 把请求交由脚本处理 SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(getEntryScript().get(), const_cast<char*>("onRequestAccountLogin"), const_cast<char*>("ssy#"), loginName.c_str(), password.c_str(), datas.c_str(), datas.length()); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); }
//------------------------------------------------------------------------------------- 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(); } }
//------------------------------------------------------------------------------------- void Proxy::onClientDeath(void) { if(getClientMailbox() == NULL) { ERROR_MSG(boost::format("%1%::onClientDeath: %2%, channel is null!\n") % this->getScriptName() % this->getID()); return; } SCOPED_PROFILE(SCRIPTCALL_PROFILE); DEBUG_MSG(boost::format("%1%::onClientDeath: %2%.\n") % this->getScriptName() % this->getID()); Py_DECREF(getClientMailbox()); setClientMailbox(NULL); addr(Mercury::Address::NONE); entitiesEnabled_ = false; SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientDeath")); }
//------------------------------------------------------------------------------------- void Proxy::onClientDeath(void) { if(clientMailbox() == NULL) { ERROR_MSG(fmt::format("{}::onClientDeath: {}, channel is null!\n", this->scriptName(), this->id())); return; } SCOPED_PROFILE(SCRIPTCALL_PROFILE); DEBUG_MSG(fmt::format("{}::onClientDeath: {}.\n", this->scriptName(), this->id())); Py_DECREF(clientMailbox()); clientMailbox(NULL); addr(Network::Address::NONE); entitiesEnabled_ = false; SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientDeath")); }
//------------------------------------------------------------------------------------- void Base::onDestroy(bool callScript) { setDirty(); if(callScript) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onDestroy")); } if(this->hasDB()) { onCellWriteToDBCompleted(0, -1, -1); } eraseEntityLog(); // 按照当前的设计来说,有clientMailbox_必定是proxy // 至于为何跑到base里来和python本身是C语言实现有关 if(clientMailbox_) static_cast<Proxy*>(this)->kick(); }
//------------------------------------------------------------------------------------- void Entity::onGetWitness(Mercury::Channel* pChannel) { KBE_ASSERT(this->getBaseMailbox() != NULL && !this->hasWitness()); PyObject* clientMailbox = PyObject_GetAttrString(this->getBaseMailbox(), "client"); KBE_ASSERT(clientMailbox != Py_None); EntityMailbox* client = static_cast<EntityMailbox*>(clientMailbox); // Py_INCREF(clientMailbox); 这里不需要增加引用, 因为每次都会产生一个新的对象 setClientMailbox(client); pWitness_ = Witness::ObjPool().createObject(); pWitness_->attach(this); Space* space = Spaces::findSpace(this->getSpaceID()); if(space) { space->onEntityAttachWitness(this); } SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onGetWitness")); }
//------------------------------------------------------------------------------------- int32 Proxy::onLogOnAttempt(const char* addr, uint32 port, const char* password) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); PyObject* pyResult = PyObject_CallMethod(this, const_cast<char*>("onLogOnAttempt"), const_cast<char*>("sks"), addr, port, password ); int32 ret = LOG_ON_REJECT; if(pyResult != NULL) { ret = PyLong_AsLong(pyResult); SCRIPT_ERROR_CHECK(); Py_DECREF(pyResult); } else SCRIPT_ERROR_CHECK(); return ret; }
//------------------------------------------------------------------------------------- void Entity::onDestroy(void) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onDestroy")); if(baseMailbox_ != NULL) { this->backupCellData(); Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject(); (*pBundle).newMessage(BaseappInterface::onLoseCell); (*pBundle) << id_; baseMailbox_->postMail((*pBundle)); Mercury::Bundle::ObjPool().reclaimObject(pBundle); } // 将entity从场景中剔除 Space* space = Spaces::findSpace(this->getSpaceID()); if(space) { space->removeEntity(this); } }
//------------------------------------------------------------------------------------- void Proxy::onGiveClientToFailure() { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onGiveClientToFailure")); }
//------------------------------------------------------------------------------------- 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; }
//------------------------------------------------------------------------------------- void Proxy::onEntitiesEnabled(void) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); entitiesEnabled_ = true; SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onEntitiesEnabled")); }
//------------------------------------------------------------------------------------- void Proxy::onClientGetCell(Mercury::Channel* pChannel) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); SCRIPT_OBJECT_CALL_ARGS0(this, const_cast<char*>("onClientGetCell")); }