mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-11-26 16:56:19 +00:00
785 lines
23 KiB
C++
785 lines
23 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/>.
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// includes
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "gus_chat.h"
|
|
#include "nel/misc/command.h"
|
|
#include "nel/net/message.h"
|
|
#include "nel/net/unified_network.h"
|
|
#include "nel/net/service.h"
|
|
|
|
#include "game_share/singleton_registry.h"
|
|
#include "game_share/dyn_chat.h"
|
|
#include "game_share/ryzom_entity_id.h"
|
|
#include "game_share/synchronised_message.h"
|
|
#include "game_share/ios_interface.h"
|
|
|
|
#include "gus_mirror.h"
|
|
#include "gus_client_manager.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// namespaces
|
|
//-----------------------------------------------------------------------------
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
using namespace NLNET;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// GUS namespace
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace GUS
|
|
{
|
|
//-----------------------------------------------------------------------------
|
|
// class CChatChannelImplementation
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CChatChannelImplementation: public CChatChannel
|
|
{
|
|
friend class CChatManagerImplementation;
|
|
public:
|
|
CChatChannelImplementation(const NLMISC::CSString &channelName);
|
|
|
|
void openChannel(const NLMISC::CSString& channelTitle, uint32 historySize, bool noBroadcast, bool forwardInput, bool autoInsertPlayer);
|
|
void closeChannel();
|
|
|
|
void addClient(GUS::TClientId clientId);
|
|
void removeClient(GUS::TClientId clientId);
|
|
|
|
void broadcastMessage(const ucstring& speakerName, const ucstring& txt);
|
|
void broadcastMessage(const std::string& speakerNameUtf8, const std::string& txtUtf8);
|
|
void sendMessage(GUS::TClientId clientId, const ucstring& speakerName,const ucstring& txt);
|
|
void sendMessage(GUS::TClientId clientId, const std::string& speakerNameUtf8, const std::string& txtUtf8);
|
|
|
|
void setChatCallback(IChatCallback *callback);
|
|
const NLMISC::CSString& getChannelName() const;
|
|
const NLMISC::CSString& getChannelTitle() const;
|
|
void setChannelTitle(const NLMISC::CSString& title);
|
|
|
|
private:
|
|
|
|
IChatCallback* _ChatCallback;
|
|
|
|
NLMISC::CSString _ChannelName;
|
|
bool _ChannelOpen;
|
|
TChanID _ChannelID;
|
|
NLMISC::CSString _ChannelTitle;
|
|
uint32 _HistorySize;
|
|
bool _NoBroadcast;
|
|
bool _ForwardInput;
|
|
bool _AutoInsertPlayer;
|
|
|
|
struct TClientValidation
|
|
{
|
|
GUS::TClientId ClientId;
|
|
TGameCycle EntryDate;
|
|
};
|
|
// List of client waiting 'validation' in the chat
|
|
list<TClientValidation> _ClientToValidate;
|
|
|
|
NLMISC_COMMAND_FRIEND(chatDisplayChannel);
|
|
NLMISC_COMMAND_FRIEND(chatPlayerInput);
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// class CChatManagerImplementation
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CChatManagerImplementation
|
|
: public CChatManager,
|
|
public CGusMirror::IMirrorModuleCallback,
|
|
public CClientManager::IConnectionHandler,
|
|
public IServiceSingleton
|
|
{
|
|
private:
|
|
// prohibit instantiation with private ctor
|
|
CChatManagerImplementation();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// specialisation of CGusMirror::IMirrorModuleCallback
|
|
|
|
void mirrorIsReady(CGusMirror *mirrorModule) {};
|
|
void serviceMirrorUp(CGusMirror *mirrorModule, const std::string &serviceName, NLNET::TServiceId serviceId);
|
|
void serviceMirrorDown(CGusMirror *mirrorModule, const std::string &serviceName, NLNET::TServiceId serviceId) {};
|
|
void mirrorTickUpdate(CGusMirror *mirrorModule);
|
|
void entityAdded(CGusMirror *mirrorModule, CMirroredDataSet *dataSet, const TDataSetRow &entityIndex) {};
|
|
void entityRemoved(CGusMirror *mirrorModule, CMirroredDataSet *dataSet, const TDataSetRow &entityIndex, const NLMISC::CEntityId *entityId) {};
|
|
void propertyChanged(CGusMirror *mirrorModule, CMirroredDataSet *dataSet, const TDataSetRow &entityIndex, TPropertyIndex propIndex) {};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// specialisation of CClientManager::IConnectionHandler
|
|
|
|
void connect(TClientId);
|
|
void disconnect(TClientId);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// specialisation of IServiceSingleton
|
|
|
|
void init();
|
|
|
|
|
|
public:
|
|
//-----------------------------------------------------------------------------
|
|
// specialisation of CChatManager
|
|
|
|
TChatChannelPtr createChatChannel(const NLMISC::CSString &channelName);
|
|
void removeChannel(CChatChannel *channel);
|
|
TChatChannelPtr getChatChannel(const NLMISC::CSString& channelName);
|
|
bool setChatChannelTitle(CChatChannel *channel,const NLMISC::CSString& channelTitle);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// propriatory public interface
|
|
|
|
// get singleton instance
|
|
static CChatManagerImplementation* getInstance();
|
|
|
|
uint32 generateChannelNumber();
|
|
|
|
static void cbDynChatForward( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId );
|
|
|
|
private:
|
|
//-----------------------------------------------------------------------------
|
|
// private data
|
|
|
|
typedef map<CSString, CSmartPtr<CChatChannelImplementation> > TChannels;
|
|
TChannels _Channels;
|
|
|
|
/// Channel numbering (incremented for each channel created)
|
|
uint32 _CurrentChannelNumber;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// friendship for associated NLMISC_COMMANDs
|
|
|
|
NLMISC_COMMAND_FRIEND(chatCreateChannel);
|
|
NLMISC_COMMAND_FRIEND(chatRemoveChannel);
|
|
NLMISC_COMMAND_FRIEND(chatSendMessage);
|
|
NLMISC_COMMAND_FRIEND(chatDisplayChannel);
|
|
NLMISC_COMMAND_FRIEND(chatPlayerInput);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// NeL service callbacks
|
|
//-----------------------------------------------------------------------------
|
|
TUnifiedCallbackItem ChatCbArray[]=
|
|
{
|
|
{ "DYN_CHAT:FORWARD", CChatManagerImplementation::cbDynChatForward},
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// methods CChatManagerImplementation
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CChatManagerImplementation::CChatManagerImplementation()
|
|
: _CurrentChannelNumber(0)
|
|
{
|
|
}
|
|
|
|
void CChatManagerImplementation::serviceMirrorUp(CGusMirror *mirrorModule, const std::string &serviceName, NLNET::TServiceId serviceId)
|
|
{
|
|
if (serviceName == "EGS")
|
|
{
|
|
// open all channel on the EGS server
|
|
TChannels::iterator it(_Channels.begin()), last(_Channels.end());
|
|
for(; it != last; ++it)
|
|
{
|
|
CChatChannelImplementation *cci = it->second;
|
|
|
|
cci->openChannel(cci->_ChannelTitle, cci->_HistorySize, cci->_NoBroadcast, cci->_ForwardInput, cci->_AutoInsertPlayer);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CChatManagerImplementation::mirrorTickUpdate(CGusMirror *mirrorModule)
|
|
{
|
|
// for each channel, update waiting clients
|
|
|
|
TGameCycle now = CTickEventHandler::getGameCycle();
|
|
|
|
TChannels::iterator it(_Channels.begin()), last(_Channels.end());
|
|
for (; it != last; ++it)
|
|
{
|
|
CChatChannelImplementation *cci = it->second;
|
|
|
|
while( !cci->_ClientToValidate.empty()
|
|
&& (cci->_ClientToValidate.front().EntryDate < (now - 50)))
|
|
{
|
|
if (cci->_ChatCallback != NULL)
|
|
cci->_ChatCallback->clientReadyInChannel(cci, cci->_ClientToValidate.front().ClientId);
|
|
|
|
cci->_ClientToValidate.pop_front();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CChatManagerImplementation::connect(TClientId client)
|
|
{
|
|
// For now, we consider connecting all client in all chat channel
|
|
TChannels::iterator it(_Channels.begin()), last(_Channels.end());
|
|
for (; it != last; ++it)
|
|
{
|
|
CChatChannelImplementation *cci = it->second;
|
|
|
|
if (cci->_AutoInsertPlayer ||
|
|
(cci->_ChatCallback != NULL && cci->_ChatCallback->isClientAllowedInChatChannel(client, cci)))
|
|
{
|
|
cci->addClient(client);
|
|
// // add the client into the chat
|
|
// TChanID chan = cci->_ChannelID;
|
|
// bool writeRight = true;
|
|
//
|
|
// CMessage msgout("DYN_CHAT:ADD_SESSION");
|
|
// msgout.serial(chan);
|
|
// msgout.serial(client);
|
|
// msgout.serial(writeRight);
|
|
//
|
|
// sendMessageViaMirror( "EGS", msgout);
|
|
//
|
|
// CChatChannelImplementation::TClientValidation cv;
|
|
// cv.ClientId = client;
|
|
// cv.EntryDate = CTickEventHandler::getGameCycle();
|
|
//
|
|
// cci->_ClientToValidate.push_back(cv);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CChatManagerImplementation::disconnect(TClientId)
|
|
{
|
|
// Nothing special to do
|
|
}
|
|
|
|
void CChatManagerImplementation::init()
|
|
{
|
|
NLNET::CUnifiedNetwork::getInstance()->addCallbackArray(ChatCbArray, sizeof(ChatCbArray) / sizeof(TUnifiedCallbackItem));
|
|
|
|
// Register a callback in client manager
|
|
CClientManager::getInstance()->setConnectionCallback(this);
|
|
|
|
// Register a callback in the gus mirror
|
|
CGusMirror::getInstance()->registerModuleCallback(this);
|
|
}
|
|
|
|
CChatManagerImplementation* CChatManagerImplementation::getInstance()
|
|
{
|
|
static CChatManagerImplementation* ptr=NULL;
|
|
if (ptr==NULL)
|
|
ptr= new CChatManagerImplementation;
|
|
return ptr;
|
|
}
|
|
|
|
TChatChannelPtr CChatManagerImplementation::createChatChannel(const NLMISC::CSString &channelName)
|
|
{
|
|
if (_Channels.find(channelName) != _Channels.end())
|
|
{
|
|
nlwarning("A channel with name '%s' already exist, creation failed", channelName.c_str());
|
|
return NULL;
|
|
}
|
|
CChatChannelImplementation *cc = new CChatChannelImplementation(channelName);
|
|
_Channels[channelName] = cc;
|
|
|
|
return cc;
|
|
}
|
|
|
|
void CChatManagerImplementation::removeChannel(CChatChannel *channel)
|
|
{
|
|
TChannels::iterator it(_Channels.begin()), last(_Channels.end());
|
|
|
|
for (; it != last; ++it)
|
|
{
|
|
if (it->second == (CChatChannelImplementation*)channel)
|
|
{
|
|
_Channels.erase(it);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
TChatChannelPtr CChatManagerImplementation::getChatChannel(const NLMISC::CSString& channelName)
|
|
{
|
|
if (_Channels.find(channelName) == _Channels.end())
|
|
{
|
|
nlwarning("Chat Channel '%s' is unknown", channelName.c_str());
|
|
return TChatChannelPtr();
|
|
}
|
|
|
|
return &*_Channels[channelName];
|
|
}
|
|
|
|
bool CChatManagerImplementation::setChatChannelTitle(CChatChannel *channel,const NLMISC::CSString& channelTitle)
|
|
{
|
|
bool ok= true;
|
|
CSString title= channelTitle;
|
|
|
|
TChannels::iterator it(_Channels.begin()), last(_Channels.end());
|
|
for (; it != last; ++it)
|
|
{
|
|
if (it->second!=NULL && it->second!= (CChatChannelImplementation*)channel &&
|
|
(it->second->getChannelTitle()==title || it->second->getChannelName()==title) )
|
|
{
|
|
// the channel title is already assigned to another channel
|
|
ok= false;
|
|
title= channel->getChannelName();
|
|
break;
|
|
}
|
|
}
|
|
channel->setChannelTitle(title);
|
|
return ok;
|
|
}
|
|
|
|
uint32 CChatManagerImplementation::generateChannelNumber()
|
|
{
|
|
return _CurrentChannelNumber++;
|
|
}
|
|
|
|
|
|
void CChatManagerImplementation::cbDynChatForward( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
|
|
{
|
|
CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
|
|
|
|
// serial the player inputs
|
|
TPlayerInputForward pif;
|
|
msgin.serial(pif);
|
|
|
|
CEntityId eid = CGusMirror::getInstance()->getDataSet("fe_temp")->getEntityId(pif.Sender);
|
|
|
|
nldebug("Receiving input '%s' from player %s %s",
|
|
pif.Content.toString().c_str(),
|
|
eid.toString().c_str(),
|
|
pif.Sender.toString().c_str());
|
|
|
|
// find the channel to callback the creator
|
|
TChannels::iterator it(cmi->_Channels.begin()), last(cmi->_Channels.end());
|
|
for (; it != last; ++it)
|
|
{
|
|
CChatChannelImplementation *cc = it->second;
|
|
|
|
if (cc->_ChannelID == pif.ChanID)
|
|
{
|
|
nldebug("Forwarding player %s input into channel '%s'",
|
|
eid.toString().c_str(),
|
|
cc->_ChannelName.c_str());
|
|
|
|
// ok, we find it !
|
|
if (cc->_ChatCallback != NULL)
|
|
{
|
|
cc->_ChatCallback->receiveMessage(pif.Sender, pif.Content);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// methods CChatManager
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CChatManager* CChatManager::getInstance()
|
|
{
|
|
return CChatManagerImplementation::getInstance();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// methods CChatChannelImplementation
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CChatChannelImplementation::CChatChannelImplementation(const CSString &channelName)
|
|
:_ChannelOpen(false),
|
|
_ChannelName(channelName)
|
|
{
|
|
}
|
|
|
|
void CChatChannelImplementation::openChannel(const NLMISC::CSString& channelTitle, uint32 historySize, bool noBroadcast, bool forwardInput, bool autoInsertPlayer)
|
|
{
|
|
if (_ChannelOpen)
|
|
return;
|
|
|
|
// create the channel id
|
|
uint32 number = CChatManagerImplementation::getInstance()->generateChannelNumber();
|
|
_ChannelID = CEntityId(RYZOMID::dynChatGroup, uint64(number));
|
|
_ChannelTitle = channelTitle;
|
|
_HistorySize = historySize;
|
|
_NoBroadcast = noBroadcast;
|
|
_ForwardInput = forwardInput;
|
|
_AutoInsertPlayer = autoInsertPlayer;
|
|
|
|
CMessage msgout("DYN_CHAT:ADD_SERVICE_CHAN");
|
|
msgout.serial(_ChannelID);
|
|
msgout.serial(_ChannelTitle);
|
|
msgout.serial(_NoBroadcast);
|
|
msgout.serial(_ForwardInput);
|
|
|
|
sendMessageViaMirror( "EGS", msgout);
|
|
|
|
if (_HistorySize != 0)
|
|
{
|
|
CMessage msgout("DYN_CHAT:SET_CHAN_HISTORY");
|
|
msgout.serial(_ChannelID);
|
|
msgout.serial(_HistorySize);
|
|
|
|
sendMessageViaMirror("EGS", msgout);
|
|
}
|
|
|
|
_ChannelOpen = true;
|
|
|
|
// put all existing client into this new channel
|
|
CMirroredDataSet *ds = CGusMirror::getInstance()->getDataSet("fe_temp");
|
|
|
|
TEntityIdToEntityIndexMap::const_iterator it(ds->entityBegin()), last(ds->entityEnd());
|
|
for (; it != last; ++it)
|
|
{
|
|
if (it->first.getType() == RYZOMID::player)
|
|
{
|
|
TDataSetRow clientID = ds->getDataSetRow(it->first);
|
|
|
|
if (_AutoInsertPlayer
|
|
|| (_ChatCallback && _ChatCallback->isClientAllowedInChatChannel(clientID, this)))
|
|
{
|
|
addClient(clientID);
|
|
// // We have a player here, open a session
|
|
//
|
|
// TChanID chan = _ChannelID;
|
|
// bool writeRight = true;
|
|
//
|
|
// CMessage msgout("DYN_CHAT:ADD_SESSION");
|
|
// msgout.serial(chan);
|
|
// msgout.serial(clientID);
|
|
// msgout.serial(writeRight);
|
|
//
|
|
// sendMessageViaMirror( "EGS", msgout);
|
|
//
|
|
// TClientValidation cv;
|
|
// cv.ClientId = clientID;
|
|
// cv.EntryDate = CTickEventHandler::getGameCycle();
|
|
//
|
|
// _ClientToValidate.push_back(cv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CChatChannelImplementation::closeChannel()
|
|
{
|
|
if (!_ChannelOpen)
|
|
return;
|
|
|
|
CMessage msgout("DYN_CHAT:REMOVE_SERVICE_CHAN");
|
|
msgout.serial(_ChannelID);
|
|
|
|
sendMessageViaMirror( "EGS", msgout);
|
|
|
|
_ChannelOpen = false;
|
|
}
|
|
|
|
void CChatChannelImplementation::addClient(GUS::TClientId clientId)
|
|
{
|
|
TChanID chan = _ChannelID;
|
|
bool writeRight = true;
|
|
|
|
CMessage msgout("DYN_CHAT:ADD_SESSION");
|
|
msgout.serial(chan);
|
|
msgout.serial(clientId);
|
|
msgout.serial(writeRight);
|
|
|
|
sendMessageViaMirror( "EGS", msgout);
|
|
|
|
TClientValidation cv;
|
|
cv.ClientId = clientId;
|
|
cv.EntryDate = CTickEventHandler::getGameCycle();
|
|
|
|
_ClientToValidate.push_back(cv);
|
|
}
|
|
|
|
void CChatChannelImplementation::removeClient(GUS::TClientId clientId)
|
|
{
|
|
TChanID chan = _ChannelID;
|
|
|
|
CMessage msgout("DYN_CHAT:REMOVE_SESSION");
|
|
msgout.serial(chan);
|
|
msgout.serial(clientId);
|
|
|
|
sendMessageViaMirror( "EGS", msgout);
|
|
}
|
|
|
|
void CChatChannelImplementation::broadcastMessage(const ucstring& speakerName, const ucstring& txt)
|
|
{
|
|
nldebug("Channel %s : broadcasting \"'%s' says '%s'\"",
|
|
_ChannelTitle.c_str(),
|
|
speakerName.toString().c_str(),
|
|
txt.toString().c_str());
|
|
|
|
CMessage msgout("DYN_CHAT:SERVICE_CHAT");
|
|
msgout.serial(_ChannelID);
|
|
msgout.serial(const_cast<ucstring&>(speakerName));
|
|
msgout.serial(const_cast<ucstring&>(txt));
|
|
|
|
sendMessageViaMirror( "IOS", msgout);
|
|
}
|
|
|
|
void CChatChannelImplementation::broadcastMessage(const std::string& speakerNameUtf8, const std::string& txtUtf8)
|
|
{
|
|
ucstring speakerName, txt;
|
|
speakerName.fromUtf8(speakerNameUtf8);
|
|
txt.fromUtf8(txtUtf8);
|
|
|
|
broadcastMessage(speakerName, txt);
|
|
}
|
|
|
|
void CChatChannelImplementation::sendMessage(GUS::TClientId clientId, const ucstring& speakerName,const ucstring& txt)
|
|
{
|
|
CEntityId eid = CGusMirror::getInstance()->getDataSet("fe_temp")->getEntityId(clientId);
|
|
nldebug("Channel %s : sending \"'%s' says '%s'\" to client %s",
|
|
_ChannelTitle.c_str(),
|
|
speakerName.toString().c_str(),
|
|
txt.toString().c_str(),
|
|
eid.toString().c_str());
|
|
|
|
CMessage msgout("DYN_CHAT:SERVICE_TELL");
|
|
msgout.serial(_ChannelID);
|
|
msgout.serial(const_cast<ucstring&>(speakerName));
|
|
msgout.serial(clientId);
|
|
msgout.serial(const_cast<ucstring&>(txt));
|
|
|
|
sendMessageViaMirror( "IOS", msgout);
|
|
}
|
|
|
|
void CChatChannelImplementation::sendMessage(GUS::TClientId clientId, const std::string& speakerNameUtf8, const std::string& txtUtf8)
|
|
{
|
|
ucstring speakerName, txt;
|
|
speakerName.fromUtf8(speakerNameUtf8);
|
|
txt.fromUtf8(txtUtf8);
|
|
|
|
sendMessage(clientId, speakerName, txt);
|
|
}
|
|
|
|
void CChatChannelImplementation::setChatCallback(IChatCallback* callback)
|
|
{
|
|
_ChatCallback = callback;
|
|
}
|
|
|
|
const NLMISC::CSString& CChatChannelImplementation::getChannelName() const
|
|
{
|
|
return _ChannelName;
|
|
}
|
|
|
|
const NLMISC::CSString& CChatChannelImplementation::getChannelTitle() const
|
|
{
|
|
return _ChannelTitle;
|
|
}
|
|
|
|
void CChatChannelImplementation::setChannelTitle(const NLMISC::CSString& title)
|
|
{
|
|
_ChannelTitle= title;
|
|
CIOSMsgSetPhrase(_ChannelName,_ChannelTitle).send();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CChat instantiator
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CChatManagerImplementationInstantiator
|
|
{
|
|
public:
|
|
CChatManagerImplementationInstantiator()
|
|
{
|
|
CChatManagerImplementation::getInstance();
|
|
}
|
|
};
|
|
static CChatManagerImplementationInstantiator ChatManagerInstantiator;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// NLMISC_COMMAND commands
|
|
//-----------------------------------------------------------------------------
|
|
|
|
NLMISC_COMMAND(chatCreateChannel, "create a new chat channel", "<channelName> <channelTitle>")
|
|
{
|
|
if (args.size() != 2)
|
|
return false;
|
|
|
|
CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
|
|
|
|
TChatChannelPtr channel = cmi->createChatChannel(args[0]);
|
|
|
|
if (channel != NULL)
|
|
{
|
|
channel->openChannel(args[1], 0, true, true, true);
|
|
}
|
|
else
|
|
{
|
|
nlwarning("Failed to create channel '%s'", args[1].c_str());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_COMMAND(chatRemoveChannel, "remove an existing chat channel", "<channelName>")
|
|
{
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
|
|
|
|
TChatChannelPtr channel = cmi->getChatChannel(args[0]);
|
|
|
|
if (channel == NULL)
|
|
{
|
|
nlwarning ("The channel '%s' is unknow", args[0].c_str());
|
|
}
|
|
else
|
|
{
|
|
channel->closeChannel();
|
|
cmi->removeChannel(channel);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_COMMAND(chatSendMessage, "send a chat message in a channel", "<channelName> <senderName> <text>")
|
|
{
|
|
if (args.size() < 3)
|
|
return false;
|
|
|
|
CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
|
|
|
|
TChatChannelPtr channel = cmi->getChatChannel(args[0]);
|
|
if (channel == NULL)
|
|
{
|
|
nlwarning ("The channel '%s' is unknow", args[0].c_str());
|
|
}
|
|
else
|
|
{
|
|
ucstring text;
|
|
for (uint i=2; i<args.size(); ++i)
|
|
text += args[i] + " ";
|
|
channel->broadcastMessage(args[1], text);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_COMMAND(chatDisplayChannel, "list all the chat channel and their states", "")
|
|
{
|
|
if (!args.empty())
|
|
return false;
|
|
|
|
CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
|
|
|
|
log.displayNL("Listing %u chat channel :", cmi->_Channels.size());
|
|
CChatManagerImplementation::TChannels::iterator it(cmi->_Channels.begin()), last(cmi->_Channels.end());
|
|
for (;it != last; ++it)
|
|
{
|
|
CChatChannelImplementation *cmi = it->second;
|
|
|
|
log.displayNL(" Name '%s', Title '%s', ChanId %s, State '%s'",
|
|
cmi->_ChannelName.c_str(),
|
|
cmi->_ChannelTitle.c_str(),
|
|
cmi->_ChannelID.toString().c_str(),
|
|
cmi->_ChannelOpen ? "OPEN" : "CLOSED");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_COMMAND(chatPlayerInput, "simulate a player input in a channel", "<player_eid> <channelName> <message>+")
|
|
{
|
|
if (args.size() < 3)
|
|
return false;
|
|
|
|
CEntityId eid(args[0]);
|
|
TDataSetRow index = CGusMirror::getInstance()->getDataSet("fe_temp")->getDataSetRow(eid);
|
|
if (index == INVALID_DATASET_ROW)
|
|
{
|
|
log.displayNL("Unknow player '%s'", eid.toString().c_str());
|
|
return true;
|
|
}
|
|
|
|
// Retreive the channel
|
|
TChatChannelPtr channel = CChatManager::getInstance()->getChatChannel(args[1]);
|
|
if (channel == NULL)
|
|
{
|
|
log.displayNL("Unknown channel '%s'", args[1].c_str());
|
|
return true;
|
|
}
|
|
CChatChannelImplementation *cmi = static_cast<CChatChannelImplementation*>(static_cast<CChatChannel*>(channel));
|
|
|
|
// concatenate the message
|
|
ucstring txt;
|
|
for (uint i=2; i<args.size(); ++i)
|
|
{
|
|
txt += args[i];
|
|
if (i < args.size() -1)
|
|
txt += " ";
|
|
}
|
|
|
|
TPlayerInputForward pif;
|
|
pif.ChanID = cmi->_ChannelID;
|
|
pif.Content = txt;
|
|
pif.Sender = index;
|
|
|
|
CMessage msg("DYN_CHAT:FORWARD");
|
|
msg.serial(pif);
|
|
msg.invert();
|
|
|
|
CChatManagerImplementation::getInstance()->cbDynChatForward(msg, IService::getInstance()->getServiceAliasName(), IService::getInstance()->getServiceId());
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// methods CChatBroadcastDisplayer
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CChatBroadcastDisplayer::CChatBroadcastDisplayer(CChatChannel* channel): IDisplayer("gusChatBroadcast")
|
|
{
|
|
_Channel= channel;
|
|
}
|
|
|
|
void CChatBroadcastDisplayer::doDisplay(const NLMISC::CLog::TDisplayInfo& args,const char *message)
|
|
{
|
|
_Channel->broadcastMessage("*",message);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// methods CChatDisplayer
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CChatDisplayer::CChatDisplayer(CChatChannel* channel,TClientId clientId): IDisplayer("gusChat")
|
|
{
|
|
_Channel= channel;
|
|
_ClientId= clientId;
|
|
}
|
|
|
|
void CChatDisplayer::doDisplay(const NLMISC::CLog::TDisplayInfo& args,const char *message)
|
|
{
|
|
_Channel->sendMessage(_ClientId,"*",message);
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|