ryzom/client/src/interface_v3/sphrase_manager.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2014  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) 2013-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 #ifndef RY_SPHRASE_MANAGER_H
  22 #define RY_SPHRASE_MANAGER_H
  23
  24 #include "nel/misc/types_nl.h"
  25 #include "game_share/sphrase_com.h"
  26 #include "game_share/skills.h"
  27 #include "game_share/brick_types.h"
  28 #include "game_share/resistance_type.h"
  29 #include "req_skill_formula.h"
  30 #include "brick_learned_callback.h"
  31 #include "skill_change_callback.h"
  32 #include "trade_common.h"
  33 #include "nel/gui/interface_element.h"
  34 #include "../time_client.h"
  35
  36
  37 // ***************************************************************************
  38 const   std::string             PHRASE_DB_BOOK="UI:PHRASE:BOOK";
  39 const   std::string             PHRASE_DB_PROGRESSION[2]= {"UI:PHRASE:PROGRESS_ACTIONS", "UI:PHRASE:PROGRESS_UPGRADES"};
  40 const   std::string             PHRASE_DB_MEMORY="UI:PHRASE:MEMORY";
  41 const   std::string             PHRASE_DB_MEMORY_ALT="UI:PHRASE:MEMORY_ALT";
  42 const   std::string             PHRASE_DB_EXECUTE_NEXT="UI:PHRASE:EXECUTE_NEXT:PHRASE";
  43 const   std::string             PHRASE_DB_EXECUTE_NEXT_IS_CYCLIC="UI:PHRASE:EXECUTE_NEXT:ISCYCLIC";
  44 const   std::string             PHRASE_DB_BOTCHAT="LOCAL:TRADING";
  45 #define PHRASE_MAX_BOOK_SLOT            512
  46 #define PHRASE_MAX_PROGRESSION_SLOT     512
  47 #define PHRASE_MAX_MEMORY_SLOT          20
  48 #define PHRASE_MAX_BOTCHAT_SLOT         TRADE_MAX_ENTRIES
  49 // u16 only for client/server com.
  50 #define PHRASE_MAX_ID                           65535
  51
  52 // For phrase execution counter
  53 #define PHRASE_EXECUTE_COUNTER_MASK             255
  54 const   std::string             PHRASE_DB_COUNTER_NEXT="SERVER:EXECUTE_PHRASE:NEXT_COUNTER";
  55 const   std::string             PHRASE_DB_COUNTER_CYCLE="SERVER:EXECUTE_PHRASE:CYCLE_COUNTER";
  56
  57
  58 // TODO_OPTIM: too big test for the list_sheet* each frame with 512 entries!!!
  59
  60 class   CSuccessTableSheet;
  61 namespace NLMISC{
  62 class   CCDBNodeLeaf;
  63 }
  64
  65
  66 /** Special helper class for lua export : enclose a phrase into an object accessible to lua
  67   * This way we can setup the phrase tooltip in lua code instead of hardcoded C++ stuff letting
  68   * the possibility to the user to customize it to his liking.
  69   */
  70 class CSPhraseComAdpater : public CReflectableRefPtrTarget
  71 {
  72 public:
  73         CSPhraseCom             Phrase;
  74         REFLECT_EXPORT_START(CSPhraseComAdpater, CInterfaceElement)
  75                 REFLECT_LUA_METHOD("getCastTime",       luaGetCastTime)
  76                 REFLECT_LUA_METHOD("getCastRange",  luaGetCastRange)
  77                 REFLECT_LUA_METHOD("getHpCost",         luaGetHpCost)
  78                 REFLECT_LUA_METHOD("getSapCost",        luaGetSapCost)
  79                 REFLECT_LUA_METHOD("getFocusCost",      luaGetFocusCost)
  80                 REFLECT_LUA_METHOD("getStaCost",        luaGetStaCost)
  81                 REFLECT_LUA_METHOD("getName",           luaGetName)
  82                 REFLECT_LUA_METHOD("getDesc",           luaGetDesc)
  83                 REFLECT_LUA_METHOD("getSuccessRate",            luaGetSuccessRate)
  84                 REFLECT_LUA_METHOD("isMagicPhrase", luaIsMagicPhrase)
  85                 REFLECT_LUA_METHOD("isCombatPhrase", luaIsCombatPhrase)
  86                 REFLECT_LUA_METHOD("isPowerPhrase", luaIsPowerPhrase)
  87                 REFLECT_LUA_METHOD("getRegenTime", luaGetRegenTime)
  88                 REFLECT_LUA_METHOD("getTotalRegenTime", luaGetTotalRegenTime)
  89                 REFLECT_LUA_METHOD("getPowerDisableTime", luaGetPowerDisableTime)
  90         REFLECT_EXPORT_END
  91         int luaGetCastTime(CLuaState &ls);
  92         int luaGetCastRange(CLuaState &ls);
  93         int luaGetHpCost(CLuaState &ls);
  94         int luaGetSapCost(CLuaState &ls);
  95         int luaGetSuccessRate(CLuaState &ls);
  96         int luaGetFocusCost(CLuaState &ls);
  97         int luaGetStaCost(CLuaState &ls);
  98         int luaGetName(CLuaState &ls);
  99         int luaGetDesc(CLuaState &ls);
 100         int luaIsMagicPhrase(CLuaState &ls);
 101         int luaIsCombatPhrase(CLuaState &ls);
 102         int luaIsPowerPhrase(CLuaState &ls);
 103         int luaGetRegenTime(CLuaState &ls);
 104         int luaGetTotalRegenTime(CLuaState &ls);
 105         int luaGetPowerDisableTime(CLuaState &ls);
 106 };
 107
 108
 109
 110 // ***************************************************************************
 111 /**
 112  * Singleton to Get/Set Sabrina Phrase in SpellBook / Memory.
 113  *      NB: you MUST create it (getInstance()), before loading of ingame.xmls.
 114  * \author Lionel Berenguier
 115  * \author Nevrax France
 116  * \date 2003
 117  */
 118 class CSPhraseManager
 119 {
 120 public:
 121         static  CSPhraseManager         *getInstance()
 122         {
 123                 if(!_Instance)
 124                         _Instance= new CSPhraseManager;
 125                 return _Instance;
 126         }
 127
 128         // release singleton
 129         static void releaseInstance();
 130
 131         // The Slot 0 of the Book indicate "NoPhrase".
 132         // The Slot 1 indicate the Edited Phrase for phrase composition, and is not "really" a part of the book.
 133         enum    {EditionSlot= 1, BookStartSlot= 2};
 134
 135         /// To call when The DB inGame is setup. Else, no write is made to it before. (NB: DB is updated here)
 136         void                            initInGame();
 137
 138         /// Reset
 139         void                            reset();
 140
 141         /// Call juste once when interface is built
 142         void                            updateMemoryBar();
 143
 144         /// Call once per pass
 145         void                            update();
 146
 147         // \name Book Edition
 148         // @{
 149         /** set a phrase on a slot.
 150          *      \param lock special for BotChat phrase buy. when true, the phrase is never written in the book DB
 151          *              the server has to unlock it (or delete if not confirmed)
 152          *      NO MSG SENT
 153          */
 154         void                            setPhrase(uint32 slot, const CSPhraseCom &phrase, bool lock= false);
 155
 156         /** Same as setPhrase() but do not update the DB of book now
 157          *      User can use this if lot of phrase must be chaned in one time.
 158          *      User must call updateBookDB() after setting all those phrases.
 159          *      Nb: suppose lock==false.
 160          */
 161         void                            setPhraseNoUpdateDB(uint32 slot, const CSPhraseCom &phrase);
 162
 163         /// update Action Book Database. You need only to use it in conjunction with setPhraseNoUpdateDB()
 164         void                            updateBookDB();
 165
 166         /// erase a phrase on a slot. NO MSG SENT
 167         void                            erasePhrase(uint32 slot);
 168
 169         /// get a phrase for a slot. Empty Phrase returned if don't exist. O(logN)
 170         const CSPhraseCom       &getPhrase(uint32 slot) const;
 171
 172         /// get the number of memory lines.
 173         uint32                          getNbMemoryLines() const { return (uint32)_Memories.size(); }
 174
 175         /** Allocate a Free Slot (for NEW phrase setup). 0 is not a free slot
 176          *      NB: the slot is not still correctly filled(), and getPhrase() will return Empty. use setPhrase() just after
 177          *      \return 0 if not possible (eg too big)
 178          */
 179         uint32                          allocatePhraseSlot();
 180
 181         /// true if a free slot is available (don't allocate)
 182         bool                            hasFreeSlot() const;
 183
 184         /// get a phrase version for a slot. -1 if phrase not present. O(1)
 185         sint32                          getPhraseVersion(uint32 slot) const;
 186
 187         // Receive a BotChat phrase Buy confirmation: NB: memorize it (and server send) if possible
 188         void                            receiveBotChatConfirmBuy(uint16 phraseId, bool confirm);
 189
 190         // test if the given phrase is known
 191         bool                            isPhraseKnown(const CSPhraseCom &phrase) const;
 192
 193         /** Filter the BOOK DB with this brickType or skill.
 194          *       NB: if brickTypeFilter is UNKNOWN then filtered by skill
 195          *       il filterSkill is unknown, then not filtered (all match). This is the default.
 196          */
 197         void                            setBookFilter(BRICK_TYPE::EBrickType brickTypeFilter, SKILLS::ESkills skillFilter);
 198
 199         /// get the book skill filter
 200         SKILLS::ESkills         getBookSkillFilter() const {return _BookSkillFitler;}
 201
 202         /// Send the PHRASE:DELETE message to the server
 203         void                            sendDeleteToServer(uint32 slot);
 204
 205         /// Send the PHRASE:LEARN message to the server
 206         void                            sendLearnToServer(uint32 slot);
 207
 208         /// This is a clean full delete: forget all phrase before, erase the phrase, send msg to server
 209         void                            fullDelete(uint32 slot);
 210
 211         /** Do it only if the phrase id is only used in this memory slot
 212          *      This is a clean full delete: forget all phrase before, erase the phrase, send msg to server
 213          */
 214         void                            fullDeletePhraseIfLast(uint32 memoryLine, uint32 memorySlot);
 215
 216         // @}
 217
 218
 219         // \name Memory Edition
 220         // @{
 221
 222         /// Memorize a phrase (no MSG send)
 223         void                            memorizePhrase(uint32 memoryLine, uint32 memorySlot, uint32 slot);
 224         /// Forget a phrase (no MSG send). NB: no-op if it is a macro
 225         void                            forgetPhrase(uint32 memoryLine, uint32 memorySlot);
 226         /// Get the phrase memorized. 0 if not found or if it is a macro
 227         uint32                          getMemorizedPhrase(uint32 memoryLine, uint32 memorySlot) const;
 228
 229         /// Memorize a macro (no MSG send). if was a phrase, forget first (client and server)
 230         void                            memorizeMacro(uint32 memoryLine, uint32 memorySlot, uint32 macroId);
 231         /// Forget a macro. NB: no-op if it is a phrase
 232         void                            forgetMacro(uint32 memoryLine, uint32 memorySlot);
 233         /// Get the phrase memorized. 0 if not found or if it is a macro
 234         uint32                          getMemorizedMacro(uint32 memoryLine, uint32 memorySlot) const;
 235         /// return true if it is a memorized macro. false if empty or if it is a phrase
 236         bool                            isMemorizedMacro(uint32 memoryLine, uint32 memorySlot) const;
 237         /// To Be called when the macro visual changes
 238         void                            updateMacroShortcuts(sint32 macroId);
 239         /// To be called when the Id changes
 240         void                            deleteMacroShortcuts(sint32 macroId);
 241
 242         /// Only one memory line is displayed in the Memory DB. if -1, erased.
 243         void                            selectMemoryLineDB(sint32 memoryLine);
 244         void                            selectMemoryLineDBalt(sint32 memoryLine);
 245         /// get the selected memory line.
 246         sint32                          getSelectedMemoryLineDB() const {return _SelectedMemoryDB;}
 247         sint32                          getSelectedMemoryAltLineDB() const {return _SelectedMemoryDBalt;}
 248         /// Common Method to send the Memorize msg to server
 249         void                            sendMemorizeToServer(uint32 memoryLine, uint32 memorySlot, uint32 phraseId);
 250         /// Common Method to send the Forget msg to server
 251         void                            sendForgetToServer(uint32 memoryLine, uint32 memorySlot);
 252
 253         /// count all memories that use this phrase
 254         uint                            countAllThatUsePhrase(uint32 slot);
 255         /// Forget all Memories that use this phrase slot, AND send appropriate message to server. if sendMsgOnly==true, only the msg is sent to server (no modification to local)
 256         void                            forgetAllThatUsePhrase(uint32 slot, bool sendMsgOnly= false);
 257         /// Rememorize all memories that use this slot
 258         void                            rememorizeAllThatUsePhrase(uint32 slot);
 259
 260         /// Update all Ctrl State of the action Bar, according to macro/itemInRightHand/available states
 261         void                            updateAllMemoryCtrlState();
 262
 263         /// Load or save the macro
 264         void                            serialMacroMemory(NLMISC::IStream &f);
 265
 266         /// is this phrase sheet can be memorized / casted?
 267         bool                            isPhraseCastable(uint32 sheetId) const;
 268         bool                            isPhraseCastable(class CSPhraseSheet *phraseSheet) const;
 269         bool                            isPhraseCharacBuying(uint32 sheetId) const;
 270         bool                            isPhraseCharacBuying(class CSPhraseSheet *phraseSheet) const;
 271
 272         /** return getMemorizedPhrase(memoryLine, memoryIndex), only if this phrase is only used in this memory slot
 273      *  else return allocatePhraseSlot()
 274          */
 275         uint32                          getMemorizedPhraseIfLastOrNewSlot(uint32 memoryLine, uint32 memoryIndex);
 276
 277         // @}
 278
 279
 280         // \name Phrase composition
 281         // @{
 282         // The phrase edited/created. If 0, it may be a phrase newly created, but not still assigned.
 283         uint32                          CompositionPhraseId;
 284         // For phrase created only. If not -1, then at creation, will be auto-memorized to this slot
 285         sint32                          CompositionPhraseMemoryLineDest;
 286         sint32                          CompositionPhraseMemorySlotDest;
 287
 288
 289         /// For BotChat learning, build a phrase from .sphrase sheetId
 290         void                            buildPhraseFromSheet(CSPhraseCom &phrase, sint32 sheetId);
 291
 292         /** For a given phrase, see if there's a matching sheet, or 0 else.
 293           * NB : O(1) algo with respect to the number of phrase sheets
 294           */
 295         sint32                          getSheetFromPhrase(const CSPhraseCom &phrase) const;
 296
 297         // @}
 298
 299
 300         // \name Phrase Execution
 301         // @{
 302         /// Start execution from Client. Only the bitmaps are displayed. A sendExecuteToServer() or a cancelClientExecution() must follow for each clientExecute
 303         void                            clientExecute(uint32 memoryLine, uint32 memorySlot, bool cyclic);
 304         /// Common Method to send the execution msg to server
 305         void                            sendExecuteToServer(uint32 memoryLine, uint32 memorySlot, bool cyclic);
 306         /// Cancel the client execution (case when used with Move in combat for instance)
 307         void                            cancelClientExecute(bool cyclic);
 308         /// Execute a craft action (after selecting the plan and MPs), on both client and server side
 309         void                            executeCraft(uint32 memoryLine, uint32 memorySlot, uint32 planSheetId,
 310                 std::vector<CFaberMsgItem> &mpItemPartList, std::vector<CFaberMsgItem> specificItemList);
 311         /// Execute a cristalize action on both client and server side
 312         void                            executeCristalize(uint32 memoryLine, uint32 memorySlot);
 313         /** Execute a default attack, on both client and server side.
 314          *      NB: try first to launch a standard action "default attack" if found,
 315          *      calling clientExecute() and sendExecuteToServer()
 316          */
 317         void                            executeDefaultAttack();
 318         /// Search the default attack like on client. false if not found. NB: find preferly in current memoryLine
 319         bool                            findDefaultAttack(uint32 &memoryLine, uint32 &memorySlot);
 320
 321         uint                            getPhraseNextExecuteCounter() const {return _PhraseNextExecuteCounter;}
 322         uint                            getPhraseCycleExecuteCounter() const {return _PhraseCycleExecuteCounter;}
 323
 324         /// Server Execution ACK
 325         void                            receiveAckExecuteFromServer(bool cyclic, uint counterValue, bool ok);
 326
 327         /// get the Next PhraseId Executed (0 if none)
 328         uint32                          getNextExecutePhraseId() const {return _CurrentExecutePhraseIdNext;}
 329         /// get the Cycle PhraseId Executed (0 if none)
 330         uint32                          getCycleExecutePhraseId() const {return _CurrentExecutePhraseIdCycle;}
 331
 332         // @}
 333
 334         // \name Misc
 335         // @{
 336         /** Build the Text description of a phrase (spell). NB: this is a TagFormated text
 337          *      \phraseSheetId not 0 if comes from a .sphrase Sheet => used to show progression info, and display phrase description
 338          *  \specialPhraseFormat if empty, format is auto selected. if "composition", same but the text is cut under the %compostart tag.
 339          *              else take directly this format.
 340          */
 341         void                            buildPhraseDesc(std::string &text, const CSPhraseCom &phrase, uint32 phraseSheetId, bool wantRequirement, const std::string &specialPhraseFormat= std::string());
 342         // Get the Phrase Success Rate %
 343         sint                            getPhraseSuccessRate(const CSPhraseCom &phrase);
 344         // Get the Phrase Success Rate %. Manually gives the Skill to do the comparison (for craft)
 345         sint                            getCraftPhraseSuccessRate(const CSPhraseCom &phrase, SKILLS::ESkills skill, uint minMpLevel, sint successModifier);
 346         // Get the Phrase Success Rate %. Manually gives the Skill to do the comparison (for Forage Extraction)
 347         sint                            getForageExtractionPhraseSuccessRate(const CSPhraseCom &phrase, SKILLS::ESkills skill);
 348         // return the fmt according to forage terrain specializing
 349         std::string                     getForageExtractionPhraseEcotypeFmt(const CSPhraseCom &phrase);
 350         // Get the Phrase Sap Cost
 351         void                            getPhraseSapCost(const CSPhraseCom &phrase, uint32 totalActionMalus, sint &cost, sint &costMalus);
 352         // Get the Phrase Sta Cost
 353         void                            getPhraseStaCost(const CSPhraseCom &phrase, uint32 totalActionMalus, sint &cost, sint &costMalus);
 354         // Get the Phrase Focus Cost
 355         void                            getPhraseFocusCost(const CSPhraseCom &phrase, uint32 totalActionMalus, sint &cost, sint &costMalus);
 356         // Get the Phrase Hp Cost
 357         void                            getPhraseHpCost(const CSPhraseCom &phrase, uint32 totalActionMalus, sint &cost, sint &costMalus);
 358         // Get the Phrase Cast Time
 359         void                            getPhraseCastTime(const CSPhraseCom &phrase, uint32 totalActionMalus, float &castTime, float &castTimeMalus);
 360         // Get the Phrase Range
 361         void                            getPhraseMagicRange(const CSPhraseCom &phrase, uint32 totalActionMalus, sint &range, sint &rangeMalus);
 362         // For all bricks, get the sum of the propId property
 363         float                           getPhraseSumBrickProp(const CSPhraseCom &phrase, uint propId, bool doAbs=false);
 364         /// If the temporary inventory is opened so we cant execute action
 365         bool                            isExecutionInvalidCauseTempInv() const;
 366         /// build a list of bricks that are needed in order to learn this phrase. NB: any brick already contained in the phrase are removed
 367         void                            buildPhraseBrickRequirement(uint32 phraseSheetId, std::vector<NLMISC::CSheetId> &bricks);
 368         /// check if all bricks of phrase meet fame requirement
 369         bool                            fameRequirementOk(uint32 phraseSheetId);
 370         /// true if interesting to list the bricks of this phrase in help
 371         bool                            allowListBrickInHelp(const CSPhraseCom &phrase) const;
 372         /// return the combat restriction text (empty if not combat)
 373         void                            getCombatWeaponRestriction(std::string &text, const CSPhraseCom &phrase, bool& usableWithMelee, bool& usableWithRange);
 374         void                            getCombatWeaponRestriction(std::string &text, sint32 phraseSheetId, bool& usableWithMelee, bool& usableWithRange);
 375         // return true if any of the Bricks contains AvoidCyclic==true (the phrase cannot be cyclic)
 376         bool                            avoidCyclicForPhrase(const CSPhraseCom &phrase) const;
 377         bool                            avoidCyclicForPhrase(sint32 phraseSheetId) const;
 378         // Get total regeneration time for a power/aura phrase, in tick (0 if not a power/aura)
 379         NLMISC::TGameCycle      getPowerDisableTime(const CSPhraseCom &phrase) const;
 380         // Get current time left for a power/aura phrase, in ticks (0 if not a power/aura)
 381         NLMISC::TGameCycle      getRegenTime(const CSPhraseCom &phrase) const;
 382         // Get total time span necessary for a power/aura phrase to be available again (in ticks)
 383         NLMISC::TGameCycle      getTotalRegenTime(const CSPhraseCom &phrase) const;
 384
 385         /// Lookup a SuccessTable and return chance
 386         enum    TSuccessTable
 387         {
 388                 STCombat= 0,
 389                 STOffensiveMagic,
 390                 STCurativeMagic,
 391                 STCraft,
 392                 STExtract,
 393                 STResistMagic,
 394                 STResistMagicLink,
 395                 STDodgeParry,
 396                 NumSuccessTable
 397         };
 398         sint                            getSuccessRate(TSuccessTable st, sint level, bool partialSuccess= false);
 399         // @}
 400
 401         // \name Phrase Execution invalidation cause of Equip
 402         // @{
 403         void                            setEquipInvalidation(sint64 serverTick, sint invalidTickTime);
 404         void                            updateEquipInvalidation(sint64 serverTick);
 405         bool                            isExecutionInvalidCauseEquip() const;
 406         // @}
 407
 408
 409
 410         // \name BotChat special
 411         // @{
 412         // get the current skill point price of a phrase sheet
 413         uint32                          getCurrentPhraseSheetPrice(uint32 phraseSheetId);
 414         // get the base skill point price of a phrase sheet (ie don't check if bricks learned or not)
 415         uint32                          getBasePhraseSheetPrice(uint32 phraseSheetId);
 416         // update bot chat prices in the range [start, end[
 417         void                            updateBotChatPhrasePrice(uint start, uint end);
 418
 419         // From a phrase required level, retrieve its section (for interface listing)
 420         uint32                          getPhraseSectionFromLevel(uint32 level);
 421         // inverse
 422         void                            getPhraseLevelFromSection(uint32 section, uint32 &minLevel, uint32 &maxLevel);
 423         // For book display of section
 424         void                            getPhraseSectionBoundFromSkillFilter(sint &minSectionId, sint &maxSectionId);
 425
 426         // Client Side Rolemaster phrase generation. return the number of db node filled
 427         uint                            fillRoleMasterGenericPhrase(uint32 rmFlags, uint32 rmRace);
 428
 429         // @}
 430
 431
 432         /// true if the compareSkill is compatible with this combat phrase, eg more restrictive for instance
 433         bool                            skillCompatibleWithCombatPhrase(SKILLS::ESkills compareSkill, const std::vector<NLMISC::CSheetId> &phraseBricks) const;
 434         bool                            skillCompatibleWithSpecialPowerPhrase(SKILLS::ESkills compareSkill, const std::vector<NLMISC::CSheetId> &phraseBricks) const;
 435
 436         /// true if phrase is usable with empty hands
 437         bool                            phraseUsableWithEmptyHands(const std::vector<NLMISC::CSheetId> &phraseBricks) const;
 438
 439         // get total action malus
 440         uint32                          getTotalActionMalus(const CSPhraseCom &phrase) const;
 441
 442         void updateAllActionRegen();
 443
 444         void touchRegenTickRangeFlag() { _RegenTickRangeTouched = true; }
 445
 446         static uint64                           getPhraseRequiredFlags(const CSPhraseCom &phrase);
 447
 448 // ****************
 449 private:
 450         /// Constructor
 451         CSPhraseManager();
 452         ~CSPhraseManager();
 453         static  CSPhraseManager         *_Instance;
 454
 455         typedef std::map<uint32, CSPhraseCom>   TPhraseMap;
 456         typedef TPhraseMap::iterator                    ItPhraseMap;
 457         typedef std::map<CSPhraseCom, uint32>   TPhraseToSheet; // map each phrase to its sheet id
 458         // Map of All Phrase. Contains the Book + some system phrase (1: the Edition Phrase)
 459         TPhraseMap                                                              _PhraseMap;
 460         TPhraseToSheet                                                  _PhraseToSheet;
 461         std::set<sint32>                                                _RegenPhrases;
 462
 463         // timeouts for the power / auras bricks
 464         CTickRange                                                              _BrickRegenRange[64];
 465
 466         // Shortcut To Phrases Leaves
 467         std::vector<NLMISC::CCDBNodeLeaf*>                              _BookDbLeaves;
 468         std::vector<NLMISC::CCDBNodeLeaf*>                              _MemoryDbLeaves;
 469         std::vector<NLMISC::CCDBNodeLeaf*>                              _MemoryAltDbLeaves;
 470         NLMISC::CCDBNodeLeaf                                                    *_NextExecuteLeaf;
 471         NLMISC::CCDBNodeLeaf                                                    *_NextExecuteIsCyclicLeaf;
 472
 473         // extra client data
 474         struct  CPhraseClient
 475         {
 476                 sint32          Version;
 477                 bool            Lock;
 478                 CPhraseClient()
 479                 {
 480                         Version= 0;
 481                         Lock= false;
 482                 }
 483         };
 484         std::vector<CPhraseClient>                              _PhraseClient;
 485         uint32                                                                  _MaxSlotSet;
 486         std::vector<uint32>                                             _FreeSlots;
 487
 488         bool                                                                    _RegenTickRangeTouched;
 489
 490         // Memory
 491         struct  CMemorySlot
 492         {
 493                 // Is this a macro
 494                 bool    IsMacro;
 495                 // Is his visual dirty?
 496                 bool    IsMacroVisualDirty;
 497                 // Macro or PhraseId
 498                 uint32  Id;
 499                 CMemorySlot()
 500                 {
 501                         IsMacro= false;
 502                         IsMacroVisualDirty= false;
 503                         Id= 0;
 504                 }
 505
 506                 // suppose Id==0 is valid for a macro, but not for a phrase
 507                 bool    isEmpty() const
 508                 {
 509                         return Id==0 && IsMacro==false;
 510                 }
 511                 // Macro possible only if IsMacro==true
 512                 bool    isMacro() const
 513                 {
 514                         return IsMacro;
 515                 }
 516                 // phrase only if not macro, and Id!=0
 517                 bool    isPhrase() const
 518                 {
 519                         return !IsMacro && Id!=0;
 520                 }
 521         };
 522         struct  CMemoryLine
 523         {
 524                 CMemorySlot             Slot[PHRASE_MAX_MEMORY_SLOT];
 525         };
 526         std::vector<CMemoryLine>        _Memories;
 527         sint32                                          _SelectedMemoryDB;
 528         sint32                                          _SelectedMemoryDBalt;
 529
 530         void            updateMemoryDBAll();
 531         void            updateMemoryDBSlot(uint32 memorySlot);
 532
 533         // The number of entries setuped to not 0
 534         uint                                            _LastBookNumDbFill;
 535         // The Book filter.
 536         SKILLS::ESkills                         _BookSkillFitler;
 537         BRICK_TYPE::EBrickType          _BookBrickTypeFilter;
 538         // true if the phrase is "compatbile" with _BookSkillFitler
 539         bool            matchBookSkillFilter(const CSPhraseCom &phrase) const;
 540
 541         uint32                                          _PhraseNextExecuteCounter;
 542         uint32                                          _PhraseCycleExecuteCounter;
 543
 544         bool                                            _InitInGameDone;
 545
 546         /// unlock a phrase (for BotChat Phrase buy confirmation)
 547         void                            unlockPhrase(uint32 slot);
 548
 549         // Phrase compute related
 550         CSuccessTableSheet      *_SuccessTableSheet[NumSuccessTable];
 551         void                            loadSuccessTable();
 552
 553         // The user was indoor
 554         bool                            _UserIndoor;
 555
 556         // called by getPhraseSuccessRate() public
 557         sint                            getPhraseSuccessRate(TSuccessTable st, const CSPhraseCom &phrase, sint skillValue, uint minMpLevel);
 558
 559         // real stuff
 560         void                            setPhraseInternal(uint32 slot, const CSPhraseCom &phrase, bool lock, bool updateDB);
 561
 562         // If the local counter and server counter are same, then view will be hid.
 563         bool                            isPhraseNextExecuteCounterSync() const;
 564         bool                            isPhraseCycleExecuteCounterSync() const;
 565
 566         // setup by AH. -1 if not activated
 567         sint32                          _CurrentExecuteLineNext;
 568         sint32                          _CurrentExecuteSlotNext;
 569         uint32                          _CurrentExecutePhraseIdNext;
 570         sint32                          _CurrentExecuteLineCycle;
 571         sint32                          _CurrentExecuteSlotCycle;
 572         uint32                          _CurrentExecutePhraseIdCycle;
 573         // For debug only. setuped by sendExecuteToServer() in local mode only
 574         sint64                          _PhraseDebugEndNextAction;
 575         sint64                          _PhraseDebugEndCyclicAction;
 576
 577         friend class CHandlerPhraseCounterUpdate;
 578         friend class CHandlerPhraseDebugClient;
 579
 580         // Equip invalidation
 581         sint64                          _EquipInvalidationEnd;
 582         sint64                          _CurrentServerTick;
 583
 584         // update the execution views
 585         void                            updateExecutionDisplay();
 586
 587         // update the memory ctrl
 588         void    updateMemoryCtrlState(uint memorySlot, class CDBCtrlSheet *ctrl, SKILLS::ESkills itemSkill);
 589         // update the ith memory ctrl in the action bar
 590         void    updateMemoryCtrlState(uint memorySlot);
 591
 592         // Shortcut To PhraseSheets Leaves in BotChat
 593         std::vector<NLMISC::CCDBNodeLeaf*>                              _BotChatPhraseSheetLeaves;
 594         std::vector<NLMISC::CCDBNodeLeaf*>                              _BotChatPhrasePriceLeaves;
 595
 596         // For phrase compatibility with enchant weapon special power
 597         NLMISC::CSheetId                                                _EnchantWeaponMainBrick;
 598
 599         // \name Phrase sheet progression
 600         // @{
 601         enum    TProgressType
 602         {
 603                 ActionProgress= 0,
 604                 UpgradeProgress,
 605
 606                 NumProgressType
 607         };
 608         std::vector<NLMISC::CCDBNodeLeaf*>                              _ProgressionDbSheets[NumProgressType];
 609         std::vector<NLMISC::CCDBNodeLeaf*>                              _ProgressionDbLevels[NumProgressType];
 610         std::vector<NLMISC::CCDBNodeLeaf*>                              _ProgressionDbLocks[NumProgressType];
 611
 612         // For each skill, which phrase are learned when the skill is gained
 613         class CPhraseProgressInfo
 614         {
 615         public:
 616                 uint32          SheetId;
 617                 uint32          Level;
 618         };
 619         friend class CPhraseSortEntry;
 620         class CPhraseProgression
 621         {
 622         public:
 623                 // All the phrase that can be learned at this level, anbd the required level of the skill
 624                 std::vector<CPhraseProgressInfo>                Phrases;
 625         };
 626         CPhraseProgression                      _ProgressionPhrases[SKILLS::NUM_SKILLS];
 627
 628         // For each phrase SheetId, gives the required Skill formula (for help)
 629         typedef std::map<uint32, CReqSkillFormula>              TPhraseReqSkillMap;
 630         TPhraseReqSkillMap                      _PhraseReqSkillMap;
 631
 632         // For db fill
 633         uint                                            _LastProgressionNumDbFill[NumProgressType];
 634         // For db update when a brick is learned
 635         class CProgressionUpdate : public IBrickLearnedCallback, public ISkillChangeCallback
 636         {
 637         public:
 638                 virtual void    onBrickLearned()
 639                 {
 640                         CSPhraseManager *pPM= CSPhraseManager::getInstance();
 641                         pPM->updatePhraseProgressionDB();
 642                 }
 643                 virtual void    onSkillChange()
 644                 {
 645                         CSPhraseManager *pPM= CSPhraseManager::getInstance();
 646                         pPM->updatePhraseProgressionDB();
 647                 }
 648         };
 649         friend class CProgressionUpdate;
 650         CProgressionUpdate                      _ProgressionUpdate;
 651
 652         // methods
 653         void                            updatePhraseProgressionDB();
 654         // called at initInGame
 655         void                            computePhraseProgression();
 656         void                            insertProgressionSkillRecurs(SKILLS::ESkills skill, uint32 value, sint *skillReqLevel, std::vector<SKILLS::ESkills>     &skillsToInsert);
 657
 658         mutable NLMISC::CRefPtr<NLMISC::CCDBNodeLeaf> _TotalMalusEquipLeaf;
 659
 660         NLMISC::CRefPtr<NLMISC::CCDBNodeLeaf> _ServerUserDefaultWeightHandsLeaf;
 661
 662         // @}
 663
 664         /// return the skill of the root
 665         SKILLS::ESkills         getPhraseRootSkill(const std::vector<NLMISC::CSheetId> &phraseBricks) const;
 666
 667         /// return true if all the requirement in order to learn this prhase are met.
 668         bool                            phraseRequirementOk(uint32 phraseSheetId);
 669
 670
 671         /// Execution ACK reception
 672         // @{
 673         struct CAckExecuteEntry
 674         {
 675                 enum    TState
 676                 {
 677                         WaitAck= 0,
 678                         OK,
 679                         KO
 680                 };
 681                 TState  State;
 682                 uint32  Counter;
 683                 sint32  MemoryLine;
 684                 sint32  MemorySlot;
 685                 uint32  PhraseId;
 686         };
 687         typedef         std::deque<CAckExecuteEntry>    TAckExecuteList;
 688         TAckExecuteList                 _AckExecuteCycleList;
 689         TAckExecuteList                 _AckExecuteNextList;
 690
 691         void    appendCurrentToAckExecute(bool cyclic);
 692         void    resetAckExecuteList(bool cyclic);
 693
 694         // @}
 695
 696         std::string     formatMalus(sint base, sint malus);
 697         std::string     formatMalus(float base, float malus);
 698         std::string             formatBonusMalus(sint32 base, sint32 mod);
 699
 700         // Special for combat: Build the "phrase skill compatible" formula
 701         // NB: Use a ReqSkillFormula, but don't use the value part, cause no requirement is made on it
 702         CReqSkillFormula        buildCombatPhraseSkillFormula(const std::vector<NLMISC::CSheetId> &phraseBricks) const;
 703
 704         // For Magic and Magic Staff
 705         uint32          getSpellLevel(const std::vector<NLMISC::CSheetId> &phraseBricks) const;
 706
 707         // For Magic
 708         void            getResistMagic(bool resistMagic[RESISTANCE_TYPE::NB_RESISTANCE_TYPE], const std::vector<NLMISC::CSheetId> &phraseBricks);
 709
 710         void    updateAllMemoryCtrlRegenTickRange();
 711         void    updateMemoryCtrlRegenTickRange(uint memorySlot, CDBCtrlSheet    *ctrl);
 712         void    updateMemoryCtrlRegenTickRange(uint memorySlot);
 713
 714         CDBCtrlSheet    *getMemorySlotCtrl(uint memorySlot);
 715         CDBCtrlSheet    *getMemoryAltSlotCtrl(uint memorySlot);
 716
 717         CTickRange getRegenTickRange(const CSPhraseCom &phrase) const;
 718
 719         NLMISC::CCDBNodeLeaf    *getRegenTickRangeDbLeaf(uint powerIndex) const;
 720         // get regen tick range for a specific power, from the database
 721         CTickRange getRegenTickRange(uint powerIndex) const;
 722 public:
 723         // tmp for test : set regen tick range locally
 724         void setRegenTickRange(uint powerIndex, const CTickRange &tickRange);
 725 };
 726
 727 #endif // NL_SPHRASE_MANAGER_H
 728
 729 /* End of sphrase_manager.h */