[3.3.5] Scripts/Commands: .learn adjustments (PR #25454)

1 files changed, 105 insertions, 124 deletions

diff --git a/src/server/scripts/Commands/cs_learn.cpp b/src/server/scripts/Commands/cs_learn.cpp
index b91e2052692..de6358ac65f 100644
--- a/src/server/scripts/Commands/cs_learn.cpp
+++ b/src/server/scripts/Commands/cs_learn.cpp
@@ -34,10 +34,6 @@ EndScriptData */
 #include "SpellMgr.h"
 #include "WorldSession.h"
 
-#if TRINITY_COMPILER == TRINITY_COMPILER_GNU
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 using namespace Trinity::ChatCommands;
 class learn_commandscript : public CommandScript
 {
@@ -46,39 +42,40 @@ public:
 
     ChatCommandTable GetCommands() const override
     {
-        static ChatCommandTable learnAllMyCommandTable =
+        static ChatCommandTable learnAllCommandTable =
         {
-            { "class",      HandleLearnAllMyClassCommand,       rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS,         Console::No },
-            { "pettalents", HandleLearnAllMyPetTalentsCommand,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS,    Console::No },
-            { "spells",     HandleLearnAllMySpellsCommand,      rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS,        Console::No },
-            { "talents",    HandleLearnAllMyTalentsCommand,     rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_TALENTS,       Console::No },
+            { "blizzard",   HandleLearnAllGMCommand,         LANG_COMMAND_LEARN_ALL_BLIZZARD_HELP,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM,        Console::No },
+            { "debug",      HandleLearnDebugSpellsCommand,   LANG_COMMAND_LEARN_ALL_DEBUG_HELP,     rbac::RBAC_PERM_COMMAND_LEARN,               Console::No },
+            { "crafts",     HandleLearnAllCraftsCommand,     LANG_COMMAND_LEARN_ALL_CRAFTS_HELP,    rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS,    Console::No },
+            { "default",    HandleLearnAllDefaultCommand,    LANG_COMMAND_LEARN_ALL_DEFAULT_HELP,   rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT,   Console::No },
+            { "languages",  HandleLearnAllLangCommand,       LANG_COMMAND_LEARN_ALL_LANGUAGES_HELP, rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG,      Console::No },
+            { "recipes",    HandleLearnAllRecipesCommand,    LANG_COMMAND_LEARN_ALL_RECIPES_HELP,   rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES,   Console::No },
+            { "talents",    HandleLearnAllTalentsCommand,    LANG_COMMAND_LEARN_ALL_TALENTS_HELP,   rbac::RBAC_PERM_COMMAND_LEARN_ALL_TALENTS,   Console::No },
+            { "pettalents", HandleLearnAllPetTalentsCommand, LANG_COMMAND_LEARN_ALL_PETTALENT_HELP, rbac::RBAC_PERM_COMMAND_LEARN_MY_PETTALENTS, Console::No },
         };
 
-        static ChatCommandTable learnAllCommandTable =
+        static ChatCommandTable learnMyCommandTable =
         {
-            { "my",      learnAllMyCommandTable },
-            { "gm",      HandleLearnAllGMCommand,       rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM,       Console::No },
-            { "crafts",  HandleLearnAllCraftsCommand,   rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS,   Console::No },
-            { "default", HandleLearnAllDefaultCommand,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT,  Console::No },
-            { "lang",    HandleLearnAllLangCommand,     rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG,     Console::No },
-            { "recipes", HandleLearnAllRecipesCommand,  rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES,  Console::No },
+            { "trainer", HandleLearnMySpellsCommand,         LANG_COMMAND_LEARN_MY_TRAINER_HELP,    rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, Console::No },
+            { "quests",  HandleLearnMyQuestsCommand,         LANG_COMMAND_LEARN_MY_QUESTS_HELP,     rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, Console::No },
         };
 
         static ChatCommandTable learnCommandTable =
         {
-            { "",       HandleLearnCommand,             rbac::RBAC_PERM_COMMAND_LEARN,              Console::No },
+            { "",       HandleLearnCommand,                  LANG_COMMAND_LEARN_HELP,               rbac::RBAC_PERM_COMMAND_LEARN,               Console::No },
             { "all",    learnAllCommandTable },
+            { "my",     learnMyCommandTable }
         };
 
         static ChatCommandTable commandTable =
         {
             { "learn",   learnCommandTable },
-            { "unlearn", HandleUnLearnCommand,          rbac::RBAC_PERM_COMMAND_UNLEARN,            Console::No },
+            { "unlearn", HandleUnLearnCommand,               LANG_COMMAND_UNLEARN_HELP,             rbac::RBAC_PERM_COMMAND_UNLEARN,             Console::No },
         };
         return commandTable;
     }
 
-    static bool HandleLearnCommand(ChatHandler* handler, char const* args)
+    static bool HandleLearnCommand(ChatHandler* handler, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks)
     {
         Player* targetPlayer = handler->getSelectedPlayerOrSelf();
 
@@ -89,25 +86,16 @@ public:
             return false;
         }
 
-        // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
-        uint32 spell = handler->extractSpellIdFromLink((char*)args);
-        if (!spell || !sSpellMgr->GetSpellInfo(spell))
-            return false;
-
-        char const* all = strtok(nullptr, " ");
-        bool allRanks = all ? (strncmp(all, "all", strlen(all)) == 0) : false;
-
-        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
-        if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, handler->GetSession()->GetPlayer()))
+        if (!SpellMgr::IsSpellValid(spell, handler->GetSession()->GetPlayer()))
         {
-            handler->PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
+            handler->PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
-        if (!allRanks && targetPlayer->HasSpell(spell))
+        if (!allRanks && targetPlayer->HasSpell(spell->Id))
         {
-            if (targetPlayer == handler->GetSession()->GetPlayer())
+            if (targetPlayer == handler->GetPlayer())
                 handler->SendSysMessage(LANG_YOU_KNOWN_SPELL);
             else
                 handler->PSendSysMessage(LANG_TARGET_KNOWN_SPELL, handler->GetNameLink(targetPlayer).c_str());
@@ -115,18 +103,21 @@ public:
             return false;
         }
 
+        targetPlayer->LearnSpell(spell->Id, false);
         if (allRanks)
-            targetPlayer->LearnSpellHighestRank(spell);
-        else
-            targetPlayer->LearnSpell(spell, false);
+        {
+            uint32 spellId = spell->Id;
+            while ((spellId = sSpellMgr->GetNextSpellInChain(spellId)))
+                targetPlayer->LearnSpell(spellId, false);
+        }
 
-        if (GetTalentSpellCost(spellInfo->GetFirstRankSpell()->Id))
+        if (GetTalentSpellCost(spell->GetFirstRankSpell()->Id))
             targetPlayer->SendTalentsInfoData(false);
 
         return true;
     }
 
