ryzom/server/src/general_utilities_service/gus_chat.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 //-----------------------------------------------------------------------------
  18 // includes
  19 //-----------------------------------------------------------------------------
  20
  21 #include "gus_chat.h"
  22 #include "nel/misc/command.h"
  23 #include "nel/net/message.h"
  24 #include "nel/net/unified_network.h"
  25 #include "nel/net/service.h"
  26
  27 #include "game_share/singleton_registry.h"
  28 #include "game_share/dyn_chat.h"
  29 #include "game_share/ryzom_entity_id.h"
  30 #include "game_share/synchronised_message.h"
  31 #include "game_share/ios_interface.h"
  32
  33 #include "gus_mirror.h"
  34 #include "gus_client_manager.h"
  35
  36
  37 //-----------------------------------------------------------------------------
  38 // namespaces
  39 //-----------------------------------------------------------------------------
  40
  41 using namespace std;
  42 using namespace NLMISC;
  43 using namespace NLNET;
  44
  45
  46 //-----------------------------------------------------------------------------
  47 // GUS namespace
  48 //-----------------------------------------------------------------------------
  49
  50 namespace GUS
  51 {
  52         //-----------------------------------------------------------------------------
  53         // class CChatChannelImplementation
  54         //-----------------------------------------------------------------------------
  55
  56         class CChatChannelImplementation: public CChatChannel
  57         {
  58                 friend class CChatManagerImplementation;
  59         public:
  60                 CChatChannelImplementation(const NLMISC::CSString &channelName);
  61
  62                 void openChannel(const NLMISC::CSString& channelTitle, uint32 historySize, bool noBroadcast, bool forwardInput, bool autoInsertPlayer);
  63                 void closeChannel();
  64
  65                 void addClient(GUS::TClientId clientId);
  66                 void removeClient(GUS::TClientId clientId);
  67
  68                 void broadcastMessage(const ucstring& speakerName, const ucstring& txt);
  69                 void broadcastMessage(const std::string& speakerNameUtf8, const std::string& txtUtf8);
  70                 void sendMessage(GUS::TClientId clientId, const ucstring& speakerName,const ucstring& txt);
  71                 void sendMessage(GUS::TClientId clientId, const std::string& speakerNameUtf8, const std::string& txtUtf8);
  72
  73                 void setChatCallback(IChatCallback *callback);
  74                 const NLMISC::CSString& getChannelName() const;
  75                 const NLMISC::CSString& getChannelTitle() const;
  76                 void setChannelTitle(const NLMISC::CSString& title);
  77
  78         private:
  79
  80                 IChatCallback*          _ChatCallback;
  81
  82                 NLMISC::CSString        _ChannelName;
  83                 bool                            _ChannelOpen;
  84                 TChanID                         _ChannelID;
  85                 NLMISC::CSString        _ChannelTitle;
  86                 uint32                          _HistorySize;
  87                 bool                            _NoBroadcast;
  88                 bool                            _ForwardInput;
  89                 bool                            _AutoInsertPlayer;
  90
  91                 struct TClientValidation
  92                 {
  93                         GUS::TClientId  ClientId;
  94                         TGameCycle              EntryDate;
  95                 };
  96                 // List of client waiting 'validation' in the chat
  97                 list<TClientValidation> _ClientToValidate;
  98
  99                 NLMISC_COMMAND_FRIEND(chatDisplayChannel);
 100                 NLMISC_COMMAND_FRIEND(chatPlayerInput);
 101         };
 102
 103
 104         //-----------------------------------------------------------------------------
 105         // class CChatManagerImplementation
 106         //-----------------------------------------------------------------------------
 107
 108         class CChatManagerImplementation
 109                 : public CChatManager,
 110                 public CGusMirror::IMirrorModuleCallback,
 111                 public CClientManager::IConnectionHandler,
 112                 public IServiceSingleton
 113         {
 114         private:
 115                 // prohibit instantiation with private ctor
 116                 CChatManagerImplementation();
 117
 118                 //-----------------------------------------------------------------------------
 119                 // specialisation of CGusMirror::IMirrorModuleCallback
 120
 121                 void mirrorIsReady(CGusMirror *mirrorModule) {};
 122                 void serviceMirrorUp(CGusMirror *mirrorModule, const std::string &serviceName, NLNET::TServiceId serviceId);
 123                 void serviceMirrorDown(CGusMirror *mirrorModule, const std::string &serviceName, NLNET::TServiceId serviceId) {};
 124                 void mirrorTickUpdate(CGusMirror *mirrorModule);
 125                 void entityAdded(CGusMirror *mirrorModule, CMirroredDataSet *dataSet, const TDataSetRow &entityIndex) {};
 126                 void entityRemoved(CGusMirror *mirrorModule, CMirroredDataSet *dataSet, const TDataSetRow &entityIndex, const NLMISC::CEntityId *entityId) {};
 127                 void propertyChanged(CGusMirror *mirrorModule, CMirroredDataSet *dataSet, const TDataSetRow &entityIndex, TPropertyIndex propIndex) {};
 128
 129
 130                 //-----------------------------------------------------------------------------
 131                 // specialisation of CClientManager::IConnectionHandler
 132
 133                 void connect(TClientId);
 134                 void disconnect(TClientId);
 135
 136
 137                 //-----------------------------------------------------------------------------
 138                 // specialisation of IServiceSingleton
 139
 140                 void init();
 141
 142
 143         public:
 144                 //-----------------------------------------------------------------------------
 145                 // specialisation of CChatManager
 146
 147                 TChatChannelPtr createChatChannel(const NLMISC::CSString &channelName);
 148                 void removeChannel(CChatChannel *channel);
 149                 TChatChannelPtr getChatChannel(const NLMISC::CSString& channelName);
 150                 bool setChatChannelTitle(CChatChannel *channel,const NLMISC::CSString& channelTitle);
 151
 152
 153                 //-----------------------------------------------------------------------------
 154                 // propriatory public interface
 155
 156                 // get singleton instance
 157                 static CChatManagerImplementation* getInstance();
 158
 159                 uint32                  generateChannelNumber();
 160
 161                 static void             cbDynChatForward( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId );
 162
 163         private:
 164                 //-----------------------------------------------------------------------------
 165                 // private data
 166
 167                 typedef map<CSString, CSmartPtr<CChatChannelImplementation> > TChannels;
 168                 TChannels _Channels;
 169
 170                 /// Channel numbering (incremented for each channel created)
 171                 uint32          _CurrentChannelNumber;
 172
 173
 174                 //-----------------------------------------------------------------------------
 175                 // friendship for associated NLMISC_COMMANDs
 176
 177                 NLMISC_COMMAND_FRIEND(chatCreateChannel);
 178                 NLMISC_COMMAND_FRIEND(chatRemoveChannel);
 179                 NLMISC_COMMAND_FRIEND(chatSendMessage);
 180                 NLMISC_COMMAND_FRIEND(chatDisplayChannel);
 181                 NLMISC_COMMAND_FRIEND(chatPlayerInput);
 182         };
 183
 184         //-----------------------------------------------------------------------------
 185         // NeL service callbacks
 186         //-----------------------------------------------------------------------------
 187         TUnifiedCallbackItem ChatCbArray[]=
 188         {
 189                 {       "DYN_CHAT:FORWARD",                             CChatManagerImplementation::cbDynChatForward},
 190         };
 191
 192         //-----------------------------------------------------------------------------
 193         // methods CChatManagerImplementation
 194         //-----------------------------------------------------------------------------
 195
 196         CChatManagerImplementation::CChatManagerImplementation()
 197                 : _CurrentChannelNumber(0)
 198         {
 199         }
 200
 201         void CChatManagerImplementation::serviceMirrorUp(CGusMirror *mirrorModule, const std::string &serviceName, NLNET::TServiceId serviceId)
 202         {
 203                 if (serviceName == "EGS")
 204                 {
 205                         // open all channel on the EGS server
 206                         TChannels::iterator it(_Channels.begin()), last(_Channels.end());
 207                         for(; it != last; ++it)
 208                         {
 209                                 CChatChannelImplementation *cci = it->second;
 210
 211                                 cci->openChannel(cci->_ChannelTitle, cci->_HistorySize, cci->_NoBroadcast, cci->_ForwardInput, cci->_AutoInsertPlayer);
 212                         }
 213                 }
 214         }
 215
 216         void CChatManagerImplementation::mirrorTickUpdate(CGusMirror *mirrorModule)
 217         {
 218                 // for each channel, update waiting clients
 219
 220                 TGameCycle now = CTickEventHandler::getGameCycle();
 221
 222                 TChannels::iterator it(_Channels.begin()), last(_Channels.end());
 223                 for (; it != last; ++it)
 224                 {
 225                         CChatChannelImplementation *cci = it->second;
 226
 227                         while( !cci->_ClientToValidate.empty()
 228                                 && (cci->_ClientToValidate.front().EntryDate < (now - 50)))
 229                         {
 230                                 if (cci->_ChatCallback != NULL)
 231                                         cci->_ChatCallback->clientReadyInChannel(cci, cci->_ClientToValidate.front().ClientId);
 232
 233                                 cci->_ClientToValidate.pop_front();
 234                         }
 235                 }
 236         }
 237
 238
 239         void CChatManagerImplementation::connect(TClientId client)
 240         {
 241                 // For now, we consider connecting all client in all chat channel
 242                 TChannels::iterator it(_Channels.begin()), last(_Channels.end());
 243                 for (; it != last; ++it)
 244                 {
 245                         CChatChannelImplementation *cci = it->second;
 246
 247                         if (cci->_AutoInsertPlayer ||
 248                                 (cci->_ChatCallback != NULL && cci->_ChatCallback->isClientAllowedInChatChannel(client, cci)))
 249                         {
 250                                 cci->addClient(client);
 251 //                              // add the client into the chat
 252 //                              TChanID         chan = cci->_ChannelID;
 253 //                              bool        writeRight = true;
 254 //
 255 //                              CMessage msgout("DYN_CHAT:ADD_SESSION");
 256 //                              msgout.serial(chan);
 257 //                              msgout.serial(client);
 258 //                              msgout.serial(writeRight);
 259 //
 260 //                              sendMessageViaMirror( "EGS", msgout);
 261 //
 262 //                              CChatChannelImplementation::TClientValidation cv;
 263 //                              cv.ClientId = client;
 264 //                              cv.EntryDate = CTickEventHandler::getGameCycle();
 265 //
 266 //                              cci->_ClientToValidate.push_back(cv);
 267                         }
 268                 }
 269         }
 270
 271         void CChatManagerImplementation::disconnect(TClientId)
 272         {
 273                 // Nothing special to do
 274         }
 275
 276         void CChatManagerImplementation::init()
 277         {
 278                 NLNET::CUnifiedNetwork::getInstance()->addCallbackArray(ChatCbArray, sizeof(ChatCbArray) / sizeof(TUnifiedCallbackItem));
 279
 280                 // Register a callback in client manager
 281                 CClientManager::getInstance()->setConnectionCallback(this);
 282
 283                 // Register a callback in the gus mirror
 284                 CGusMirror::getInstance()->registerModuleCallback(this);
 285         }
 286
 287         CChatManagerImplementation* CChatManagerImplementation::getInstance()
 288         {
 289                 static CChatManagerImplementation* ptr=NULL;
 290                 if (ptr==NULL)
 291                         ptr= new CChatManagerImplementation;
 292                 return ptr;
 293         }
 294
 295         TChatChannelPtr CChatManagerImplementation::createChatChannel(const NLMISC::CSString &channelName)
 296         {
 297                 if (_Channels.find(channelName) != _Channels.end())
 298                 {
 299                         nlwarning("A channel with name '%s' already exist, creation failed", channelName.c_str());
 300                         return NULL;
 301                 }
 302                 CChatChannelImplementation *cc = new CChatChannelImplementation(channelName);
 303                 _Channels[channelName] = cc;
 304
 305                 return cc;
 306         }
 307
 308         void CChatManagerImplementation::removeChannel(CChatChannel *channel)
 309         {
 310                 TChannels::iterator it(_Channels.begin()), last(_Channels.end());
 311
 312                 for (; it != last; ++it)
 313                 {
 314                         if (it->second == (CChatChannelImplementation*)channel)
 315                         {
 316                                 _Channels.erase(it);
 317                                 break;
 318                         }
 319                 }
 320         }
 321
 322         TChatChannelPtr CChatManagerImplementation::getChatChannel(const NLMISC::CSString& channelName)
 323         {
 324                 if (_Channels.find(channelName) == _Channels.end())
 325                 {
 326                         nlwarning("Chat Channel '%s' is unknown", channelName.c_str());
 327                         return TChatChannelPtr();
 328                 }
 329
 330                 return &*_Channels[channelName];
 331         }
 332
 333         bool CChatManagerImplementation::setChatChannelTitle(CChatChannel *channel,const NLMISC::CSString& channelTitle)
 334         {
 335                 bool ok= true;
 336                 CSString title= channelTitle;
 337
 338                 TChannels::iterator it(_Channels.begin()), last(_Channels.end());
 339                 for (; it != last; ++it)
 340                 {
 341                         if (it->second!=NULL && it->second!= (CChatChannelImplementation*)channel &&
 342                                 (it->second->getChannelTitle()==title || it->second->getChannelName()==title) )
 343                         {
 344                                 // the channel title is already assigned to another channel
 345                                 ok= false;
 346                                 title= channel->getChannelName();
 347                                 break;
 348                         }
 349                 }
 350                 channel->setChannelTitle(title);
 351                 return ok;
 352         }
 353
 354         uint32 CChatManagerImplementation::generateChannelNumber()
 355         {
 356                 return _CurrentChannelNumber++;
 357         }
 358
 359
 360         void CChatManagerImplementation::cbDynChatForward( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 361         {
 362                 CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
 363
 364                 // serial the player inputs
 365                 TPlayerInputForward     pif;
 366                 msgin.serial(pif);
 367
 368                 CEntityId eid = CGusMirror::getInstance()->getDataSet("fe_temp")->getEntityId(pif.Sender);
 369
 370                 nldebug("Receiving input '%s' from player %s %s",
 371                         pif.Content.toString().c_str(),
 372                         eid.toString().c_str(),
 373                         pif.Sender.toString().c_str());
 374
 375                 // find the channel to callback the creator
 376                 TChannels::iterator it(cmi->_Channels.begin()), last(cmi->_Channels.end());
 377                 for (; it != last; ++it)
 378                 {
 379                         CChatChannelImplementation *cc = it->second;
 380
 381                         if (cc->_ChannelID == pif.ChanID)
 382                         {
 383                                 nldebug("Forwarding player %s input into channel '%s'",
 384                                         eid.toString().c_str(),
 385                                         cc->_ChannelName.c_str());
 386
 387                                 // ok, we find it !
 388                                 if (cc->_ChatCallback != NULL)
 389                                 {
 390                                         cc->_ChatCallback->receiveMessage(pif.Sender, pif.Content);
 391                                         break;
 392                                 }
 393                         }
 394                 }
 395         }
 396
 397
 398         //-----------------------------------------------------------------------------
 399         // methods CChatManager
 400         //-----------------------------------------------------------------------------
 401
 402         CChatManager* CChatManager::getInstance()
 403         {
 404                 return CChatManagerImplementation::getInstance();
 405         }
 406
 407         //-----------------------------------------------------------------------------
 408         // methods CChatChannelImplementation
 409         //-----------------------------------------------------------------------------
 410
 411         CChatChannelImplementation::CChatChannelImplementation(const CSString &channelName)
 412         :_ChannelOpen(false),
 413         _ChannelName(channelName)
 414         {
 415         }
 416
 417         void CChatChannelImplementation::openChannel(const NLMISC::CSString& channelTitle, uint32 historySize, bool noBroadcast, bool forwardInput, bool autoInsertPlayer)
 418         {
 419                 if (_ChannelOpen)
 420                         return;
 421
 422                 // create the channel id
 423                 uint32 number = CChatManagerImplementation::getInstance()->generateChannelNumber();
 424                 _ChannelID = CEntityId(RYZOMID::dynChatGroup, uint64(number));
 425                 _ChannelTitle = channelTitle;
 426                 _HistorySize = historySize;
 427                 _NoBroadcast = noBroadcast;
 428                 _ForwardInput = forwardInput;
 429                 _AutoInsertPlayer = autoInsertPlayer;
 430
 431                 CMessage        msgout("DYN_CHAT:ADD_SERVICE_CHAN");
 432                 msgout.serial(_ChannelID);
 433                 msgout.serial(_ChannelTitle);
 434                 msgout.serial(_NoBroadcast);
 435                 msgout.serial(_ForwardInput);
 436
 437                 sendMessageViaMirror( "EGS", msgout);
 438
 439                 if (_HistorySize != 0)
 440                 {
 441                         CMessage msgout("DYN_CHAT:SET_CHAN_HISTORY");
 442                         msgout.serial(_ChannelID);
 443                         msgout.serial(_HistorySize);
 444
 445                         sendMessageViaMirror("EGS", msgout);
 446                 }
 447
 448                 _ChannelOpen = true;
 449
 450                 // put all existing client into this new channel
 451                 CMirroredDataSet *ds = CGusMirror::getInstance()->getDataSet("fe_temp");
 452
 453                 TEntityIdToEntityIndexMap::const_iterator it(ds->entityBegin()), last(ds->entityEnd());
 454                 for (; it != last; ++it)
 455                 {
 456                         if (it->first.getType() == RYZOMID::player)
 457                         {
 458                                 TDataSetRow     clientID = ds->getDataSetRow(it->first);
 459
 460                                 if (_AutoInsertPlayer
 461                                         || (_ChatCallback && _ChatCallback->isClientAllowedInChatChannel(clientID, this)))
 462                                 {
 463                                         addClient(clientID);
 464 //                                      // We have a player here, open a session
 465 //
 466 //                                      TChanID         chan = _ChannelID;
 467 //                                      bool        writeRight = true;
 468 //
 469 //                                      CMessage msgout("DYN_CHAT:ADD_SESSION");
 470 //                                      msgout.serial(chan);
 471 //                                      msgout.serial(clientID);
 472 //                                      msgout.serial(writeRight);
 473 //
 474 //                                      sendMessageViaMirror( "EGS", msgout);
 475 //
 476 //                                      TClientValidation cv;
 477 //                                      cv.ClientId = clientID;
 478 //                                      cv.EntryDate = CTickEventHandler::getGameCycle();
 479 //
 480 //                                      _ClientToValidate.push_back(cv);
 481                                 }
 482                         }
 483                 }
 484         }
 485
 486         void CChatChannelImplementation::closeChannel()
 487         {
 488                 if (!_ChannelOpen)
 489                         return;
 490
 491                 CMessage        msgout("DYN_CHAT:REMOVE_SERVICE_CHAN");
 492                 msgout.serial(_ChannelID);
 493
 494                 sendMessageViaMirror( "EGS", msgout);
 495
 496                 _ChannelOpen = false;
 497         }
 498
 499         void CChatChannelImplementation::addClient(GUS::TClientId clientId)
 500         {
 501                 TChanID         chan = _ChannelID;
 502                 bool        writeRight = true;
 503
 504                 CMessage msgout("DYN_CHAT:ADD_SESSION");
 505                 msgout.serial(chan);
 506                 msgout.serial(clientId);
 507                 msgout.serial(writeRight);
 508
 509                 sendMessageViaMirror( "EGS", msgout);
 510
 511                 TClientValidation cv;
 512                 cv.ClientId = clientId;
 513                 cv.EntryDate = CTickEventHandler::getGameCycle();
 514
 515                 _ClientToValidate.push_back(cv);
 516         }
 517
 518         void CChatChannelImplementation::removeClient(GUS::TClientId clientId)
 519         {
 520                 TChanID         chan = _ChannelID;
 521
 522                 CMessage msgout("DYN_CHAT:REMOVE_SESSION");
 523                 msgout.serial(chan);
 524                 msgout.serial(clientId);
 525
 526                 sendMessageViaMirror( "EGS", msgout);
 527         }
 528
 529         void CChatChannelImplementation::broadcastMessage(const ucstring& speakerName, const ucstring& txt)
 530         {
 531                 nldebug("Channel %s : broadcasting \"'%s' says '%s'\"",
 532                         _ChannelTitle.c_str(),
 533                         speakerName.toString().c_str(),
 534                         txt.toString().c_str());
 535
 536                 CMessage msgout("DYN_CHAT:SERVICE_CHAT");
 537                 msgout.serial(_ChannelID);
 538                 msgout.serial(const_cast<ucstring&>(speakerName));
 539                 msgout.serial(const_cast<ucstring&>(txt));
 540
 541                 sendMessageViaMirror( "IOS", msgout);
 542         }
 543
 544         void CChatChannelImplementation::broadcastMessage(const std::string& speakerNameUtf8, const std::string& txtUtf8)
 545         {
 546                 ucstring speakerName, txt;
 547                 speakerName.fromUtf8(speakerNameUtf8);
 548                 txt.fromUtf8(txtUtf8);
 549
 550                 broadcastMessage(speakerName, txt);
 551         }
 552
 553         void CChatChannelImplementation::sendMessage(GUS::TClientId clientId, const ucstring& speakerName,const ucstring& txt)
 554         {
 555                 CEntityId eid = CGusMirror::getInstance()->getDataSet("fe_temp")->getEntityId(clientId);
 556                 nldebug("Channel %s : sending \"'%s' says '%s'\" to client %s",
 557                         _ChannelTitle.c_str(),
 558                         speakerName.toString().c_str(),
 559                         txt.toString().c_str(),
 560                         eid.toString().c_str());
 561
 562                 CMessage msgout("DYN_CHAT:SERVICE_TELL");
 563                 msgout.serial(_ChannelID);
 564                 msgout.serial(const_cast<ucstring&>(speakerName));
 565                 msgout.serial(clientId);
 566                 msgout.serial(const_cast<ucstring&>(txt));
 567
 568                 sendMessageViaMirror( "IOS", msgout);
 569         }
 570
 571         void CChatChannelImplementation::sendMessage(GUS::TClientId clientId, const std::string& speakerNameUtf8, const std::string& txtUtf8)
 572         {
 573                 ucstring speakerName, txt;
 574                 speakerName.fromUtf8(speakerNameUtf8);
 575                 txt.fromUtf8(txtUtf8);
 576
 577                 sendMessage(clientId, speakerName, txt);
 578         }
 579
 580         void CChatChannelImplementation::setChatCallback(IChatCallback* callback)
 581         {
 582                 _ChatCallback = callback;
 583         }
 584
 585         const NLMISC::CSString& CChatChannelImplementation::getChannelName() const
 586         {
 587                 return _ChannelName;
 588         }
 589
 590         const NLMISC::CSString& CChatChannelImplementation::getChannelTitle() const
 591         {
 592                 return _ChannelTitle;
 593         }
 594
 595         void CChatChannelImplementation::setChannelTitle(const NLMISC::CSString& title)
 596         {
 597                 _ChannelTitle= title;
 598                 CIOSMsgSetPhrase(_ChannelName,_ChannelTitle).send();
 599         }
 600
 601
 602         //-----------------------------------------------------------------------------
 603         // CChat instantiator
 604         //-----------------------------------------------------------------------------
 605
 606         class CChatManagerImplementationInstantiator
 607         {
 608         public:
 609                 CChatManagerImplementationInstantiator()
 610                 {
 611                         CChatManagerImplementation::getInstance();
 612                 }
 613         };
 614         static CChatManagerImplementationInstantiator ChatManagerInstantiator;
 615
 616
 617         //-----------------------------------------------------------------------------
 618         // NLMISC_COMMAND commands
 619         //-----------------------------------------------------------------------------
 620
 621         NLMISC_COMMAND(chatCreateChannel, "create a new chat channel", "<channelName> <channelTitle>")
 622         {
 623                 if (args.size() != 2)
 624                         return false;
 625
 626                 CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
 627
 628                 TChatChannelPtr channel = cmi->createChatChannel(args[0]);
 629
 630                 if (channel != NULL)
 631                 {
 632                         channel->openChannel(args[1], 0, true, true, true);
 633                 }
 634                 else
 635                 {
 636                         nlwarning("Failed to create channel '%s'", args[1].c_str());
 637                 }
 638
 639                 return true;
 640         }
 641
 642         NLMISC_COMMAND(chatRemoveChannel, "remove an existing chat channel", "<channelName>")
 643         {
 644                 if (args.size() != 1)
 645                         return false;
 646
 647                 CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
 648
 649                 TChatChannelPtr channel = cmi->getChatChannel(args[0]);
 650
 651                 if (channel == NULL)
 652                 {
 653                         nlwarning ("The channel '%s' is unknow", args[0].c_str());
 654                 }
 655                 else
 656                 {
 657                         channel->closeChannel();
 658                         cmi->removeChannel(channel);
 659                 }
 660
 661                 return true;
 662         }
 663
 664         NLMISC_COMMAND(chatSendMessage, "send a chat message in a channel", "<channelName> <senderName> <text>")
 665         {
 666                 if (args.size() < 3)
 667                         return false;
 668
 669                 CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
 670
 671                 TChatChannelPtr channel = cmi->getChatChannel(args[0]);
 672                 if (channel == NULL)
 673                 {
 674                         nlwarning ("The channel '%s' is unknow", args[0].c_str());
 675                 }
 676                 else
 677                 {
 678                         ucstring text;
 679                         for (uint i=2; i<args.size(); ++i)
 680                                 text += args[i] + " ";
 681                         channel->broadcastMessage(args[1], text);
 682                 }
 683
 684                 return true;
 685         }
 686
 687         NLMISC_COMMAND(chatDisplayChannel, "list all the chat channel and their states", "")
 688         {
 689                 if (!args.empty())
 690                         return false;
 691
 692                 CChatManagerImplementation *cmi = CChatManagerImplementation::getInstance();
 693
 694                 log.displayNL("Listing %u chat channel :", cmi->_Channels.size());
 695                 CChatManagerImplementation::TChannels::iterator it(cmi->_Channels.begin()), last(cmi->_Channels.end());
 696                 for (;it != last; ++it)
 697                 {
 698                         CChatChannelImplementation *cmi = it->second;
 699
 700                         log.displayNL("  Name '%s', Title '%s', ChanId %s, State '%s'",
 701                                 cmi->_ChannelName.c_str(),
 702                                 cmi->_ChannelTitle.c_str(),
 703                                 cmi->_ChannelID.toString().c_str(),
 704                                 cmi->_ChannelOpen ? "OPEN" : "CLOSED");
 705                 }
 706
 707                 return true;
 708         }
 709
 710         NLMISC_COMMAND(chatPlayerInput, "simulate a player input in a channel", "<player_eid> <channelName> <message>+")
 711         {
 712                 if (args.size() < 3)
 713                         return false;
 714
 715                 CEntityId eid(args[0]);
 716                 TDataSetRow index = CGusMirror::getInstance()->getDataSet("fe_temp")->getDataSetRow(eid);
 717                 if (index == INVALID_DATASET_ROW)
 718                 {
 719                         log.displayNL("Unknow player '%s'", eid.toString().c_str());
 720                         return true;
 721                 }
 722
 723                 // Retreive the channel
 724                 TChatChannelPtr channel = CChatManager::getInstance()->getChatChannel(args[1]);
 725                 if (channel == NULL)
 726                 {
 727                         log.displayNL("Unknown channel '%s'", args[1].c_str());
 728                         return true;
 729                 }
 730                 CChatChannelImplementation *cmi = static_cast<CChatChannelImplementation*>(static_cast<CChatChannel*>(channel));
 731
 732                 // concatenate the message
 733                 ucstring txt;
 734                 for (uint i=2; i<args.size(); ++i)
 735                 {
 736                         txt += args[i];
 737                         if (i < args.size() -1)
 738                                 txt += " ";
 739                 }
 740
 741                 TPlayerInputForward pif;
 742                 pif.ChanID = cmi->_ChannelID;
 743                 pif.Content = txt;
 744                 pif.Sender = index;
 745
 746                 CMessage msg("DYN_CHAT:FORWARD");
 747                 msg.serial(pif);
 748                 msg.invert();
 749
 750                 CChatManagerImplementation::getInstance()->cbDynChatForward(msg, IService::getInstance()->getServiceAliasName(), IService::getInstance()->getServiceId());
 751
 752                 return true;
 753         }
 754
 755         //-----------------------------------------------------------------------------
 756         // methods CChatBroadcastDisplayer
 757         //-----------------------------------------------------------------------------
 758
 759         CChatBroadcastDisplayer::CChatBroadcastDisplayer(CChatChannel* channel): IDisplayer("gusChatBroadcast")
 760         {
 761                 _Channel= channel;
 762         }
 763
 764         void CChatBroadcastDisplayer::doDisplay(const NLMISC::CLog::TDisplayInfo& args,const char *message)
 765         {
 766                 _Channel->broadcastMessage("*",message);
 767         }
 768
 769
 770         //-----------------------------------------------------------------------------
 771         // methods CChatDisplayer
 772         //-----------------------------------------------------------------------------
 773
 774         CChatDisplayer::CChatDisplayer(CChatChannel* channel,TClientId clientId): IDisplayer("gusChat")
 775         {
 776                 _Channel=       channel;
 777                 _ClientId=      clientId;
 778         }
 779
 780         void CChatDisplayer::doDisplay(const NLMISC::CLog::TDisplayInfo& args,const char *message)
 781         {
 782                 _Channel->sendMessage(_ClientId,"*",message);
 783         }
 784 }
 785 //-----------------------------------------------------------------------------