nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-01-16 10:30:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
IntelligentQuantum
2021-11-12 15:33:38 +03:30
committed by GitHub
parent b1f038336d
commit 4a69d1fc07
4 changed files with 79 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
src/server/scripts/Commands/PlayerCommand.cpp
View File

@@ -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)
return false;
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
if (!spellInfo)
if (!SpellMgr::IsSpellValid(spell))
{
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);
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())
if (targetPlayer == handler->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
targetPlayer->learnSpell(spell);
{
uint32 spellId = spell->Id;
while ((spellId = sSpellMgr->GetNextSpellInChain(spellId)))
targetPlayer->learnSpell(spellId, false);
}
uint32 firstSpell = sSpellMgr->GetFirstSpellInChain(spell);
if (GetTalentSpellCost(firstSpell))
if (GetTalentSpellCost(spell->GetFirstRankSpell()->Id))
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)
return false;
bool allRanks = allStr ? (strncmp(allStr, "all", 3) == 0) : false;
uint32 spellId = spell->Id;
if (allRanks)
spellId = sSpellMgr->GetFirstSpellInChain (spellId);

6
src/server/scripts/Commands/PlayerCommand.h
View File

@@ -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 HandleUnlearnSpellCommand(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, SpellInfo const* spell, Optional<EXACT_SEQUENCE("all")> allRanks);
};
};
#endif // _PLAYER_COMMAND_H
#endif // _PLAYER_COMMAND_H

123
src/server/scripts/Commands/cs_learn.cpp
View File

@@ -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, "" },
{ "pettalents", SEC_GAMEMASTER, false, &HandleLearnAllMyPetTalentsCommand, "" },
{ "spells", SEC_GAMEMASTER, false, &HandleLearnAllMySpellsCommand, "" },
{ "talents", SEC_GAMEMASTER, false, &HandleLearnAllMyTalentsCommand, "" }
{ "class", HandleLearnAllMyClassCommand, SEC_GAMEMASTER, Console::No },
{ "pettalents", HandleLearnAllMyPetTalentsCommand, SEC_GAMEMASTER, Console::No },
{ "spells", HandleLearnAllMySpellsCommand, SEC_GAMEMASTER, Console::No },
{ "talents", HandleLearnAllMyTalentsCommand, SEC_GAMEMASTER, Console::No }
};
static ChatCommandTable learnAllCommandTable =
{
{ "my", SEC_GAMEMASTER, false, nullptr, "", learnAllMyCommandTable },
{ "gm", SEC_GAMEMASTER, false, &HandleLearnAllGMCommand, "" },
{ "crafts", SEC_GAMEMASTER, false, &HandleLearnAllCraftsCommand, "" },
{ "default", SEC_GAMEMASTER, false, &HandleLearnAllDefaultCommand, "" },
{ "lang", SEC_GAMEMASTER, false, &HandleLearnAllLangCommand, "" },
{ "recipes", SEC_GAMEMASTER, false, &HandleLearnAllRecipesCommand, "" }
{ "my", learnAllMyCommandTable },
{ "gm", HandleLearnAllGMCommand, SEC_GAMEMASTER, Console::No },
{ "crafts", HandleLearnAllCraftsCommand, SEC_GAMEMASTER, Console::No },
{ "default", HandleLearnAllDefaultCommand, SEC_GAMEMASTER, Console::No },
{ "lang", HandleLearnAllLangCommand, SEC_GAMEMASTER, Console::No },
{ "recipes", HandleLearnAllRecipesCommand, SEC_GAMEMASTER, Console::No },
};
static ChatCommandTable learnCommandTable =
{
{ "all", SEC_GAMEMASTER, false, nullptr, "", learnAllCommandTable },
{ "", SEC_GAMEMASTER, false, &HandleLearnCommand, "" }
{ "all", learnAllCommandTable },
{ "", HandleLearnCommand, SEC_GAMEMASTER, Console::No }
};
static ChatCommandTable commandTable =
{
{ "learn", SEC_GAMEMASTER, false, nullptr, "", learnCommandTable },
{ "unlearn", SEC_GAMEMASTER, false, &HandleUnLearnCommand, "" }
{ "learn", learnCommandTable },
{ "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
uint32 spell = handler->extractSpellIdFromLink((char*)args);
char const* all = strtok(nullptr, " ");
return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, all);
return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
}
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, "");
HandleLearnAllMyTalentsCommand(handler, "");
HandleLearnAllMySpellsCommand(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 (!handler->extractPlayerTarget((char*)args, &target))
if (!player)
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)
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);
@@ -365,30 +351,19 @@ public:
continue;
if ((skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
skillInfo->categoryId != SKILL_CATEGORY_SECONDARY) ||
!skillInfo->canLink) // only prof with recipes have set
skillInfo->categoryId != SKILL_CATEGORY_SECONDARY) ||
!skillInfo->canLink) // only prof with recipes have set
continue;
int locale = handler->GetSessionDbcLocale();
name = skillInfo->name[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;
name = skillInfo->name[locale];
if (!name || !*name)
continue;
name = skillInfo->name[locale];
if (name.empty())
continue;
if (Utf8FitTo(name, namePart))
break;
}
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
uint32 spellId = handler->extractSpellIdFromLink((char*)args);
char const* allStr = strtok(nullptr, " ");
return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spellId, allStr);
return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spell, allRanks);
}
};

82
src/server/scripts/Commands/cs_player.cpp
View File

@@ -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, "" },
{ "unlearn", SEC_GAMEMASTER, true, &HandlePlayerUnLearnCommand, "" }
{ "learn", HandlePlayerLearnCommand, SEC_GAMEMASTER, Console::Yes },
{ "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, " ");
char* spellId = strtok(nullptr, " ");
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);
Player* targetPlayer = player->GetConnectedPlayer();
return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
}
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, " ");
char* spellId = strtok(nullptr, " ");
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;
Player* targetPlayer = player->GetConnectedPlayer();
return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, targetPlayer, spell, allRanks);
}
};