ryzom/server/src/entities_game_service/stat_db.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 #include "stdpch.h"
  19 #include "stat_db.h"
  20
  21 #include "nel/net/service.h"
  22
  23 #include "server_share/mail_forum_validator.h"
  24
  25 #include "player_manager/character.h"
  26 #include "player_manager/player_manager.h"
  27 #include "player_manager/player.h"
  28
  29 #include "guild_manager/guild_manager.h"
  30 #include "guild_manager/guild.h"
  31
  32 using namespace std;
  33 using namespace NLMISC;
  34 using namespace NLNET;
  35
  36 // ****************************************************************************
  37
  38 CStatDB *CStatDB::_Instance = NULL;
  39
  40 CVariable<uint32> StatDBSavePeriod("egs", "StatDBSavePeriod","stat database save period in ticks", 6, 0, true);
  41
  42 extern CVariable<bool> EGSLight;
  43
  44 // ****************************************************************************
  45 // Helpers
  46 // ****************************************************************************
  47
  48 // ****************************************************************************
  49 static bool getPlayerName(CEntityId playerId, string & playerName)
  50 {
  51         playerName = CEntityIdTranslator::getInstance()->getByEntity(playerId).toUtf8();
  52         return !playerName.empty();
  53 }
  54
  55 // ****************************************************************************
  56 static bool getGuildName(EGSPD::TGuildId guildId, string & guildName)
  57 {
  58         CGuild * guild = CGuildManager::getInstance()->getGuildFromId(guildId);
  59         if (guild == NULL)
  60                 return false;
  61
  62         guildName = guild->getName().toUtf8();
  63         return true;
  64 }
  65
  66 // ****************************************************************************
  67 static void getNamesFromTable(const CStatDBTableLeafMsg & tableLeafMsg, CStatDBNamesMsg & namesMsg)
  68 {
  69         for (   map<NLMISC::CEntityId,sint32>::const_iterator it = tableLeafMsg.PlayerValues.begin();
  70                         it != tableLeafMsg.PlayerValues.end();
  71                         ++it)
  72         {
  73                 const CEntityId & playerId = (*it).first;
  74
  75                 string playerName;
  76                 if (!getPlayerName(playerId, playerName))
  77                 {
  78 #if FINAL_VERSION
  79                         nlwarning("SDB: cannot find the name of the player %s", playerId.toString().c_str());
  80 #endif // FINAL_VERSION
  81                         continue;
  82                 }
  83
  84                 namesMsg.PlayerNames[playerId] = playerName;
  85         }
  86
  87         for (   map<EGSPD::TGuildId,sint32>::const_iterator it = tableLeafMsg.GuildValues.begin();
  88                         it != tableLeafMsg.GuildValues.end();
  89                         ++it)
  90         {
  91                 const EGSPD::TGuildId & guildId = (*it).first;
  92
  93                 string guildName;
  94                 if (!getGuildName(guildId, guildName))
  95                 {
  96 #if FINAL_VERSION
  97                         nlwarning("SDB: cannot find the name of the guild %u", guildId);
  98 #endif // FINAL_VERSION
  99                         continue;
 100                 }
 101
 102                 namesMsg.GuildNames[guildId] = guildName;
 103         }
 104 }
 105
 106 // ****************************************************************************
 107 // CStatDBBackupLeafCollector
 108 // ****************************************************************************
 109
 110 // ****************************************************************************
 111 void CStatDBBackupLeafCollector::loadLeaves(IStatDBNodePtr root)
 112 {
 113         nlassert(root != NULL);
 114
 115         clearLeaves();
 116         _Root = root;
 117         _Root->acceptVisitor(*this, "");
 118 }
 119
 120 // ****************************************************************************
 121 bool CStatDBBackupLeafCollector::popTableLeafPD(CStatDBTableLeafPD & tableLeafPD)
 122 {
 123         if (_Root == NULL)
 124                 return false;
 125
 126         while (!_TableLeafPaths.empty())
 127         {
 128                 string path = _TableLeafPaths.back();
 129                 _TableLeafPaths.pop_back();
 130
 131                 CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 132                 if (tableLeaf != NULL)
 133                 {
 134                         tableLeafPD.Path = path;
 135                         tableLeafPD.PlayerValues = tableLeaf->getPlayerValues();
 136                         tableLeafPD.GuildValues = tableLeaf->getGuildValues();
 137                         return true;
 138                 }
 139         }
 140
 141         return false;
 142 }
 143
 144 // ****************************************************************************
 145 void CStatDBBackupLeafCollector::visitValueLeaf(CStatDBValueLeaf * valueLeaf, const std::string & path)
 146 {
 147         CStatDBValueLeafPD valueLeafPD;
 148         valueLeafPD.Path = path;
 149         valueLeafPD.Value = valueLeaf->getValue();
 150
 151         _ValueLeavesPD.ValueLeavesPD.push_back(valueLeafPD);
 152 }
 153
 154 // ****************************************************************************
 155 void CStatDBBackupLeafCollector::visitTableLeaf(CStatDBTableLeaf * tableLeaf, const std::string & path)
 156 {
 157         _TableLeafPaths.push_back(path);
 158 }
 159
 160 // ****************************************************************************
 161 // CStatDBMFSInitLeafCollector
 162 // ****************************************************************************
 163
 164 // ****************************************************************************
 165 void CStatDBMFSInitLeafCollector::loadLeaves(IStatDBNodePtr root, CStatDBAllLeavesMsg & allLeavesMsg)
 166 {
 167         nlassert(root != NULL);
 168
 169         _AllLeavesMsg = &allLeavesMsg;
 170         _AllLeavesMsg->ValueLeavesMsg.clear();
 171         _AllLeavesMsg->TableLeavesMsg.clear();
 172         _AllLeavesMsg->NamesMsg.PlayerNames.clear();
 173         _AllLeavesMsg->NamesMsg.GuildNames.clear();
 174
 175         root->acceptVisitor(*this, "");
 176 }
 177
 178 // ****************************************************************************
 179 void CStatDBMFSInitLeafCollector::visitValueLeaf(CStatDBValueLeaf * valueLeaf, const std::string & path)
 180 {
 181         CStatDBValueLeafMsg valueLeafMsg;
 182         valueLeafMsg.Path = path;
 183         valueLeafMsg.Value = valueLeaf->getValue();
 184
 185         _AllLeavesMsg->ValueLeavesMsg.push_back(valueLeafMsg);
 186 }
 187
 188 // ****************************************************************************
 189 void CStatDBMFSInitLeafCollector::visitTableLeaf(CStatDBTableLeaf * tableLeaf, const std::string & path)
 190 {
 191         CStatDBTableLeafMsg tableLeafMsg;
 192         tableLeafMsg.Path = path;
 193         tableLeafMsg.PlayerValues = tableLeaf->getPlayerValues();
 194         tableLeafMsg.GuildValues = tableLeaf->getGuildValues();
 195
 196         _AllLeavesMsg->TableLeavesMsg.push_back(tableLeafMsg);
 197
 198         getNamesFromTable(tableLeafMsg, _AllLeavesMsg->NamesMsg);
 199 }
 200
 201 // ****************************************************************************
 202 // CStatDBNodeDisplayer
 203 // ****************************************************************************
 204
 205 // ****************************************************************************
 206 void CStatDBNodeDisplayer::displayNode(IStatDBNodePtr node, const std::string & currentPath, NLMISC::CLog & log)
 207 {
 208         _Log = &log;
 209
 210         if (_Settings.Recursive)
 211         {
 212                 node->acceptVisitor(*this, currentPath);
 213         }
 214         else
 215         {
 216                 displayOneNode(node, currentPath);
 217
 218                 // if the node is a branch
 219                 CStatDBBranch * branch = dynamic_cast<CStatDBBranch *>(node.getPtr());
 220                 if (branch != NULL)
 221                 {
 222                         vector<IStatDBNode::CMatchingNode> children;
 223                         branch->getNodes("*", children, currentPath);
 224                         for (uint i = 0; i < children.size(); i++)
 225                         {
 226                                 displayOneNode(children[i].Node, children[i].Path);
 227                         }
 228                         return;
 229                 }
 230         }
 231 }
 232
 233 // ****************************************************************************
 234 void CStatDBNodeDisplayer::displayOneNode(IStatDBNodePtr node, const std::string & currentPath)
 235 {
 236         BOMB_IF(node == NULL, "node is NULL!", return);
 237
 238         CStatDBBranch * branch = dynamic_cast<CStatDBBranch *>(node.getPtr());
 239         if (branch != NULL)
 240         {
 241                 visitBranch(branch, currentPath);
 242                 return;
 243         }
 244
 245         CStatDBValueLeaf * valueLeaf = dynamic_cast<CStatDBValueLeaf *>(node.getPtr());
 246         if (valueLeaf != NULL)
 247         {
 248                 visitValueLeaf(valueLeaf, currentPath);
 249                 return;
 250         }
 251
 252         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(node.getPtr());
 253         if (tableLeaf != NULL)
 254         {
 255                 visitTableLeaf(tableLeaf, currentPath);
 256                 return;
 257         }
 258 }
 259
 260 // ****************************************************************************
 261 void CStatDBNodeDisplayer::visitBranch(CStatDBBranch * branch, const std::string & path)
 262 {
 263         if (_Settings.DisplayBranch)
 264         {
 265                 _Log->displayNL("(B) %s", path.c_str());
 266         }
 267 }
 268
 269 // ****************************************************************************
 270 void CStatDBNodeDisplayer::visitValueLeaf(CStatDBValueLeaf * valueLeaf, const std::string & path)
 271 {
 272         if (_Settings.DisplayValueLeaf)
 273         {
 274                 if (_Settings.DisplayValueLeafContent)
 275                         _Log->displayNL("(V) %s = %d", path.c_str(), valueLeaf->getValue());
 276                 else
 277                         _Log->displayNL("(V) %s", path.c_str());
 278         }
 279 }
 280
 281 // ****************************************************************************
 282 void CStatDBNodeDisplayer::visitTableLeaf(CStatDBTableLeaf * tableLeaf, const std::string & path)
 283 {
 284         if (_Settings.DisplayTableLeaf)
 285         {
 286                 _Log->displayNL("(T) %s", path.c_str());
 287                 if (_Settings.DisplayTableLeafContent)
 288                 {
 289                         for (   map<NLMISC::CEntityId,sint32>::const_iterator it = tableLeaf->getPlayerValues().begin();
 290                                         it != tableLeaf->getPlayerValues().end();
 291                                         ++it)
 292                         {
 293                                 string playerName;
 294                                 if (!getPlayerName((*it).first, playerName))
 295                                 {
 296                                         playerName = "[not found] " + (*it).first.toString();
 297                                 }
 298
 299                                 _Log->displayNL("\tplayer '%s' = %d", playerName.c_str(), (*it).second);
 300                         }
 301
 302                         for (   map<EGSPD::TGuildId,sint32>::const_iterator it = tableLeaf->getGuildValues().begin();
 303                                         it != tableLeaf->getGuildValues().end();
 304                                         ++it)
 305                         {
 306                                 string guildName;
 307                                 if (!getGuildName((*it).first, guildName))
 308                                 {
 309                                         guildName = toString("[not found] %u", (*it).first);
 310                                 }
 311
 312                                 _Log->displayNL("\tguild '%s' = %d", guildName.c_str(), (*it).second);
 313                         }
 314                 }
 315         }
 316 }
 317
 318 // ****************************************************************************
 319 // CStatDB
 320 // ****************************************************************************
 321
 322 // ****************************************************************************
 323 CStatDB::CStatDB()
 324 {
 325         _Root = new CStatDBBranch;
 326         _SDBIsLoaded = false;
 327         _GuildsAreLoaded = false;
 328         _MFSIsUp = false;
 329         _MFSIsInitialized = false;
 330 }
 331
 332 // ****************************************************************************
 333 bool CStatDB::createValue(const std::string & path, sint32 val)
 334 {
 335         nlassert(_SDBIsLoaded);
 336
 337         IStatDBNodePtr node = _Root->getNode(path);
 338         if (node != NULL)
 339                 return false;
 340
 341         bool res = _Root->setNode(path, new CStatDBValueLeaf(val));
 342
 343         if (res && _MFSIsInitialized)
 344         {
 345                 uint32 shardId = IService::getInstance()->getShardId();
 346                 CStatDBValueLeafMsg valueLeafMsg;
 347                 valueLeafMsg.Path = path;
 348                 valueLeafMsg.Value = val;
 349
 350                 CMessage msgout("SDB:CREATE_VALUE");
 351                 msgout.serial(shardId);
 352                 msgout.serial(valueLeafMsg);
 353                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 354         }
 355
 356         return res;
 357 }
 358
 359 // ****************************************************************************
 360 bool CStatDB::valueSet(const std::string & path, sint32 val)
 361 {
 362         nlassert(_SDBIsLoaded);
 363
 364         CStatDBValueLeaf * valueLeaf = dynamic_cast<CStatDBValueLeaf *>(_Root->getNode(path).getPtr());
 365         if (valueLeaf == NULL)
 366                 return false;
 367
 368         valueLeaf->setValue(val);
 369
 370         if (_MFSIsInitialized)
 371         {
 372                 uint32 shardId = IService::getInstance()->getShardId();
 373
 374                 CMessage msgout("SDB:VALUE_SET");
 375                 msgout.serial(shardId);
 376                 msgout.serial(const_cast<string &>(path));
 377                 msgout.serial(val);
 378                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 379         }
 380
 381         return true;
 382 }
 383
 384 // ****************************************************************************
 385 bool CStatDB::valueAdd(const std::string & path, sint32 val)
 386 {
 387         nlassert(_SDBIsLoaded);
 388
 389         CStatDBValueLeaf * valueLeaf = dynamic_cast<CStatDBValueLeaf *>(_Root->getNode(path).getPtr());
 390         if (valueLeaf == NULL)
 391                 return false;
 392
 393         valueLeaf->addValue(val);
 394
 395         if (_MFSIsInitialized)
 396         {
 397                 uint32 shardId = IService::getInstance()->getShardId();
 398
 399                 CMessage msgout("SDB:VALUE_ADD");
 400                 msgout.serial(shardId);
 401                 msgout.serial(const_cast<string &>(path));
 402                 msgout.serial(val);
 403                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 404         }
 405
 406         return true;
 407 }
 408
 409 // ****************************************************************************
 410 bool CStatDB::valueGet(const std::string & path, sint32 & val)
 411 {
 412         nlassert(_SDBIsLoaded);
 413
 414         CStatDBValueLeaf * valueLeaf = dynamic_cast<CStatDBValueLeaf *>(_Root->getNode(path).getPtr());
 415         if (valueLeaf == NULL)
 416                 return false;
 417
 418         val = valueLeaf->getValue();
 419         return true;
 420 }
 421
 422 // ****************************************************************************
 423 bool CStatDB::createTable(const std::string & path)
 424 {
 425         nlassert(_SDBIsLoaded);
 426
 427         IStatDBNodePtr node = _Root->getNode(path);
 428         if (node != NULL)
 429                 return false;
 430
 431         return createTable(path, map<NLMISC::CEntityId,sint32>(), map<EGSPD::TGuildId,sint32>());
 432 }
 433
 434 // ****************************************************************************
 435 bool CStatDB::createTable(const std::string & path,
 436                                                   const std::map<NLMISC::CEntityId,sint32> & playerValues,
 437                                                   const std::map<EGSPD::TGuildId,sint32> & guildValues
 438                                                   )
 439 {
 440         nlassert(_SDBIsLoaded);
 441
 442         IStatDBNodePtr node = _Root->getNode(path);
 443         if (node != NULL)
 444                 return false;
 445
 446         bool res = _Root->setNode(path, new CStatDBTableLeaf(playerValues, guildValues));
 447
 448         if (res && _MFSIsInitialized)
 449         {
 450                 uint32 shardId = IService::getInstance()->getShardId();
 451                 CStatDBTableLeafMsg tableLeafMsg;
 452                 tableLeafMsg.Path = path;
 453                 tableLeafMsg.PlayerValues = playerValues;
 454                 tableLeafMsg.GuildValues = guildValues;
 455
 456                 CStatDBNamesMsg namesMsg;
 457                 getNamesFromTable(tableLeafMsg, namesMsg);
 458
 459                 CMessage msgout("SDB:CREATE_TABLE");
 460                 msgout.serial(shardId);
 461                 msgout.serial(tableLeafMsg);
 462                 msgout.serial(namesMsg);
 463                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 464         }
 465
 466         return res;
 467 }
 468
 469 // ****************************************************************************
 470 bool CStatDB::tablePlayerAdd(const std::string & path, NLMISC::CEntityId playerId, sint32 val)
 471 {
 472         nlassert(_SDBIsLoaded);
 473
 474         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 475         if (tableLeaf == NULL)
 476                 return false;
 477
 478         tableLeaf->playerAdd(playerId, val);
 479
 480         if (_MFSIsInitialized)
 481         {
 482                 uint32 shardId = IService::getInstance()->getShardId();
 483                 string playerName;
 484                 getPlayerName(playerId, playerName);
 485
 486                 CMessage msgout("SDB:TABLE_PLAYER_ADD");
 487                 msgout.serial(shardId);
 488                 msgout.serial(const_cast<string &>(path));
 489                 msgout.serial(playerId);
 490                 msgout.serial(playerName);
 491                 msgout.serial(val);
 492                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 493         }
 494
 495         return true;
 496 }
 497
 498 // ****************************************************************************
 499 bool CStatDB::tablePlayerSet(const std::string & path, NLMISC::CEntityId playerId, sint32 val)
 500 {
 501         nlassert(_SDBIsLoaded);
 502
 503         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 504         if (tableLeaf == NULL)
 505                 return false;
 506
 507         tableLeaf->playerSet(playerId, val);
 508
 509         if (_MFSIsInitialized)
 510         {
 511                 uint32 shardId = IService::getInstance()->getShardId();
 512                 string playerName;
 513                 getPlayerName(playerId, playerName);
 514
 515                 CMessage msgout("SDB:TABLE_PLAYER_SET");
 516                 msgout.serial(shardId);
 517                 msgout.serial(const_cast<string &>(path));
 518                 msgout.serial(playerId);
 519                 msgout.serial(playerName);
 520                 msgout.serial(val);
 521                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 522         }
 523
 524         return true;
 525 }
 526
 527 // ****************************************************************************
 528 bool CStatDB::tablePlayerGet(const std::string & path, NLMISC::CEntityId playerId, sint32& val)
 529 {
 530         nlassert(_SDBIsLoaded);
 531
 532         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 533         if (tableLeaf == NULL)
 534                 return false;
 535
 536         return tableLeaf->playerGet(playerId, val);
 537 }
 538
 539 // ****************************************************************************
 540 bool CStatDB::tableGuildAdd(const std::string & path, EGSPD::TGuildId guildId, sint32 val)
 541 {
 542         nlassert(_SDBIsLoaded);
 543
 544         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 545         if (tableLeaf == NULL)
 546                 return false;
 547
 548         tableLeaf->guildAdd(guildId, val);
 549
 550         if (_MFSIsInitialized)
 551         {
 552                 uint32 shardId = IService::getInstance()->getShardId();
 553                 string guildName;
 554                 getGuildName(guildId, guildName);
 555
 556                 CMessage msgout("SDB:TABLE_GUILD_ADD");
 557                 msgout.serial(shardId);
 558                 msgout.serial(const_cast<string &>(path));
 559                 msgout.serial(guildId);
 560                 msgout.serial(guildName);
 561                 msgout.serial(val);
 562                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 563         }
 564
 565         return true;
 566 }
 567
 568 // ****************************************************************************
 569 bool CStatDB::tableGuildSet(const std::string & path, EGSPD::TGuildId guildId, sint32 val)
 570 {
 571         nlassert(_SDBIsLoaded);
 572
 573         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 574         if (tableLeaf == NULL)
 575                 return false;
 576
 577         tableLeaf->guildSet(guildId, val);
 578
 579         if (_MFSIsInitialized)
 580         {
 581                 uint32 shardId = IService::getInstance()->getShardId();
 582                 string guildName;
 583                 getGuildName(guildId, guildName);
 584
 585                 CMessage msgout("SDB:TABLE_GUILD_SET");
 586                 msgout.serial(shardId);
 587                 msgout.serial(const_cast<string &>(path));
 588                 msgout.serial(guildId);
 589                 msgout.serial(guildName);
 590                 msgout.serial(val);
 591                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 592         }
 593
 594         return true;
 595 }
 596
 597 // ****************************************************************************
 598 bool CStatDB::tableGuildGet(const std::string & path, EGSPD::TGuildId guildId, sint32& val)
 599 {
 600         nlassert(_SDBIsLoaded);
 601
 602         CStatDBTableLeaf * tableLeaf = dynamic_cast<CStatDBTableLeaf *>(_Root->getNode(path).getPtr());
 603         if (tableLeaf == NULL)
 604                 return false;
 605
 606         return tableLeaf->guildGet(guildId, val);
 607 }
 608
 609 // ****************************************************************************
 610 class CStatDBBackupFileCleaner : private CStatDBNodeVisitor
 611 {
 612 public:
 613         void submitRemovedNode(IStatDBNodePtr removedNode, const std::string & removedNodePath, bool keepBackupOfFiles)
 614         {
 615                 _KeepBackupOfFiles = keepBackupOfFiles;
 616                 if (removedNode != NULL)
 617                         removedNode->acceptVisitor(*this, removedNodePath);
 618         }
 619
 620 private:
 621         void visitTableLeaf(CStatDBTableLeaf * tableLeaf, const std::string & path)
 622         {
 623                 string sFilePath = toString("sdb/table_leaf_%s_pdr.%s", path.c_str(), (XMLSave?"xml":"bin"));
 624                 Bsi.deleteFile(sFilePath, _KeepBackupOfFiles);
 625         }
 626
 627 private:
 628         bool _KeepBackupOfFiles;
 629 };
 630
 631 bool CStatDB::removeNode(const std::string & path, bool keepBackupOfFiles)
 632 {
 633         nlassert(_SDBIsLoaded);
 634
 635         IStatDBNodePtr removedNode = _Root->removeNode(path);
 636         bool res = (removedNode != NULL);
 637
 638         if (res && _MFSIsInitialized)
 639         {
 640                 uint32 shardId = IService::getInstance()->getShardId();
 641
 642                 CMessage msgout("SDB:REMOVE_NODE");
 643                 msgout.serial(shardId);
 644                 msgout.serial(const_cast<string &>(path));
 645                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 646         }
 647
 648         if (res)
 649         {
 650                 // remove save files associated to the removed node if any
 651                 // only table leaves have their own save files
 652                 CStatDBBackupFileCleaner backupFileCleaner;
 653                 backupFileCleaner.submitRemovedNode(removedNode, path, keepBackupOfFiles);
 654         }
 655
 656         return res;
 657 }
 658
 659 // ****************************************************************************
 660 void CStatDB::removePlayer(NLMISC::CEntityId playerId)
 661 {
 662         _EntitiesRemoval.addPlayerToRemove(playerId);
 663
 664         if (_MFSIsInitialized)
 665         {
 666                 uint32 shardId = IService::getInstance()->getShardId();
 667
 668                 CMessage msgout("SDB:REMOVE_PLAYER");
 669                 msgout.serial(shardId);
 670                 msgout.serial(playerId);
 671                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 672         }
 673 }
 674
 675 // ****************************************************************************
 676 void CStatDB::removeGuild(EGSPD::TGuildId guildId)
 677 {
 678         _EntitiesRemoval.addGuildToRemove(guildId);
 679
 680         if (_MFSIsInitialized)
 681         {
 682                 uint32 shardId = IService::getInstance()->getShardId();
 683
 684                 CMessage msgout("SDB:REMOVE_GUILD");
 685                 msgout.serial(shardId);
 686                 msgout.serial(guildId);
 687                 CUnifiedNetwork::getInstance()->send("MFS", msgout);
 688         }
 689 }
 690
 691 // ****************************************************************************
 692 bool CStatDB::displayNodes(const std::string & pathPattern, NLMISC::CLog & log, const CStatDBNodeDisplayer::CSettings & settings)
 693 {
 694         vector<IStatDBNode::CMatchingNode> nodes;
 695         _Root->getNodes(pathPattern, nodes, "");
 696
 697         if (nodes.empty())
 698                 return false;
 699
 700         CStatDBNodeDisplayer nodeDisplayer;
 701         nodeDisplayer.setSettings(settings);
 702
 703         for (uint i = 0; i < nodes.size(); i++)
 704         {
 705                 nodeDisplayer.displayNode(nodes[i].Node, nodes[i].Path, log);
 706         }
 707
 708         return true;
 709 }
 710
 711
 712 uint32 nTotalLoaded = 0;
 713
 714 struct TValueLeaveFileCallback : public IBackupFileReceiveCallback
 715 {
 716         virtual void callback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
 717         {
 718                 CStatDB::getInstance()->valueLeaveFileCallback(fileDescription, dataStream);
 719         }
 720 };
 721
 722 void  CStatDB::valueLeaveFileCallback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
 723 {
 724         if (!fileDescription.FileName.empty())
 725         {
 726                 static CPersistentDataRecord    pdr;
 727                 pdr.clear();
 728                 CStatDBValueLeavesPD valueLeavesPD;
 729
 730                 pdr.fromBuffer(dataStream);
 731 //              pdr.readFromFile(sFilePath);
 732                 valueLeavesPD.apply(pdr);
 733                 nTotalLoaded += fileDescription.FileSize;
 734
 735                 for (uint32 i = 0; i < valueLeavesPD.ValueLeavesPD.size(); ++i)
 736                 {
 737                         const CStatDBValueLeafPD & valueLeafPD = valueLeavesPD.ValueLeavesPD[i];
 738
 739                         IStatDBNodePtr node = _Root->getNode(valueLeafPD.Path);
 740                         if (node == NULL)
 741                         {
 742                                 bool res = _Root->setNode(valueLeafPD.Path, new CStatDBValueLeaf(valueLeafPD.Value));
 743                                 if (!res)
 744                                 {
 745                                         nlwarning("value leaf '%s' cannot be created!", valueLeafPD.Path.c_str());
 746                                         DEBUG_STOP;
 747                                 }
 748                         }
 749                         else
 750                         {
 751                                 nlwarning("leaf '%s' already exists!", valueLeafPD.Path.c_str());
 752                                 DEBUG_STOP;
 753                         }
 754                 }
 755         }
 756 }
 757
 758 vector<string>  fileNames;
 759
 760 struct TFileClassCallback : public IBackupFileClassReceiveCallback
 761 {
 762         virtual void callback(const CFileDescriptionContainer& fileList)
 763         {
 764                 for (uint i=0; i<fileList.size(); ++i)
 765                 {
 766                         fileNames.push_back(fileList[i].FileName);
 767                 }
 768         }
 769
 770 };
 771
 772 struct TTableLeaveFileCallback : public IBackupFileReceiveCallback
 773 {
 774         virtual void callback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
 775         {
 776                 CStatDB::getInstance()->tableLeaveFileCallback(fileDescription, dataStream);
 777         }
 778 };
 779
 780 void  CStatDB::tableLeaveFileCallback(const CFileDescription& fileDescription, NLMISC::IStream& dataStream)
 781 {
 782         const string & fileName = CFile::getFilename(fileDescription.FileName);
 783
 784         if (    CFile::getFilename(fileName).substr(0, 11) == "table_leaf_"
 785                 &&      CFile::getExtension(fileName) == (XMLSave?"xml":"bin"))
 786         {
 787                 H_AUTO(CStatDB_load_2);
 788
 789                 static CPersistentDataRecord    pdr;
 790                 pdr.clear();
 791                 CStatDBTableLeafPD tableLeafPD;
 792
 793                 pdr.fromBuffer(dataStream);
 794 //              pdr.readFromFile(fileName);
 795                 tableLeafPD.apply(pdr);
 796                 nTotalLoaded += CFile::getFileSize(fileName);
 797
 798                 IStatDBNodePtr node = _Root->getNode(tableLeafPD.Path);
 799                 if (node == NULL)
 800                 {
 801                         bool res = _Root->setNode(tableLeafPD.Path, new CStatDBTableLeaf(tableLeafPD.PlayerValues, tableLeafPD.GuildValues));
 802                         if (!res)
 803                         {
 804                                 nlwarning("table leaf '%s' cannot be created!", tableLeafPD.Path.c_str());
 805                                 DEBUG_STOP;
 806                         }
 807                 }
 808                 else
 809                 {
 810                         nlwarning("leaf '%s' already exists!", tableLeafPD.Path.c_str());
 811                         DEBUG_STOP;
 812                 }
 813         }
 814 }
 815
 816
 817 // ****************************************************************************
 818 void CStatDB::load()
 819 {
 820         H_AUTO(CStatDB_load);
 821
 822         if (EGSLight)
 823         {
 824                 _SDBIsLoaded = true;
 825                 return;
 826         }
 827
 828         if (_SDBIsLoaded)
 829                 return;
 830
 831         nTotalLoaded = 0;
 832
 833 //      // create SDB path
 834 //      {
 835 //              string sPath = Bsi.getLocalPath() + "sdb";
 836 //              if (!CFile::isExists(sPath))
 837 //                      CFile::createDirectory(sPath);
 838 //      }
 839
 840         // load value leaves
 841         {
 842                 H_AUTO(CStatDB_load_1);
 843
 844 //              string sFilePath = Bsi.getLocalPath();
 845                 string sFilePath = toString("sdb/value_leaves_pdr.%s", (XMLSave?"xml":"bin"));
 846
 847                 TValueLeaveFileCallback *cb = new TValueLeaveFileCallback;
 848
 849                 Bsi.syncLoadFile(sFilePath, cb);
 850
 851 //              if (CFile::isExists(sFilePath))
 852 //              {
 853 //                      static CPersistentDataRecord    pdr;
 854 //                      pdr.clear();
 855 //                      CStatDBValueLeavesPD valueLeavesPD;
 856 //
 857 //                      pdr.readFromFile(sFilePath);
 858 //                      valueLeavesPD.apply(pdr);
 859 //                      nTotalLoaded += CFile::getFileSize(sFilePath);
 860 //
 861 //                      for (uint32 i = 0; i < valueLeavesPD.ValueLeavesPD.size(); ++i)
 862 //                      {
 863 //                              const CStatDBValueLeafPD & valueLeafPD = valueLeavesPD.ValueLeavesPD[i];
 864 //
 865 //                              IStatDBNodePtr node = _Root->getNode(valueLeafPD.Path);
 866 //                              if (node == NULL)
 867 //                              {
 868 //                                      bool res = _Root->setNode(valueLeafPD.Path, new CStatDBValueLeaf(valueLeafPD.Value));
 869 //                                      if (!res)
 870 //                                      {
 871 //                                              nlwarning("value leaf '%s' cannot be created!", valueLeafPD.Path.c_str());
 872 //                                              DEBUG_STOP;
 873 //                                      }
 874 //                              }
 875 //                              else
 876 //                              {
 877 //                                      nlwarning("leaf '%s' already exists!", valueLeafPD.Path.c_str());
 878 //                                      DEBUG_STOP;
 879 //                              }
 880 //                      }
 881 //              }
 882         }
 883
 884         // load table leaves
 885 //      string sdbSavePath = Bsi.getLocalPath() + "sdb";
 886
 887
 888         // get the file list
 889         vector<CBackupFileClass> fileClasses(1);
 890         fileClasses[0].Patterns.push_back(toString("table_leaf_*.%s", XMLSave ? "xml" : "bin"));
 891         TFileClassCallback *ccb = new TFileClassCallback;
 892         Bsi.syncLoadFileClass("sdb", fileClasses, ccb);
 893
 894         // load the files
 895         TTableLeaveFileCallback *cb2 = new TTableLeaveFileCallback;
 896         Bsi.syncLoadFiles(fileNames, cb2);
 897
 898 //      std::vector<std::string> files;
 899 //      CPath::getPathContent(sdbSavePath, false, false, true, files);
 900 //      for (uint i = 0; i < files.size(); i++)
 901 //      {
 902 //              const string & fileName = files[i];
 903 //
 904 //              if (    CFile::getFilename(fileName).substr(0, 11) == "table_leaf_"
 905 //                      &&      CFile::getExtension(fileName) == (XMLSave?"xml":"bin"))
 906 //              {
 907 //                      H_AUTO(CStatDB_load_2);
 908 //
 909 //                      static CPersistentDataRecord    pdr;
 910 //                      pdr.clear();
 911 //                      CStatDBTableLeafPD tableLeafPD;
 912 //
 913 //                      pdr.readFromFile(fileName);
 914 //                      tableLeafPD.apply(pdr);
 915 //                      nTotalLoaded += CFile::getFileSize(fileName);
 916 //
 917 //                      IStatDBNodePtr node = _Root->getNode(tableLeafPD.Path);
 918 //                      if (node == NULL)
 919 //                      {
 920 //                              bool res = _Root->setNode(tableLeafPD.Path, new CStatDBTableLeaf(tableLeafPD.PlayerValues, tableLeafPD.GuildValues));
 921 //                              if (!res)
 922 //                              {
 923 //                                      nlwarning("table leaf '%s' cannot be created!", tableLeafPD.Path.c_str());
 924 //                                      DEBUG_STOP;
 925 //                              }
 926 //                      }
 927 //                      else
 928 //                      {
 929 //                              nlwarning("leaf '%s' already exists!", tableLeafPD.Path.c_str());
 930 //                              DEBUG_STOP;
 931 //                      }
 932 //              }
 933 //      }
 934
 935         nlinfo("SDB: loaded %u bytes", nTotalLoaded);
 936
 937         _SDBIsLoaded = true;
 938         if (canInitMFS())
 939                 initMFS();
 940 }
 941
 942 // ****************************************************************************
 943 bool CStatDB::canInitMFS() const
 944 {
 945         return (_SDBIsLoaded && _GuildsAreLoaded && _MFSIsUp);
 946 }
 947
 948 // ****************************************************************************
 949 void CStatDB::initMFS()
 950 {
 951         H_AUTO(CStatDB_initMFS);
 952
 953         nlassert(canInitMFS());
 954
 955         if (_MFSIsInitialized)
 956                 return;
 957
 958         uint32 shardId = IService::getInstance()->getShardId();
 959         if ( shardId == DEFAULT_SHARD_ID )
 960         {
 961 #ifdef NL_OS_WINDOWS
 962                 nlwarning
 963 #else
 964                 nlerror
 965 #endif
 966                 ( "SDB: Sending default shard id (%u) to MFS", DEFAULT_SHARD_ID );
 967         }
 968         CStatDBAllLeavesMsg allLeavesMsg;
 969         CStatDBMFSInitLeafCollector().loadLeaves(_Root, allLeavesMsg);
 970
 971         CMessage msgout("SDB:INIT");
 972         msgout.serial(shardId);
 973         msgout.serial(allLeavesMsg);
 974
 975         nlinfo("SDB: initMFS: send %u bytes to MFS", msgout.length());
 976
 977         CUnifiedNetwork::getInstance()->send("MFS", msgout);
 978
 979         _MFSIsInitialized = true;
 980 }
 981
 982 // ****************************************************************************
 983 void CStatDB::cbMFServiceUp()
 984 {
 985         _MFSIsUp = true;
 986         if (canInitMFS())
 987                 initMFS();
 988 }
 989
 990 // ****************************************************************************
 991 void CStatDB::cbMFServiceDown()
 992 {
 993         _MFSIsUp = false;
 994         _MFSIsInitialized = false;
 995 }
 996
 997 // ****************************************************************************
 998 void CStatDB::cbGuildsLoaded()
 999 {
1000         _GuildsAreLoaded = true;
1001         if (canInitMFS())
1002                 initMFS();
1003 }
1004
1005 // ****************************************************************************
1006 void CStatDB::tickUpdate()
1007 {
1008         H_AUTO(CStatDB_tickUpdate);
1009
1010         if (!_SDBIsLoaded)
1011                 return;
1012
1013         // process players and guilds removal at every ticks
1014         {
1015                 H_AUTO(CStatDB_tickUpdate_1);
1016                 _EntitiesRemoval.processRemoval(_Root);
1017         }
1018
1019         // save SDB at every StatDBSavePeriod ticks
1020         if (CTickEventHandler::getGameCycle() % StatDBSavePeriod.get() != 0)
1021                 return;
1022
1023         if (_BackupLeafCollector.isEmpty())
1024         {
1025                 H_AUTO(CStatDB_tickUpdate_2);
1026                 _BackupLeafCollector.loadLeaves(_Root);
1027
1028                 // save value leaves file
1029                 // even if there is no value leaf because a complete database erase must be saved
1030                 saveValueLeaves(_BackupLeafCollector.getValueLeavesPD());
1031                 _BackupLeafCollector.getValueLeavesPD().ValueLeavesPD.clear();
1032         }
1033         else
1034         {
1035                 CStatDBTableLeafPD tableLeafPD;
1036                 if (_BackupLeafCollector.popTableLeafPD(tableLeafPD))
1037                 {
1038                         H_AUTO(CStatDB_tickUpdate_4);
1039                         saveTableLeaf(tableLeafPD);
1040                 }
1041         }
1042 }
1043
1044 // ****************************************************************************
1045 void CStatDB::saveAll()
1046 {
1047         _BackupLeafCollector.loadLeaves(_Root);
1048
1049         saveValueLeaves(_BackupLeafCollector.getValueLeavesPD());
1050         _BackupLeafCollector.getValueLeavesPD().ValueLeavesPD.clear();
1051
1052         CStatDBTableLeafPD tableLeafPD;
1053         while (_BackupLeafCollector.popTableLeafPD(tableLeafPD))
1054         {
1055                 saveTableLeaf(tableLeafPD);
1056         }
1057 }
1058
1059 // ****************************************************************************
1060 void CStatDB::saveValueLeaves(const CStatDBValueLeavesPD & valueLeavesPD)
1061 {
1062         string sFilePath = toString("sdb/value_leaves_pdr.%s", (XMLSave?"xml":"bin"));
1063
1064         static CPersistentDataRecordRyzomStore  pdr;
1065         pdr.clear();
1066         valueLeavesPD.store(pdr);
1067
1068         CBackupMsgSaveFile msg( sFilePath, CBackupMsgSaveFile::SaveFile, Bsi );
1069         if (XMLSave)
1070         {
1071                 string s;
1072                 pdr.toString(s);
1073                 msg.DataMsg.serialBuffer((uint8*)&s[0], (uint)s.size());
1074         }
1075         else
1076         {
1077                 uint size = pdr.totalDataSize();
1078                 vector<char> buffer(size);
1079                 pdr.toBuffer(&buffer[0], size);
1080                 msg.DataMsg.serialBuffer((uint8*)&buffer[0], size);
1081         }
1082
1083 //      nlinfo("saveValueLeaves send %u bytes to BS", msgout.length());
1084         Bsi.sendFile( msg );
1085 }
1086
1087 // ****************************************************************************
1088 void CStatDB::saveTableLeaf(const CStatDBTableLeafPD & tableLeafPD)
1089 {
1090         string sFilePath = toString("sdb/table_leaf_%s_pdr.%s", tableLeafPD.Path.c_str(), (XMLSave?"xml":"bin"));
1091
1092         static CPersistentDataRecordRyzomStore  pdr;
1093         pdr.clear();
1094         tableLeafPD.store(pdr);
1095
1096         CBackupMsgSaveFile msg( sFilePath, CBackupMsgSaveFile::SaveFile, Bsi );
1097         if (XMLSave)
1098         {
1099                 string s;
1100                 pdr.toString(s);
1101                 msg.DataMsg.serialBuffer((uint8*)&s[0], (uint)s.size());
1102         }
1103         else
1104         {
1105                 uint size = pdr.totalDataSize();
1106                 vector<char> buffer(size);
1107                 pdr.toBuffer(&buffer[0], size);
1108                 msg.DataMsg.serialBuffer((uint8*)&buffer[0], size);
1109         }
1110
1111 //      nlinfo("saveTableLeaf(%s) send %u bytes to BS", tableLeafPD.Path.c_str(), msgout.length());
1112         Bsi.sendFile( msg );
1113 }
1114
1115 // ****************************************************************************
1116 // Commands
1117 // ****************************************************************************
1118
1119 // ****************************************************************************
1120 NLMISC_COMMAND (sdbCreateValue, "create a value leaf in SDB", "<path> [<value>]")
1121 {
1122         if (args.size() < 1 || args.size() > 2)
1123                 return false;
1124
1125         const string & path = args[0];
1126         sint32 val;
1127         if (args.size() < 2)
1128                 val = 0;
1129         else
1130                 NLMISC::fromString(args[1], val);
1131
1132         if (!CStatDB::getInstance()->createValue(path, val))
1133         {
1134                 log.displayNL("cannot create a value leaf at the path '%s' (invalid path or already existing node)",
1135                         path.c_str());
1136         }
1137
1138         return true;
1139 }
1140
1141 // ****************************************************************************
1142 NLMISC_COMMAND (sdbCreateTable, "create a table leaf in SDB", "<path>")
1143 {
1144         if (args.size() != 1)
1145                 return false;
1146
1147         const string & path = args[0];
1148         if (!CStatDB::getInstance()->createTable(path))
1149         {
1150                 log.displayNL("cannot create a table leaf at the path '%s' (invalid path or already existing node)",
1151                         path.c_str());
1152         }
1153
1154         return true;
1155 }
1156
1157 // ****************************************************************************
1158 NLMISC_COMMAND (sdbRemoveNode, "remove a node from SDB", "<path>")
1159 {
1160         if (args.size() != 1)
1161                 return false;
1162
1163         const string & path = args[0];
1164         if (!CStatDB::getInstance()->removeNode(path))
1165         {
1166                 log.displayNL("path '%s' not found", path.c_str());
1167         }
1168
1169         return true;
1170 }
1171
1172 // ****************************************************************************
1173 NLMISC_COMMAND (sdbValueSet, "set a value leaf in SDB", "<path> <value>")
1174 {
1175         if (args.size() != 2)
1176                 return false;
1177
1178         const string & path = args[0];
1179         sint32 val;
1180         NLMISC::fromString(args[1], val);
1181
1182         if (!CStatDB::getInstance()->valueSet(path, val))
1183         {
1184                 log.displayNL("cannot find a value leaf at the path '%s'", path.c_str());
1185         }
1186
1187         return true;
1188 }
1189
1190 // ****************************************************************************
1191 NLMISC_COMMAND (sdbValueAdd, "add a value to a value leaf in SDB", "<path> <value>")
1192 {
1193         if (args.size() != 2)
1194                 return false;
1195
1196         const string & path = args[0];
1197         sint32 val;
1198         NLMISC::fromString(args[1], val);
1199
1200         if (!CStatDB::getInstance()->valueAdd(path, val))
1201         {
1202                 log.displayNL("cannot find a value leaf at the path '%s'", path.c_str());
1203         }
1204
1205         return true;
1206 }
1207
1208 // ****************************************************************************
1209 NLMISC_COMMAND (sdbTableAdd, "add a value to a table leaf in SDB", "<path> <value> <target=player|guild> <player_id|guild_name>")
1210 {
1211         if (args.size() != 4)
1212                 return false;
1213
1214         const string & path = args[0];
1215         sint32 val;
1216         NLMISC::fromString(args[1], val);
1217         const string & targetType = args[2];
1218
1219         if (targetType == "guild")
1220         {
1221                 CGuild * guild = CGuildManager::getInstance()->getGuildByName(args[3]);
1222                 if (guild == NULL)
1223                 {
1224                         log.displayNL("unknown guild: '%s'", args[3].c_str());
1225                         return true;
1226                 }
1227
1228                 if (!CStatDB::getInstance()->tableGuildAdd(path, guild->getId(), val))
1229                 {
1230                         log.displayNL("cannot find a table leaf at the path '%s'", path.c_str());
1231                 }
1232         }
1233         else
1234         {
1235                 CEntityId playerId;
1236                 playerId.fromString(args[3].c_str());
1237
1238                 if (playerId.getType() != RYZOMID::player)
1239                 {
1240                         log.displayNL("id %s is not a player id", playerId.toString().c_str());
1241                         return true;
1242                 }
1243
1244                 if (!CEntityIdTranslator::getInstance()->isEntityRegistered(playerId))
1245                 {
1246                         log.displayNL("player id %s is unknown", playerId.toString().c_str());
1247                         return true;
1248                 }
1249
1250                 if (!CStatDB::getInstance()->tablePlayerAdd(path, playerId, val))
1251                 {
1252                         log.displayNL("cannot find a table leaf at the path '%s'", path.c_str());
1253                 }
1254         }
1255
1256         return true;
1257 }
1258
1259 // ****************************************************************************
1260 NLMISC_COMMAND (sdbRemovePlayer, "remove a player from the whole SDB", "<player_id>")
1261 {
1262         if (args.size() != 1)
1263                 return false;
1264
1265         CEntityId playerId;
1266         playerId.fromString(args[0].c_str());
1267
1268         CStatDB::getInstance()->removePlayer(playerId);
1269
1270         return true;
1271 }
1272
1273 // ****************************************************************************
1274 NLMISC_COMMAND (sdbRemoveGuild, "remove a guild from the whole SDB", "<guild_name>")
1275 {
1276         if (args.size() != 1)
1277                 return false;
1278
1279         CGuild * guild = CGuildManager::getInstance()->getGuildByName(args[0]);
1280         if (guild == NULL)
1281         {
1282                 log.displayNL("unknown guild: '%s'", args[0].c_str());
1283                 return true;
1284         }
1285
1286         CStatDB::getInstance()->removeGuild(guild->getId());
1287
1288         return true;
1289 }
1290
1291 // ****************************************************************************
1292 NLMISC_COMMAND (sdbDisplayNodes, "display nodes of SDB", "<path> [<recursive>] [<display_values>] [<display_tables>]")
1293 {
1294         if (args.size() < 1 || args.size() > 4)
1295                 return false;
1296
1297         const string & pathPattern = args[0];
1298
1299         CStatDBNodeDisplayer::CSettings settings;
1300
1301         if (args.size() >= 2)
1302                 settings.Recursive = (args[1] == "1" || args[1] == "true");
1303
1304         if (args.size() >= 3)
1305                 settings.DisplayValueLeafContent = (args[2] == "1" || args[2] == "true");
1306
1307         if (args.size() >= 4)
1308                 settings.DisplayTableLeafContent = (args[3] == "1" || args[3] == "true");
1309
1310         settings.DisplayBranch = !settings.Recursive;
1311
1312         if (!CStatDB::getInstance()->displayNodes(pathPattern, log, settings))
1313         {
1314                 log.displayNL("path '%s' not found", pathPattern.c_str());
1315         }
1316
1317         return true;
1318 }
1319
1320 // ****************************************************************************
1321 NLMISC_COMMAND (sdbSaveNow, "save the whole SDB now (WARNING: it may stall the shard and flood the Backup Service)", "")
1322 {
1323         if (args.size() != 0)
1324                 return false;
1325
1326         CStatDB::getInstance()->saveAll();
1327
1328         return true;
1329 }
1330
1331
1332 #if !FINAL_VERSION
1333
1334 extern NLMISC::CRandom RandomGenerator;
1335 // ****************************************************************************
1336 NLMISC_COMMAND (sdbInitEpisode2, "(debug) init fake database for Episode2 tests", "")
1337 {
1338         // Episode II init
1339         // Leaf simple pour le harvest
1340         const char *peuple[] = { "fyros", "matis", "tryker", "zorai" };
1341         uint peupleNB = sizeof(peuple)/sizeof(peuple[0]);
1342         const char *faction[] = { "kami", "karavan" };
1343         uint factionNB = sizeof(faction)/sizeof(faction[0]);
1344         const char *mp[] = { "carapace_a", "resine_a", "bois_a", "fibre_o","resine_o", "ecorce_o",
1345                                         "carapace_i", "resine_i", "boucle_i", "bois_i" };
1346         uint mpNB = sizeof(mp)/sizeof(mp[0]);
1347         const char *mpByFaction[] = { "seve", "amber" };
1348         uint mpByFactionNB = sizeof(mpByFaction)/sizeof(mpByFaction[0]);
1349
1350         for (uint i = 0; i < peupleNB; ++i)
1351         for (uint j = 0; j < factionNB; ++j)
1352         {
1353                 string sPath = "storyline.episode2.";
1354                 sPath += toString(peuple[i]) + ".";
1355                 sPath += toString(faction[j]) + ".";
1356                 for (uint k = 0; k < mpNB; ++k)
1357                 {
1358                         string sTmpPath = sPath + mp[k];
1359                         CStatDB::getInstance()->createValue(sTmpPath+toString(".qtemin"), RandomGenerator.rand(500));
1360                         CStatDB::getInstance()->createValue(sTmpPath+toString(".qtemax"), RandomGenerator.rand(500));
1361                 }
1362                 CStatDB::getInstance()->createValue(sPath+mpByFaction[j]+toString(".qtemin"), RandomGenerator.rand(500));
1363                 CStatDB::getInstance()->createValue(sPath+mpByFaction[j]+toString(".qtemax"), RandomGenerator.rand(500));
1364         }
1365
1366         // Leaf simple pour le craft
1367         const char *craft[] = { "socle", "colonne", "comble", "muraille", "revetement", "ornement", "statue",
1368                 "colonne_justice", "racine", "tronc", "fibre", "ecorce", "feuille", "fleur", "symbole", "noyau" };
1369         uint craftNB = sizeof(craft)/sizeof(craft[0]);
1370         for (uint i = 0; i < peupleNB; ++i)
1371         {
1372                 for (uint j = 0; j < craftNB; ++j)
1373                 {
1374                         string sPath = "storyline.episode2.";
1375                         sPath += toString(peuple[i]) + ".";
1376                         sPath += toString(craft[j]);
1377                         CStatDB::getInstance()->createValue(sPath+toString(".qtemin"), RandomGenerator.rand(500));
1378                         CStatDB::getInstance()->createValue(sPath+toString(".qtemax"), RandomGenerator.rand(500));
1379                 }
1380         }
1381
1382         // Leaf simple pour les maxima
1383         const char *max_values[] = { "socle_max", "colonne_max", "comble_max", "muraille_max", "revetement_max",
1384                 "ornement_max", "statue_max", "colonne_justice_max", "racine_max", "tronc_max", "fibre_max",
1385                 "ecorce_max", "feuille_max", "fleur_max", "symbole_max", "noyau_max" };
1386         uint max_valuesNB = sizeof(max_values)/sizeof(max_values[0]);
1387         for (uint i = 0; i < peupleNB; ++i)
1388         {
1389                 for (uint j = 0; j < max_valuesNB; ++j)
1390                 {
1391                         string sPath = "storyline.episode2.";
1392                         sPath += toString(peuple[i]) + ".";
1393                         sPath += toString(max_values[j]);
1394                         CStatDB::getInstance()->createValue(sPath, 500 + RandomGenerator.rand(500));
1395                 }
1396         }
1397
1398         // Tableaux de joueurs
1399         const char *action[] = { "craft", "harvest", "kill" };
1400         uint actionNB = sizeof(action)/sizeof(action[0]);
1401         const char *acte[] = { "acte1", "acte2", "acte3" };
1402         uint acteNB = sizeof(acte)/sizeof(acte[0]);
1403         for (uint i = 0; i < peupleNB; ++i)
1404         for (uint j = 0; j < factionNB; ++j)
1405         for (uint k = 0; k < actionNB; ++k)
1406         for (uint m = 0; m < acteNB; ++m)
1407         {
1408                 string sPath = "storyline.episode2.";
1409                 sPath += toString(peuple[i]) + ".";
1410                 sPath += toString(faction[j]) + ".";
1411                 sPath += toString(action[k]) + ".";
1412                 sPath += toString(acte[m]);
1413
1414                 CStatDB::getInstance()->createTable(sPath);
1415
1416                 uint nbjoueur = 100+RandomGenerator.rand(400);
1417                 for (uint n = 0; n < nbjoueur; ++n)
1418                 {
1419                         CEntityId playerId;
1420                         playerId.setShortId(RandomGenerator.rand(5000) << 4);
1421                         playerId.setType(RYZOMID::player);
1422                         CStatDB::getInstance()->tablePlayerAdd(sPath, playerId, 10 * RandomGenerator.rand(5000));
1423                 }
1424
1425                 uint nbguild = 250+RandomGenerator.rand(250);
1426                 for (uint n = 0; n < nbguild; ++n)
1427                 {
1428
1429                         EGSPD::TGuildId guildId = uint32(RandomGenerator.rand(20500));
1430                         CStatDB::getInstance()->tableGuildAdd(sPath, guildId, 100 * RandomGenerator.rand(10000));
1431                 }
1432         }
1433
1434         return true;
1435 }
1436
1437 #endif // !FINAL_VERSION
1438