ryzom/common/src/game_share/character_sync_itf.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 // WARNING : this is a generated file, don't change it !
  19 /////////////////////////////////////////////////////////////////
  20
  21 #include "stdpch.h"
  22
  23 #include "character_sync_itf.h"
  24
  25 namespace CHARSYNC
  26 {
  27
  28         /////////////////////////////////////////////////////////////////
  29         // WARNING : this is a generated file, don't change it !
  30         /////////////////////////////////////////////////////////////////
  31
  32
  33         const CCharacterSyncSkel::TMessageHandlerMap &CCharacterSyncSkel::getMessageHandlers() const
  34         {
  35                 static TMessageHandlerMap handlers;
  36                 static bool init = false;
  37
  38                 if (!init)
  39                 {
  40                         std::pair < TMessageHandlerMap::iterator, bool > res;
  41
  42                         res = handlers.insert(std::make_pair(std::string("CS_ACH"), &CCharacterSyncSkel::addCharacter_skel));
  43                         // if this assert, you have a doubly message name in your interface definition !
  44                         nlassert(res.second);
  45
  46                         res = handlers.insert(std::make_pair(std::string("CS_DCH"), &CCharacterSyncSkel::deleteCharacter_skel));
  47                         // if this assert, you have a doubly message name in your interface definition !
  48                         nlassert(res.second);
  49
  50                         res = handlers.insert(std::make_pair(std::string("CS_UPDCG"), &CCharacterSyncSkel::updateCharGuild_skel));
  51                         // if this assert, you have a doubly message name in your interface definition !
  52                         nlassert(res.second);
  53
  54                         res = handlers.insert(std::make_pair(std::string("CS_UPDCR"), &CCharacterSyncSkel::updateCharRespawnPoints_skel));
  55                         // if this assert, you have a doubly message name in your interface definition !
  56                         nlassert(res.second);
  57
  58                         res = handlers.insert(std::make_pair(std::string("CS_UPDCL"), &CCharacterSyncSkel::updateCharsBestLevel_skel));
  59                         // if this assert, you have a doubly message name in your interface definition !
  60                         nlassert(res.second);
  61
  62                         res = handlers.insert(std::make_pair(std::string("CS_UPCNF"), &CCharacterSyncSkel::updateCharNewbieFlag_skel));
  63                         // if this assert, you have a doubly message name in your interface definition !
  64                         nlassert(res.second);
  65
  66                         res = handlers.insert(std::make_pair(std::string("CS_UPDCA"), &CCharacterSyncSkel::updateCharAllegiance_skel));
  67                         // if this assert, you have a doubly message name in your interface definition !
  68                         nlassert(res.second);
  69
  70                         res = handlers.insert(std::make_pair(std::string("CS_UPDCHMSI"), &CCharacterSyncSkel::updateCharHomeMainlandSessionId_skel));
  71                         // if this assert, you have a doubly message name in your interface definition !
  72                         nlassert(res.second);
  73
  74                         res = handlers.insert(std::make_pair(std::string("CS_UPDCS"), &CCharacterSyncSkel::syncUserChars_skel));
  75                         // if this assert, you have a doubly message name in your interface definition !
  76                         nlassert(res.second);
  77
  78                         init = true;
  79                 }
  80
  81                 return handlers;
  82         }
  83         bool CCharacterSyncSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
  84         {
  85                 const TMessageHandlerMap &mh = getMessageHandlers();
  86
  87                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
  88
  89                 if (it == mh.end())
  90                 {
  91                         return false;
  92                 }
  93
  94                 TMessageHandler cmd = it->second;
  95                 (this->*cmd)(sender, message);
  96
  97                 return true;
  98         }
  99
 100
 101         void CCharacterSyncSkel::addCharacter_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 102         {
 103                 H_AUTO(CCharacterSyncSkel_addCharacter_CS_ACH);
 104                 TCharInfo       charInfo;
 105                         nlRead(__message, serial, charInfo);
 106                 addCharacter(sender, charInfo);
 107         }
 108
 109         void CCharacterSyncSkel::deleteCharacter_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 110         {
 111                 H_AUTO(CCharacterSyncSkel_deleteCharacter_CS_DCH);
 112                 uint32  charId;
 113                         nlRead(__message, serial, charId);
 114                 deleteCharacter(sender, charId);
 115         }
 116
 117         void CCharacterSyncSkel::updateCharGuild_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 118         {
 119                 H_AUTO(CCharacterSyncSkel_updateCharGuild_CS_UPDCG);
 120                 NLMISC::CEntityId       charEId;
 121                         nlRead(__message, serial, charEId);
 122                 uint32  guildId;
 123                         nlRead(__message, serial, guildId);
 124                 updateCharGuild(sender, charEId, guildId);
 125         }
 126
 127         void CCharacterSyncSkel::updateCharRespawnPoints_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 128         {
 129                 H_AUTO(CCharacterSyncSkel_updateCharRespawnPoints_CS_UPDCR);
 130                 NLMISC::CEntityId       charEId;
 131                         nlRead(__message, serial, charEId);
 132                 CONTINENT::TRespawnPointCounters        respawnPoints;
 133                         nlRead(__message, serialCont, respawnPoints);
 134                 updateCharRespawnPoints(sender, charEId, respawnPoints);
 135         }
 136
 137         void CCharacterSyncSkel::updateCharsBestLevel_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 138         {
 139                 H_AUTO(CCharacterSyncSkel_updateCharsBestLevel_CS_UPDCL);
 140                 std::vector < TCharBestLevelInfo >      charLevelInfos;
 141                         nlRead(__message, serialCont, charLevelInfos);
 142                 updateCharsBestLevel(sender, charLevelInfos);
 143         }
 144
 145         void CCharacterSyncSkel::updateCharNewbieFlag_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 146         {
 147                 H_AUTO(CCharacterSyncSkel_updateCharNewbieFlag_CS_UPCNF);
 148                 NLMISC::CEntityId       charEId;
 149                         nlRead(__message, serial, charEId);
 150                 bool    newbie;
 151                         nlRead(__message, serial, newbie);
 152                 updateCharNewbieFlag(sender, charEId, newbie);
 153         }
 154
 155         void CCharacterSyncSkel::updateCharAllegiance_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 156         {
 157                 H_AUTO(CCharacterSyncSkel_updateCharAllegiance_CS_UPDCA);
 158                 NLMISC::CEntityId       charEId;
 159                         nlRead(__message, serial, charEId);
 160                 TCivilisation   civilisation;
 161                         nlRead(__message, serial, civilisation);
 162                 TCult   cult;
 163                         nlRead(__message, serial, cult);
 164                 updateCharAllegiance(sender, charEId, civilisation, cult);
 165         }
 166
 167         void CCharacterSyncSkel::updateCharHomeMainlandSessionId_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 168         {
 169                 H_AUTO(CCharacterSyncSkel_updateCharHomeMainlandSessionId_CS_UPDCHMSI);
 170                 NLMISC::CEntityId       charEId;
 171                         nlRead(__message, serial, charEId);
 172                 TSessionId      homeMainlandSessionId;
 173                         nlRead(__message, serial, homeMainlandSessionId);
 174                 updateCharHomeMainlandSessionId(sender, charEId, homeMainlandSessionId);
 175         }
 176
 177         void CCharacterSyncSkel::syncUserChars_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 178         {
 179                 H_AUTO(CCharacterSyncSkel_syncUserChars_CS_UPDCS);
 180                 uint32  userId;
 181                         nlRead(__message, serial, userId);
 182                 std::vector < TCharInfo >       charInfos;
 183                         nlRead(__message, serialCont, charInfos);
 184                 syncUserChars(sender, userId, charInfos);
 185         }
 186                 // A new character have been create by a client
 187         void CCharacterSyncProxy::addCharacter(NLNET::IModule *sender, const TCharInfo &charInfo)
 188         {
 189                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 190                 {
 191                         // immediate local synchronous dispatching
 192                         _LocalModuleSkel->addCharacter(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charInfo);
 193                 }
 194                 else
 195                 {
 196                         // send the message for remote dispatching and execution or local queing
 197                         NLNET::CMessage __message;
 198
 199                         buildMessageFor_addCharacter(__message, charInfo);
 200
 201                         _ModuleProxy->sendModuleMessage(sender, __message);
 202                 }
 203         }
 204                 // A character have been deleted
 205         void CCharacterSyncProxy::deleteCharacter(NLNET::IModule *sender, uint32 charId)
 206         {
 207                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 208                 {
 209                         // immediate local synchronous dispatching
 210                         _LocalModuleSkel->deleteCharacter(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId);
 211                 }
 212                 else
 213                 {
 214                         // send the message for remote dispatching and execution or local queing
 215                         NLNET::CMessage __message;
 216
 217                         buildMessageFor_deleteCharacter(__message, charId);
 218
 219                         _ModuleProxy->sendModuleMessage(sender, __message);
 220                 }
 221         }
 222                 // A character guild have changed
 223         void CCharacterSyncProxy::updateCharGuild(NLNET::IModule *sender, const NLMISC::CEntityId &charEId, uint32 guildId)
 224         {
 225                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 226                 {
 227                         // immediate local synchronous dispatching
 228                         _LocalModuleSkel->updateCharGuild(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charEId, guildId);
 229                 }
 230                 else
 231                 {
 232                         // send the message for remote dispatching and execution or local queing
 233                         NLNET::CMessage __message;
 234
 235                         buildMessageFor_updateCharGuild(__message, charEId, guildId);
 236
 237                         _ModuleProxy->sendModuleMessage(sender, __message);
 238                 }
 239         }
 240                 // Update the respawn points count of a character
 241         void CCharacterSyncProxy::updateCharRespawnPoints(NLNET::IModule *sender, const NLMISC::CEntityId &charEId, const CONTINENT::TRespawnPointCounters &respawnPoints)
 242         {
 243                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 244                 {
 245                         // immediate local synchronous dispatching
 246                         _LocalModuleSkel->updateCharRespawnPoints(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charEId, respawnPoints);
 247                 }
 248                 else
 249                 {
 250                         // send the message for remote dispatching and execution or local queing
 251                         NLNET::CMessage __message;
 252
 253                         buildMessageFor_updateCharRespawnPoints(__message, charEId, respawnPoints);
 254
 255                         _ModuleProxy->sendModuleMessage(sender, __message);
 256                 }
 257         }
 258                 // Update the best level for a set of characters
 259         void CCharacterSyncProxy::updateCharsBestLevel(NLNET::IModule *sender, const std::vector < TCharBestLevelInfo > &charLevelInfos)
 260         {
 261                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 262                 {
 263                         // immediate local synchronous dispatching
 264                         _LocalModuleSkel->updateCharsBestLevel(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charLevelInfos);
 265                 }
 266                 else
 267                 {
 268                         // send the message for remote dispatching and execution or local queing
 269                         NLNET::CMessage __message;
 270
 271                         buildMessageFor_updateCharsBestLevel(__message, charLevelInfos);
 272
 273                         _ModuleProxy->sendModuleMessage(sender, __message);
 274                 }
 275         }
 276                 // Update the newbie flag of a characters
 277         void CCharacterSyncProxy::updateCharNewbieFlag(NLNET::IModule *sender, const NLMISC::CEntityId &charEId, bool newbie)
 278         {
 279                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 280                 {
 281                         // immediate local synchronous dispatching
 282                         _LocalModuleSkel->updateCharNewbieFlag(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charEId, newbie);
 283                 }
 284                 else
 285                 {
 286                         // send the message for remote dispatching and execution or local queing
 287                         NLNET::CMessage __message;
 288
 289                         buildMessageFor_updateCharNewbieFlag(__message, charEId, newbie);
 290
 291                         _ModuleProxy->sendModuleMessage(sender, __message);
 292                 }
 293         }
 294                 // Update the allegiance of a characters
 295         void CCharacterSyncProxy::updateCharAllegiance(NLNET::IModule *sender, const NLMISC::CEntityId &charEId, TCivilisation civilisation, TCult cult)
 296         {
 297                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 298                 {
 299                         // immediate local synchronous dispatching
 300                         _LocalModuleSkel->updateCharAllegiance(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charEId, civilisation, cult);
 301                 }
 302                 else
 303                 {
 304                         // send the message for remote dispatching and execution or local queing
 305                         NLNET::CMessage __message;
 306
 307                         buildMessageFor_updateCharAllegiance(__message, charEId, civilisation, cult);
 308
 309                         _ModuleProxy->sendModuleMessage(sender, __message);
 310                 }
 311         }
 312                 // The home mainland has changed (used when converting a character file from an old version)
 313         void CCharacterSyncProxy::updateCharHomeMainlandSessionId(NLNET::IModule *sender, const NLMISC::CEntityId &charEId, TSessionId homeMainlandSessionId)
 314         {
 315                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 316                 {
 317                         // immediate local synchronous dispatching
 318                         _LocalModuleSkel->updateCharHomeMainlandSessionId(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charEId, homeMainlandSessionId);
 319                 }
 320                 else
 321                 {
 322                         // send the message for remote dispatching and execution or local queing
 323                         NLNET::CMessage __message;
 324
 325                         buildMessageFor_updateCharHomeMainlandSessionId(__message, charEId, homeMainlandSessionId);
 326
 327                         _ModuleProxy->sendModuleMessage(sender, __message);
 328                 }
 329         }
 330                 // The characters for a player have been loaded
 331                 // EGS send the full list to SU to make
 332                 // sure any divergence in the database is cleared
 333                 // SU send back the list of character with there
 334                 // unified names and home session ID
 335         void CCharacterSyncProxy::syncUserChars(NLNET::IModule *sender, uint32 userId, const std::vector < TCharInfo > &charInfos)
 336         {
 337                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 338                 {
 339                         // immediate local synchronous dispatching
 340                         _LocalModuleSkel->syncUserChars(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userId, charInfos);
 341                 }
 342                 else
 343                 {
 344                         // send the message for remote dispatching and execution or local queing
 345                         NLNET::CMessage __message;
 346
 347                         buildMessageFor_syncUserChars(__message, userId, charInfos);
 348
 349                         _ModuleProxy->sendModuleMessage(sender, __message);
 350                 }
 351         }
 352
 353         // Message serializer. Return the message received in reference for easier integration
 354         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_addCharacter(NLNET::CMessage &__message, const TCharInfo &charInfo)
 355         {
 356                 __message.setType("CS_ACH");
 357                         nlWrite(__message, serial, const_cast < TCharInfo& > (charInfo));
 358
 359
 360                 return __message;
 361         }
 362
 363         // Message serializer. Return the message received in reference for easier integration
 364         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_deleteCharacter(NLNET::CMessage &__message, uint32 charId)
 365         {
 366                 __message.setType("CS_DCH");
 367                         nlWrite(__message, serial, charId);
 368
 369
 370                 return __message;
 371         }
 372
 373         // Message serializer. Return the message received in reference for easier integration
 374         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_updateCharGuild(NLNET::CMessage &__message, const NLMISC::CEntityId &charEId, uint32 guildId)
 375         {
 376                 __message.setType("CS_UPDCG");
 377                         nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (charEId));
 378                         nlWrite(__message, serial, guildId);
 379
 380
 381                 return __message;
 382         }
 383
 384         // Message serializer. Return the message received in reference for easier integration
 385         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_updateCharRespawnPoints(NLNET::CMessage &__message, const NLMISC::CEntityId &charEId, const CONTINENT::TRespawnPointCounters &respawnPoints)
 386         {
 387                 __message.setType("CS_UPDCR");
 388                         nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (charEId));
 389                         nlWrite(__message, serialCont, const_cast < CONTINENT::TRespawnPointCounters& > (respawnPoints));
 390
 391
 392                 return __message;
 393         }
 394
 395         // Message serializer. Return the message received in reference for easier integration
 396         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_updateCharsBestLevel(NLNET::CMessage &__message, const std::vector < TCharBestLevelInfo > &charLevelInfos)
 397         {
 398                 __message.setType("CS_UPDCL");
 399                         nlWrite(__message, serialCont, const_cast < std::vector < TCharBestLevelInfo >& > (charLevelInfos));
 400
 401
 402                 return __message;
 403         }
 404
 405         // Message serializer. Return the message received in reference for easier integration
 406         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_updateCharNewbieFlag(NLNET::CMessage &__message, const NLMISC::CEntityId &charEId, bool newbie)
 407         {
 408                 __message.setType("CS_UPCNF");
 409                         nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (charEId));
 410                         nlWrite(__message, serial, newbie);
 411
 412
 413                 return __message;
 414         }
 415
 416         // Message serializer. Return the message received in reference for easier integration
 417         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_updateCharAllegiance(NLNET::CMessage &__message, const NLMISC::CEntityId &charEId, TCivilisation civilisation, TCult cult)
 418         {
 419                 __message.setType("CS_UPDCA");
 420                         nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (charEId));
 421                         nlWrite(__message, serial, civilisation);
 422                         nlWrite(__message, serial, cult);
 423
 424
 425                 return __message;
 426         }
 427
 428         // Message serializer. Return the message received in reference for easier integration
 429         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_updateCharHomeMainlandSessionId(NLNET::CMessage &__message, const NLMISC::CEntityId &charEId, TSessionId homeMainlandSessionId)
 430         {
 431                 __message.setType("CS_UPDCHMSI");
 432                         nlWrite(__message, serial, const_cast < NLMISC::CEntityId& > (charEId));
 433                         nlWrite(__message, serial, homeMainlandSessionId);
 434
 435
 436                 return __message;
 437         }
 438
 439         // Message serializer. Return the message received in reference for easier integration
 440         const NLNET::CMessage &CCharacterSyncProxy::buildMessageFor_syncUserChars(NLNET::CMessage &__message, uint32 userId, const std::vector < TCharInfo > &charInfos)
 441         {
 442                 __message.setType("CS_UPDCS");
 443                         nlWrite(__message, serial, userId);
 444                         nlWrite(__message, serialCont, const_cast < std::vector < TCharInfo >& > (charInfos));
 445
 446
 447                 return __message;
 448         }
 449
 450         /////////////////////////////////////////////////////////////////
 451         // WARNING : this is a generated file, don't change it !
 452         /////////////////////////////////////////////////////////////////
 453
 454
 455         const CNameUnifierSkel::TMessageHandlerMap &CNameUnifierSkel::getMessageHandlers() const
 456         {
 457                 static TMessageHandlerMap handlers;
 458                 static bool init = false;
 459
 460                 if (!init)
 461                 {
 462                         std::pair < TMessageHandlerMap::iterator, bool > res;
 463
 464                         res = handlers.insert(std::make_pair(std::string("NU_RNUC"), &CNameUnifierSkel::registerNameUnifierClient_skel));
 465                         // if this assert, you have a doubly message name in your interface definition !
 466                         nlassert(res.second);
 467
 468                         res = handlers.insert(std::make_pair(std::string("NU_VCN"), &CNameUnifierSkel::validateCharacterName_skel));
 469                         // if this assert, you have a doubly message name in your interface definition !
 470                         nlassert(res.second);
 471
 472                         res = handlers.insert(std::make_pair(std::string("NU_ANTC"), &CNameUnifierSkel::assignNameToCharacter_skel));
 473                         // if this assert, you have a doubly message name in your interface definition !
 474                         nlassert(res.second);
 475
 476                         res = handlers.insert(std::make_pair(std::string("NU_RC"), &CNameUnifierSkel::renameCharacter_skel));
 477                         // if this assert, you have a doubly message name in your interface definition !
 478                         nlassert(res.second);
 479
 480                         res = handlers.insert(std::make_pair(std::string("NU_RLGN"), &CNameUnifierSkel::registerLoadedGuildNames_skel));
 481                         // if this assert, you have a doubly message name in your interface definition !
 482                         nlassert(res.second);
 483
 484                         res = handlers.insert(std::make_pair(std::string("NU_VGN"), &CNameUnifierSkel::validateGuildName_skel));
 485                         // if this assert, you have a doubly message name in your interface definition !
 486                         nlassert(res.second);
 487
 488                         res = handlers.insert(std::make_pair(std::string("NU_AG"), &CNameUnifierSkel::addGuild_skel));
 489                         // if this assert, you have a doubly message name in your interface definition !
 490                         nlassert(res.second);
 491
 492                         res = handlers.insert(std::make_pair(std::string("NU_RG"), &CNameUnifierSkel::removeGuild_skel));
 493                         // if this assert, you have a doubly message name in your interface definition !
 494                         nlassert(res.second);
 495
 496                         init = true;
 497                 }
 498
 499                 return handlers;
 500         }
 501         bool CNameUnifierSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 502         {
 503                 const TMessageHandlerMap &mh = getMessageHandlers();
 504
 505                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 506
 507                 if (it == mh.end())
 508                 {
 509                         return false;
 510                 }
 511
 512                 TMessageHandler cmd = it->second;
 513                 (this->*cmd)(sender, message);
 514
 515                 return true;
 516         }
 517
 518
 519         void CNameUnifierSkel::registerNameUnifierClient_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &/* __message */)
 520         {
 521                 H_AUTO(CNameUnifierSkel_registerNameUnifierClient_NU_RNUC);
 522                 registerNameUnifierClient(sender);
 523         }
 524
 525         void CNameUnifierSkel::validateCharacterName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 526         {
 527                 H_AUTO(CNameUnifierSkel_validateCharacterName_NU_VCN);
 528                 uint32  userId;
 529                         nlRead(__message, serial, userId);
 530                 uint8   charIndex;
 531                         nlRead(__message, serial, charIndex);
 532                 std::string     name;
 533                         nlRead(__message, serial, name);
 534                 uint32  homeMainlandSessionId;
 535                         nlRead(__message, serial, homeMainlandSessionId);
 536                 validateCharacterName(sender, userId, charIndex, name, homeMainlandSessionId);
 537         }
 538
 539         void CNameUnifierSkel::assignNameToCharacter_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 540         {
 541                 H_AUTO(CNameUnifierSkel_assignNameToCharacter_NU_ANTC);
 542                 uint32  charId;
 543                         nlRead(__message, serial, charId);
 544                 std::string     name;
 545                         nlRead(__message, serial, name);
 546                 uint32  homeSessionId;
 547                         nlRead(__message, serial, homeSessionId);
 548                 assignNameToCharacter(sender, charId, name, homeSessionId);
 549         }
 550
 551         void CNameUnifierSkel::renameCharacter_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 552         {
 553                 H_AUTO(CNameUnifierSkel_renameCharacter_NU_RC);
 554                 uint32  charId;
 555                         nlRead(__message, serial, charId);
 556                 renameCharacter(sender, charId);
 557         }
 558
 559         void CNameUnifierSkel::registerLoadedGuildNames_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 560         {
 561                 H_AUTO(CNameUnifierSkel_registerLoadedGuildNames_NU_RLGN);
 562                 uint32  chardId;
 563                         nlRead(__message, serial, chardId);
 564                 std::vector < CGuildInfo >      guildInfos;
 565                         nlRead(__message, serialCont, guildInfos);
 566                 registerLoadedGuildNames(sender, chardId, guildInfos);
 567         }
 568
 569         void CNameUnifierSkel::validateGuildName_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 570         {
 571                 H_AUTO(CNameUnifierSkel_validateGuildName_NU_VGN);
 572                 uint32  guildId;
 573                         nlRead(__message, serial, guildId);
 574                 ucstring        guildName;
 575                         nlRead(__message, serial, guildName);
 576                 validateGuildName(sender, guildId, guildName);
 577         }
 578
 579         void CNameUnifierSkel::addGuild_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 580         {
 581                 H_AUTO(CNameUnifierSkel_addGuild_NU_AG);
 582                 uint32  shardId;
 583                         nlRead(__message, serial, shardId);
 584                 uint32  guildId;
 585                         nlRead(__message, serial, guildId);
 586                 ucstring        guildName;
 587                         nlRead(__message, serial, guildName);
 588                 addGuild(sender, shardId, guildId, guildName);
 589         }
 590
 591         void CNameUnifierSkel::removeGuild_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 592         {
 593                 H_AUTO(CNameUnifierSkel_removeGuild_NU_RG);
 594                 uint32  shardId;
 595                         nlRead(__message, serial, shardId);
 596                 uint32  guildId;
 597                         nlRead(__message, serial, guildId);
 598                 removeGuild(sender, shardId, guildId);
 599         }
 600                 // EGS register it's name unifier in order to receive
 601                 // an updated eid to name translation table
 602         void CNameUnifierProxy::registerNameUnifierClient(NLNET::IModule *sender)
 603         {
 604                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 605                 {
 606                         // immediate local synchronous dispatching
 607                         _LocalModuleSkel->registerNameUnifierClient(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender));
 608                 }
 609                 else
 610                 {
 611                         // send the message for remote dispatching and execution or local queing
 612                         NLNET::CMessage __message;
 613
 614                         buildMessageFor_registerNameUnifierClient(__message);
 615
 616                         _ModuleProxy->sendModuleMessage(sender, __message);
 617                 }
 618         }
 619                 // EGS ask to validate a character name
 620                 // If the NU valide the name, it temporary
 621                 // lock it to the associated player.
 622                 // This function is called before character creation.
 623         void CNameUnifierProxy::validateCharacterName(NLNET::IModule *sender, uint32 userId, uint8 charIndex, const std::string &name, uint32 homeMainlandSessionId)
 624         {
 625                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 626                 {
 627                         // immediate local synchronous dispatching
 628                         _LocalModuleSkel->validateCharacterName(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userId, charIndex, name, homeMainlandSessionId);
 629                 }
 630                 else
 631                 {
 632                         // send the message for remote dispatching and execution or local queing
 633                         NLNET::CMessage __message;
 634
 635                         buildMessageFor_validateCharacterName(__message, userId, charIndex, name, homeMainlandSessionId);
 636
 637                         _ModuleProxy->sendModuleMessage(sender, __message);
 638                 }
 639         }
 640                 // EGS ask to assign a name to a character
 641                 // This function is called during character creation
 642         void CNameUnifierProxy::assignNameToCharacter(NLNET::IModule *sender, uint32 charId, const std::string &name, uint32 homeSessionId)
 643         {
 644                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 645                 {
 646                         // immediate local synchronous dispatching
 647                         _LocalModuleSkel->assignNameToCharacter(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, name, homeSessionId);
 648                 }
 649                 else
 650                 {
 651                         // send the message for remote dispatching and execution or local queing
 652                         NLNET::CMessage __message;
 653
 654                         buildMessageFor_assignNameToCharacter(__message, charId, name, homeSessionId);
 655
 656                         _ModuleProxy->sendModuleMessage(sender, __message);
 657                 }
 658         }
 659                 // EGS ask to rename a character.
 660                 // Renaming consist of assigning a default ramdomly generated name to the character
 661         void CNameUnifierProxy::renameCharacter(NLNET::IModule *sender, uint32 charId)
 662         {
 663                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 664                 {
 665                         // immediate local synchronous dispatching
 666                         _LocalModuleSkel->renameCharacter(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId);
 667                 }
 668                 else
 669                 {
 670                         // send the message for remote dispatching and execution or local queing
 671                         NLNET::CMessage __message;
 672
 673                         buildMessageFor_renameCharacter(__message, charId);
 674
 675                         _ModuleProxy->sendModuleMessage(sender, __message);
 676                 }
 677         }
 678                 // EGS send info about the list of loaded guild.
 679                 // The name unifier will update is internal name table if needed
 680                 // and rename any guild having a conflicting name.
 681                 // If any guild is renamed, then the name unifier send back
 682                 // a guildRenamed message to EGS.
 683         void CNameUnifierProxy::registerLoadedGuildNames(NLNET::IModule *sender, uint32 chardId, const std::vector < CGuildInfo > &guildInfos)
 684         {
 685                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 686                 {
 687                         // immediate local synchronous dispatching
 688                         _LocalModuleSkel->registerLoadedGuildNames(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), chardId, guildInfos);
 689                 }
 690                 else
 691                 {
 692                         // send the message for remote dispatching and execution or local queing
 693                         NLNET::CMessage __message;
 694
 695                         buildMessageFor_registerLoadedGuildNames(__message, chardId, guildInfos);
 696
 697                         _ModuleProxy->sendModuleMessage(sender, __message);
 698                 }
 699         }
 700                 // EGS ask to the name unifier to validate a new guild name
 701         void CNameUnifierProxy::validateGuildName(NLNET::IModule *sender, uint32 guildId, const ucstring &guildName)
 702         {
 703                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 704                 {
 705                         // immediate local synchronous dispatching
 706                         _LocalModuleSkel->validateGuildName(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), guildId, guildName);
 707                 }
 708                 else
 709                 {
 710                         // send the message for remote dispatching and execution or local queing
 711                         NLNET::CMessage __message;
 712
 713                         buildMessageFor_validateGuildName(__message, guildId, guildName);
 714
 715                         _ModuleProxy->sendModuleMessage(sender, __message);
 716                 }
 717         }
 718                 // EGS add newly created guild info
 719         void CNameUnifierProxy::addGuild(NLNET::IModule *sender, uint32 shardId, uint32 guildId, const ucstring &guildName)
 720         {
 721                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 722                 {
 723                         // immediate local synchronous dispatching
 724                         _LocalModuleSkel->addGuild(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), shardId, guildId, guildName);
 725                 }
 726                 else
 727                 {
 728                         // send the message for remote dispatching and execution or local queing
 729                         NLNET::CMessage __message;
 730
 731                         buildMessageFor_addGuild(__message, shardId, guildId, guildName);
 732
 733                         _ModuleProxy->sendModuleMessage(sender, __message);
 734                 }
 735         }
 736                 // EGS remove deleted guild info
 737         void CNameUnifierProxy::removeGuild(NLNET::IModule *sender, uint32 shardId, uint32 guildId)
 738         {
 739                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
 740                 {
 741                         // immediate local synchronous dispatching
 742                         _LocalModuleSkel->removeGuild(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), shardId, guildId);
 743                 }
 744                 else
 745                 {
 746                         // send the message for remote dispatching and execution or local queing
 747                         NLNET::CMessage __message;
 748
 749                         buildMessageFor_removeGuild(__message, shardId, guildId);
 750
 751                         _ModuleProxy->sendModuleMessage(sender, __message);
 752                 }
 753         }
 754
 755         // Message serializer. Return the message received in reference for easier integration
 756         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_registerNameUnifierClient(NLNET::CMessage &__message)
 757         {
 758                 __message.setType("NU_RNUC");
 759
 760
 761                 return __message;
 762         }
 763
 764         // Message serializer. Return the message received in reference for easier integration
 765         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_validateCharacterName(NLNET::CMessage &__message, uint32 userId, uint8 charIndex, const std::string &name, uint32 homeMainlandSessionId)
 766         {
 767                 __message.setType("NU_VCN");
 768                         nlWrite(__message, serial, userId);
 769                         nlWrite(__message, serial, charIndex);
 770                         nlWrite(__message, serial, const_cast < std::string& > (name));
 771                         nlWrite(__message, serial, homeMainlandSessionId);
 772
 773
 774                 return __message;
 775         }
 776
 777         // Message serializer. Return the message received in reference for easier integration
 778         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_assignNameToCharacter(NLNET::CMessage &__message, uint32 charId, const std::string &name, uint32 homeSessionId)
 779         {
 780                 __message.setType("NU_ANTC");
 781                         nlWrite(__message, serial, charId);
 782                         nlWrite(__message, serial, const_cast < std::string& > (name));
 783                         nlWrite(__message, serial, homeSessionId);
 784
 785
 786                 return __message;
 787         }
 788
 789         // Message serializer. Return the message received in reference for easier integration
 790         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_renameCharacter(NLNET::CMessage &__message, uint32 charId)
 791         {
 792                 __message.setType("NU_RC");
 793                         nlWrite(__message, serial, charId);
 794
 795
 796                 return __message;
 797         }
 798
 799         // Message serializer. Return the message received in reference for easier integration
 800         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_registerLoadedGuildNames(NLNET::CMessage &__message, uint32 chardId, const std::vector < CGuildInfo > &guildInfos)
 801         {
 802                 __message.setType("NU_RLGN");
 803                         nlWrite(__message, serial, chardId);
 804                         nlWrite(__message, serialCont, const_cast < std::vector < CGuildInfo >& > (guildInfos));
 805
 806
 807                 return __message;
 808         }
 809
 810         // Message serializer. Return the message received in reference for easier integration
 811         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_validateGuildName(NLNET::CMessage &__message, uint32 guildId, const ucstring &guildName)
 812         {
 813                 __message.setType("NU_VGN");
 814                         nlWrite(__message, serial, guildId);
 815                         nlWrite(__message, serial, const_cast < ucstring& > (guildName));
 816
 817
 818                 return __message;
 819         }
 820
 821         // Message serializer. Return the message received in reference for easier integration
 822         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_addGuild(NLNET::CMessage &__message, uint32 shardId, uint32 guildId, const ucstring &guildName)
 823         {
 824                 __message.setType("NU_AG");
 825                         nlWrite(__message, serial, shardId);
 826                         nlWrite(__message, serial, guildId);
 827                         nlWrite(__message, serial, const_cast < ucstring& > (guildName));
 828
 829
 830                 return __message;
 831         }
 832
 833         // Message serializer. Return the message received in reference for easier integration
 834         const NLNET::CMessage &CNameUnifierProxy::buildMessageFor_removeGuild(NLNET::CMessage &__message, uint32 shardId, uint32 guildId)
 835         {
 836                 __message.setType("NU_RG");
 837                         nlWrite(__message, serial, shardId);
 838                         nlWrite(__message, serial, guildId);
 839
 840
 841                 return __message;
 842         }
 843
 844         /////////////////////////////////////////////////////////////////
 845         // WARNING : this is a generated file, don't change it !
 846         /////////////////////////////////////////////////////////////////
 847
 848
 849         const CNameUnifierClientSkel::TMessageHandlerMap &CNameUnifierClientSkel::getMessageHandlers() const
 850         {
 851                 static TMessageHandlerMap handlers;
 852                 static bool init = false;
 853
 854                 if (!init)
 855                 {
 856                         std::pair < TMessageHandlerMap::iterator, bool > res;
 857
 858                         res = handlers.insert(std::make_pair(std::string("NUC_IET"), &CNameUnifierClientSkel::initEIdTranslator_skel));
 859                         // if this assert, you have a doubly message name in your interface definition !
 860                         nlassert(res.second);
 861
 862                         res = handlers.insert(std::make_pair(std::string("NUC_UET"), &CNameUnifierClientSkel::updateEIdTranslator_skel));
 863                         // if this assert, you have a doubly message name in your interface definition !
 864                         nlassert(res.second);
 865
 866                         res = handlers.insert(std::make_pair(std::string("NUC_VCNR"), &CNameUnifierClientSkel::validateCharacterNameResult_skel));
 867                         // if this assert, you have a doubly message name in your interface definition !
 868                         nlassert(res.second);
 869
 870                         res = handlers.insert(std::make_pair(std::string("NUC_ACNR"), &CNameUnifierClientSkel::assignCharacterNameResult_skel));
 871                         // if this assert, you have a doubly message name in your interface definition !
 872                         nlassert(res.second);
 873
 874                         res = handlers.insert(std::make_pair(std::string("NUC_CR"), &CNameUnifierClientSkel::characterRenamed_skel));
 875                         // if this assert, you have a doubly message name in your interface definition !
 876                         nlassert(res.second);
 877
 878                         res = handlers.insert(std::make_pair(std::string("NUC_UCUAV"), &CNameUnifierClientSkel::userCharUpdatedAndValidated_skel));
 879                         // if this assert, you have a doubly message name in your interface definition !
 880                         nlassert(res.second);
 881
 882                         res = handlers.insert(std::make_pair(std::string("NUC_UCSF"), &CNameUnifierClientSkel::userCharSyncFailed_skel));
 883                         // if this assert, you have a doubly message name in your interface definition !
 884                         nlassert(res.second);
 885
 886                         res = handlers.insert(std::make_pair(std::string("NUC_GR"), &CNameUnifierClientSkel::guildRenamed_skel));
 887                         // if this assert, you have a doubly message name in your interface definition !
 888                         nlassert(res.second);
 889
 890                         res = handlers.insert(std::make_pair(std::string("NUC_VGNR"), &CNameUnifierClientSkel::validateGuildNameResult_skel));
 891                         // if this assert, you have a doubly message name in your interface definition !
 892                         nlassert(res.second);
 893
 894                         res = handlers.insert(std::make_pair(std::string("NUC_RCFG"), &CNameUnifierClientSkel::removeCharFromGuild_skel));
 895                         // if this assert, you have a doubly message name in your interface definition !
 896                         nlassert(res.second);
 897
 898                         init = true;
 899                 }
 900
 901                 return handlers;
 902         }
 903         bool CNameUnifierClientSkel::fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message)
 904         {
 905                 const TMessageHandlerMap &mh = getMessageHandlers();
 906
 907                 TMessageHandlerMap::const_iterator it(mh.find(message.getName()));
 908
 909                 if (it == mh.end())
 910                 {
 911                         return false;
 912                 }
 913
 914                 TMessageHandler cmd = it->second;
 915                 (this->*cmd)(sender, message);
 916
 917                 return true;
 918         }
 919
 920
 921         void CNameUnifierClientSkel::initEIdTranslator_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 922         {
 923                 H_AUTO(CNameUnifierClientSkel_initEIdTranslator_NUC_IET);
 924                 bool    firstPacket;
 925                         nlRead(__message, serial, firstPacket);
 926                 bool    lastPacket;
 927                         nlRead(__message, serial, lastPacket);
 928                 std::vector < TNameEntry >      nameEntries;
 929                         nlRead(__message, serialCont, nameEntries);
 930                 initEIdTranslator(sender, firstPacket, lastPacket, nameEntries);
 931         }
 932
 933         void CNameUnifierClientSkel::updateEIdTranslator_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 934         {
 935                 H_AUTO(CNameUnifierClientSkel_updateEIdTranslator_NUC_UET);
 936                 std::vector < uint32 >  releasedNames;
 937                         nlRead(__message, serialCont, releasedNames);
 938                 std::vector < TNameEntry >      changedNames;
 939                         nlRead(__message, serialCont, changedNames);
 940                 updateEIdTranslator(sender, releasedNames, changedNames);
 941         }
 942
 943         void CNameUnifierClientSkel::validateCharacterNameResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 944         {
 945                 H_AUTO(CNameUnifierClientSkel_validateCharacterNameResult_NUC_VCNR);
 946                 CValidateNameResult     nameResult;
 947                         nlRead(__message, serial, nameResult);
 948                 validateCharacterNameResult(sender, nameResult);
 949         }
 950
 951         void CNameUnifierClientSkel::assignCharacterNameResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 952         {
 953                 H_AUTO(CNameUnifierClientSkel_assignCharacterNameResult_NUC_ACNR);
 954                 CValidateNameResult     nameResult;
 955                         nlRead(__message, serial, nameResult);
 956                 assignCharacterNameResult(sender, nameResult);
 957         }
 958
 959         void CNameUnifierClientSkel::characterRenamed_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 960         {
 961                 H_AUTO(CNameUnifierClientSkel_characterRenamed_NUC_CR);
 962                 uint32  charId;
 963                         nlRead(__message, serial, charId);
 964                 std::string     newName;
 965                         nlRead(__message, serial, newName);
 966                 bool    sendSummary;
 967                         nlRead(__message, serial, sendSummary);
 968                 characterRenamed(sender, charId, newName, sendSummary);
 969         }
 970
 971         void CNameUnifierClientSkel::userCharUpdatedAndValidated_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 972         {
 973                 H_AUTO(CNameUnifierClientSkel_userCharUpdatedAndValidated_NUC_UCUAV);
 974                 uint32  userId;
 975                         nlRead(__message, serial, userId);
 976                 std::vector < TCharSyncResultEntry >    charInfos;
 977                         nlRead(__message, serialCont, charInfos);
 978                 userCharUpdatedAndValidated(sender, userId, charInfos);
 979         }
 980
 981         void CNameUnifierClientSkel::userCharSyncFailed_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 982         {
 983                 H_AUTO(CNameUnifierClientSkel_userCharSyncFailed_NUC_UCSF);
 984                 uint32  userId;
 985                         nlRead(__message, serial, userId);
 986                 userCharSyncFailed(sender, userId);
 987         }
 988
 989         void CNameUnifierClientSkel::guildRenamed_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
 990         {
 991                 H_AUTO(CNameUnifierClientSkel_guildRenamed_NUC_GR);
 992                 uint32  guildId;
 993                         nlRead(__message, serial, guildId);
 994                 ucstring        newName;
 995                         nlRead(__message, serial, newName);
 996                 guildRenamed(sender, guildId, newName);
 997         }
 998
 999         void CNameUnifierClientSkel::validateGuildNameResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1000         {
1001                 H_AUTO(CNameUnifierClientSkel_validateGuildNameResult_NUC_VGNR);
1002                 uint32  guildId;
1003                         nlRead(__message, serial, guildId);
1004                 ucstring        guildName;
1005                         nlRead(__message, serial, guildName);
1006                 TCharacterNameResult    result;
1007                         nlRead(__message, serial, result);
1008                 validateGuildNameResult(sender, guildId, guildName, result);
1009         }
1010
1011         void CNameUnifierClientSkel::removeCharFromGuild_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message)
1012         {
1013                 H_AUTO(CNameUnifierClientSkel_removeCharFromGuild_NUC_RCFG);
1014                 uint32  charId;
1015                         nlRead(__message, serial, charId);
1016                 uint32  guildId;
1017                         nlRead(__message, serial, guildId);
1018                 removeCharFromGuild(sender, charId, guildId);
1019         }
1020                 // The name unifier send the initial content for the Eid translator.
1021                 // EGS need to wait until it receive this message before continuing
1022                 // it's startup sequence in order to have coherent name in guild.
1023         void CNameUnifierClientProxy::initEIdTranslator(NLNET::IModule *sender, bool firstPacket, bool lastPacket, const std::vector < TNameEntry > &nameEntries)
1024         {
1025                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1026                 {
1027                         // immediate local synchronous dispatching
1028                         _LocalModuleSkel->initEIdTranslator(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), firstPacket, lastPacket, nameEntries);
1029                 }
1030                 else
1031                 {
1032                         // send the message for remote dispatching and execution or local queing
1033                         NLNET::CMessage __message;
1034
1035                         buildMessageFor_initEIdTranslator(__message, firstPacket, lastPacket, nameEntries);
1036
1037                         _ModuleProxy->sendModuleMessage(sender, __message);
1038                 }
1039         }
1040                 // The name unifier send an update for the EID translator.
1041                 // releasedNames contains a list of charId whose names have been released
1042                 // changedNames contains a list of add or update entries
1043         void CNameUnifierClientProxy::updateEIdTranslator(NLNET::IModule *sender, const std::vector < uint32 > &releasedNames, const std::vector < TNameEntry > &changedNames)
1044         {
1045                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1046                 {
1047                         // immediate local synchronous dispatching
1048                         _LocalModuleSkel->updateEIdTranslator(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), releasedNames, changedNames);
1049                 }
1050                 else
1051                 {
1052                         // send the message for remote dispatching and execution or local queing
1053                         NLNET::CMessage __message;
1054
1055                         buildMessageFor_updateEIdTranslator(__message, releasedNames, changedNames);
1056
1057                         _ModuleProxy->sendModuleMessage(sender, __message);
1058                 }
1059         }
1060                 // The name unifier send the result for validation
1061                 // of a character name before creation.
1062         void CNameUnifierClientProxy::validateCharacterNameResult(NLNET::IModule *sender, const CValidateNameResult &nameResult)
1063         {
1064                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1065                 {
1066                         // immediate local synchronous dispatching
1067                         _LocalModuleSkel->validateCharacterNameResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), nameResult);
1068                 }
1069                 else
1070                 {
1071                         // send the message for remote dispatching and execution or local queing
1072                         NLNET::CMessage __message;
1073
1074                         buildMessageFor_validateCharacterNameResult(__message, nameResult);
1075
1076                         _ModuleProxy->sendModuleMessage(sender, __message);
1077                 }
1078         }
1079                 // The name unifier send the result for name assignment
1080                 // of a new character name during creation.
1081         void CNameUnifierClientProxy::assignCharacterNameResult(NLNET::IModule *sender, const CValidateNameResult &nameResult)
1082         {
1083                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1084                 {
1085                         // immediate local synchronous dispatching
1086                         _LocalModuleSkel->assignCharacterNameResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), nameResult);
1087                 }
1088                 else
1089                 {
1090                         // send the message for remote dispatching and execution or local queing
1091                         NLNET::CMessage __message;
1092
1093                         buildMessageFor_assignCharacterNameResult(__message, nameResult);
1094
1095                         _ModuleProxy->sendModuleMessage(sender, __message);
1096                 }
1097         }
1098                 // The name unifier has renamed a character
1099                 // EGS must do what it need to take the new name into account
1100         void CNameUnifierClientProxy::characterRenamed(NLNET::IModule *sender, uint32 charId, const std::string &newName, bool sendSummary)
1101         {
1102                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1103                 {
1104                         // immediate local synchronous dispatching
1105                         _LocalModuleSkel->characterRenamed(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, newName, sendSummary);
1106                 }
1107                 else
1108                 {
1109                         // send the message for remote dispatching and execution or local queing
1110                         NLNET::CMessage __message;
1111
1112                         buildMessageFor_characterRenamed(__message, charId, newName, sendSummary);
1113
1114                         _ModuleProxy->sendModuleMessage(sender, __message);
1115                 }
1116         }
1117                 // The name unifier has updated/validated/eventualy renamed
1118                 // all the characters send by EGS for a user.
1119                 // EGS can proceed to send the characters summary to client
1120                 // The result message contains the list of all characters
1121                 // with their unified name and home session id from the
1122                 // ring database
1123         void CNameUnifierClientProxy::userCharUpdatedAndValidated(NLNET::IModule *sender, uint32 userId, const std::vector < TCharSyncResultEntry > &charInfos)
1124         {
1125                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1126                 {
1127                         // immediate local synchronous dispatching
1128                         _LocalModuleSkel->userCharUpdatedAndValidated(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userId, charInfos);
1129                 }
1130                 else
1131                 {
1132                         // send the message for remote dispatching and execution or local queing
1133                         NLNET::CMessage __message;
1134
1135                         buildMessageFor_userCharUpdatedAndValidated(__message, userId, charInfos);
1136
1137                         _ModuleProxy->sendModuleMessage(sender, __message);
1138                 }
1139         }
1140                 // The name unifier has failed tp updated/validated/eventualy renamed
1141                 // all the characters send by EGS for a user.
1142                 // EGS can proceed to send the characters summary to client
1143                 // but the character names are perhaps not good ?
1144         void CNameUnifierClientProxy::userCharSyncFailed(NLNET::IModule *sender, uint32 userId)
1145         {
1146                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1147                 {
1148                         // immediate local synchronous dispatching
1149                         _LocalModuleSkel->userCharSyncFailed(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), userId);
1150                 }
1151                 else
1152                 {
1153                         // send the message for remote dispatching and execution or local queing
1154                         NLNET::CMessage __message;
1155
1156                         buildMessageFor_userCharSyncFailed(__message, userId);
1157
1158                         _ModuleProxy->sendModuleMessage(sender, __message);
1159                 }
1160         }
1161                 // The name unifier has renamed a guild to resolve a name conflict
1162         void CNameUnifierClientProxy::guildRenamed(NLNET::IModule *sender, uint32 guildId, const ucstring &newName)
1163         {
1164                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1165                 {
1166                         // immediate local synchronous dispatching
1167                         _LocalModuleSkel->guildRenamed(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), guildId, newName);
1168                 }
1169                 else
1170                 {
1171                         // send the message for remote dispatching and execution or local queing
1172                         NLNET::CMessage __message;
1173
1174                         buildMessageFor_guildRenamed(__message, guildId, newName);
1175
1176                         _ModuleProxy->sendModuleMessage(sender, __message);
1177                 }
1178         }
1179                 // The name unifier respond to EGS about guild name validation request
1180         void CNameUnifierClientProxy::validateGuildNameResult(NLNET::IModule *sender, uint32 guildId, const ucstring &guildName, TCharacterNameResult result)
1181         {
1182                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1183                 {
1184                         // immediate local synchronous dispatching
1185                         _LocalModuleSkel->validateGuildNameResult(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), guildId, guildName, result);
1186                 }
1187                 else
1188                 {
1189                         // send the message for remote dispatching and execution or local queing
1190                         NLNET::CMessage __message;
1191
1192                         buildMessageFor_validateGuildNameResult(__message, guildId, guildName, result);
1193
1194                         _ModuleProxy->sendModuleMessage(sender, __message);
1195                 }
1196         }
1197                 // The unifier has detected an invalid guild/character association
1198                 // and ask to the EGS to remove the character from the guild
1199         void CNameUnifierClientProxy::removeCharFromGuild(NLNET::IModule *sender, uint32 charId, uint32 guildId)
1200         {
1201                 if (_LocalModuleSkel && _LocalModule->isImmediateDispatchingSupported())
1202                 {
1203                         // immediate local synchronous dispatching
1204                         _LocalModuleSkel->removeCharFromGuild(_ModuleProxy->getModuleGateway()->getPluggedModuleProxy(sender), charId, guildId);
1205                 }
1206                 else
1207                 {
1208                         // send the message for remote dispatching and execution or local queing
1209                         NLNET::CMessage __message;
1210
1211                         buildMessageFor_removeCharFromGuild(__message, charId, guildId);
1212
1213                         _ModuleProxy->sendModuleMessage(sender, __message);
1214                 }
1215         }
1216
1217         // Message serializer. Return the message received in reference for easier integration
1218         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_initEIdTranslator(NLNET::CMessage &__message, bool firstPacket, bool lastPacket, const std::vector < TNameEntry > &nameEntries)
1219         {
1220                 __message.setType("NUC_IET");
1221                         nlWrite(__message, serial, firstPacket);
1222                         nlWrite(__message, serial, lastPacket);
1223                         nlWrite(__message, serialCont, const_cast < std::vector < TNameEntry >& > (nameEntries));
1224
1225
1226                 return __message;
1227         }
1228
1229         // Message serializer. Return the message received in reference for easier integration
1230         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_updateEIdTranslator(NLNET::CMessage &__message, const std::vector < uint32 > &releasedNames, const std::vector < TNameEntry > &changedNames)
1231         {
1232                 __message.setType("NUC_UET");
1233                         nlWrite(__message, serialCont, const_cast < std::vector < uint32 >& > (releasedNames));
1234                         nlWrite(__message, serialCont, const_cast < std::vector < TNameEntry >& > (changedNames));
1235
1236
1237                 return __message;
1238         }
1239
1240         // Message serializer. Return the message received in reference for easier integration
1241         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_validateCharacterNameResult(NLNET::CMessage &__message, const CValidateNameResult &nameResult)
1242         {
1243                 __message.setType("NUC_VCNR");
1244                         nlWrite(__message, serial, const_cast < CValidateNameResult& > (nameResult));
1245
1246
1247                 return __message;
1248         }
1249
1250         // Message serializer. Return the message received in reference for easier integration
1251         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_assignCharacterNameResult(NLNET::CMessage &__message, const CValidateNameResult &nameResult)
1252         {
1253                 __message.setType("NUC_ACNR");
1254                         nlWrite(__message, serial, const_cast < CValidateNameResult& > (nameResult));
1255
1256
1257                 return __message;
1258         }
1259
1260         // Message serializer. Return the message received in reference for easier integration
1261         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_characterRenamed(NLNET::CMessage &__message, uint32 charId, const std::string &newName, bool sendSummary)
1262         {
1263                 __message.setType("NUC_CR");
1264                         nlWrite(__message, serial, charId);
1265                         nlWrite(__message, serial, const_cast < std::string& > (newName));
1266                         nlWrite(__message, serial, sendSummary);
1267
1268
1269                 return __message;
1270         }
1271
1272         // Message serializer. Return the message received in reference for easier integration
1273         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_userCharUpdatedAndValidated(NLNET::CMessage &__message, uint32 userId, const std::vector < TCharSyncResultEntry > &charInfos)
1274         {
1275                 __message.setType("NUC_UCUAV");
1276                         nlWrite(__message, serial, userId);
1277                         nlWrite(__message, serialCont, const_cast < std::vector < TCharSyncResultEntry >& > (charInfos));
1278
1279
1280                 return __message;
1281         }
1282
1283         // Message serializer. Return the message received in reference for easier integration
1284         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_userCharSyncFailed(NLNET::CMessage &__message, uint32 userId)
1285         {
1286                 __message.setType("NUC_UCSF");
1287                         nlWrite(__message, serial, userId);
1288
1289
1290                 return __message;
1291         }
1292
1293         // Message serializer. Return the message received in reference for easier integration
1294         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_guildRenamed(NLNET::CMessage &__message, uint32 guildId, const ucstring &newName)
1295         {
1296                 __message.setType("NUC_GR");
1297                         nlWrite(__message, serial, guildId);
1298                         nlWrite(__message, serial, const_cast < ucstring& > (newName));
1299
1300
1301                 return __message;
1302         }
1303
1304         // Message serializer. Return the message received in reference for easier integration
1305         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_validateGuildNameResult(NLNET::CMessage &__message, uint32 guildId, const ucstring &guildName, TCharacterNameResult result)
1306         {
1307                 __message.setType("NUC_VGNR");
1308                         nlWrite(__message, serial, guildId);
1309                         nlWrite(__message, serial, const_cast < ucstring& > (guildName));
1310                         nlWrite(__message, serial, result);
1311
1312
1313                 return __message;
1314         }
1315
1316         // Message serializer. Return the message received in reference for easier integration
1317         const NLNET::CMessage &CNameUnifierClientProxy::buildMessageFor_removeCharFromGuild(NLNET::CMessage &__message, uint32 charId, uint32 guildId)
1318         {
1319                 __message.setType("NUC_RCFG");
1320                         nlWrite(__message, serial, charId);
1321                         nlWrite(__message, serial, guildId);
1322
1323
1324                 return __message;
1325         }
1326
1327 }