ryzom/client/src/interface_v3/sbrick_manager.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2014-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23 #include "stdpch.h"
  24 #include "sbrick_manager.h"
  25 #include "interface_manager.h"
  26 #include "../sheet_manager.h"
  27 #include "dbgroup_build_phrase.h"
  28 #include "skill_manager.h"
  29
  30
  31 using namespace std;
  32 using namespace NLMISC;
  33 using namespace NLGEORGES;
  34
  35
  36 CSBrickManager* CSBrickManager::_Instance = NULL;
  37
  38 // ***************************************************************************
  39 void CSBrickManager::releaseInstance()
  40 {
  41         if( _Instance )
  42         {
  43                 delete _Instance;
  44                 _Instance = NULL;
  45         }
  46 }
  47
  48 // ***************************************************************************
  49 CSBrickManager::CSBrickManager() : _NbFamily(0), _SabrinaCom(&_BrickContainer)
  50 {
  51         _BrickFamilyObs.Owner= this;
  52 }
  53
  54 // ***************************************************************************
  55 void CSBrickManager::init()
  56 {
  57         // Read the Bricks from the SheetMngr.
  58         const CSheetManager::TEntitySheetMap &sheetMap = SheetMngr.getSheets();
  59         _BrickVector.clear();
  60         _BrickVector.reserve(16 * 1024);
  61         uint32 shtype = CSheetId::typeFromFileExtension("sbrick");
  62         for (CSheetManager::TEntitySheetMap::const_iterator it(sheetMap.begin()), end(sheetMap.end()); it != end; ++it)
  63         {
  64                 // it's a brick?
  65                 CSBrickSheet *br = dynamic_cast<CSBrickSheet *>(it->second.EntitySheet); // TODO: Avoid dynamic_cast, depend on getSheetType
  66                 if (br)
  67                 {
  68                         // ok, add it
  69                         uint32 shid = it->first.getShortId();
  70                         nlassert(shtype == it->first.getSheetType());
  71                         if (shid >= _BrickVector.size())
  72                                 _BrickVector.resize(shid + 1);
  73                         _BrickVector[shid] = br;
  74                 }
  75         }
  76
  77         // Process Bricks
  78         if (_BrickVector.empty()) return;
  79
  80         // Build the vector of family bit fields, and the vector of existing bricks
  81         for (std::vector<CSBrickSheet *>::iterator itb(_BrickVector.begin()), endb(_BrickVector.end()); itb != endb; ++itb)
  82         {
  83                 CSBrickSheet *brickSheet = *itb;
  84                 if (!brickSheet)
  85                         continue;
  86
  87                 // Resize our vectors if necessary
  88                 if (brickSheet->BrickFamily >= (sint32)_NbFamily)
  89                 {
  90                         _SheetsByFamilies.resize(brickSheet->BrickFamily + 1);
  91                         _FamiliesBits.resize(brickSheet->BrickFamily + 1, 0);
  92                         _NbBricksPerFamily.resize(brickSheet->BrickFamily + 1, 0);
  93
  94                         _NbFamily = brickSheet->BrickFamily + 1;
  95                 }
  96         }
  97
  98         // Since _SheetsByFamilies is a vector of vector, avoid long reallocation by building it in 2 pass
  99         sint32 shidc = -1;
 100         for (std::vector<CSBrickSheet *>::iterator itb(_BrickVector.begin()), endb(_BrickVector.end()); itb != endb; ++itb)
 101         {
 102                 ++shidc;
 103                 CSBrickSheet *brickSheet = *itb;
 104                 if (!brickSheet)
 105                         continue;
 106
 107                 // Resize our vectors if necessary
 108                 // The index in familly must be decremented because the values start at 1 in the sheets
 109                 if (brickSheet->IndexInFamily < 1)
 110                 {
 111                         nlwarning("CSBrickManager::CSBrickManager(): Reading file: %s: IndexInFamily==0 but should be >=1 - entry ignored", brickSheet->Id.toString().c_str());
 112                         continue;
 113                 }
 114                 if (_NbBricksPerFamily[brickSheet->BrickFamily] < (uint)(brickSheet->IndexInFamily))
 115                 {
 116                         _SheetsByFamilies[brickSheet->BrickFamily].resize(brickSheet->IndexInFamily);
 117                         _NbBricksPerFamily[brickSheet->BrickFamily] = brickSheet->IndexInFamily;
 118                 }
 119                 _SheetsByFamilies[brickSheet->BrickFamily][brickSheet->IndexInFamily - 1] = brickSheet->Id;
 120         }
 121
 122         // check brick content for client.
 123         checkBricks();
 124
 125         // make root list
 126         makeRoots();
 127
 128         // Make interface bricks
 129         makeVisualBrickForSkill();
 130
 131         // compile brick properties
 132         compileBrickProperties();
 133
 134         // see getInterfaceRemoveBrick
 135         _InterfaceRemoveBrick.buildSheetId("big_remove.sbrick");
 136 }
 137
 138 // ***************************************************************************
 139 void CSBrickManager::initInGame()
 140 {
 141         CInterfaceManager* pIM = CInterfaceManager::getInstance();
 142
 143         // shortcut to the node
 144         char buf[100];
 145         for(uint i=0;i<_FamiliesBits.size();i++)
 146         {
 147                 //get the known brick entries in the database
 148                 sprintf(buf,"SERVER:BRICK_FAMILY:%d:BRICKS",i);
 149                 _FamiliesBits[i] = NLGUI::CDBManager::getInstance()->getDbProp(buf);
 150         }
 151
 152         // Add a branch observer on brick family
 153         NLGUI::CDBManager::getInstance()->addBranchObserver( "SERVER:BRICK_FAMILY", &_BrickFamilyObs);
 154 }
 155
 156 // ***************************************************************************
 157 void CSBrickManager::uninitInGame()
 158 {
 159         CInterfaceManager* pIM = CInterfaceManager::getInstance();
 160
 161         // remove shortcuts to the node
 162         for(uint i=0;i<_FamiliesBits.size();i++)
 163         {
 164                 _FamiliesBits[i] = NULL;
 165         }
 166
 167         // remove branch observer on brick family
 168         CCDBNodeBranch  *branch= NLGUI::CDBManager::getInstance()->getDbBranch("SERVER:BRICK_FAMILY");
 169         if(branch)
 170                 branch->removeBranchObserver(&_BrickFamilyObs);
 171 }
 172
 173 // ***************************************************************************
 174 CSBrickManager::~CSBrickManager()
 175 {
 176 }
 177
 178
 179 // ***************************************************************************
 180 CSheetId CSBrickManager::getBrickSheet(uint family, uint index) const
 181 {
 182         if (family >= _NbFamily)
 183                 return NLMISC::CSheetId(0);
 184         if ( index >= _NbBricksPerFamily[family] )
 185                 return NLMISC::CSheetId(0);
 186         return _SheetsByFamilies[family][index];
 187 }
 188
 189
 190 // ***************************************************************************
 191 sint64 CSBrickManager::getKnownBrickBitField(uint family) const
 192 {
 193         if (family < _NbFamily && _FamiliesBits[family])
 194                 return _FamiliesBits[family]->getValue64();
 195         return 0;
 196 }
 197
 198 // ***************************************************************************
 199 CCDBNodeLeaf*   CSBrickManager::getKnownBrickBitFieldDB(uint family) const
 200 {
 201         if (family < _NbFamily && _FamiliesBits[family])
 202                 return _FamiliesBits[family];
 203         return NULL;
 204 }
 205
 206
 207
 208 // ***************************************************************************
 209 void                    CSBrickManager::makeRoots()
 210 {
 211         _Roots.clear();
 212
 213         for (std::vector<CSBrickSheet *>::size_type ib = 0; ib < _BrickVector.size(); ++ib)
 214         {
 215                 const CSBrickSheet *brickSheet = _BrickVector[ib];
 216                 if (!brickSheet)
 217                         continue;
 218
 219                 // List only the Roots
 220                 if (!brickSheet->isRoot())
 221                         continue;
 222
 223                 _Roots.push_back(brickSheet->Id);
 224         }
 225
 226 }
 227
 228 // ***************************************************************************
 229 const std::vector<NLMISC::CSheetId>             &CSBrickManager::getFamilyBricks(uint family) const
 230 {
 231         static  std::vector<NLMISC::CSheetId>   empty;
 232
 233         if (family >= _NbFamily)
 234                 return empty;
 235         return _SheetsByFamilies[family];
 236 }
 237
 238 // ***************************************************************************
 239 void                    CSBrickManager::checkBricks()
 240 {
 241         for (std::vector<CSBrickSheet *>::size_type ib = 0; ib < _BrickVector.size(); ++ib)
 242         {
 243                 CSBrickSheet *brickSheet = _BrickVector[ib];
 244                 if (!brickSheet)
 245                         continue;
 246
 247                 if (brickSheet->ParameterFamilies.size() > CDBGroupBuildPhrase::MaxParam)
 248                 {
 249                         nlwarning("The Sheet %s has too many parameters for Client Composition: %d/%d",
 250                                 brickSheet->Id.toString().c_str(), brickSheet->ParameterFamilies.size(), CDBGroupBuildPhrase::MaxParam);
 251
 252                         // reset them... don't crahs client, but won't work.
 253                         brickSheet->ParameterFamilies.clear();
 254                 }
 255         }
 256 }
 257
 258 // ***************************************************************************
 259 sint32          CSBrickManager::CBrickContainer::getSabrinaCost(NLMISC::CSheetId id) const
 260 {
 261         // get the true container
 262         CSBrickManager  *pBM= CSBrickManager::getInstance();
 263         CSBrickSheet    *brick= pBM->getBrick(id);
 264         if(brick)
 265         {
 266                 return brick->SabrinaCost;
 267         }
 268         else
 269         {
 270                 return 0;
 271         }
 272 }
 273
 274 // ***************************************************************************
 275 float           CSBrickManager::CBrickContainer::getSabrinaRelativeCost(NLMISC::CSheetId id) const
 276 {
 277         // get the true container
 278         CSBrickManager  *pBM= CSBrickManager::getInstance();
 279         CSBrickSheet    *brick= pBM->getBrick(id);
 280         if(brick)
 281         {
 282                 return brick->SabrinaRelativeCost;
 283         }
 284         else
 285         {
 286                 return 0.f;
 287         }
 288 }
 289
 290 // ***************************************************************************
 291 sint32          CSBrickManager::CBrickContainer::getNumParameters(NLMISC::CSheetId id) const
 292 {
 293         CSBrickManager  *pBM= CSBrickManager::getInstance();
 294         CSBrickSheet    *brick= pBM->getBrick(id);
 295         if(brick)
 296         {
 297                 return (sint32)brick->ParameterFamilies.size();
 298         }
 299         else
 300         {
 301                 return 0;
 302         }
 303 }
 304
 305
 306 // ***************************************************************************
 307 BRICK_FAMILIES::TBrickFamily    CSBrickManager::CBrickContainer::getBrickFamily(NLMISC::CSheetId id, uint& indexInFamily ) const
 308 {
 309         CSBrickManager  *pBM= CSBrickManager::getInstance();
 310         CSBrickSheet    *brick= pBM->getBrick(id);
 311         if(brick)
 312         {
 313                 indexInFamily = brick->IndexInFamily;
 314                 return brick->BrickFamily;
 315         }
 316         else
 317         {
 318                 return BRICK_FAMILIES::Unknown;
 319         }
 320 }
 321
 322 // ***************************************************************************
 323 BRICK_TYPE::EBrickType  CSBrickManager::CBrickContainer::getBrickType(NLMISC::CSheetId id) const
 324 {
 325         CSBrickManager  *pBM= CSBrickManager::getInstance();
 326         CSBrickSheet    *brick= pBM->getBrick(id);
 327         if(brick)
 328         {
 329                 return BRICK_FAMILIES::brickType(brick->BrickFamily);
 330         }
 331         else
 332         {
 333                 return BRICK_TYPE::UNKNOWN;
 334         }
 335 }
 336
 337 // ***************************************************************************
 338 TOOL_TYPE::TCraftingToolType    CSBrickManager::CBrickContainer::getFaberPlanToolType(NLMISC::CSheetId id) const
 339 {
 340         CSBrickManager  *pBM= CSBrickManager::getInstance();
 341         CSBrickSheet    *brick= pBM->getBrick(id);
 342         if(brick)
 343         {
 344                 return brick->FaberPlan.ToolType;
 345         }
 346         else
 347         {
 348                 return TOOL_TYPE::Unknown;
 349         }
 350 }
 351
 352
 353 // ***************************************************************************
 354 void                    CSBrickManager::makeVisualBrickForSkill()
 355 {
 356         // clear
 357         for (uint i = 0; i < SKILLS::NUM_SKILLS; ++i)
 358         {
 359                 _VisualBrickForSkill[i] = CSheetId();
 360         }
 361
 362         // fill with interface bricks
 363         for (std::vector<CSBrickSheet *>::size_type ib = 0; ib < _BrickVector.size(); ++ib)
 364         {
 365                 const CSBrickSheet *brickSheet = _BrickVector[ib];
 366                 if (!brickSheet)
 367                         continue;
 368
 369                 // List only bricks with family == BIF
 370                 if (brickSheet->BrickFamily == BRICK_FAMILIES::BIF)
 371                 {
 372                         if (brickSheet->getSkill() < SKILLS::NUM_SKILLS)
 373                         {
 374                                 _VisualBrickForSkill[brickSheet->getSkill()] = brickSheet->Id;
 375                         }
 376                 }
 377         }
 378 }
 379
 380 // ***************************************************************************
 381 CSheetId                CSBrickManager::getVisualBrickForSkill(SKILLS::ESkills s)
 382 {
 383         if(s<SKILLS::NUM_SKILLS)
 384                 return _VisualBrickForSkill[s];
 385         else
 386                 return CSheetId();
 387 }
 388
 389
 390 // ***************************************************************************
 391 void                    CSBrickManager::compileBrickProperties()
 392 {
 393         // clear
 394         _BrickPropIdMap.clear();
 395         uint    NumIds= 0;
 396
 397         // **** for all bricks, compile props
 398         for (std::vector<CSBrickSheet *>::size_type ib = 0; ib < _BrickVector.size(); ++ib)
 399         {
 400                 CSBrickSheet *brickSheet = _BrickVector[ib];
 401                 if (!brickSheet)
 402                         continue;
 403
 404                 // For all properties of this brick, compile
 405                 for (uint i = 0; i < brickSheet->Properties.size(); ++i)
 406                 {
 407                         CSBrickSheet::CProperty &prop = brickSheet->Properties[i];
 408                         string::size_type pos = prop.Text.find(':');
 409                         if (pos != string::npos)
 410                         {
 411                                 string key = toLowerAscii(prop.Text.substr(0, pos));
 412                                 string value = prop.Text.substr(pos + 1);
 413                                 // get key id.
 414                                 if (_BrickPropIdMap.find(key) == _BrickPropIdMap.end())
 415                                 {
 416                                         // Inc before to leave 0 as "undefined"
 417                                         _BrickPropIdMap[key] = ++NumIds;
 418                                 }
 419                                 prop.PropId = _BrickPropIdMap[key];
 420                                 fromString(value, prop.Value);
 421                                 pos = value.find(':');
 422                                 if (pos != string::npos)
 423                                         fromString(value.substr(pos + 1), prop.Value2);
 424                         }
 425                 }
 426         }
 427
 428         // Get usual PropIds
 429         HpPropId= getBrickPropId("hp");
 430         SapPropId= getBrickPropId("sap");
 431         StaPropId= getBrickPropId("sta");
 432         StaWeightFactorId = getBrickPropId("sta_weight_factor");
 433         FocusPropId= getBrickPropId("focus");
 434         CastTimePropId= getBrickPropId("ma_casting_time");
 435         RangePropId= getBrickPropId("ma_range");
 436
 437
 438         // **** for all bricks, recompute localized text with formated version
 439         string  textTemp;
 440         textTemp.reserve(1000);
 441         for (std::vector<CSBrickSheet *>::size_type ib = 0; ib < _BrickVector.size(); ++ib)
 442         {
 443                 CSBrickSheet *brickSheet = _BrickVector[ib];
 444                 if (!brickSheet)
 445                         continue;
 446
 447                 // Get the Brick texts
 448                 std::string texts[3];
 449                 texts[0]= STRING_MANAGER::CStringManagerClient::getSBrickLocalizedName(brickSheet->Id);
 450                 texts[1]= STRING_MANAGER::CStringManagerClient::getSBrickLocalizedDescription(brickSheet->Id);
 451                 texts[2]= STRING_MANAGER::CStringManagerClient::getSBrickLocalizedCompositionDescription(brickSheet->Id);
 452
 453                 // For alls texts, parse format
 454                 for(uint i=0;i<3;i++)
 455                 {
 456                         string  &text= texts[i];
 457                         textTemp.erase();
 458
 459                         // Parse the text
 460                         uint    textSize= (uint)text.size();
 461                         for(uint j=0;j<textSize;)
 462                         {
 463                                 // Property parsing?
 464                                 if(text[j]=='$')
 465                                 {
 466                                         // double $ ??
 467                                         if(j+1<textSize && text[j+1]=='$')
 468                                         {
 469                                                 textTemp+= '$';
 470                                                 j+= 2;
 471                                         }
 472                                         // else this is a key desc.
 473                                         else
 474                                         {
 475                                                 string  key;
 476                                                 uint    k= j+1;
 477                                                 bool    doAbs= false;
 478                                                 uint    paramId= 0;
 479                                                 // read option formating option
 480                                                 for(;;)
 481                                                 {
 482                                                         // Abs Value?
 483                                                         if(k<textSize && text[k]=='|')
 484                                                         {
 485                                                                 doAbs= true;
 486                                                                 k++;
 487                                                         }
 488                                                         // Param Id modifier? (ie read not the 0th value, but the 1th etc... up to 9)
 489                                                         else if(k<textSize && (uint8)text[k] < (uint8)'\x80' && isdigit(text[k]))
 490                                                         {
 491                                                                 char    tp[2];
 492                                                                 tp[0]= (char)text[k];
 493                                                                 tp[1]= 0;
 494                                                                 fromString(tp, paramId);
 495                                                                 k++;
 496                                                         }
 497                                                         else
 498                                                                 break;
 499                                                 }
 500                                                 // find the key end.
 501                                                 while(k<textSize && (isalpha((char)text[k]) || text[k]=='_'))
 502                                                 {
 503                                                         key+= (char)text[k];
 504                                                         k++;
 505                                                 }
 506                                                 // get the key and replace text with value
 507                                                 if (!key.empty())
 508                                                 {
 509                                                         // Parse all the brick properties if match the key
 510                                                         float   value= 0.f;
 511                                                         // get the wanted prop id
 512                                                         key = toLowerAscii(key);
 513                                                         uint    propId= getBrickPropId(key);
 514                                                         // if propid exist
 515                                                         if(propId)
 516                                                         {
 517                                                                 for(uint p=0;p<brickSheet->Properties.size();p++)
 518                                                                 {
 519                                                                         const CSBrickSheet::CProperty   &prop= brickSheet->Properties[p];
 520                                                                         if(prop.PropId==propId)
 521                                                                         {
 522                                                                                 if(paramId==0)
 523                                                                                         value= brickSheet->Properties[p].Value;
 524                                                                                 else
 525                                                                                 {
 526                                                                                         // must parse the initial text/ skip the identifier
 527                                                                                         string::size_type       pos= prop.Text.find(':');
 528                                                                                         uint    id= 0;
 529                                                                                         while(pos!=string::npos && id<paramId)
 530                                                                                         {
 531                                                                                                 // skip the ':', and next
 532                                                                                                 pos= prop.Text.find(':', pos+1);
 533                                                                                                 id++;
 534                                                                                         }
 535                                                                                         if(pos!=string::npos)
 536                                                                                         {
 537                                                                                                 // skip the :, and read the value
 538                                                                                                 fromString(prop.Text.substr(pos+1), value);
 539                                                                                         }
 540                                                                                 }
 541                                                                                 break;
 542                                                                         }
 543                                                                 }
 544                                                         }
 545                                                         // abs value?
 546                                                         if(doAbs)
 547                                                                 value= (float)fabs(value);
 548
 549                                                         // append to text wisely
 550                                                         sint32  floorVal= (sint32)floorf(value);
 551                                                         if( floorVal==value )
 552                                                                 textTemp+= toString("%d", floorVal);
 553                                                         else
 554                                                                 textTemp+= toString("%.3f", value);
 555                                                 }
 556                                                 // skip the keyword
 557                                                 j= k;
 558                                         }
 559                                 }
 560                                 // no, std letter
 561                                 else
 562                                 {
 563                                         textTemp+= text[j];
 564                                         j++;
 565                                 }
 566                         }
 567
 568                         // repalce with result
 569                         text= textTemp;
 570                 }
 571
 572                 // reset
 573                 STRING_MANAGER::CStringManagerClient::replaceSBrickName(brickSheet->Id, texts[0], texts[1], texts[2]);
 574         }
 575 }
 576
 577 // ***************************************************************************
 578 uint                    CSBrickManager::getBrickPropId(const std::string &name)
 579 {
 580         std::map<std::string, uint>::const_iterator             it;
 581         it= _BrickPropIdMap.find(name);
 582         if(it!=_BrickPropIdMap.end())
 583                 return it->second;
 584
 585         return 0;
 586 }
 587
 588 // ***************************************************************************
 589 NLMISC::CSheetId        CSBrickManager::getInterfaceRemoveBrick()
 590 {
 591         return _InterfaceRemoveBrick;
 592 }
 593
 594 // ***************************************************************************
 595 void                            CSBrickManager::filterKnownBricks(std::vector<CSheetId> &bricks)
 596 {
 597         std::vector<CSheetId>   res;
 598         res.reserve(bricks.size());
 599
 600         // keep only known ones
 601         for(uint i=0;i<bricks.size();i++)
 602         {
 603                 if(isBrickKnown(bricks[i]))
 604                         res.push_back(bricks[i]);
 605         }
 606
 607         // replace with filtered one
 608         bricks= res;
 609 }
 610
 611 // ***************************************************************************
 612 void                            CSBrickManager::appendBrickLearnedCallback(IBrickLearnedCallback *cb)
 613 {
 614         if(cb)
 615                 _BrickLearnedCallbackSet.insert(cb);
 616 }
 617
 618 // ***************************************************************************
 619 void                            CSBrickManager::removeBrickLearnedCallback(IBrickLearnedCallback *cb)
 620 {
 621         if(cb)
 622                 _BrickLearnedCallbackSet.erase(cb);
 623 }
 624
 625 // ***************************************************************************
 626 void                            CSBrickManager::CBrickFamilyObs::update(ICDBNode * /* node */)
 627 {
 628         CSBrickManager::TBLCBSet::iterator      it;
 629         for(it=Owner->_BrickLearnedCallbackSet.begin();it!=Owner->_BrickLearnedCallbackSet.end();it++)
 630         {
 631                 (*it)->onBrickLearned();
 632         }
 633 }