///////////////////////////////////////////////////////////////// // WARNING : this is a generated file, don't change it ! ///////////////////////////////////////////////////////////////// #include "stdpch.h" #include "r2_share_itf.h" namespace R2 { ///////////////////////////////////////////////////////////////// // WARNING : this is a generated file, don't change it ! ///////////////////////////////////////////////////////////////// const CShareServerAnimationItfSkel::TMessageHandlerMap &CShareServerAnimationItfSkel::getMessageHandlers() const { static TMessageHandlerMap handlers; static bool init = false; if (!init) { std::pair < TMessageHandlerMap::iterator, bool > res; res = handlers.insert(std::make_pair(std::string("RCAMP"), &CShareServerAnimationItfSkel::connectAnimationModePlay_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SAID"), &CShareServerAnimationItfSkel::askMissionItemsDescription_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SAAPD"), &CShareServerAnimationItfSkel::askActPositionDescriptions_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SAUTD"), &CShareServerAnimationItfSkel::askUserTriggerDescriptions_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SOUTT"), &CShareServerAnimationItfSkel::onUserTriggerTriggered_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SODT"), &CShareServerAnimationItfSkel::onDssTarget_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); init = true; } return handlers; } bool CShareServerAnimationItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message) { const TMessageHandlerMap &mh = getMessageHandlers(); TMessageHandlerMap::const_iterator it(mh.find(message.getName())); if (it == mh.end()) { return false; } TMessageHandler cmd = it->second; (this->*cmd)(sender, message); return true; } void CShareServerAnimationItfSkel::connectAnimationModePlay_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareServerAnimationItfSkel_connectAnimationModePlay_RCAMP); connectAnimationModePlay(sender); } void CShareServerAnimationItfSkel::askMissionItemsDescription_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareServerAnimationItfSkel_askMissionItemsDescription_SAID); askMissionItemsDescription(sender); } void CShareServerAnimationItfSkel::askActPositionDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareServerAnimationItfSkel_askActPositionDescriptions_SAAPD); askActPositionDescriptions(sender); } void CShareServerAnimationItfSkel::askUserTriggerDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareServerAnimationItfSkel_askUserTriggerDescriptions_SAUTD); askUserTriggerDescriptions(sender); } void CShareServerAnimationItfSkel::onUserTriggerTriggered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerAnimationItfSkel_onUserTriggerTriggered_SOUTT); uint32 actId; nlRead(__message, serial, actId); uint32 triggerId; nlRead(__message, serial, triggerId); onUserTriggerTriggered(sender, actId, triggerId); } void CShareServerAnimationItfSkel::onDssTarget_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerAnimationItfSkel_onDssTarget_SODT); std::vector args; nlRead(__message, serialCont, args); onDssTarget(sender, args); } // request the connection to play mode in an animation session void CShareServerAnimationItfProxy::connectAnimationModePlay(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->connectAnimationModePlay(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_connectAnimationModePlay(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // A client Message to register mission item of a scenario void CShareServerAnimationItfProxy::askMissionItemsDescription(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->askMissionItemsDescription(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_askMissionItemsDescription(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // A client Message to update client Act Position Description void CShareServerAnimationItfProxy::askActPositionDescriptions(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->askActPositionDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_askActPositionDescriptions(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // A client Message to update client User Trigger Description void CShareServerAnimationItfProxy::askUserTriggerDescriptions(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->askUserTriggerDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_askUserTriggerDescriptions(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // client wants to trigger an user trigger void CShareServerAnimationItfProxy::onUserTriggerTriggered(NLNET::IModule *sender, uint32 actId, uint32 triggerId) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onUserTriggerTriggered(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actId, triggerId); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onUserTriggerTriggered(__message, actId, triggerId); _ModuleProxy->sendModuleMessage(sender, __message); } } // client wants to execute a dm action on its target void CShareServerAnimationItfProxy::onDssTarget(NLNET::IModule *sender, const std::vector &args) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onDssTarget(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), args); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onDssTarget(__message, args); _ModuleProxy->sendModuleMessage(sender, __message); } } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_connectAnimationModePlay(NLNET::CMessage &__message) { __message.setType("RCAMP"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_askMissionItemsDescription(NLNET::CMessage &__message) { __message.setType("SAID"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_askActPositionDescriptions(NLNET::CMessage &__message) { __message.setType("SAAPD"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_askUserTriggerDescriptions(NLNET::CMessage &__message) { __message.setType("SAUTD"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_onUserTriggerTriggered(NLNET::CMessage &__message, uint32 actId, uint32 triggerId) { __message.setType("SOUTT"); nlWrite(__message, serial, actId); nlWrite(__message, serial, triggerId); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerAnimationItfProxy::buildMessageFor_onDssTarget(NLNET::CMessage &__message, const std::vector &args) { __message.setType("SODT"); nlWrite(__message, serialCont, const_cast < std::vector& > (args)); return __message; } ///////////////////////////////////////////////////////////////// // WARNING : this is a generated file, don't change it ! ///////////////////////////////////////////////////////////////// const CShareServerEditionItfSkel::TMessageHandlerMap &CShareServerEditionItfSkel::getMessageHandlers() const { static TMessageHandlerMap handlers; static bool init = false; if (!init) { std::pair < TMessageHandlerMap::iterator, bool > res; res = handlers.insert(std::make_pair(std::string("RSS1"), &CShareServerEditionItfSkel::startingScenario_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("RSS2"), &CShareServerEditionItfSkel::startScenario_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("ADC_ACK"), &CShareServerEditionItfSkel::advConnACK_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SUCR"), &CShareServerEditionItfSkel::onUserComponentRegistered_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SUCD"), &CShareServerEditionItfSkel::onUserComponentDownloading_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SSUA"), &CShareServerEditionItfSkel::onScenarioUploadAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SNSA"), &CShareServerEditionItfSkel::onNodeSetAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SNIA"), &CShareServerEditionItfSkel::onNodeInsertAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SNEA"), &CShareServerEditionItfSkel::onNodeEraseAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SNMA"), &CShareServerEditionItfSkel::onNodeMoveAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SMCA"), &CShareServerEditionItfSkel::onMapConnectionAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SCMUA"), &CShareServerEditionItfSkel::onCharModeUpdateAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("STPA"), &CShareServerEditionItfSkel::onTpPositionAsked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("TPEP"), &CShareServerEditionItfSkel::tpToEntryPoint_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("STA"), &CShareServerEditionItfSkel::setStartingAct_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SRAU"), &CShareServerEditionItfSkel::onScenarioRingAccessUpdated_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SSSFA"), &CShareServerEditionItfSkel::saveScenarioFile_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SLSFA"), &CShareServerEditionItfSkel::loadScenarioFile_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SUCF"), &CShareServerEditionItfSkel::saveUserComponentFile_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("LUCF"), &CShareServerEditionItfSkel::loadUserComponentFile_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("STOCTA"), &CShareServerEditionItfSkel::teleportOneCharacterToAnother_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("STWUS"), &CShareServerEditionItfSkel::teleportWhileUploadingScenario_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_HEAD"), &CShareServerEditionItfSkel::multiPartMsgHead_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_MSG"), &CShareServerEditionItfSkel::multiPartMsgBody_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_FOOT"), &CShareServerEditionItfSkel::multiPartMsgFoot_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_FW"), &CShareServerEditionItfSkel::forwardToDss_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); init = true; } return handlers; } bool CShareServerEditionItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message) { const TMessageHandlerMap &mh = getMessageHandlers(); TMessageHandlerMap::const_iterator it(mh.find(message.getName())); if (it == mh.end()) { return false; } TMessageHandler cmd = it->second; (this->*cmd)(sender, message); return true; } void CShareServerEditionItfSkel::startingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareServerEditionItfSkel_startingScenario_RSS1); startingScenario(sender); } void CShareServerEditionItfSkel::startScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_startScenario_RSS2); bool ok; nlRead(__message, serial, ok); TScenarioHeaderSerializer header; nlRead(__message, serial, header); CObjectSerializerServer data; nlRead(__message, serial, data); uint32 startingAct; nlRead(__message, serial, startingAct); startScenario(sender, ok, header, data, startingAct); } void CShareServerEditionItfSkel::advConnACK_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareServerEditionItfSkel_advConnACK_ADC_ACK); advConnACK(sender); } void CShareServerEditionItfSkel::onUserComponentRegistered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onUserComponentRegistered_SUCR); NLMISC::CHashKeyMD5 md5; nlRead(__message, serial, md5); onUserComponentRegistered(sender, md5); } void CShareServerEditionItfSkel::onUserComponentDownloading_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onUserComponentDownloading_SUCD); NLMISC::CHashKeyMD5 md5; nlRead(__message, serial, md5); onUserComponentDownloading(sender, md5); } void CShareServerEditionItfSkel::onScenarioUploadAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onScenarioUploadAsked_SSUA); uint32 msgId; nlRead(__message, serial, msgId); CObjectSerializerServer hlScenario; nlRead(__message, serial, hlScenario); bool mustBrodcast; nlRead(__message, serial, mustBrodcast); onScenarioUploadAsked(sender, msgId, hlScenario, mustBrodcast); } void CShareServerEditionItfSkel::onNodeSetAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onNodeSetAsked_SNSA); uint32 msgId; nlRead(__message, serial, msgId); std::string instanceId; nlRead(__message, serial, instanceId); std::string attrName; nlRead(__message, serial, attrName); R2::CObjectSerializerServer value; nlRead(__message, serial, value); onNodeSetAsked(sender, msgId, instanceId, attrName, value); } void CShareServerEditionItfSkel::onNodeInsertAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onNodeInsertAsked_SNIA); uint32 msgId; nlRead(__message, serial, msgId); std::string instanceId; nlRead(__message, serial, instanceId); std::string attrName; nlRead(__message, serial, attrName); sint32 position; nlRead(__message, serial, position); std::string key; nlRead(__message, serial, key); R2::CObjectSerializerServer value; nlRead(__message, serial, value); onNodeInsertAsked(sender, msgId, instanceId, attrName, position, key, value); } void CShareServerEditionItfSkel::onNodeEraseAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onNodeEraseAsked_SNEA); uint32 msgId; nlRead(__message, serial, msgId); std::string instanceId; nlRead(__message, serial, instanceId); std::string attrName; nlRead(__message, serial, attrName); sint32 position; nlRead(__message, serial, position); onNodeEraseAsked(sender, msgId, instanceId, attrName, position); } void CShareServerEditionItfSkel::onNodeMoveAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onNodeMoveAsked_SNMA); uint32 msgId; nlRead(__message, serial, msgId); std::string instanceId1; nlRead(__message, serial, instanceId1); std::string attrName1; nlRead(__message, serial, attrName1); sint32 position1; nlRead(__message, serial, position1); std::string instanceId2; nlRead(__message, serial, instanceId2); std::string attrName2; nlRead(__message, serial, attrName2); sint32 position2; nlRead(__message, serial, position2); onNodeMoveAsked(sender, msgId, instanceId1, attrName1, position1, instanceId2, attrName2, position2); } void CShareServerEditionItfSkel::onMapConnectionAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onMapConnectionAsked_SMCA); TSessionId scenarioId; nlRead(__message, serial, scenarioId); bool updateHighLevel; nlRead(__message, serial, updateHighLevel); bool mustTp; nlRead(__message, serial, mustTp); R2::TUserRole role; nlRead(__message, serial, role); onMapConnectionAsked(sender, scenarioId, updateHighLevel, mustTp, role); } void CShareServerEditionItfSkel::onCharModeUpdateAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onCharModeUpdateAsked_SCMUA); R2::TCharMode mode; nlRead(__message, serial, mode); onCharModeUpdateAsked(sender, mode); } void CShareServerEditionItfSkel::onTpPositionAsked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onTpPositionAsked_STPA); float x; nlRead(__message, serial, x); float y; nlRead(__message, serial, y); float z; nlRead(__message, serial, z); onTpPositionAsked(sender, x, y, z); } void CShareServerEditionItfSkel::tpToEntryPoint_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_tpToEntryPoint_TPEP); uint32 actIndex; nlRead(__message, serial, actIndex); tpToEntryPoint(sender, actIndex); } void CShareServerEditionItfSkel::setStartingAct_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_setStartingAct_STA); uint32 actIndex; nlRead(__message, serial, actIndex); setStartingAct(sender, actIndex); } void CShareServerEditionItfSkel::onScenarioRingAccessUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_onScenarioRingAccessUpdated_SRAU); bool ok; nlRead(__message, serial, ok); std::string ringAccess; nlRead(__message, serial, ringAccess); std::string errMsg; nlRead(__message, serial, errMsg); onScenarioRingAccessUpdated(sender, ok, ringAccess, errMsg); } void CShareServerEditionItfSkel::saveScenarioFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_saveScenarioFile_SSSFA); std::string md5; nlRead(__message, serial, md5); R2::TScenarioHeaderSerializer header; nlRead(__message, serial, header); saveScenarioFile(sender, md5, header); } void CShareServerEditionItfSkel::loadScenarioFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_loadScenarioFile_SLSFA); std::string md5; nlRead(__message, serial, md5); std::string signature; nlRead(__message, serial, signature); loadScenarioFile(sender, md5, signature); } void CShareServerEditionItfSkel::saveUserComponentFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_saveUserComponentFile_SUCF); std::string md5; nlRead(__message, serial, md5); R2::TScenarioHeaderSerializer header; nlRead(__message, serial, header); saveUserComponentFile(sender, md5, header); } void CShareServerEditionItfSkel::loadUserComponentFile_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_loadUserComponentFile_LUCF); std::string md5; nlRead(__message, serial, md5); std::string signature; nlRead(__message, serial, signature); loadUserComponentFile(sender, md5, signature); } void CShareServerEditionItfSkel::teleportOneCharacterToAnother_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_teleportOneCharacterToAnother_STOCTA); TSessionId sessionId; nlRead(__message, serial, sessionId); uint32 sourceId; nlRead(__message, serial, sourceId); uint32 destId; nlRead(__message, serial, destId); teleportOneCharacterToAnother(sender, sessionId, sourceId, destId); } void CShareServerEditionItfSkel::teleportWhileUploadingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_teleportWhileUploadingScenario_STWUS); std::string island; nlRead(__message, serial, island); std::string entryPoint; nlRead(__message, serial, entryPoint); std::string season; nlRead(__message, serial, season); teleportWhileUploadingScenario(sender, island, entryPoint, season); } void CShareServerEditionItfSkel::multiPartMsgHead_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_multiPartMsgHead_DSS_HEAD); uint32 charId; nlRead(__message, serial, charId); std::string msgName; nlRead(__message, serial, msgName); uint32 nbPacket; nlRead(__message, serial, nbPacket); uint32 size; nlRead(__message, serial, size); multiPartMsgHead(sender, charId, msgName, nbPacket, size); } void CShareServerEditionItfSkel::multiPartMsgBody_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_multiPartMsgBody_DSS_MSG); uint32 charId; nlRead(__message, serial, charId); uint32 partId; nlRead(__message, serial, partId); std::vector data; nlRead(__message, serialCont, data); multiPartMsgBody(sender, charId, partId, data); } void CShareServerEditionItfSkel::multiPartMsgFoot_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_multiPartMsgFoot_DSS_FOOT); uint32 charId; nlRead(__message, serial, charId); multiPartMsgFoot(sender, charId); } void CShareServerEditionItfSkel::forwardToDss_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareServerEditionItfSkel_forwardToDss_DSS_FW); uint32 charId; nlRead(__message, serial, charId); NLNET::CMessage msg; nlRead(__message, serialMessage, msg); forwardToDss(sender, charId, msg); } void CShareServerEditionItfProxy::startingScenario(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->startingScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_startingScenario(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // Request the start of a test scenario void CShareServerEditionItfProxy::startScenario(NLNET::IModule *sender, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->startScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ok, header, data, startingAct); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_startScenario(__message, ok, header, data, startingAct); _ModuleProxy->sendModuleMessage(sender, __message); } } // Client has received the ADV_CONN message void CShareServerEditionItfProxy::advConnACK(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->advConnACK(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_advConnACK(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client announce to the server that he has registered a component. void CShareServerEditionItfProxy::onUserComponentRegistered(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onUserComponentRegistered(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onUserComponentRegistered(__message, md5); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client announce to the server that he need a componennt so the server must uploading it. void CShareServerEditionItfProxy::onUserComponentDownloading(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onUserComponentDownloading(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onUserComponentDownloading(__message, md5); _ModuleProxy->sendModuleMessage(sender, __message); } } // Upload the high level scenario. void CShareServerEditionItfProxy::onScenarioUploadAsked(NLNET::IModule *sender, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onScenarioUploadAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, hlScenario, mustBrodcast); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onScenarioUploadAsked(__message, msgId, hlScenario, mustBrodcast); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client request to set a node on a hl scenario. void CShareServerEditionItfProxy::onNodeSetAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeSetAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId, attrName, value); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeSetAsked(__message, msgId, instanceId, attrName, value); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client request to insert a node on a hl scenario. void CShareServerEditionItfProxy::onNodeInsertAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeInsertAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId, attrName, position, key, value); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeInsertAsked(__message, msgId, instanceId, attrName, position, key, value); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client request to erase a node on a hl scenario. void CShareServerEditionItfProxy::onNodeEraseAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeEraseAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId, attrName, position); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeEraseAsked(__message, msgId, instanceId, attrName, position); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client request to move a node on a hl scenario. void CShareServerEditionItfProxy::onNodeMoveAsked(NLNET::IModule *sender, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeMoveAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, instanceId1, attrName1, position1, instanceId2, attrName2, position2); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeMoveAsked(__message, msgId, instanceId1, attrName1, position1, instanceId2, attrName2, position2); _ModuleProxy->sendModuleMessage(sender, __message); } } // Call by the client in order to download its current scenario (and tp). void CShareServerEditionItfProxy::onMapConnectionAsked(NLNET::IModule *sender, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onMapConnectionAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), scenarioId, updateHighLevel, mustTp, role); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onMapConnectionAsked(__message, scenarioId, updateHighLevel, mustTp, role); _ModuleProxy->sendModuleMessage(sender, __message); } } // Call by the client when he change its mode (Dm, Tester, Player) void CShareServerEditionItfProxy::onCharModeUpdateAsked(NLNET::IModule *sender, R2::TCharMode mode) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onCharModeUpdateAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), mode); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onCharModeUpdateAsked(__message, mode); _ModuleProxy->sendModuleMessage(sender, __message); } } // client wants to tp at a specific position (clicking in map) void CShareServerEditionItfProxy::onTpPositionAsked(NLNET::IModule *sender, float x, float y, float z) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onTpPositionAsked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), x, y, z); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onTpPositionAsked(__message, x, y, z); _ModuleProxy->sendModuleMessage(sender, __message); } } // Update the mode of the pioneer (DM/TEST). void CShareServerEditionItfProxy::tpToEntryPoint(NLNET::IModule *sender, uint32 actIndex) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->tpToEntryPoint(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actIndex); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_tpToEntryPoint(__message, actIndex); _ModuleProxy->sendModuleMessage(sender, __message); } } // Set the starting act of the scenario void CShareServerEditionItfProxy::setStartingAct(NLNET::IModule *sender, uint32 actIndex) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->setStartingAct(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actIndex); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_setStartingAct(__message, actIndex); _ModuleProxy->sendModuleMessage(sender, __message); } } // Update the the ring access of a scenario. void CShareServerEditionItfProxy::onScenarioRingAccessUpdated(NLNET::IModule *sender, bool ok, const std::string &ringAccess, const std::string &errMsg) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onScenarioRingAccessUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ok, ringAccess, errMsg); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onScenarioRingAccessUpdated(__message, ok, ringAccess, errMsg); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a file waiting to be saved void CShareServerEditionItfProxy::saveScenarioFile(NLNET::IModule *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->saveScenarioFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, header); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_saveScenarioFile(__message, md5, header); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a file waiting to be loaded void CShareServerEditionItfProxy::loadScenarioFile(NLNET::IModule *sender, const std::string &md5, const std::string &signature) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->loadScenarioFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_loadScenarioFile(__message, md5, signature); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a user component file waiting to be saved void CShareServerEditionItfProxy::saveUserComponentFile(NLNET::IModule *sender, const std::string &md5, const R2::TScenarioHeaderSerializer &header) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->saveUserComponentFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, header); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_saveUserComponentFile(__message, md5, header); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a user component file waiting to be loaded void CShareServerEditionItfProxy::loadUserComponentFile(NLNET::IModule *sender, const std::string &md5, const std::string &signature) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->loadUserComponentFile(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_loadUserComponentFile(__message, md5, signature); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to ask the dss to teleport a character to another character void CShareServerEditionItfProxy::teleportOneCharacterToAnother(NLNET::IModule *sender, TSessionId sessionId, uint32 sourceId, uint32 destId) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->teleportOneCharacterToAnother(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, sourceId, destId); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_teleportOneCharacterToAnother(__message, sessionId, sourceId, destId); _ModuleProxy->sendModuleMessage(sender, __message); } } // teleport the player while uploading the scenario void CShareServerEditionItfProxy::teleportWhileUploadingScenario(NLNET::IModule *sender, const std::string &island, const std::string &entryPoint, const std::string &season) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->teleportWhileUploadingScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), island, entryPoint, season); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_teleportWhileUploadingScenario(__message, island, entryPoint, season); _ModuleProxy->sendModuleMessage(sender, __message); } } // send the header of a multi-part message void CShareServerEditionItfProxy::multiPartMsgHead(NLNET::IModule *sender, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->multiPartMsgHead(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, msgName, nbPacket, size); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_multiPartMsgHead(__message, charId, msgName, nbPacket, size); _ModuleProxy->sendModuleMessage(sender, __message); } } // send a part of a multi-part message void CShareServerEditionItfProxy::multiPartMsgBody(NLNET::IModule *sender, uint32 charId, uint32 partId, const std::vector &data) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->multiPartMsgBody(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, partId, data); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_multiPartMsgBody(__message, charId, partId, data); _ModuleProxy->sendModuleMessage(sender, __message); } } // send the footer of a multi-part message void CShareServerEditionItfProxy::multiPartMsgFoot(NLNET::IModule *sender, uint32 charId) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->multiPartMsgFoot(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_multiPartMsgFoot(__message, charId); _ModuleProxy->sendModuleMessage(sender, __message); } } // simulate the forward of a message (to dss) void CShareServerEditionItfProxy::forwardToDss(NLNET::IModule *sender, uint32 charId, const NLNET::CMessage &msg) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->forwardToDss(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, msg); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_forwardToDss(__message, charId, msg); _ModuleProxy->sendModuleMessage(sender, __message); } } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_startingScenario(NLNET::CMessage &__message) { __message.setType("RSS1"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_startScenario(NLNET::CMessage &__message, bool ok, const TScenarioHeaderSerializer &header, const CObjectSerializerServer &data, uint32 startingAct) { __message.setType("RSS2"); nlWrite(__message, serial, ok); nlWrite(__message, serial, const_cast < TScenarioHeaderSerializer& > (header)); nlWrite(__message, serial, const_cast < CObjectSerializerServer& > (data)); nlWrite(__message, serial, startingAct); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_advConnACK(NLNET::CMessage &__message) { __message.setType("ADC_ACK"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onUserComponentRegistered(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5) { __message.setType("SUCR"); nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onUserComponentDownloading(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5) { __message.setType("SUCD"); nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onScenarioUploadAsked(NLNET::CMessage &__message, uint32 msgId, const CObjectSerializerServer &hlScenario, bool mustBrodcast) { __message.setType("SSUA"); nlWrite(__message, serial, msgId); nlWrite(__message, serial, const_cast < CObjectSerializerServer& > (hlScenario)); nlWrite(__message, serial, mustBrodcast); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeSetAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerServer &value) { __message.setType("SNSA"); nlWrite(__message, serial, msgId); nlWrite(__message, serial, const_cast < std::string& > (instanceId)); nlWrite(__message, serial, const_cast < std::string& > (attrName)); nlWrite(__message, serial, const_cast < R2::CObjectSerializerServer& > (value)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeInsertAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerServer &value) { __message.setType("SNIA"); nlWrite(__message, serial, msgId); nlWrite(__message, serial, const_cast < std::string& > (instanceId)); nlWrite(__message, serial, const_cast < std::string& > (attrName)); nlWrite(__message, serial, position); nlWrite(__message, serial, const_cast < std::string& > (key)); nlWrite(__message, serial, const_cast < R2::CObjectSerializerServer& > (value)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeEraseAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId, const std::string &attrName, sint32 position) { __message.setType("SNEA"); nlWrite(__message, serial, msgId); nlWrite(__message, serial, const_cast < std::string& > (instanceId)); nlWrite(__message, serial, const_cast < std::string& > (attrName)); nlWrite(__message, serial, position); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onNodeMoveAsked(NLNET::CMessage &__message, uint32 msgId, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2) { __message.setType("SNMA"); nlWrite(__message, serial, msgId); nlWrite(__message, serial, const_cast < std::string& > (instanceId1)); nlWrite(__message, serial, const_cast < std::string& > (attrName1)); nlWrite(__message, serial, position1); nlWrite(__message, serial, const_cast < std::string& > (instanceId2)); nlWrite(__message, serial, const_cast < std::string& > (attrName2)); nlWrite(__message, serial, position2); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onMapConnectionAsked(NLNET::CMessage &__message, TSessionId scenarioId, bool updateHighLevel, bool mustTp, R2::TUserRole role) { __message.setType("SMCA"); nlWrite(__message, serial, scenarioId); nlWrite(__message, serial, updateHighLevel); nlWrite(__message, serial, mustTp); nlWrite(__message, serial, role); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onCharModeUpdateAsked(NLNET::CMessage &__message, R2::TCharMode mode) { __message.setType("SCMUA"); nlWrite(__message, serial, mode); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onTpPositionAsked(NLNET::CMessage &__message, float x, float y, float z) { __message.setType("STPA"); nlWrite(__message, serial, x); nlWrite(__message, serial, y); nlWrite(__message, serial, z); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_tpToEntryPoint(NLNET::CMessage &__message, uint32 actIndex) { __message.setType("TPEP"); nlWrite(__message, serial, actIndex); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_setStartingAct(NLNET::CMessage &__message, uint32 actIndex) { __message.setType("STA"); nlWrite(__message, serial, actIndex); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_onScenarioRingAccessUpdated(NLNET::CMessage &__message, bool ok, const std::string &ringAccess, const std::string &errMsg) { __message.setType("SRAU"); nlWrite(__message, serial, ok); nlWrite(__message, serial, const_cast < std::string& > (ringAccess)); nlWrite(__message, serial, const_cast < std::string& > (errMsg)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_saveScenarioFile(NLNET::CMessage &__message, const std::string &md5, const R2::TScenarioHeaderSerializer &header) { __message.setType("SSSFA"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, const_cast < R2::TScenarioHeaderSerializer& > (header)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_loadScenarioFile(NLNET::CMessage &__message, const std::string &md5, const std::string &signature) { __message.setType("SLSFA"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, const_cast < std::string& > (signature)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_saveUserComponentFile(NLNET::CMessage &__message, const std::string &md5, const R2::TScenarioHeaderSerializer &header) { __message.setType("SUCF"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, const_cast < R2::TScenarioHeaderSerializer& > (header)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_loadUserComponentFile(NLNET::CMessage &__message, const std::string &md5, const std::string &signature) { __message.setType("LUCF"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, const_cast < std::string& > (signature)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_teleportOneCharacterToAnother(NLNET::CMessage &__message, TSessionId sessionId, uint32 sourceId, uint32 destId) { __message.setType("STOCTA"); nlWrite(__message, serial, sessionId); nlWrite(__message, serial, sourceId); nlWrite(__message, serial, destId); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_teleportWhileUploadingScenario(NLNET::CMessage &__message, const std::string &island, const std::string &entryPoint, const std::string &season) { __message.setType("STWUS"); nlWrite(__message, serial, const_cast < std::string& > (island)); nlWrite(__message, serial, const_cast < std::string& > (entryPoint)); nlWrite(__message, serial, const_cast < std::string& > (season)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_multiPartMsgHead(NLNET::CMessage &__message, uint32 charId, const std::string &msgName, uint32 nbPacket, uint32 size) { __message.setType("DSS_HEAD"); nlWrite(__message, serial, charId); nlWrite(__message, serial, const_cast < std::string& > (msgName)); nlWrite(__message, serial, nbPacket); nlWrite(__message, serial, size); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_multiPartMsgBody(NLNET::CMessage &__message, uint32 charId, uint32 partId, const std::vector &data) { __message.setType("DSS_MSG"); nlWrite(__message, serial, charId); nlWrite(__message, serial, partId); nlWrite(__message, serialCont, const_cast < std::vector& > (data)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_multiPartMsgFoot(NLNET::CMessage &__message, uint32 charId) { __message.setType("DSS_FOOT"); nlWrite(__message, serial, charId); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareServerEditionItfProxy::buildMessageFor_forwardToDss(NLNET::CMessage &__message, uint32 charId, const NLNET::CMessage &msg) { __message.setType("DSS_FW"); nlWrite(__message, serial, charId); nlWrite(__message, serialMessage, const_cast < NLNET::CMessage& > (msg)); return __message; } ///////////////////////////////////////////////////////////////// // WARNING : this is a generated file, don't change it ! ///////////////////////////////////////////////////////////////// const CShareClientEditionItfSkel::TMessageHandlerMap &CShareClientEditionItfSkel::getMessageHandlers() const { static TMessageHandlerMap handlers; static bool init = false; if (!init) { std::pair < TMessageHandlerMap::iterator, bool > res; res = handlers.insert(std::make_pair(std::string("RSS1"), &CShareClientEditionItfSkel::startingScenario_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("RSS2"), &CShareClientEditionItfSkel::startScenario_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUCR"), &CShareClientEditionItfSkel::onUserComponentRegistered_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUCU"), &CShareClientEditionItfSkel::onUserComponentUploading_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CSUA"), &CShareClientEditionItfSkel::onScenarioUploaded_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CNSA"), &CShareClientEditionItfSkel::onNodeSet_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CNIA"), &CShareClientEditionItfSkel::onNodeInserted_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CNEA"), &CShareClientEditionItfSkel::onNodeErased_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CNMA"), &CShareClientEditionItfSkel::onNodeMoved_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CQU"), &CShareClientEditionItfSkel::onQuotaUpdated_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CCMU"), &CShareClientEditionItfSkel::onCharModeUpdated_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CTMD"), &CShareClientEditionItfSkel::onTestModeDisconnected_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CTPPS"), &CShareClientEditionItfSkel::onTpPositionSimulated_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("COK"), &CShareClientEditionItfSkel::onKicked_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("COD"), &CShareClientEditionItfSkel::onDisconnected_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SSA1"), &CShareClientEditionItfSkel::scheduleStartAct_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("OAMC"), &CShareClientEditionItfSkel::onAnimationModePlayConnected_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUSH"), &CShareClientEditionItfSkel::updateScenarioHeader_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUIT"), &CShareClientEditionItfSkel::updateMissionItemsDescription_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUAPD"), &CShareClientEditionItfSkel::updateActPositionDescriptions_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUUTD"), &CShareClientEditionItfSkel::updateUserTriggerDescriptions_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUAIU"), &CShareClientEditionItfSkel::onCurrentActIndexUpdated_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUTAL"), &CShareClientEditionItfSkel::updateTalkingAsList_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CUIL"), &CShareClientEditionItfSkel::updateIncarningList_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CSM"), &CShareClientEditionItfSkel::systemMsg_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CRAU"), &CShareClientEditionItfSkel::onRingAccessUpdated_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CSSFA"), &CShareClientEditionItfSkel::saveScenarioFileAccepted_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CLSFA"), &CShareClientEditionItfSkel::loadScenarioFileAccepted_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("SUCFA"), &CShareClientEditionItfSkel::saveUserComponentFileAccepted_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("LUCFA"), &CShareClientEditionItfSkel::loadUserComponentFileAccepted_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_HEAD"), &CShareClientEditionItfSkel::multiPartMsgHead_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_MSG"), &CShareClientEditionItfSkel::multiPartMsgBody_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("DSS_FOOT"), &CShareClientEditionItfSkel::multiPartMsgFoot_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); res = handlers.insert(std::make_pair(std::string("CACKMSG"), &CShareClientEditionItfSkel::ackMsg_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); init = true; } return handlers; } bool CShareClientEditionItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message) { const TMessageHandlerMap &mh = getMessageHandlers(); TMessageHandlerMap::const_iterator it(mh.find(message.getName())); if (it == mh.end()) { return false; } TMessageHandler cmd = it->second; (this->*cmd)(sender, message); return true; } void CShareClientEditionItfSkel::startingScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_startingScenario_RSS1); uint32 charId; nlRead(__message, serial, charId); startingScenario(sender, charId); } void CShareClientEditionItfSkel::startScenario_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_startScenario_RSS2); bool ok; nlRead(__message, serial, ok); uint32 startingAct; nlRead(__message, serial, startingAct); std::string errorMsg; nlRead(__message, serial, errorMsg); startScenario(sender, ok, startingAct, errorMsg); } void CShareClientEditionItfSkel::onUserComponentRegistered_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onUserComponentRegistered_CUCR); NLMISC::CHashKeyMD5 md5; nlRead(__message, serial, md5); onUserComponentRegistered(sender, md5); } void CShareClientEditionItfSkel::onUserComponentUploading_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onUserComponentUploading_CUCU); NLMISC::CHashKeyMD5 md5; nlRead(__message, serial, md5); onUserComponentUploading(sender, md5); } void CShareClientEditionItfSkel::onScenarioUploaded_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onScenarioUploaded_CSUA); R2::CObjectSerializerClient hlScenario; nlRead(__message, serial, hlScenario); onScenarioUploaded(sender, hlScenario); } void CShareClientEditionItfSkel::onNodeSet_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onNodeSet_CNSA); std::string instanceId; nlRead(__message, serial, instanceId); std::string attrName; nlRead(__message, serial, attrName); R2::CObjectSerializerClient value; nlRead(__message, serial, value); onNodeSet(sender, instanceId, attrName, value); } void CShareClientEditionItfSkel::onNodeInserted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onNodeInserted_CNIA); std::string instanceId; nlRead(__message, serial, instanceId); std::string attrName; nlRead(__message, serial, attrName); sint32 position; nlRead(__message, serial, position); std::string key; nlRead(__message, serial, key); R2::CObjectSerializerClient value; nlRead(__message, serial, value); onNodeInserted(sender, instanceId, attrName, position, key, value); } void CShareClientEditionItfSkel::onNodeErased_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onNodeErased_CNEA); std::string instanceId; nlRead(__message, serial, instanceId); std::string attrName; nlRead(__message, serial, attrName); sint32 position; nlRead(__message, serial, position); onNodeErased(sender, instanceId, attrName, position); } void CShareClientEditionItfSkel::onNodeMoved_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onNodeMoved_CNMA); std::string instanceId1; nlRead(__message, serial, instanceId1); std::string attrName1; nlRead(__message, serial, attrName1); sint32 position1; nlRead(__message, serial, position1); std::string instanceId2; nlRead(__message, serial, instanceId2); std::string attrName2; nlRead(__message, serial, attrName2); sint32 position2; nlRead(__message, serial, position2); onNodeMoved(sender, instanceId1, attrName1, position1, instanceId2, attrName2, position2); } void CShareClientEditionItfSkel::onQuotaUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onQuotaUpdated_CQU); uint32 maxNpcs; nlRead(__message, serial, maxNpcs); uint32 maxStaticObjects; nlRead(__message, serial, maxStaticObjects); onQuotaUpdated(sender, maxNpcs, maxStaticObjects); } void CShareClientEditionItfSkel::onCharModeUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onCharModeUpdated_CCMU); R2::TCharMode mode; nlRead(__message, serial, mode); onCharModeUpdated(sender, mode); } void CShareClientEditionItfSkel::onTestModeDisconnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onTestModeDisconnected_CTMD); TSessionId sessionId; nlRead(__message, serial, sessionId); uint32 lastActIndex; nlRead(__message, serial, lastActIndex); R2::TScenarioSessionType animationType; nlRead(__message, serialEnum, animationType); onTestModeDisconnected(sender, sessionId, lastActIndex, animationType); } void CShareClientEditionItfSkel::onTpPositionSimulated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onTpPositionSimulated_CTPPS); TSessionId sessionId; nlRead(__message, serial, sessionId); uint64 characterId64; nlRead(__message, serial, characterId64); sint32 x; nlRead(__message, serial, x); sint32 y; nlRead(__message, serial, y); sint32 z; nlRead(__message, serial, z); uint8 scenarioSeason; nlRead(__message, serial, scenarioSeason); onTpPositionSimulated(sender, sessionId, characterId64, x, y, z, scenarioSeason); } void CShareClientEditionItfSkel::onKicked_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onKicked_COK); uint32 timeBeforeDisconnection; nlRead(__message, serial, timeBeforeDisconnection); bool mustKick; nlRead(__message, serial, mustKick); onKicked(sender, timeBeforeDisconnection, mustKick); } void CShareClientEditionItfSkel::onDisconnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareClientEditionItfSkel_onDisconnected_COD); onDisconnected(sender); } void CShareClientEditionItfSkel::scheduleStartAct_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_scheduleStartAct_SSA1); uint32 errorId; nlRead(__message, serial, errorId); uint32 actId; nlRead(__message, serial, actId); uint32 nbSeconds; nlRead(__message, serial, nbSeconds); scheduleStartAct(sender, errorId, actId, nbSeconds); } void CShareClientEditionItfSkel::onAnimationModePlayConnected_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareClientEditionItfSkel_onAnimationModePlayConnected_OAMC); onAnimationModePlayConnected(sender); } void CShareClientEditionItfSkel::updateScenarioHeader_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_updateScenarioHeader_CUSH); R2::TScenarioHeaderSerializer scenarioHeader; nlRead(__message, serial, scenarioHeader); updateScenarioHeader(sender, scenarioHeader); } void CShareClientEditionItfSkel::updateMissionItemsDescription_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_updateMissionItemsDescription_CUIT); TSessionId sessionId; nlRead(__message, serial, sessionId); std::vector missionItem; nlRead(__message, serialCont, missionItem); updateMissionItemsDescription(sender, sessionId, missionItem); } void CShareClientEditionItfSkel::updateActPositionDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_updateActPositionDescriptions_CUAPD); R2::TActPositionDescriptions actPositionDescriptions; nlRead(__message, serialCont, actPositionDescriptions); updateActPositionDescriptions(sender, actPositionDescriptions); } void CShareClientEditionItfSkel::updateUserTriggerDescriptions_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_updateUserTriggerDescriptions_CUUTD); R2::TUserTriggerDescriptions userTriggerDescriptions; nlRead(__message, serialCont, userTriggerDescriptions); updateUserTriggerDescriptions(sender, userTriggerDescriptions); } void CShareClientEditionItfSkel::onCurrentActIndexUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onCurrentActIndexUpdated_CUAIU); uint32 actIndex; nlRead(__message, serial, actIndex); onCurrentActIndexUpdated(sender, actIndex); } void CShareClientEditionItfSkel::updateTalkingAsList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_updateTalkingAsList_CUTAL); std::vector botsId; nlRead(__message, serialCont, botsId); updateTalkingAsList(sender, botsId); } void CShareClientEditionItfSkel::updateIncarningList_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_updateIncarningList_CUIL); std::vector botsId; nlRead(__message, serialCont, botsId); updateIncarningList(sender, botsId); } void CShareClientEditionItfSkel::systemMsg_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_systemMsg_CSM); std::string msgType; nlRead(__message, serial, msgType); std::string who; nlRead(__message, serial, who); std::string msg; nlRead(__message, serial, msg); systemMsg(sender, msgType, who, msg); } void CShareClientEditionItfSkel::onRingAccessUpdated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_onRingAccessUpdated_CRAU); std::string ringAccess; nlRead(__message, serial, ringAccess); onRingAccessUpdated(sender, ringAccess); } void CShareClientEditionItfSkel::saveScenarioFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_saveScenarioFileAccepted_CSSFA); std::string md5; nlRead(__message, serial, md5); std::string signature; nlRead(__message, serial, signature); bool isAccepted; nlRead(__message, serial, isAccepted); saveScenarioFileAccepted(sender, md5, signature, isAccepted); } void CShareClientEditionItfSkel::loadScenarioFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_loadScenarioFileAccepted_CLSFA); std::string md5; nlRead(__message, serial, md5); bool ok; nlRead(__message, serial, ok); loadScenarioFileAccepted(sender, md5, ok); } void CShareClientEditionItfSkel::saveUserComponentFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_saveUserComponentFileAccepted_SUCFA); std::string md5; nlRead(__message, serial, md5); std::string signature; nlRead(__message, serial, signature); bool isAccepted; nlRead(__message, serial, isAccepted); saveUserComponentFileAccepted(sender, md5, signature, isAccepted); } void CShareClientEditionItfSkel::loadUserComponentFileAccepted_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_loadUserComponentFileAccepted_LUCFA); std::string md5; nlRead(__message, serial, md5); bool ok; nlRead(__message, serial, ok); loadUserComponentFileAccepted(sender, md5, ok); } void CShareClientEditionItfSkel::multiPartMsgHead_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_multiPartMsgHead_DSS_HEAD); std::string msgName; nlRead(__message, serial, msgName); uint32 nbPacket; nlRead(__message, serial, nbPacket); uint32 size; nlRead(__message, serial, size); multiPartMsgHead(sender, msgName, nbPacket, size); } void CShareClientEditionItfSkel::multiPartMsgBody_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_multiPartMsgBody_DSS_MSG); uint32 partId; nlRead(__message, serial, partId); uint32 packetSize; nlRead(__message, serial, packetSize); multiPartMsgBody(sender, partId, packetSize); } void CShareClientEditionItfSkel::multiPartMsgFoot_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */) { H_AUTO(CShareClientEditionItfSkel_multiPartMsgFoot_DSS_FOOT); multiPartMsgFoot(sender); } void CShareClientEditionItfSkel::ackMsg_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CShareClientEditionItfSkel_ackMsg_CACKMSG); uint32 msgId; nlRead(__message, serial, msgId); bool ok; nlRead(__message, serial, ok); ackMsg(sender, msgId, ok); } // The start of a test has been requested void CShareClientEditionItfProxy::startingScenario(NLNET::IModule *sender, uint32 charId) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->startingScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_startingScenario(__message, charId); _ModuleProxy->sendModuleMessage(sender, __message); } } // A Scenario has started void CShareClientEditionItfProxy::startScenario(NLNET::IModule *sender, bool ok, uint32 startingAct, const std::string &errorMsg) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->startScenario(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ok, startingAct, errorMsg); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_startScenario(__message, ok, startingAct, errorMsg); _ModuleProxy->sendModuleMessage(sender, __message); } } // A User component has been registered void CShareClientEditionItfProxy::onUserComponentRegistered(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onUserComponentRegistered(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onUserComponentRegistered(__message, md5); _ModuleProxy->sendModuleMessage(sender, __message); } } // Request the upload of a component void CShareClientEditionItfProxy::onUserComponentUploading(NLNET::IModule *sender, const NLMISC::CHashKeyMD5 &md5) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onUserComponentUploading(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onUserComponentUploading(__message, md5); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client request to upload an hl ata. void CShareClientEditionItfProxy::onScenarioUploaded(NLNET::IModule *sender, const R2::CObjectSerializerClient &hlScenario) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onScenarioUploaded(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), hlScenario); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onScenarioUploaded(__message, hlScenario); _ModuleProxy->sendModuleMessage(sender, __message); } } // The client request to set a node on a hl scenario. void CShareClientEditionItfProxy::onNodeSet(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeSet(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId, attrName, value); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeSet(__message, instanceId, attrName, value); _ModuleProxy->sendModuleMessage(sender, __message); } } // The ServerEditionMode inserts a node on a hl scenario. void CShareClientEditionItfProxy::onNodeInserted(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeInserted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId, attrName, position, key, value); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeInserted(__message, instanceId, attrName, position, key, value); _ModuleProxy->sendModuleMessage(sender, __message); } } // The ServerEditionMode erases a node on a hl scenario. void CShareClientEditionItfProxy::onNodeErased(NLNET::IModule *sender, const std::string &instanceId, const std::string &attrName, sint32 position) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeErased(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId, attrName, position); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeErased(__message, instanceId, attrName, position); _ModuleProxy->sendModuleMessage(sender, __message); } } // The ServerEditionMode a move node on a hl scenario. void CShareClientEditionItfProxy::onNodeMoved(NLNET::IModule *sender, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onNodeMoved(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), instanceId1, attrName1, position1, instanceId2, attrName2, position2); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onNodeMoved(__message, instanceId1, attrName1, position1, instanceId2, attrName2, position2); _ModuleProxy->sendModuleMessage(sender, __message); } } // Updates the client quota void CShareClientEditionItfProxy::onQuotaUpdated(NLNET::IModule *sender, uint32 maxNpcs, uint32 maxStaticObjects) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onQuotaUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), maxNpcs, maxStaticObjects); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onQuotaUpdated(__message, maxNpcs, maxStaticObjects); _ModuleProxy->sendModuleMessage(sender, __message); } } // Updates the client Mode (tester, dm, editor, player) be the speed void CShareClientEditionItfProxy::onCharModeUpdated(NLNET::IModule *sender, R2::TCharMode mode) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onCharModeUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), mode); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onCharModeUpdated(__message, mode); _ModuleProxy->sendModuleMessage(sender, __message); } } // Indicates to the client that an animation has stop (animation, play, test) void CShareClientEditionItfProxy::onTestModeDisconnected(NLNET::IModule *sender, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onTestModeDisconnected(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, lastActIndex, animationType); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onTestModeDisconnected(__message, sessionId, lastActIndex, animationType); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to make a local client tp (because egs can not do it)/ void CShareClientEditionItfProxy::onTpPositionSimulated(NLNET::IModule *sender, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onTpPositionSimulated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, characterId64, x, y, z, scenarioSeason); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onTpPositionSimulated(__message, sessionId, characterId64, x, y, z, scenarioSeason); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to indicates that the client will be disconnect in secondes./ void CShareClientEditionItfProxy::onKicked(NLNET::IModule *sender, uint32 timeBeforeDisconnection, bool mustKick) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onKicked(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), timeBeforeDisconnection, mustKick); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onKicked(__message, timeBeforeDisconnection, mustKick); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to make to disconnect the client./ void CShareClientEditionItfProxy::onDisconnected(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onDisconnected(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onDisconnected(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // Tell to the client that an act begin in nbSeconds void CShareClientEditionItfProxy::scheduleStartAct(NLNET::IModule *sender, uint32 errorId, uint32 actId, uint32 nbSeconds) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->scheduleStartAct(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), errorId, actId, nbSeconds); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_scheduleStartAct(__message, errorId, actId, nbSeconds); _ModuleProxy->sendModuleMessage(sender, __message); } } // Tell to the client that he is connected in play mode in an animation session void CShareClientEditionItfProxy::onAnimationModePlayConnected(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onAnimationModePlayConnected(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onAnimationModePlayConnected(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to update the scenario Header void CShareClientEditionItfProxy::updateScenarioHeader(NLNET::IModule *sender, const R2::TScenarioHeaderSerializer &scenarioHeader) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->updateScenarioHeader(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), scenarioHeader); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_updateScenarioHeader(__message, scenarioHeader); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to update discription mission item of a scenario void CShareClientEditionItfProxy::updateMissionItemsDescription(NLNET::IModule *sender, TSessionId sessionId, const std::vector &missionItem) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->updateMissionItemsDescription(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), sessionId, missionItem); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_updateMissionItemsDescription(__message, sessionId, missionItem); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to update the discription of acts (name and positions) void CShareClientEditionItfProxy::updateActPositionDescriptions(NLNET::IModule *sender, const R2::TActPositionDescriptions &actPositionDescriptions) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->updateActPositionDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actPositionDescriptions); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_updateActPositionDescriptions(__message, actPositionDescriptions); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to update the discription of acts (name and positions) void CShareClientEditionItfProxy::updateUserTriggerDescriptions(NLNET::IModule *sender, const R2::TUserTriggerDescriptions &userTriggerDescriptions) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->updateUserTriggerDescriptions(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userTriggerDescriptions); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_updateUserTriggerDescriptions(__message, userTriggerDescriptions); _ModuleProxy->sendModuleMessage(sender, __message); } } // A DSS Message to update the discription of acts (name and positions) void CShareClientEditionItfProxy::onCurrentActIndexUpdated(NLNET::IModule *sender, uint32 actIndex) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onCurrentActIndexUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), actIndex); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onCurrentActIndexUpdated(__message, actIndex); _ModuleProxy->sendModuleMessage(sender, __message); } } // Update the Talking as list. void CShareClientEditionItfProxy::updateTalkingAsList(NLNET::IModule *sender, const std::vector &botsId) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->updateTalkingAsList(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), botsId); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_updateTalkingAsList(__message, botsId); _ModuleProxy->sendModuleMessage(sender, __message); } } // Update the Incarning list. void CShareClientEditionItfProxy::updateIncarningList(NLNET::IModule *sender, const std::vector &botsId) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->updateIncarningList(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), botsId); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_updateIncarningList(__message, botsId); _ModuleProxy->sendModuleMessage(sender, __message); } } // A message that will be printed an client void CShareClientEditionItfProxy::systemMsg(NLNET::IModule *sender, const std::string &msgType, const std::string &who, const std::string &msg) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->systemMsg(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgType, who, msg); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_systemMsg(__message, msgType, who, msg); _ModuleProxy->sendModuleMessage(sender, __message); } } // Update the ring access of the client void CShareClientEditionItfProxy::onRingAccessUpdated(NLNET::IModule *sender, const std::string &ringAccess) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->onRingAccessUpdated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), ringAccess); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_onRingAccessUpdated(__message, ringAccess); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a file waiting to be saved void CShareClientEditionItfProxy::saveScenarioFileAccepted(NLNET::IModule *sender, const std::string &md5, const std::string &signature, bool isAccepted) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->saveScenarioFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature, isAccepted); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_saveScenarioFileAccepted(__message, md5, signature, isAccepted); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a file waiting to be loaded void CShareClientEditionItfProxy::loadScenarioFileAccepted(NLNET::IModule *sender, const std::string &md5, bool ok) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->loadScenarioFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, ok); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_loadScenarioFileAccepted(__message, md5, ok); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a user component file waiting to be saved void CShareClientEditionItfProxy::saveUserComponentFileAccepted(NLNET::IModule *sender, const std::string &md5, const std::string &signature, bool isAccepted) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->saveUserComponentFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, signature, isAccepted); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_saveUserComponentFileAccepted(__message, md5, signature, isAccepted); _ModuleProxy->sendModuleMessage(sender, __message); } } // a message to validate a user component file waiting to be loaded void CShareClientEditionItfProxy::loadUserComponentFileAccepted(NLNET::IModule *sender, const std::string &md5, bool ok) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->loadUserComponentFileAccepted(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), md5, ok); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_loadUserComponentFileAccepted(__message, md5, ok); _ModuleProxy->sendModuleMessage(sender, __message); } } // send the header of a multi-part message void CShareClientEditionItfProxy::multiPartMsgHead(NLNET::IModule *sender, const std::string &msgName, uint32 nbPacket, uint32 size) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->multiPartMsgHead(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgName, nbPacket, size); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_multiPartMsgHead(__message, msgName, nbPacket, size); _ModuleProxy->sendModuleMessage(sender, __message); } } // send a part of a multi-part message void CShareClientEditionItfProxy::multiPartMsgBody(NLNET::IModule *sender, uint32 partId, uint32 packetSize) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->multiPartMsgBody(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), partId, packetSize); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_multiPartMsgBody(__message, partId, packetSize); _ModuleProxy->sendModuleMessage(sender, __message); } } // send the footer of a multi-part message void CShareClientEditionItfProxy::multiPartMsgFoot(NLNET::IModule *sender) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->multiPartMsgFoot(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender)); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_multiPartMsgFoot(__message); _ModuleProxy->sendModuleMessage(sender, __message); } } // send an ack messag to the client void CShareClientEditionItfProxy::ackMsg(NLNET::IModule *sender, uint32 msgId, bool ok) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->ackMsg(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), msgId, ok); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_ackMsg(__message, msgId, ok); _ModuleProxy->sendModuleMessage(sender, __message); } } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_startingScenario(NLNET::CMessage &__message, uint32 charId) { __message.setType("RSS1"); nlWrite(__message, serial, charId); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_startScenario(NLNET::CMessage &__message, bool ok, uint32 startingAct, const std::string &errorMsg) { __message.setType("RSS2"); nlWrite(__message, serial, ok); nlWrite(__message, serial, startingAct); nlWrite(__message, serial, const_cast < std::string& > (errorMsg)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onUserComponentRegistered(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5) { __message.setType("CUCR"); nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onUserComponentUploading(NLNET::CMessage &__message, const NLMISC::CHashKeyMD5 &md5) { __message.setType("CUCU"); nlWrite(__message, serial, const_cast < NLMISC::CHashKeyMD5& > (md5)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onScenarioUploaded(NLNET::CMessage &__message, const R2::CObjectSerializerClient &hlScenario) { __message.setType("CSUA"); nlWrite(__message, serial, const_cast < R2::CObjectSerializerClient& > (hlScenario)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeSet(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, const R2::CObjectSerializerClient &value) { __message.setType("CNSA"); nlWrite(__message, serial, const_cast < std::string& > (instanceId)); nlWrite(__message, serial, const_cast < std::string& > (attrName)); nlWrite(__message, serial, const_cast < R2::CObjectSerializerClient& > (value)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeInserted(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, sint32 position, const std::string &key, const R2::CObjectSerializerClient &value) { __message.setType("CNIA"); nlWrite(__message, serial, const_cast < std::string& > (instanceId)); nlWrite(__message, serial, const_cast < std::string& > (attrName)); nlWrite(__message, serial, position); nlWrite(__message, serial, const_cast < std::string& > (key)); nlWrite(__message, serial, const_cast < R2::CObjectSerializerClient& > (value)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeErased(NLNET::CMessage &__message, const std::string &instanceId, const std::string &attrName, sint32 position) { __message.setType("CNEA"); nlWrite(__message, serial, const_cast < std::string& > (instanceId)); nlWrite(__message, serial, const_cast < std::string& > (attrName)); nlWrite(__message, serial, position); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onNodeMoved(NLNET::CMessage &__message, const std::string &instanceId1, const std::string &attrName1, sint32 position1, const std::string &instanceId2, const std::string &attrName2, sint32 position2) { __message.setType("CNMA"); nlWrite(__message, serial, const_cast < std::string& > (instanceId1)); nlWrite(__message, serial, const_cast < std::string& > (attrName1)); nlWrite(__message, serial, position1); nlWrite(__message, serial, const_cast < std::string& > (instanceId2)); nlWrite(__message, serial, const_cast < std::string& > (attrName2)); nlWrite(__message, serial, position2); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onQuotaUpdated(NLNET::CMessage &__message, uint32 maxNpcs, uint32 maxStaticObjects) { __message.setType("CQU"); nlWrite(__message, serial, maxNpcs); nlWrite(__message, serial, maxStaticObjects); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onCharModeUpdated(NLNET::CMessage &__message, R2::TCharMode mode) { __message.setType("CCMU"); nlWrite(__message, serial, mode); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onTestModeDisconnected(NLNET::CMessage &__message, TSessionId sessionId, uint32 lastActIndex, R2::TScenarioSessionType animationType) { __message.setType("CTMD"); nlWrite(__message, serial, sessionId); nlWrite(__message, serial, lastActIndex); nlWrite(__message, serialEnum, animationType); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onTpPositionSimulated(NLNET::CMessage &__message, TSessionId sessionId, uint64 characterId64, sint32 x, sint32 y, sint32 z, uint8 scenarioSeason) { __message.setType("CTPPS"); nlWrite(__message, serial, sessionId); nlWrite(__message, serial, characterId64); nlWrite(__message, serial, x); nlWrite(__message, serial, y); nlWrite(__message, serial, z); nlWrite(__message, serial, scenarioSeason); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onKicked(NLNET::CMessage &__message, uint32 timeBeforeDisconnection, bool mustKick) { __message.setType("COK"); nlWrite(__message, serial, timeBeforeDisconnection); nlWrite(__message, serial, mustKick); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onDisconnected(NLNET::CMessage &__message) { __message.setType("COD"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_scheduleStartAct(NLNET::CMessage &__message, uint32 errorId, uint32 actId, uint32 nbSeconds) { __message.setType("SSA1"); nlWrite(__message, serial, errorId); nlWrite(__message, serial, actId); nlWrite(__message, serial, nbSeconds); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onAnimationModePlayConnected(NLNET::CMessage &__message) { __message.setType("OAMC"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateScenarioHeader(NLNET::CMessage &__message, const R2::TScenarioHeaderSerializer &scenarioHeader) { __message.setType("CUSH"); nlWrite(__message, serial, const_cast < R2::TScenarioHeaderSerializer& > (scenarioHeader)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateMissionItemsDescription(NLNET::CMessage &__message, TSessionId sessionId, const std::vector &missionItem) { __message.setType("CUIT"); nlWrite(__message, serial, sessionId); nlWrite(__message, serialCont, const_cast < std::vector& > (missionItem)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateActPositionDescriptions(NLNET::CMessage &__message, const R2::TActPositionDescriptions &actPositionDescriptions) { __message.setType("CUAPD"); nlWrite(__message, serialCont, const_cast < R2::TActPositionDescriptions& > (actPositionDescriptions)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateUserTriggerDescriptions(NLNET::CMessage &__message, const R2::TUserTriggerDescriptions &userTriggerDescriptions) { __message.setType("CUUTD"); nlWrite(__message, serialCont, const_cast < R2::TUserTriggerDescriptions& > (userTriggerDescriptions)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onCurrentActIndexUpdated(NLNET::CMessage &__message, uint32 actIndex) { __message.setType("CUAIU"); nlWrite(__message, serial, actIndex); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateTalkingAsList(NLNET::CMessage &__message, const std::vector &botsId) { __message.setType("CUTAL"); nlWrite(__message, serialCont, const_cast < std::vector& > (botsId)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_updateIncarningList(NLNET::CMessage &__message, const std::vector &botsId) { __message.setType("CUIL"); nlWrite(__message, serialCont, const_cast < std::vector& > (botsId)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_systemMsg(NLNET::CMessage &__message, const std::string &msgType, const std::string &who, const std::string &msg) { __message.setType("CSM"); nlWrite(__message, serial, const_cast < std::string& > (msgType)); nlWrite(__message, serial, const_cast < std::string& > (who)); nlWrite(__message, serial, const_cast < std::string& > (msg)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_onRingAccessUpdated(NLNET::CMessage &__message, const std::string &ringAccess) { __message.setType("CRAU"); nlWrite(__message, serial, const_cast < std::string& > (ringAccess)); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_saveScenarioFileAccepted(NLNET::CMessage &__message, const std::string &md5, const std::string &signature, bool isAccepted) { __message.setType("CSSFA"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, const_cast < std::string& > (signature)); nlWrite(__message, serial, isAccepted); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_loadScenarioFileAccepted(NLNET::CMessage &__message, const std::string &md5, bool ok) { __message.setType("CLSFA"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, ok); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_saveUserComponentFileAccepted(NLNET::CMessage &__message, const std::string &md5, const std::string &signature, bool isAccepted) { __message.setType("SUCFA"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, const_cast < std::string& > (signature)); nlWrite(__message, serial, isAccepted); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_loadUserComponentFileAccepted(NLNET::CMessage &__message, const std::string &md5, bool ok) { __message.setType("LUCFA"); nlWrite(__message, serial, const_cast < std::string& > (md5)); nlWrite(__message, serial, ok); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_multiPartMsgHead(NLNET::CMessage &__message, const std::string &msgName, uint32 nbPacket, uint32 size) { __message.setType("DSS_HEAD"); nlWrite(__message, serial, const_cast < std::string& > (msgName)); nlWrite(__message, serial, nbPacket); nlWrite(__message, serial, size); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_multiPartMsgBody(NLNET::CMessage &__message, uint32 partId, uint32 packetSize) { __message.setType("DSS_MSG"); nlWrite(__message, serial, partId); nlWrite(__message, serial, packetSize); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_multiPartMsgFoot(NLNET::CMessage &__message) { __message.setType("DSS_FOOT"); return __message; } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CShareClientEditionItfProxy::buildMessageFor_ackMsg(NLNET::CMessage &__message, uint32 msgId, bool ok) { __message.setType("CACKMSG"); nlWrite(__message, serial, msgId); nlWrite(__message, serial, ok); return __message; } ///////////////////////////////////////////////////////////////// // WARNING : this is a generated file, don't change it ! ///////////////////////////////////////////////////////////////// const CIOSRingItfSkel::TMessageHandlerMap &CIOSRingItfSkel::getMessageHandlers() const { static TMessageHandlerMap handlers; static bool init = false; if (!init) { std::pair < TMessageHandlerMap::iterator, bool > res; res = handlers.insert(std::make_pair(std::string("SINFAI"), &CIOSRingItfSkel::storeItemNamesForAIInstance_skel)); // if this assert, you have a doubly message name in your interface definition ! nlassert(res.second); init = true; } return handlers; } bool CIOSRingItfSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message) { const TMessageHandlerMap &mh = getMessageHandlers(); TMessageHandlerMap::const_iterator it(mh.find(message.getName())); if (it == mh.end()) { return false; } TMessageHandler cmd = it->second; (this->*cmd)(sender, message); return true; } void CIOSRingItfSkel::storeItemNamesForAIInstance_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message) { H_AUTO(CIOSRingItfSkel_storeItemNamesForAIInstance_SINFAI); uint32 aiInstance; nlRead(__message, serial, aiInstance); std::vector < TCharMappedInfo > itemInfos; nlRead(__message, serialCont, itemInfos); storeItemNamesForAIInstance(sender, aiInstance, itemInfos); } // DSS send a list of ring names user item with a AI instance void CIOSRingItfProxy::storeItemNamesForAIInstance(NLNET::IModule *sender, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos) { if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported()) { // immediate local synchronous dispatching _LocalModuleSkel->storeItemNamesForAIInstance(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), aiInstance, itemInfos); } else { // send the message for remote dispatching and execution or local queing NLNET::CMessage __message; buildMessageFor_storeItemNamesForAIInstance(__message, aiInstance, itemInfos); _ModuleProxy->sendModuleMessage(sender, __message); } } // Message serializer. Return the message received in reference for easier integration const NLNET::CMessage &CIOSRingItfProxy::buildMessageFor_storeItemNamesForAIInstance(NLNET::CMessage &__message, uint32 aiInstance, const std::vector < TCharMappedInfo > &itemInfos) { __message.setType("SINFAI"); nlWrite(__message, serial, aiInstance); nlWrite(__message, serialCont, const_cast < std::vector < TCharMappedInfo >& > (itemInfos)); return __message; } }