-    static bool HandleLearnAllGMCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllGMCommand(ChatHandler* handler)
     {
         for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i)
         {
@@ -144,58 +135,54 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllMyClassCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnMyQuestsCommand(ChatHandler* handler)
     {
-        HandleLearnAllMySpellsCommand(handler, "");
-        HandleLearnAllMyTalentsCommand(handler, "");
+        Player* player = handler->GetPlayer();
+        for (auto const& [id, quest] : sObjectMgr->GetQuestTemplates())
+        {
+            if (quest.GetRequiredClasses() && player->SatisfyQuestClass(&quest, false))
+                player->LearnQuestRewardedSpells(&quest);
+        }
         return true;
     }
 
-    static bool HandleLearnAllMySpellsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnMySpellsCommand(ChatHandler* handler)
     {
-        ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(handler->GetSession()->GetPlayer()->GetClass());
+        ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(handler->GetPlayer()->GetClass());
         if (!classEntry)
             return true;
-        uint32 family = classEntry->SpellClassSet;
-
-        for (uint32 i = 0; i < sSkillLineAbilityStore.GetNumRows(); ++i)
-        {
-            SkillLineAbilityEntry const* entry = sSkillLineAbilityStore.LookupEntry(i);
-            if (!entry)
-                continue;
-
-            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Spell);
-            if (!spellInfo)
-                continue;
 
-            // skip server-side/triggered spells
-            if (spellInfo->SpellLevel == 0)
-                continue;
+        Player* player = handler->GetPlayer();
+        std::vector<Trainer::Trainer const*> const& trainers = sObjectMgr->GetClassTrainers(player->GetClass());
 
-            // skip wrong class/race skills
-            if (!handler->GetSession()->GetPlayer()->IsSpellFitByClassAndRace(spellInfo->Id))
-                continue;
-
-            // skip other spell families
-            if (spellInfo->SpellFamilyName != family)
-                continue;
-
-            // skip spells with first rank learned as talent (and all talents then also)
-            if (GetTalentSpellCost(spellInfo->GetFirstRankSpell()->Id) > 0)
-                continue;
+        bool hadNew;
+        do
+        {
+            hadNew = false;
+            for (Trainer::Trainer const* trainer : trainers)
+            {
+                if (!trainer->IsTrainerValidForPlayer(player))
+                    continue;
+                for (Trainer::Spell const& trainerSpell : trainer->GetSpells())
+                {
+                    if (!trainer->CanTeachSpell(player, &trainerSpell))
+                        continue;
 
-            // skip broken spells
-            if (!SpellMgr::IsSpellValid(spellInfo, handler->GetSession()->GetPlayer(), false))
-                continue;
+                    if (trainerSpell.IsCastable())
+                        player->CastSpell(player, trainerSpell.SpellId, true);
+                    else
+                        player->LearnSpell(trainerSpell.SpellId, false);
 
-            handler->GetSession()->GetPlayer()->LearnSpell(spellInfo->Id, false);
-        }
+                    hadNew = true;
+                }
+            }
+        } while (hadNew);
 
         handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_SPELLS);
         return true;
     }
 
-    static bool HandleLearnAllMyTalentsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllTalentsCommand(ChatHandler* handler)
     {
         Player* player = handler->GetSession()->GetPlayer();
         uint32 classMask = player->GetClassMask();
@@ -231,18 +218,18 @@ public:
             if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, handler->GetSession()->GetPlayer(), false))
                 continue;
 
-            // learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
-            player->LearnSpellHighestRank(spellId);
+            player->LearnSpell(spellId, false);
             player->AddTalent(spellId, player->GetActiveSpec(), true);
         }
 
         player->SetFreeTalentPoints(0);
+        player->SendTalentsInfoData(false);
 
         handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_TALENTS);
         return true;
     }
 
-    static bool HandleLearnAllMyPetTalentsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllPetTalentsCommand(ChatHandler* handler)
     {
         Player* player = handler->GetSession()->GetPlayer();
 
@@ -320,22 +307,37 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllLangCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllLangCommand(ChatHandler* handler)
     {
         for (LanguageDesc const& langDesc : lang_description)
             if (uint32 langSpellId = langDesc.spell_id)
-                handler->GetSession()->GetPlayer()->LearnSpell(langSpellId, false);
+                handler->GetPlayer()->LearnSpell(langSpellId, false);
 
         handler->SendSysMessage(LANG_COMMAND_LEARN_ALL_LANG);
         return true;
     }
 
-    static bool HandleLearnAllDefaultCommand(ChatHandler* handler, char const* args)
+    static bool HandleLearnDebugSpellsCommand(ChatHandler* handler)
     {
-        Player* target;
-        if (!handler->extractPlayerTarget((char*)args, &target))
+        Player* const player = handler->GetPlayer();
+        player->LearnSpell(63364, false); /* 63364 - Saronite Barrier (reduces damage taken by 99%) */
+        player->LearnSpell(1908, false);  /*  1908 - Uber Heal Over Time (heals target to full constantly) */
+        player->LearnSpell(27680, false); /* 27680 - Berserk (+500% damage, +150% speed, 10m duration) */
+        player->LearnSpell(62555, false); /* 62555 - Berserk (+500% damage, +150% melee haste, 10m duration) */
+        player->LearnSpell(64238, false); /* 64238 - Berserk (+900% damage, +150% melee haste, 30m duration) */
+        player->LearnSpell(72525, false); /* 72525 - Berserk (+240% damage, +160% haste, infinite duration) */
+        player->LearnSpell(66776, false); /* 66776 - Rage (+300% damage, -95% damage taken, +100% speed, infinite duration) */
+        return true;
+    }
+
+    static bool HandleLearnAllDefaultCommand(ChatHandler* handler, Optional<PlayerIdentifier> player)
+    {
+        if (!player)
+            player = PlayerIdentifier::FromTargetOrSelf(handler);
+        if (!player || !player->IsConnected())
             return false;
 
+        Player* target = player->GetConnectedPlayer();
         target->LearnDefaultSkills();
         target->LearnCustomSpells();
         target->LearnQuestRewardedSpells();
@@ -344,12 +346,14 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllCraftsCommand(ChatHandler* handler, char const* args)
+    static bool HandleLearnAllCraftsCommand(ChatHandler* handler, Optional<PlayerIdentifier> player)
     {
-        Player* target;
-        if (!handler->extractPlayerTarget((char*)args, &target))
+        if (!player)
+            player = PlayerIdentifier::FromTargetOrSelf(handler);
+        if (!player || !player->IsConnected())
             return false;
 
+        Player* target = player->GetConnectedPlayer();
         for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
         {
             SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(i);
@@ -367,7 +371,7 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllRecipesCommand(ChatHandler* handler, char const* args)
+    static bool HandleLearnAllRecipesCommand(ChatHandler* handler, WTail namePart)
     {
         //  Learns all recipes of specified profession and sets skill to max
         //  Example: .learn all_recipes enchanting
@@ -379,20 +383,14 @@ public:
             return false;
         }
 
-        if (!*args)
-            return false;
-
-        std::wstring namePart;
-
-        if (!Utf8toWStr(args, namePart))
+        if (namePart.empty())
             return false;
 
         // converting string that we try to find to lower case
         wstrToLower(namePart);
 
-        std::string name;
-
         SkillLineEntry const* targetSkillInfo = nullptr;
+        char const* name = nullptr;
         for (uint32 i = 1; i < sSkillLineStore.GetNumRows(); ++i)
         {
             SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(i);
@@ -404,26 +402,18 @@ public:
                 !skillInfo->CanLink)                            // only prof with recipes have set
                 continue;
 
-            int locale = handler->GetSessionDbcLocale();
-            name = skillInfo->DisplayName[locale];
-            if (name.empty())
-                continue;
-
-            if (!Utf8FitTo(name, namePart))
+            uint8 locale = 0;
+            for (; locale < TOTAL_LOCALES; ++locale)
             {
-                locale = 0;
-                for (; locale < TOTAL_LOCALES; ++locale)
-                {
-                    if (locale == handler->GetSessionDbcLocale())
-                        continue;
+                if (locale == handler->GetSessionDbcLocale())
+                    continue;
 
-                    name = skillInfo->DisplayName[locale];
-                    if (name.empty())
-                        continue;
+                name = skillInfo->DisplayName[locale];
+                if (!name || !*name)
+                    continue;
 
-                    if (Utf8FitTo(name, namePart))
-                        break;
-                }
+                if (Utf8FitTo(name, namePart))
+                    break;
             }
 
             if (locale < TOTAL_LOCALES)
@@ -433,14 +423,14 @@ public:
             }
         }
 
-        if (!targetSkillInfo)
+        if (!(name && targetSkillInfo))
             return false;
 
         HandleLearnSkillRecipesHelper(target, targetSkillInfo->ID);
 
         uint16 maxLevel = target->GetPureMaxSkillValue(targetSkillInfo->ID);
         target->SetSkill(targetSkillInfo->ID, target->GetSkillStep(targetSkillInfo->ID), maxLevel, maxLevel);
-        handler->PSendSysMessage(LANG_COMMAND_LEARN_ALL_RECIPES, name.c_str());
+        handler->PSendSysMessage(LANG_COMMAND_LEARN_ALL_RECIPES, name);
         return true;
     }
 
@@ -478,20 +468,10 @@ public:
         }
     }
 
-    static bool HandleUnLearnCommand(ChatHandler* handler, char const* args)
+    static bool HandleUnLearnCommand(ChatHandler* handler, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks)
     {
-        if (!*args)
-            return false;
-
-        // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
-        uint32 spellId = handler->extractSpellIdFromLink((char*)args);
-        if (!spellId)
-            return false;
-
-        char const* allStr = strtok(nullptr, " ");
-        bool allRanks = allStr ? (strncmp(allStr, "all", strlen(allStr)) == 0) : false;
-
         Player* target = handler->getSelectedPlayer();
+
         if (!target)
         {
             handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
@@ -499,6 +479,7 @@ public:
             return false;
         }
 
+        uint32 spellId = spell->Id;
         if (allRanks)
             spellId = sSpellMgr->GetFirstSpellInChain(spellId);