nel/src/misc/eid_translator.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010-2019  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 //
  21 // Includes
  22 //
  23
  24 #include "stdmisc.h"
  25
  26 #include "nel/misc/algo.h"
  27 #include "nel/misc/file.h"
  28 #include "nel/misc/path.h"
  29 #include "nel/misc/command.h"
  30 #include "nel/misc/types_nl.h"
  31 #include "nel/misc/entity_id.h"
  32 #include "nel/misc/eid_translator.h"
  33 #include "nel/misc/hierarchical_timer.h"
  34
  35 using namespace std;
  36
  37 #ifdef DEBUG_NEW
  38         #define new DEBUG_NEW
  39 #endif
  40
  41 namespace NLMISC {
  42
  43 //
  44 // Variables
  45 //
  46
  47 //CEntityIdTranslator *CEntityIdTranslator::Instance = NULL;
  48 NLMISC_SAFE_SINGLETON_IMPL(CEntityIdTranslator);
  49
  50 // don't forget to increment the number when you change the file format
  51 const uint CEntityIdTranslator::Version = 1;
  52
  53 //
  54 // Functions
  55 //
  56
  57 void CEntityIdTranslator::CEntity::serial (NLMISC::IStream &s)
  58 {
  59         H_AUTO(EIdTrans_serial);
  60         s.serial (EntityName);
  61
  62         if (CEntityIdTranslator::getInstance()->FileVersion >= 1)
  63                 s.serial (EntitySlot);
  64         else
  65         {
  66                 if(s.isReading())
  67                 {
  68                         EntitySlot = -1;
  69                 }
  70                 else
  71                 {
  72                         sint8 slot = -1;
  73                         s.serial (slot);
  74                 }
  75         }
  76         s.serial (UId);
  77         s.serial (UserName);
  78 }
  79
  80 //CEntityIdTranslator *CEntityIdTranslator::getInstance ()
  81 //{
  82 //      if(Instance == NULL)
  83 //      {
  84 //              Instance = new CEntityIdTranslator;
  85 //      }
  86 //      return Instance;
  87 //}
  88
  89 void CEntityIdTranslator::getByUser (uint32 uid, vector<CEntityId> &res)
  90 {
  91         H_AUTO(EIdTrans_getByUser);
  92         for (TEntityCont::iterator it = RegisteredEntities.begin(); it != RegisteredEntities.end(); it++)
  93         {
  94                 CEntity &entity = it->second;
  95                 if (entity.UId == uid)
  96                 {
  97                         res.push_back(it->first);
  98                 }
  99         }
 100 }
 101
 102 void CEntityIdTranslator::getByUser (const string &userName, vector<CEntityId> &res, bool exact)
 103 {
 104         H_AUTO(EIdTrans_getByUser2);
 105         string lowerName = toLower(userName);
 106
 107         for (TEntityCont::iterator it = RegisteredEntities.begin(); it != RegisteredEntities.end(); it++)
 108         {
 109                 if (exact)
 110                 {
 111                         CEntity &entity = it->second;
 112                         if (toLower(entity.UserName) == lowerName)
 113                         {
 114                                 res.push_back(it->first);
 115                         }
 116                 }
 117                 else
 118                 {
 119                         CEntity &entity = it->second;
 120                         if (toLower(entity.UserName).find(lowerName) != string::npos)
 121                         {
 122                                 res.push_back(it->first);
 123                         }
 124                 }
 125         }
 126 }
 127
 128 const ucstring &CEntityIdTranslator::getByEntity (const CEntityId &eid)
 129 {
 130         H_AUTO(EIdTrans_getByEntity);
 131         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 132         CEntityId reid(eid);
 133         reid.setCreatorId(0);
 134         reid.setDynamicId(0);
 135
 136         TEntityCont::iterator it = RegisteredEntities.find (reid);
 137         if (it == RegisteredEntities.end ())
 138         {
 139                 static ucstring emptyString;
 140                 return emptyString;
 141         }
 142         else
 143         {
 144                 CEntity &entity = it->second;
 145                 return entity.EntityName;
 146         }
 147 }
 148
 149 CEntityId CEntityIdTranslator::getByEntity (const ucstring &entityName)
 150 {
 151         H_AUTO(EIdTrans_getByEntity2);
 152         vector<CEntityId> res;
 153         getByEntity (entityName, res, true);
 154         if (res.empty())
 155                 return CEntityId::Unknown;
 156         else
 157                 return res[0];
 158 }
 159
 160 void CEntityIdTranslator::getByEntity (const ucstring &entityName, vector<CEntityId> &res, bool exact)
 161 {
 162         H_AUTO(EIdTrans_getByEntity3);
 163         string lowerName = toLower(entityName.toString());
 164
 165         if (exact)
 166         {
 167                 // use the reverse index to speed up search
 168                 TNameIndexCont::iterator it(NameIndex.find(lowerName));
 169                 if (it != NameIndex.end())
 170                         res.push_back(it->second);
 171
 172                 return;
 173         }
 174         // parse the entire container to match all entities
 175         for (TEntityCont::iterator it = RegisteredEntities.begin(); it != RegisteredEntities.end(); ++it)
 176         {
 177                 CEntity &entity = it->second;
 178                 if (toLower(entity.EntityName.toString()).find(lowerName) != string::npos)
 179                 {
 180                         res.push_back(it->first);
 181                 }
 182         }
 183 }
 184
 185 bool CEntityIdTranslator::isValidEntityName (const ucstring &entityName,CLog *log)
 186 {
 187         H_AUTO(EIdTrans_isValidEntityName);
 188         // 3 char at least
 189         if (entityName.size() < 3)
 190         {
 191                 log->displayNL("Bad entity name '%s' (less than 3 char)", entityName.toString().c_str());
 192                 return false;
 193         }
 194
 195         if (entityName.size() > 15)
 196         {
 197                 // if a parenthesis is found before 15 chars, the name is valid
 198                 if (entityName.find(ucstring("(")) > 15 || entityName[entityName.size()-1] != ucchar(')'))
 199                 {
 200                         log->displayNL("EIT: Bad entity name '%s' (more than 15 char)", entityName.toString().c_str());
 201                         return false;
 202                 }
 203         }
 204
 205         bool allowNumeric = false;
 206         for (uint i = 0; i < entityName.size(); i++)
 207         {
 208                 if (entityName[i] == '(')
 209                 {
 210                         // starting from shard name, allow alphanumeric character
 211                         allowNumeric = true;
 212                 }
 213                 // only accept name with alphabetic and numeric value [a-zA-Z] and parenthesis
 214                 if (!allowNumeric && !isalpha (entityName[i]) && entityName[i] != '(' && entityName[i] != ')')
 215                 {
 216                         log->displayNL("Bad entity name '%s' (only char and num)", entityName.toString().c_str());
 217                         return false;
 218                 }
 219         }
 220
 221         // now check with the invalid name list
 222         string en = getRegisterableString( entityName );
 223
 224         for (uint i = 0; i < InvalidEntityNames.size(); i++)
 225         {
 226                 if(testWildCard(en, InvalidEntityNames[i]))
 227                 {
 228                         log->displayNL("Bad entity name '%s' (match the invalid entity name pattern '%s')", entityName.toString().c_str(), InvalidEntityNames[i].c_str());
 229                         return false;
 230                 }
 231         }
 232
 233         return true;
 234 }
 235
 236 void CEntityIdTranslator::clear()
 237 {
 238         NameIndex.clear();
 239         RegisteredEntities.clear();
 240 }
 241
 242
 243 bool CEntityIdTranslator::checkEntityName (const ucstring &entityName )
 244 {
 245         H_AUTO(EIdTrans_entityNameExists);
 246         // if bad name, don't accept it
 247         if (!isValidEntityName (entityName,NLMISC::InfoLog)) return false;
 248         return !entityNameExists( entityName );
 249 }
 250
 251 bool CEntityIdTranslator::entityNameExists (const ucstring &entityName )
 252 {
 253         // Names are stored in case dependant, so we have to test them without case.
 254         ucstring registerable = getRegisterableString (entityName);
 255
 256         return NameIndex.find(registerable) !=NameIndex.end();
 257 /*      for (TEntityCont::iterator it = RegisteredEntities.begin(); it != RegisteredEntities.end(); it++)
 258         {
 259                 if (getRegisterableString ((*it).second.EntityName) == registerable)
 260                 {
 261                         return true;
 262                 }
 263         }
 264         return false;
 265 */
 266 }
 267
 268 void CEntityIdTranslator::registerEntity (const CEntityId &eid, const ucstring &entityName, sint8 entitySlot, uint32 uid, const string &userName, uint32 shardId)
 269 {
 270         H_AUTO(EIdTrans_registerEntity);
 271         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 272         CEntityId reid(eid);
 273         reid.setCreatorId(0);
 274         reid.setDynamicId(0);
 275
 276         if (RegisteredEntities.find (reid) != RegisteredEntities.end ())
 277         {
 278                 nlwarning ("EIT: Can't register EId %s EntityName '%s' UId %d UserName '%s' because EId is already in the map", reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 279                 return;
 280         }
 281
 282         if (!checkEntityName(entityName))
 283         {
 284                 if (isValidEntityName(entityName))
 285                         nlwarning ("EIT: Can't register EId %s EntityName '%s' UId %d UserName '%s' because EntityName is already in the map", reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 286                 else
 287                         nlwarning ("EIT: Can't register EId %s EntityName '%s' UId %d UserName '%s' because EntityName is invalid", reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 288                 return;
 289         }
 290
 291         //nlinfo ("EIT: Register EId %s EntityName '%s' UId %d UserName '%s'", reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 292         RegisteredEntities.insert (make_pair(reid, CEntityIdTranslator::CEntity(entityName, uid, userName, entitySlot, shardId)));
 293         NameIndex.insert(make_pair(toLower(entityName), reid));
 294 }
 295
 296 void CEntityIdTranslator::updateEntity (const CEntityId &eid, const ucstring &entityName, sint8 entitySlot, uint32 uid, const std::string &userName, uint32 shardId)
 297 {
 298         CEntityId reid(eid);
 299         reid.setCreatorId(0);
 300         reid.setDynamicId(0);
 301
 302         TEntityCont::iterator it = RegisteredEntities.find (reid);
 303
 304         if (it == RegisteredEntities.end())
 305         {
 306                 // just register
 307                 registerEntity(eid, entityName, entitySlot, uid, userName, shardId);
 308         }
 309         else
 310         {
 311                 // update entity entry and name index
 312                 CEntity &entity = it->second;
 313                 if (entity.EntityName != entityName)
 314                 {
 315                         if (!checkEntityName(entityName))
 316                         {
 317                                 nlwarning ("EIT: Can't update EId %s EntityName '%s' UId %d UserName '%s' with new name '%s' because EntityName is already in the map",
 318                                         reid.toString().c_str(),
 319                                         entity.EntityName.toString().c_str(),
 320                                         uid,
 321                                         userName.c_str(),
 322                                         entityName.toString().c_str());
 323                                 return;
 324                         }
 325                         // update the name and name index
 326                         NameIndex.erase(toLower(entity.EntityName));
 327                         NameIndex.insert(make_pair(toLower(entityName), reid));
 328                         entity.EntityName = entityName;
 329                         entity.EntityNameStringId = 0;
 330                 }
 331                 entity.EntitySlot = entitySlot;
 332                 entity.UId = uid;
 333                 entity.UserName = userName;
 334                 entity.ShardId = shardId;
 335         }
 336 }
 337
 338
 339 void CEntityIdTranslator::unregisterEntity (const CEntityId &eid)
 340 {
 341         H_AUTO(EIdTrans_unregisterEntity);
 342         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 343         CEntityId reid(eid);
 344         reid.setCreatorId(0);
 345         reid.setDynamicId(0);
 346
 347         TEntityCont::iterator it = RegisteredEntities.find (reid);
 348
 349         if (it == RegisteredEntities.end ())
 350         {
 351                 nlwarning ("EIT: Can't unregister EId %s because EId is not in the map", reid.toString().c_str());
 352                 return;
 353         }
 354
 355         CEntity &entity = it->second;
 356
 357         nldebug ("EIT: Unregister EId %s EntityName '%s' UId %d UserName '%s'", reid.toString().c_str(), entity.EntityName.toString().c_str(), entity.UId, entity.UserName.c_str());
 358         NameIndex.erase(toLower(entity.EntityName));
 359         RegisteredEntities.erase (reid);
 360 }
 361
 362 bool CEntityIdTranslator::isEntityRegistered(const CEntityId &eid)
 363 {
 364         H_AUTO(EIdTrans_unregisterEntity);
 365         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 366         CEntityId reid(eid);
 367         reid.setCreatorId(0);
 368         reid.setDynamicId(0);
 369
 370         TEntityCont::iterator it = RegisteredEntities.find (reid);
 371
 372         return it != RegisteredEntities.end ();
 373 }
 374
 375
 376 void CEntityIdTranslator::checkEntity (const CEntityId &eid, const ucstring &entityName, uint32 uid, const string &userName)
 377 {
 378         H_AUTO(EIdTrans_checkEntity);
 379         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 380         CEntityId reid(eid);
 381         reid.setCreatorId(0);
 382         reid.setDynamicId(0);
 383
 384         map<CEntityId, CEntityIdTranslator::CEntity>::iterator it = RegisteredEntities.find (reid);
 385
 386         nlinfo ("EIT: Checking EId %s EntityName '%s' UId %d UserName '%s'", reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 387
 388         if (it == RegisteredEntities.end ())
 389         {
 390                 nlwarning ("EIT: Check failed because EId is not in the CEntityIdTranslator map for EId %s EntityName '%s' UId %d UserName '%s'", reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 391
 392                 if (checkEntityName(entityName))
 393                 {
 394                         nlwarning ("EIT: Check failed because entity name already exist '%s' for EId %s EntityName '%s' UId %d UserName '%s'", getByEntity(entityName).toString().c_str(), reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 395                 }
 396         }
 397         else
 398         {
 399                 CEntity &entity = it->second;
 400                 if (entity.EntityName != entityName)
 401                 {
 402                         nlwarning ("EIT: Check failed because entity name not identical '%s' in the CEntityIdTranslator map for EId %s EntityName '%s' UId %d UserName '%s'", entity.EntityName.toString().c_str(), reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 403                         if(!entityName.empty())
 404                         {
 405                                 entity.EntityName = entityName;
 406                         }
 407                 }
 408                 if (entity.UId != uid)
 409                 {
 410                         nlwarning ("EIT: Check failed because uid not identical (%d) in the CEntityIdTranslator map for EId %s EntityName '%s' UId %d UserName '%s'", entity.UId, reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 411                         if (uid != 0)
 412                         {
 413                                 entity.UId = uid;
 414                         }
 415                 }
 416                 if (entity.UserName != userName)
 417                 {
 418                         nlwarning ("EIT: Check failed because user name not identical '%s' in the CEntityIdTranslator map for EId %s EntityName '%s' UId %d UserName '%s'", entity.UserName.c_str(), reid.toString().c_str(), entityName.toString().c_str(), uid, userName.c_str());
 419                         if(!userName.empty())
 420                         {
 421                                 entity.UserName = userName;
 422                         }
 423                 }
 424         }
 425 }
 426
 427 void CEntityIdTranslator::removeShardFromName(ucstring& name)
 428 {
 429         // The string must contain a '(' and a ')'
 430         ucstring::size_type     p0= name.find('(');
 431         ucstring::size_type     p1= name.find(')');
 432         if (p0 == ucstring::npos || p1 == ucstring::npos || p1 <= p0)
 433                 return;
 434
 435         name = name.substr(0, p0) + name.substr(p1 + 1);
 436 }
 437
 438 // this callback is call when the file is changed
 439 void cbInvalidEntityNamesFilename(const std::string &invalidEntityNamesFilename)
 440 {
 441         CEntityIdTranslator::getInstance()->InvalidEntityNames.clear ();
 442
 443         string fn = CPath::lookup(invalidEntityNamesFilename, false);
 444
 445         if (fn.empty())
 446         {
 447                 nlwarning ("EIT: Can't load filename '%s' for invalid entity names filename (not found)", invalidEntityNamesFilename.c_str());
 448                 return;
 449         }
 450
 451         FILE *fp = nlfopen (fn, "r");
 452         if (fp == NULL)
 453         {
 454                 nlwarning ("EIT: Can't load filename '%s' for invalid entity names filename", fn.c_str());
 455                 return;
 456         }
 457
 458         for(;;)
 459         {
 460                 char str[512];
 461                 if (!fgets(str, 511, fp))
 462                         break;
 463                 if(feof(fp))
 464                         break;
 465                 if (strlen(str) > 0)
 466                 {
 467                         str[strlen(str)-1] = '\0';
 468                         CEntityIdTranslator::getInstance()->InvalidEntityNames.push_back(str);
 469                 }
 470         }
 471
 472         fclose (fp);
 473 }
 474
 475 void CEntityIdTranslator::load (const string &fileName, const string &invalidEntityNamesFilename)
 476 {
 477         H_AUTO(EIdTrans_load);
 478         if (fileName.empty())
 479         {
 480                 nlwarning ("EIT: Can't load empty filename for EntityIdTranslator");
 481                 return;
 482         }
 483
 484         if (!FileName.empty())
 485         {
 486                 nlwarning ("EIT: Can't load file '%s' for EntityIdTranslator because we already load the file '%s'", fileName.c_str(), FileName.c_str());
 487                 return;
 488         }
 489
 490         nlinfo ("EIT: CEntityIdTranslator: load '%s'", fileName.c_str());
 491
 492         FileName = fileName;
 493
 494         if(CFile::fileExists(FileName))
 495         {
 496                 CIFile ifile;
 497                 if( ifile.open(FileName) )
 498                 {
 499                         FileVersion = Version;
 500                         ifile.serialVersion (FileVersion);
 501                         ifile.serialCont (RegisteredEntities);
 502
 503                         ifile.close ();
 504
 505                         // fill the entity name index container
 506                         NameIndex.clear();
 507                         TEntityCont::iterator first(RegisteredEntities.begin()), last(RegisteredEntities.end());
 508                         for (; first != last; ++first)
 509                         {
 510                                 NameIndex.insert(make_pair(toLower(first->second.EntityName), first->first));
 511                         }
 512                 }
 513                 else
 514                 {
 515                         nlwarning ("EIT: Can't load filename '%s' for EntityIdTranslator", FileName.c_str());
 516                 }
 517         }
 518
 519         cbInvalidEntityNamesFilename (invalidEntityNamesFilename);
 520
 521         NLMISC::CFile::addFileChangeCallback (invalidEntityNamesFilename, cbInvalidEntityNamesFilename);
 522 }
 523
 524 void CEntityIdTranslator::save ()
 525 {
 526         H_AUTO(EIdTrans_save);
 527
 528         if (FileName.empty())
 529         {
 530                 nlwarning ("EIT: Can't save empty filename for EntityIdTranslator (you forgot to load() it before?)");
 531                 return;
 532         }
 533
 534         nlinfo ("EIT: CEntityIdTranslator: save");
 535
 536         COFile ofile;
 537         if( ofile.open(FileName) )
 538         {
 539                 ofile.serialVersion (Version);
 540                 FileVersion = Version;
 541                 ofile.serialCont (RegisteredEntities);
 542
 543                 ofile.close ();
 544         }
 545         else
 546         {
 547                 nlwarning ("EIT: Can't save filename '%s' for EntityIdTranslator", FileName.c_str());
 548         }
 549 }
 550
 551 uint32 CEntityIdTranslator::getUId (const string &userName)
 552 {
 553         const TEntityCont::iterator itEnd = RegisteredEntities.end();
 554         for (TEntityCont::iterator it = RegisteredEntities.begin(); it != itEnd ; ++it)
 555         {
 556                 CEntity &entity = it->second;
 557                 if (entity.UserName == userName)
 558                 {
 559                         return entity.UId;
 560                 }
 561         }
 562         return 0;
 563 }
 564
 565 string CEntityIdTranslator::getUserName (uint32 uid)
 566 {
 567         const TEntityCont::iterator itEnd = RegisteredEntities.end();
 568         for (TEntityCont::iterator it = RegisteredEntities.begin(); it != itEnd ; ++it)
 569         {
 570                 CEntity &entity = it->second;
 571                 if (entity.UId == uid)
 572                 {
 573                         return entity.UserName;
 574                 }
 575         }
 576         return string();
 577 }
 578
 579 void CEntityIdTranslator::getEntityIdInfo (const CEntityId &eid, ucstring &entityName, sint8 &entitySlot, uint32 &uid, string &userName, bool &online, std::string* additional)
 580 {
 581         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 582         CEntityId reid(eid);
 583         reid.setCreatorId(0);
 584         reid.setDynamicId(0);
 585
 586         if (additional != NULL)
 587                 additional->clear();
 588
 589         TEntityCont::iterator it = RegisteredEntities.find (reid);
 590         if (it == RegisteredEntities.end ())
 591         {
 592                 nlwarning ("EIT: %s is not registered in CEntityIdTranslator", reid.toString().c_str());
 593                 entityName.clear();
 594                 entitySlot = -1;
 595                 uid = std::numeric_limits<uint32>::max();
 596                 userName.clear();
 597                 online = false;
 598         }
 599         else
 600         {
 601                 CEntity &entity = it->second;
 602                 entityName = entity.EntityName;
 603                 entitySlot = entity.EntitySlot;
 604                 uid = entity.UId;
 605                 userName = entity.UserName;
 606                 online = entity.Online;
 607
 608                 if (EntityInfoCallback != NULL && additional != NULL)
 609                         *additional = EntityInfoCallback(eid);
 610         }
 611 }
 612
 613 bool CEntityIdTranslator::setEntityNameStringId(const ucstring &entityName, uint32 stringId)
 614 {
 615         const TEntityCont::iterator itEnd = RegisteredEntities.end();
 616         for (TEntityCont::iterator it = RegisteredEntities.begin(); it != itEnd ; ++it)
 617         {
 618                 CEntity &entity = it->second;
 619                 if (entity.EntityName == entityName)
 620                 {
 621                         entity.EntityNameStringId = stringId;
 622                         return true;
 623                 }
 624         }
 625
 626         return false;
 627 }
 628
 629 bool CEntityIdTranslator::setEntityNameStringId(const CEntityId &eid, uint32 stringId)
 630 {
 631         TEntityCont::iterator it (RegisteredEntities.find(eid));
 632         if (it == RegisteredEntities.end())
 633         {
 634                 // there is nothing we can do !
 635                 return false;
 636         }
 637
 638         CEntity &entity = it->second;
 639         entity.EntityNameStringId = stringId;
 640
 641         return true;
 642 }
 643
 644 uint32 CEntityIdTranslator::getEntityNameStringId(const CEntityId &eid)
 645 {
 646         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 647         CEntityId reid(eid);
 648         reid.setCreatorId(0);
 649         reid.setDynamicId(0);
 650
 651         const TEntityCont::iterator it = RegisteredEntities.find (reid);
 652         if (it == RegisteredEntities.end ())
 653         {
 654                 return 0;
 655         }
 656         else
 657         {
 658                 CEntity &entity = it->second;
 659                 return entity.EntityNameStringId;
 660         }
 661 }
 662
 663 // get the shard id of an entity
 664 uint32  CEntityIdTranslator::getEntityShardId(const CEntityId &eid)
 665 {
 666         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 667         CEntityId reid(eid);
 668         reid.setCreatorId(0);
 669         reid.setDynamicId(0);
 670
 671         const TEntityCont::iterator it = RegisteredEntities.find (reid);
 672         if (it == RegisteredEntities.end ())
 673         {
 674                 return 0;
 675         }
 676         else
 677         {
 678                 CEntity &entity = it->second;
 679                 return entity.ShardId;
 680         }
 681 }
 682
 683
 684 void CEntityIdTranslator::setEntityOnline (const CEntityId &eid, bool online)
 685 {
 686         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 687         CEntityId reid(eid);
 688         reid.setCreatorId(0);
 689         reid.setDynamicId(0);
 690
 691         TEntityCont::iterator it = RegisteredEntities.find (reid);
 692         if (it == RegisteredEntities.end ())
 693         {
 694                 nlwarning ("EIT: %s is not registered in CEntityIdTranslator", reid.toString().c_str());
 695         }
 696         else
 697         {
 698                 CEntity &entity = it->second;
 699                 entity.Online = online;
 700         }
 701 }
 702
 703 bool CEntityIdTranslator::isEntityOnline (const CEntityId &eid)
 704 {
 705         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 706         CEntityId reid(eid);
 707         reid.setCreatorId(0);
 708         reid.setDynamicId(0);
 709
 710         TEntityCont::iterator it = RegisteredEntities.find (reid);
 711         if (it == RegisteredEntities.end ())
 712         {
 713                 nlwarning ("EIT: %s is not registered in CEntityIdTranslator", reid.toString().c_str());
 714                 return false;
 715         }
 716         else
 717         {
 718                 CEntity &entity = it->second;
 719                 return entity.Online;
 720         }
 721 }
 722
 723 std::string CEntityIdTranslator::getRegisterableString( const ucstring & entityName )
 724 {
 725         string ret = toLower( entityName.toString() );
 726         string::size_type pos = ret.find( 0x20 );
 727         while( pos != string::npos )
 728         {
 729                 ret.erase( pos,1 );
 730                 pos = ret.find( 0x20 );
 731         }
 732         return ret;
 733 }
 734
 735
 736 NLMISC_CATEGORISED_COMMAND(nel,findEIdByUser,"Find entity ids using the user name","<username>|<uid>")
 737 {
 738         if (args.size () != 1)
 739                 return false;
 740
 741         vector<CEntityId> res;
 742
 743         string userName = args[0];
 744         uint32 uid = atoi (userName.c_str());
 745
 746         if (uid != 0)
 747         {
 748                 CEntityIdTranslator::getInstance()->getByUser(uid, res);
 749                 userName = CEntityIdTranslator::getInstance()->getUserName(uid);
 750         }
 751         else
 752         {
 753                 CEntityIdTranslator::getInstance()->getByUser(userName, res);
 754                 CEntityIdTranslator::getInstance()->getUId(userName);
 755         }
 756
 757         log.displayNL("User Name '%s' (uid=%d) has %d entities:", userName.c_str(), uid, res.size());
 758         for (uint i = 0 ; i < res.size(); i++)
 759         {
 760                 log.displayNL(">  %s '%s'", res[i].toString().c_str(), CEntityIdTranslator::getInstance()->getByEntity (res[i]).c_str());
 761         }
 762
 763         return true;
 764 }
 765
 766 NLMISC_CATEGORISED_COMMAND(nel,findEIdByEntity,"Find entity id using the entity name","<entityname>|<eid>")
 767 {
 768         if (args.size () != 1)
 769                 return false;
 770
 771         CEntityId eid (args[0].c_str());
 772
 773         if (eid == CEntityId::Unknown)
 774         {
 775                 eid = CEntityIdTranslator::getInstance()->getByEntity(args[0]);
 776         }
 777
 778         if (eid == CEntityId::Unknown)
 779         {
 780                 log.displayNL("'%s' is not an eid or an entity name", args[0].c_str());
 781                 return false;
 782         }
 783
 784         ucstring entityName;
 785         sint8 entitySlot;
 786         uint32 uid;
 787         string userName;
 788         bool online;
 789         std::string     extinf;
 790
 791         CEntityIdTranslator::getInstance()->getEntityIdInfo(eid, entityName, entitySlot, uid, userName, online, &extinf);
 792
 793         log.displayNL("UId %d UserName '%s' EId %s EntityName '%s' EntitySlot %hd %s%s%s", uid, userName.c_str(), eid.toString().c_str(), entityName.toString().c_str(), (sint16)entitySlot, (extinf.c_str()), (extinf.empty() ? "" : " "), (online?"Online":"Offline"));
 794
 795         return true;
 796 }
 797
 798 NLMISC_CATEGORISED_COMMAND(nel,entityNameValid,"Tell if an entity name is valid or not using CEntityIdTranslator validation rulez","<entityname>")
 799 {
 800         if (args.size () != 1) return false;
 801
 802         if(!CEntityIdTranslator::getInstance()->isValidEntityName(args[0], &log))
 803         {
 804                 log.displayNL("Entity name '%s' is not valid", args[0].c_str());
 805         }
 806         else
 807         {
 808                 if (CEntityIdTranslator::getInstance()->checkEntityName(args[0]))
 809                 {
 810                         log.displayNL("Entity name '%s' is already used by another player", args[0].c_str());
 811                 }
 812                 else
 813                 {
 814                         log.displayNL("Entity name '%s' is available", args[0].c_str());
 815                 }
 816         }
 817
 818         return true;
 819 }
 820
 821 NLMISC_CATEGORISED_COMMAND(nel,playerInfo,"Get information about a player or all players in CEntityIdTranslator","[<entityname>|<eid>|<username>|<uid>]")
 822 {
 823         if (args.size () == 0)
 824         {
 825                 const map<CEntityId, CEntityIdTranslator::CEntity>      &res = CEntityIdTranslator::getInstance()->getRegisteredEntities ();
 826                 log.displayNL("%d result(s) for 'all players information'", res.size());
 827                 for (map<CEntityId, CEntityIdTranslator::CEntity>::const_iterator it = res.begin(); it != res.end(); it++)
 828                 {
 829                         const CEntityIdTranslator::CEntity &entity = it->second;
 830                         log.displayNL("UId %d UserName '%s' EId %s EntityName '%s' EntitySlot %hd %s", entity.UId, entity.UserName.c_str(), it->first.toString().c_str(), entity.EntityName.toString().c_str(), (sint16)(entity.EntitySlot), (entity.Online?"Online":"Offline"));
 831                 }
 832
 833                 return true;
 834         }
 835         else if (args.size () == 1)
 836         {
 837                 vector<CEntityId> res;
 838
 839                 CEntityId eid (args[0].c_str());
 840                 uint32 uid = atoi (args[0].c_str());
 841
 842                 if (eid != CEntityId::Unknown)
 843                 {
 844                         // we have to remove the crea and dyna because it can changed dynamically and will not be found in the storage array
 845                         eid.setCreatorId(0);
 846                         eid.setDynamicId(0);
 847
 848                         res.push_back(eid);
 849                 }
 850                 else if (uid != 0)
 851                 {
 852                         // the parameter is an uid
 853                         CEntityIdTranslator::getInstance()->getByUser (uid, res);
 854                 }
 855                 else
 856                 {
 857                         CEntityIdTranslator::getInstance()->getByUser (args[0], res, false);
 858
 859                         CEntityIdTranslator::getInstance()->getByEntity (args[0], res, false);
 860                 }
 861
 862                 log.displayNL("%d result(s) for '%s'", res.size(), args[0].c_str());
 863                 for (uint i = 0; i < res.size(); i++)
 864                 {
 865                         ucstring entityName;
 866                         sint8 entitySlot;
 867                         uint32 uid2;
 868                         string userName;
 869                         bool online;
 870                         std::string     extinf;
 871                         CEntityIdTranslator::getInstance()->getEntityIdInfo (res[i], entityName, entitySlot, uid2, userName, online, &extinf);
 872
 873                         log.displayNL("UId %d UserName '%s' EId %s EntityName '%s' EntitySlot %hd %s%s%s", uid2, userName.c_str(), res[i].toString().c_str(), entityName.toString().c_str(), (sint16)entitySlot, (extinf.c_str()), (extinf.empty() ? "" : " "), (online?"Online":"Offline"));
 874                 }
 875
 876                 return true;
 877         }
 878
 879         return false;
 880 }
 881
 882 }