refactor(Scripts/Commands): convert cs_learn & cs_player to new system (#9050)

src/server/scripts/Commands/PlayerCommand.cpp

@@ -15,46 +15,22 @@
  * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "SpellInfo.h"
 #include "PlayerCommand.h"
 #include "Language.h"
 
-bool Acore::PlayerCommand::HandleLearnSpellCommand(ChatHandler* handler, Player* targetPlayer, uint32 spell, char const* all)
+bool Acore::PlayerCommand::HandleLearnSpellCommand(ChatHandler* handler, Player* targetPlayer, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks)
 {
-    if (!spell)
+    if (!SpellMgr::IsSpellValid(spell))
-        return false;
-
-    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
-    if (!spellInfo)
     {
-        handler->PSendSysMessage(LANG_COMMAND_NOSPELLFOUND);
+        handler->PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell->Id);
         handler->SetSentErrorMessage(true);
         return false;
     }
 
-    if (!SpellMgr::IsSpellValid(spellInfo))
+    if (!allRanks && targetPlayer->HasSpell(spell->Id))
     {
-        handler->PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
+        if (targetPlayer == handler->GetPlayer())
-        handler->SetSentErrorMessage(true);
-        return false;
-    }
-
-    if (handler->GetSession())
-    {
-        SpellScriptsBounds bounds = sObjectMgr->GetSpellScriptsBounds(spell);
-        uint32 spellDifficultyId = sSpellMgr->GetSpellDifficultyId(spell);
-        if (handler->GetSession() && handler->GetSession()->GetSecurity() < SEC_ADMINISTRATOR && (bounds.first != bounds.second || spellDifficultyId))
-        {
-            handler->PSendSysMessage("Spell %u cannot be learnt using a command!", spell);
-            handler->SetSentErrorMessage(true);
-            return false;
-        }
-    }
-
-    bool allRanks = all ? (strncmp(all, "all", 3) == 0) : false;
-
-    if (!allRanks && targetPlayer->HasSpell(spell))
-    {
-        if (handler->GetSession() && targetPlayer == handler->GetSession()->GetPlayer())
             handler->SendSysMessage(LANG_YOU_KNOWN_SPELL);
         else
             handler->PSendSysMessage(LANG_TARGET_KNOWN_SPELL, handler->GetNameLink(targetPlayer).c_str());
@@ -62,25 +38,23 @@ bool Acore::PlayerCommand::HandleLearnSpellCommand(ChatHandler* handler, Player*
         return false;
     }
 
+    targetPlayer->learnSpell(spell->Id, false);
     if (allRanks)
-        targetPlayer->learnSpellHighRank(spell);
+    {
-    else
+        uint32 spellId = spell->Id;
-        targetPlayer->learnSpell(spell);
+        while ((spellId = sSpellMgr->GetNextSpellInChain(spellId)))
+            targetPlayer->learnSpell(spellId, false);
+    }
 
-    uint32 firstSpell = sSpellMgr->GetFirstSpellInChain(spell);
+    if (GetTalentSpellCost(spell->GetFirstRankSpell()->Id))
-    if (GetTalentSpellCost(firstSpell))
         targetPlayer->SendTalentsInfoData(false);
 
     return true;
 }
 
-bool Acore::PlayerCommand::HandleUnlearnSpellCommand(ChatHandler* handler, Player* target, uint32 spellId, char const* allStr)
+bool Acore::PlayerCommand::HandleUnlearnSpellCommand(ChatHandler* handler, Player* target, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks)
 {
-    if (!spellId)
+    uint32 spellId = spell->Id;
-        return false;
-
-    bool allRanks = allStr ? (strncmp(allStr, "all", 3) == 0) : false;
-
     if (allRanks)
         spellId = sSpellMgr->GetFirstSpellInChain (spellId);
 

src/server/scripts/Commands/PlayerCommand.h

@@ -25,9 +25,9 @@ namespace Acore
     // Used in player/character commands
     namespace PlayerCommand
     {
-        bool HandleLearnSpellCommand(ChatHandler* handler, Player* targetPlayer, uint32 spell, char const* all);
+        bool HandleLearnSpellCommand(ChatHandler* handler, Player* targetPlayer, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks);
-        bool HandleUnlearnSpellCommand(ChatHandler* handler, Player* targetPlayer, uint32 spell, char const* all);
+        bool HandleUnlearnSpellCommand(ChatHandler* handler, Player* targetPlayer,  SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks);
     };
 };
 
-#endif // _PLAYER_COMMAND_H
+#endif // _PLAYER_COMMAND_H

src/server/scripts/Commands/cs_learn.cpp

@@ -30,10 +30,6 @@ EndScriptData */
 #include "SpellInfo.h"
 #include "SpellMgr.h"
 
-#if AC_COMPILER == AC_COMPILER_GNU
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 using namespace Acore::ChatCommands;
 
 class learn_commandscript : public CommandScript
@@ -45,41 +41,38 @@ public:
     {
         static ChatCommandTable learnAllMyCommandTable =
         {
-            { "class",          SEC_GAMEMASTER,  false, &HandleLearnAllMyClassCommand,       "" },
+            { "class",      HandleLearnAllMyClassCommand,      SEC_GAMEMASTER, Console::No },
-            { "pettalents",     SEC_GAMEMASTER,  false, &HandleLearnAllMyPetTalentsCommand,  "" },
+            { "pettalents", HandleLearnAllMyPetTalentsCommand, SEC_GAMEMASTER, Console::No },
-            { "spells",         SEC_GAMEMASTER,  false, &HandleLearnAllMySpellsCommand,      "" },
+            { "spells",     HandleLearnAllMySpellsCommand,     SEC_GAMEMASTER, Console::No },
-            { "talents",        SEC_GAMEMASTER,  false, &HandleLearnAllMyTalentsCommand,     "" }
+            { "talents",    HandleLearnAllMyTalentsCommand,    SEC_GAMEMASTER, Console::No }
         };
 
         static ChatCommandTable learnAllCommandTable =
         {
-            { "my",             SEC_GAMEMASTER,  false, nullptr,                             "", learnAllMyCommandTable },
+            { "my", learnAllMyCommandTable },
-            { "gm",             SEC_GAMEMASTER,  false, &HandleLearnAllGMCommand,            "" },
+            { "gm",        HandleLearnAllGMCommand,            SEC_GAMEMASTER, Console::No },
-            { "crafts",         SEC_GAMEMASTER,  false, &HandleLearnAllCraftsCommand,        "" },
+            { "crafts",    HandleLearnAllCraftsCommand,        SEC_GAMEMASTER, Console::No },
-            { "default",        SEC_GAMEMASTER,  false, &HandleLearnAllDefaultCommand,       "" },
+            { "default",   HandleLearnAllDefaultCommand,       SEC_GAMEMASTER, Console::No },
-            { "lang",           SEC_GAMEMASTER,  false, &HandleLearnAllLangCommand,          "" },
+            { "lang",      HandleLearnAllLangCommand,          SEC_GAMEMASTER, Console::No },
-            { "recipes",        SEC_GAMEMASTER,  false, &HandleLearnAllRecipesCommand,       "" }
+            { "recipes",   HandleLearnAllRecipesCommand,       SEC_GAMEMASTER, Console::No },
         };
 
         static ChatCommandTable learnCommandTable =
         {
-            { "all",            SEC_GAMEMASTER,  false, nullptr,                             "", learnAllCommandTable },
+            { "all", learnAllCommandTable },
-            { "",               SEC_GAMEMASTER,  false, &HandleLearnCommand,                 "" }
+            { "",     HandleLearnCommand,                      SEC_GAMEMASTER, Console::No }
         };
 
         static ChatCommandTable commandTable =
         {
-            { "learn",          SEC_GAMEMASTER,  false, nullptr,                             "", learnCommandTable },
+            { "learn", learnCommandTable },
-            { "unlearn",        SEC_GAMEMASTER,  false, &HandleUnLearnCommand,               "" }
+            { "unlearn",     HandleUnLearnCommand,             SEC_GAMEMASTER, 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)
     {
-        if (!*args)
-            return false;
-
         Player* targetPlayer = handler->getSelectedPlayer();
 
         if (!targetPlayer)
@@ -89,13 +82,10 @@ public:
             return false;
         }
 
-        // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r or Htalent form
+        return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
-        uint32 spell = handler->extractSpellIdFromLink((char*)args);
-        char const* all = strtok(nullptr, " ");
-        return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, all);
     }
 
-    static bool HandleLearnAllGMCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllGMCommand(ChatHandler* handler)
     {
         for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i)
         {
@@ -113,14 +103,14 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllMyClassCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllMyClassCommand(ChatHandler* handler)
     {
-        HandleLearnAllMySpellsCommand(handler, "");
+        HandleLearnAllMySpellsCommand(handler);
-        HandleLearnAllMyTalentsCommand(handler, "");
+        HandleLearnAllMyTalentsCommand(handler);
         return true;
     }
 
-    static bool HandleLearnAllMySpellsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllMySpellsCommand(ChatHandler* handler)
     {
         ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(handler->GetSession()->GetPlayer()->getClass());
         if (!classEntry)
@@ -165,7 +155,7 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllMyTalentsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllMyTalentsCommand(ChatHandler* handler)
     {
         Player* player = handler->GetSession()->GetPlayer();
         uint32 classMask = player->getClassMask();
@@ -211,7 +201,7 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllMyPetTalentsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllMyPetTalentsCommand(ChatHandler* handler)
     {
         Player* player = handler->GetSession()->GetPlayer();
 
@@ -289,7 +279,7 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllLangCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllLangCommand(ChatHandler* handler)
     {
         // skipping UNIVERSAL language (0)
         for (uint8 i = 1; i < LANGUAGES_COUNT; ++i)
@@ -299,12 +289,14 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllDefaultCommand(ChatHandler* handler, char const* args)
+    static bool HandleLearnAllDefaultCommand(ChatHandler* handler, Optional<PlayerIdentifier> player)
     {
-        Player* target;
+        if (!player)
-        if (!handler->extractPlayerTarget((char*)args, &target))
+            player = PlayerIdentifier::FromTargetOrSelf(handler);
+        if (!player || !player->IsConnected())
             return false;
 
+        Player* target = player->GetConnectedPlayer();
         target->LearnDefaultSkills();
         target->LearnCustomSpells();
         target->learnQuestRewardedSpells();
@@ -313,7 +305,7 @@ public:
         return true;
     }
 
-    static bool HandleLearnAllCraftsCommand(ChatHandler* handler, char const* /*args*/)
+    static bool HandleLearnAllCraftsCommand(ChatHandler* handler)
     {
         for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
         {
@@ -332,7 +324,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
@@ -344,20 +336,14 @@ public:
             return false;
         }
 
-        if (!*args)
+        if (namePart.empty())
-            return false;
-
-        std::wstring namePart;
-
-        if (!Utf8toWStr(args, namePart))
             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);
@@ -365,30 +351,19 @@ public:
                 continue;
 
             if ((skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
-                    skillInfo->categoryId != SKILL_CATEGORY_SECONDARY) ||
+                 skillInfo->categoryId != SKILL_CATEGORY_SECONDARY) ||
-                    !skillInfo->canLink)                            // only prof with recipes have set
+                !skillInfo->canLink)                            // only prof with recipes have set
                 continue;
 
-            int locale = handler->GetSessionDbcLocale();
+            uint8 locale = 0;
-            name = skillInfo->name[locale];
+            for (; locale < TOTAL_LOCALES; ++locale)
-            if (name.empty())
-                continue;
-
-            if (!Utf8FitTo(name, namePart))
             {
-                locale = 0;
+                name = skillInfo->name[locale];
-                for (; locale < TOTAL_LOCALES; ++locale)
+                if (!name || !*name)
-                {
+                    continue;
-                    if (locale == handler->GetSessionDbcLocale())
-                        continue;
 
-                    name = skillInfo->name[locale];
+                if (Utf8FitTo(name, namePart))
-                    if (name.empty())
+                    break;
-                        continue;
-
-                    if (Utf8FitTo(name, namePart))
-                        break;
-                }
             }
 
             if (locale < TOTAL_LOCALES)
@@ -398,14 +373,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;
     }
 
@@ -443,11 +418,8 @@ 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;
-
         Player* target = handler->getSelectedPlayer();
         if (!target)
         {
@@ -456,10 +428,7 @@ public:
             return false;
         }
 
-        // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
+        return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spell, allRanks);
-        uint32 spellId = handler->extractSpellIdFromLink((char*)args);
-        char const* allStr = strtok(nullptr, " ");
-        return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spellId, allStr);
     }
 };
 

