521 lines
20 KiB
C++
521 lines
20 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// WARNING : this is a generated file, don't change it !
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdpch.h"
|
|
|
|
#include "chat_unifier_itf.h"
|
|
|
|
namespace CHATUNI
|
|
{
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// WARNING : this is a generated file, don't change it !
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
|
|
const CChatUnifierSkel::TMessageHandlerMap &CChatUnifierSkel::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("CUSFT"), &CChatUnifierSkel::sendFarTell_skel));
|
|
// if this assert, you have a doubly message name in your interface definition !
|
|
nlassert(res.second);
|
|
|
|
init = true;
|
|
}
|
|
|
|
return handlers;
|
|
}
|
|
bool CChatUnifierSkel::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 CChatUnifierSkel::sendFarTell_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierSkel_sendFarTell_CUSFT);
|
|
NLMISC::CEntityId senderCharId;
|
|
nlRead(__message, serial, senderCharId);
|
|
bool havePrivilege;
|
|
nlRead(__message, serial, havePrivilege);
|
|
ucstring destName;
|
|
nlRead(__message, serial, destName);
|
|
ucstring text;
|
|
nlRead(__message, serial, text);
|
|
sendFarTell(sender, senderCharId, havePrivilege, destName, text);
|
|
}
|
|
// IOS forward a tell message to the unifier
|
|
// If IOS can't find the player localy, it forward
|
|
// the tell to the unifier
|
|
void CChatUnifierProxy::sendFarTell(NLNET::IModule *sender, const NLMISC::CEntityId &senderCharId, bool havePrivilege, const ucstring &destName, const ucstring &text)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->sendFarTell(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderCharId, havePrivilege, destName, text);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_sendFarTell(__message, senderCharId, havePrivilege, destName, text);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierProxy::buildMessageFor_sendFarTell(NLNET::CMessage &__message, const NLMISC::CEntityId &senderCharId, bool havePrivilege, const ucstring &destName, const ucstring &text)
|
|
{
|
|
__message.setType("CUSFT");
|
|
nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (senderCharId));
|
|
nlWrite(__message, serial, havePrivilege);
|
|
nlWrite(__message, serial, const_cast < ucstring& > (destName));
|
|
nlWrite(__message, serial, const_cast < ucstring& > (text));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
// WARNING : this is a generated file, don't change it !
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
|
|
const CChatUnifierClientSkel::TMessageHandlerMap &CChatUnifierClientSkel::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("CURFTF"), &CChatUnifierClientSkel::recvFarTellFail_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("CURFT"), &CChatUnifierClientSkel::recvFarTell_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("CURFGC"), &CChatUnifierClientSkel::farGuildChat_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("CURFGC2"), &CChatUnifierClientSkel::farGuildChat2_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("CURFGC2E"), &CChatUnifierClientSkel::farGuildChat2Ex_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("CURUB"), &CChatUnifierClientSkel::universeBroadcast_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("CUDCB"), &CChatUnifierClientSkel::dynChanBroadcast_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("CURBM"), &CChatUnifierClientSkel::recvBroadcastMessage_skel));
|
|
// if this assert, you have a doubly message name in your interface definition !
|
|
nlassert(res.second);
|
|
|
|
init = true;
|
|
}
|
|
|
|
return handlers;
|
|
}
|
|
bool CChatUnifierClientSkel::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 CChatUnifierClientSkel::recvFarTellFail_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_recvFarTellFail_CURFTF);
|
|
NLMISC::CEntityId senderCharId;
|
|
nlRead(__message, serial, senderCharId);
|
|
ucstring destName;
|
|
nlRead(__message, serial, destName);
|
|
TFailInfo failInfo;
|
|
nlRead(__message, serial, failInfo);
|
|
recvFarTellFail(sender, senderCharId, destName, failInfo);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::recvFarTell_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_recvFarTell_CURFT);
|
|
NLMISC::CEntityId senderCharId;
|
|
nlRead(__message, serial, senderCharId);
|
|
ucstring senderName;
|
|
nlRead(__message, serial, senderName);
|
|
bool havePrivilege;
|
|
nlRead(__message, serial, havePrivilege);
|
|
ucstring destName;
|
|
nlRead(__message, serial, destName);
|
|
ucstring text;
|
|
nlRead(__message, serial, text);
|
|
recvFarTell(sender, senderCharId, senderName, havePrivilege, destName, text);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::farGuildChat_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_farGuildChat_CURFGC);
|
|
ucstring senderName;
|
|
nlRead(__message, serial, senderName);
|
|
uint32 guildId;
|
|
nlRead(__message, serial, guildId);
|
|
ucstring text;
|
|
nlRead(__message, serial, text);
|
|
farGuildChat(sender, senderName, guildId, text);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::farGuildChat2_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_farGuildChat2_CURFGC2);
|
|
ucstring senderName;
|
|
nlRead(__message, serial, senderName);
|
|
uint32 guildId;
|
|
nlRead(__message, serial, guildId);
|
|
ucstring phraseName;
|
|
nlRead(__message, serial, phraseName);
|
|
farGuildChat2(sender, senderName, guildId, phraseName);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::farGuildChat2Ex_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_farGuildChat2Ex_CURFGC2E);
|
|
ucstring senderName;
|
|
nlRead(__message, serial, senderName);
|
|
uint32 guildId;
|
|
nlRead(__message, serial, guildId);
|
|
uint32 phraseId;
|
|
nlRead(__message, serial, phraseId);
|
|
farGuildChat2Ex(sender, senderName, guildId, phraseId);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::universeBroadcast_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_universeBroadcast_CURUB);
|
|
ucstring senderName;
|
|
nlRead(__message, serial, senderName);
|
|
uint32 senderHomeSession;
|
|
nlRead(__message, serial, senderHomeSession);
|
|
ucstring text;
|
|
nlRead(__message, serial, text);
|
|
universeBroadcast(sender, senderName, senderHomeSession, text);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::dynChanBroadcast_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_dynChanBroadcast_CUDCB);
|
|
NLMISC::CEntityId chanId;
|
|
nlRead(__message, serial, chanId);
|
|
ucstring senderName;
|
|
nlRead(__message, serial, senderName);
|
|
ucstring text;
|
|
nlRead(__message, serial, text);
|
|
dynChanBroadcast(sender, chanId, senderName, text);
|
|
}
|
|
|
|
void CChatUnifierClientSkel::recvBroadcastMessage_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
|
|
{
|
|
H_AUTO(CChatUnifierClientSkel_recvBroadcastMessage_CURBM);
|
|
ucstring message;
|
|
nlRead(__message, serial, message);
|
|
recvBroadcastMessage(sender, message);
|
|
}
|
|
// SU send a far tell failure to IOS. This mean that the player is offline or unknow
|
|
void CChatUnifierClientProxy::recvFarTellFail(NLNET::IModule *sender, const NLMISC::CEntityId &senderCharId, const ucstring &destName, TFailInfo failInfo)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->recvFarTellFail(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderCharId, destName, failInfo);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_recvFarTellFail(__message, senderCharId, destName, failInfo);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// SU send a far tell to the IOS hosting the addresse character
|
|
void CChatUnifierClientProxy::recvFarTell(NLNET::IModule *sender, const NLMISC::CEntityId &senderCharId, const ucstring &senderName, bool havePrivilege, const ucstring &destName, const ucstring &text)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->recvFarTell(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderCharId, senderName, havePrivilege, destName, text);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_recvFarTell(__message, senderCharId, senderName, havePrivilege, destName, text);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// IOS forward a guild chat message to the IOS
|
|
void CChatUnifierClientProxy::farGuildChat(NLNET::IModule *sender, const ucstring &senderName, uint32 guildId, const ucstring &text)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->farGuildChat(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderName, guildId, text);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_farGuildChat(__message, senderName, guildId, text);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// IOS forward a guild chat message to the IOS
|
|
void CChatUnifierClientProxy::farGuildChat2(NLNET::IModule *sender, const ucstring &senderName, uint32 guildId, const ucstring &phraseName)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->farGuildChat2(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderName, guildId, phraseName);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_farGuildChat2(__message, senderName, guildId, phraseName);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// IOS forward a guild chat message to the IOS
|
|
void CChatUnifierClientProxy::farGuildChat2Ex(NLNET::IModule *sender, const ucstring &senderName, uint32 guildId, uint32 phraseId)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->farGuildChat2Ex(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderName, guildId, phraseId);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_farGuildChat2Ex(__message, senderName, guildId, phraseId);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// IOS forward a univers chat message to the IOSs
|
|
void CChatUnifierClientProxy::universeBroadcast(NLNET::IModule *sender, const ucstring &senderName, uint32 senderHomeSession, const ucstring &text)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->universeBroadcast(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), senderName, senderHomeSession, text);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_universeBroadcast(__message, senderName, senderHomeSession, text);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// IOS forward a dyn chat chat message to the IOSs
|
|
void CChatUnifierClientProxy::dynChanBroadcast(NLNET::IModule *sender, const NLMISC::CEntityId &chanId, const ucstring &senderName, const ucstring &text)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->dynChanBroadcast(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), chanId, senderName, text);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_dynChanBroadcast(__message, chanId, senderName, text);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
// SU send a broadcast message to the IOS
|
|
void CChatUnifierClientProxy::recvBroadcastMessage(NLNET::IModule *sender, const ucstring &message)
|
|
{
|
|
if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
|
|
{
|
|
// immediate local synchronous dispatching
|
|
_LocalModuleSkel->recvBroadcastMessage(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), message);
|
|
}
|
|
else
|
|
{
|
|
// send the message for remote dispatching and execution or local queing
|
|
NLNET::CMessage __message;
|
|
|
|
buildMessageFor_recvBroadcastMessage(__message, message);
|
|
|
|
_ModuleProxy->sendModuleMessage(sender, __message);
|
|
}
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_recvFarTellFail(NLNET::CMessage &__message, const NLMISC::CEntityId &senderCharId, const ucstring &destName, TFailInfo failInfo)
|
|
{
|
|
__message.setType("CURFTF");
|
|
nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (senderCharId));
|
|
nlWrite(__message, serial, const_cast < ucstring& > (destName));
|
|
nlWrite(__message, serial, failInfo);
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_recvFarTell(NLNET::CMessage &__message, const NLMISC::CEntityId &senderCharId, const ucstring &senderName, bool havePrivilege, const ucstring &destName, const ucstring &text)
|
|
{
|
|
__message.setType("CURFT");
|
|
nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (senderCharId));
|
|
nlWrite(__message, serial, const_cast < ucstring& > (senderName));
|
|
nlWrite(__message, serial, havePrivilege);
|
|
nlWrite(__message, serial, const_cast < ucstring& > (destName));
|
|
nlWrite(__message, serial, const_cast < ucstring& > (text));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_farGuildChat(NLNET::CMessage &__message, const ucstring &senderName, uint32 guildId, const ucstring &text)
|
|
{
|
|
__message.setType("CURFGC");
|
|
nlWrite(__message, serial, const_cast < ucstring& > (senderName));
|
|
nlWrite(__message, serial, guildId);
|
|
nlWrite(__message, serial, const_cast < ucstring& > (text));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_farGuildChat2(NLNET::CMessage &__message, const ucstring &senderName, uint32 guildId, const ucstring &phraseName)
|
|
{
|
|
__message.setType("CURFGC2");
|
|
nlWrite(__message, serial, const_cast < ucstring& > (senderName));
|
|
nlWrite(__message, serial, guildId);
|
|
nlWrite(__message, serial, const_cast < ucstring& > (phraseName));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_farGuildChat2Ex(NLNET::CMessage &__message, const ucstring &senderName, uint32 guildId, uint32 phraseId)
|
|
{
|
|
__message.setType("CURFGC2E");
|
|
nlWrite(__message, serial, const_cast < ucstring& > (senderName));
|
|
nlWrite(__message, serial, guildId);
|
|
nlWrite(__message, serial, phraseId);
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_universeBroadcast(NLNET::CMessage &__message, const ucstring &senderName, uint32 senderHomeSession, const ucstring &text)
|
|
{
|
|
__message.setType("CURUB");
|
|
nlWrite(__message, serial, const_cast < ucstring& > (senderName));
|
|
nlWrite(__message, serial, senderHomeSession);
|
|
nlWrite(__message, serial, const_cast < ucstring& > (text));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_dynChanBroadcast(NLNET::CMessage &__message, const NLMISC::CEntityId &chanId, const ucstring &senderName, const ucstring &text)
|
|
{
|
|
__message.setType("CUDCB");
|
|
nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (chanId));
|
|
nlWrite(__message, serial, const_cast < ucstring& > (senderName));
|
|
nlWrite(__message, serial, const_cast < ucstring& > (text));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
// Message serializer. Return the message received in reference for easier integration
|
|
const NLNET::CMessage &CChatUnifierClientProxy::buildMessageFor_recvBroadcastMessage(NLNET::CMessage &__message, const ucstring &message)
|
|
{
|
|
__message.setType("CURBM");
|
|
nlWrite(__message, serial, const_cast < ucstring& > (message));
|
|
|
|
|
|
return __message;
|
|
}
|
|
|
|
}
|