src/server/scripts/Commands/cs_player.cpp

@@ -16,13 +16,8 @@
  */
 
 #include "ScriptMgr.h"
-#include "Language.h"
 #include "PlayerCommand.h"
 
-#if AC_COMPILER == AC_COMPILER_GNU
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
 using namespace Acore::ChatCommands;
 
 class player_commandscript : public CommandScript
@@ -34,84 +29,37 @@ public:
     {
         static ChatCommandTable playerCommandTable =
         {
-            { "learn",               SEC_GAMEMASTER,  true, &HandlePlayerLearnCommand,           "" },
+            { "learn",   HandlePlayerLearnCommand,   SEC_GAMEMASTER, Console::Yes },
-            { "unlearn",             SEC_GAMEMASTER,  true, &HandlePlayerUnLearnCommand,         "" }
+            { "unlearn", HandlePlayerUnLearnCommand, SEC_GAMEMASTER, Console::Yes }
         };
 
         static ChatCommandTable commandTable =
         {
-            { "player",              SEC_GAMEMASTER,  true, nullptr,                             "", playerCommandTable }
+            { "player", playerCommandTable }
         };
         return commandTable;
     }
 
-    static bool HandlePlayerLearnCommand(ChatHandler* handler, char const* args)
+    static bool HandlePlayerLearnCommand(ChatHandler* handler, Optional<PlayerIdentifier> player, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks)
     {
-        if (!*args)
+        if (!player)
+            player = PlayerIdentifier::FromTargetOrSelf(handler);
+        if (!player || !player->IsConnected())
             return false;
 
-        char* playerName = strtok((char*)args, " ");
+        Player* targetPlayer = player->GetConnectedPlayer();
-        char* spellId = strtok(nullptr, " ");
+        return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
-        char const* all = strtok(nullptr, " ");
-        Player* targetPlayer = FindPlayer(handler, playerName);
-        if (!spellId || !targetPlayer)
-        {
-            return false;
-        }
-
-        uint32 spell = handler->extractSpellIdFromLink(spellId);
-
-        if (!spell)
-        {
-            return false;
-        }
-
-        return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, all);
     }
 
-    static bool HandlePlayerUnLearnCommand(ChatHandler* handler, char const* args)
+    static bool HandlePlayerUnLearnCommand(ChatHandler* handler, Optional<PlayerIdentifier> player, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks)
     {
-        if (!*args)
+        if (!player)
+            player = PlayerIdentifier::FromTargetOrSelf(handler);
+        if (!player || !player->IsConnected())
             return false;
 
-        char* playerName = strtok((char*)args, " ");
+        Player* targetPlayer = player->GetConnectedPlayer();
-        char* spellId = strtok(nullptr, " ");
+        return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, targetPlayer, spell, allRanks);
-        char const* all = strtok(nullptr, " ");
-        Player* targetPlayer = FindPlayer(handler, playerName);
-
-        if (!spellId || !targetPlayer)
-        {
-            return false;
-        }
-
-        uint32 spell = handler->extractSpellIdFromLink(spellId);
-
-        if (!spell)
-        {
-            return false;
-        }
-
-        return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, targetPlayer, spell, all);
-    }
-
-private:
-    static Player* FindPlayer(ChatHandler* handler, char* playerName)
-    {
-        if (!playerName)
-            return nullptr;
-
-        Player* targetPlayer;
-        if (!handler->extractPlayerTarget(playerName, &targetPlayer))
-            return nullptr;
-
-        if (!targetPlayer)
-        {
-            handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
-            handler->SetSentErrorMessage(true);
-            return nullptr;
-        }
-
-        return targetPlayer;
     }
 };