learn_commandscript Class Reference

Inheritance diagram for learn_commandscript:

Public Member Functions
	learn_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
std::string const &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleLearnCommand (ChatHandler *handler, SpellInfo const *spell, Optional< EXACT_SEQUENCE("all")> allRanks)
static bool	HandleLearnAllGMCommand (ChatHandler *handler)
static bool	HandleLearnAllMyClassCommand (ChatHandler *handler)
static bool	HandleLearnAllMyQuestSpells (ChatHandler *handler)
static bool	HandleLearnAllMyTrainerSpellsCommand (ChatHandler *handler)
static bool	HandleLearnAllMyTalentsCommand (ChatHandler *handler)
static bool	HandleLearnAllMyPetTalentsCommand (ChatHandler *handler)
static bool	HandleLearnAllLangCommand (ChatHandler *handler)
static bool	HandleLearnAllDefaultCommand (ChatHandler *handler, Optional< PlayerIdentifier > player)
static bool	HandleLearnAllCraftsCommand (ChatHandler *handler)
static bool	HandleLearnAllRecipesCommand (ChatHandler *handler, WTail namePart)
static void	HandleLearnSkillRecipesHelper (Player *player, uint32 skillId)
static bool	HandleUnLearnCommand (ChatHandler *handler, SpellInfo const *spell, Optional< EXACT_SEQUENCE("all")> allRanks)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (char const *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (char const *name, uint16 totalAvailableHooks=0)
virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

learn_commandscript()

learn_commandscript::learn_commandscript ( )

inline

: CommandScript("learn_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable learn_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable learnAllMyCommandTable =
        {
            { "class",      HandleLearnAllMyClassCommand,      rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS, Console::No },
            { "pettalents", HandleLearnAllMyPetTalentsCommand, rbac::RBAC_PERM_COMMAND_LEARN_MY_PETTALENTS, Console::No },
            { "trainer",    HandleLearnAllMyTrainerSpellsCommand, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, Console::No },
            { "talents",    HandleLearnAllMyTalentsCommand,    rbac::RBAC_PERM_COMMAND_LEARN_ALL_TALENTS, Console::No },
            { "quest",      HandleLearnAllMyQuestSpells,       rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, Console::No }
        };
 
        static ChatCommandTable learnAllCommandTable =
        {
            { "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 },
        };
 
        static ChatCommandTable learnCommandTable =
        {
            { "all",  learnAllCommandTable },
            { "",     HandleLearnCommand,                      rbac::RBAC_PERM_COMMAND_LEARN, Console::No }
        };
 
        static ChatCommandTable commandTable =
        {
            { "learn",   learnCommandTable },
            { "unlearn", HandleUnLearnCommand,             rbac::RBAC_PERM_COMMAND_UNLEARN, Console::No }
        };
        return commandTable;
    }

References HandleLearnAllCraftsCommand(), HandleLearnAllDefaultCommand(), HandleLearnAllGMCommand(), HandleLearnAllLangCommand(), HandleLearnAllMyClassCommand(), HandleLearnAllMyPetTalentsCommand(), HandleLearnAllMyQuestSpells(), HandleLearnAllMyTalentsCommand(), HandleLearnAllMyTrainerSpellsCommand(), HandleLearnAllRecipesCommand(), HandleLearnCommand(), HandleUnLearnCommand(), rbac::RBAC_PERM_COMMAND_LEARN, rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS, rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT, rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM, rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS, rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES, rbac::RBAC_PERM_COMMAND_LEARN_ALL_TALENTS, rbac::RBAC_PERM_COMMAND_LEARN_MY_PETTALENTS, and rbac::RBAC_PERM_COMMAND_UNLEARN.

HandleLearnAllCraftsCommand()

static bool learn_commandscript::HandleLearnAllCraftsCommand ( ChatHandler *  handler )

inlinestatic

    {
        Player* target = handler->GetSession()->GetPlayer();
 
        for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
        {
            SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(i);
            if (!skillInfo)
                continue;
 
            if ((skillInfo->categoryId == SKILL_CATEGORY_PROFESSION || skillInfo->categoryId == SKILL_CATEGORY_SECONDARY) &&
                    skillInfo->canLink)                             // only prof. with recipes have
            {
                HandleLearnSkillRecipesHelper(target, skillInfo->id);
 
                uint16 const maxLevel = target->GetPureMaxSkillValue(skillInfo->id);
                target->SetSkill(skillInfo->id, target->GetSkillStep(skillInfo->id), maxLevel, maxLevel);
            }
        }
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_ALL_CRAFT);
        return true;
    }

References SkillLineEntry::canLink, SkillLineEntry::categoryId, WorldSession::GetPlayer(), Player::GetPureMaxSkillValue(), ChatHandler::GetSession(), Player::GetSkillStep(), HandleLearnSkillRecipesHelper(), SkillLineEntry::id, LANG_COMMAND_LEARN_ALL_CRAFT, ChatHandler::SendSysMessage(), Player::SetSkill(), SKILL_CATEGORY_PROFESSION, SKILL_CATEGORY_SECONDARY, and sSkillLineStore.

Referenced by GetCommands().

HandleLearnAllDefaultCommand()

static bool learn_commandscript::HandleLearnAllDefaultCommand ( ChatHandler *  handler, Optional< PlayerIdentifier >  player  )

inlinestatic

    {
        if (!player)
            player = PlayerIdentifier::FromTargetOrSelf(handler);
        if (!player || !player->IsConnected())
            return false;
 
        Player* target = player->GetConnectedPlayer();
        target->LearnDefaultSkills();
        target->LearnCustomSpells();
        target->learnQuestRewardedSpells();
 
        handler->PSendSysMessage(LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST, handler->GetNameLink(target));
        return true;
    }

References Acore::ChatCommands::PlayerIdentifier::FromTargetOrSelf(), ChatHandler::GetNameLink(), LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST, Player::LearnCustomSpells(), Player::LearnDefaultSkills(), Player::learnQuestRewardedSpells(), and ChatHandler::PSendSysMessage().

Referenced by GetCommands().

HandleLearnAllGMCommand()

static bool learn_commandscript::HandleLearnAllGMCommand ( ChatHandler *  handler )

inlinestatic

    {
        for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i)
        {
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(i);
            if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
                continue;
 
            if (!spellInfo->IsAbilityOfSkillType(SKILL_INTERNAL))
                continue;
 
            handler->GetSession()->GetPlayer()->learnSpell(i);
        }
 
        handler->SendSysMessage(LANG_LEARNING_GM_SKILLS);
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), SpellInfo::IsAbilityOfSkillType(), SpellMgr::IsSpellValid(), LANG_LEARNING_GM_SKILLS, Player::learnSpell(), ChatHandler::SendSysMessage(), SKILL_INTERNAL, and sSpellMgr.

Referenced by GetCommands().

HandleLearnAllLangCommand()

static bool learn_commandscript::HandleLearnAllLangCommand ( ChatHandler *  handler )

inlinestatic

    {
        for (LanguageDesc const& langDesc : lang_description)
            if (uint32 langSpellId = langDesc.spell_id)
            {
                handler->GetPlayer()->learnSpell(langSpellId);
                handler->GetPlayer()->SetSkill(langDesc.skill_id, 0, 300, 300);
            }
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_ALL_LANG);
        return true;
    }

References ChatHandler::GetPlayer(), LANG_COMMAND_LEARN_ALL_LANG, lang_description, Player::learnSpell(), ChatHandler::SendSysMessage(), and Player::SetSkill().

Referenced by GetCommands().

HandleLearnAllMyClassCommand()

static bool learn_commandscript::HandleLearnAllMyClassCommand ( ChatHandler *  handler )

inlinestatic

    {
        HandleLearnAllMyTrainerSpellsCommand(handler);
        HandleLearnAllMyTalentsCommand(handler);
        HandleLearnAllMyQuestSpells(handler);
        return true;
    }

References HandleLearnAllMyQuestSpells(), HandleLearnAllMyTalentsCommand(), and HandleLearnAllMyTrainerSpellsCommand().

Referenced by GetCommands().

HandleLearnAllMyPetTalentsCommand()

static bool learn_commandscript::HandleLearnAllMyPetTalentsCommand ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        Pet* pet = player->GetPet();
        if (!pet)
        {
            handler->SendErrorMessage(LANG_NO_PET_FOUND);
            return false;
        }
 
        CreatureTemplate const* creatureInfo = pet->GetCreatureTemplate();
        if (!creatureInfo)
        {
            handler->SendErrorMessage(LANG_WRONG_PET_TYPE);
            return false;
        }
 
        CreatureFamilyEntry const* petFamily = sCreatureFamilyStore.LookupEntry(creatureInfo->family);
        if (!petFamily)
        {
            handler->SendErrorMessage(LANG_WRONG_PET_TYPE);
            return false;
        }
 
        if (petFamily->petTalentType < 0)                       // not hunter pet
        {
            handler->SendErrorMessage(LANG_WRONG_PET_TYPE);
            return false;
        }
 
        for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
        {
            TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
            if (!talentInfo)
                continue;
 
            TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
            if (!talentTabInfo)
                continue;
 
            // prevent learn talent for different family (cheating)
            if (((1 << petFamily->petTalentType) & talentTabInfo->petTalentMask) == 0)
                continue;
 
            // search highest talent rank
            uint32 spellId = 0;
 
            for (int8 rank = MAX_TALENT_RANK - 1; rank >= 0; --rank)
            {
                if (talentInfo->RankID[rank] != 0)
                {
                    spellId = talentInfo->RankID[rank];
                    break;
                }
            }
 
            if (!spellId)                                        // ??? none spells in talent
                continue;
 
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
            if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
                continue;
 
            // learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
            pet->learnSpellHighRank(spellId);
        }
 
        pet->SetFreeTalentPoints(0);
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_PET_TALENTS);
        return true;
    }

References CreatureTemplate::family, Creature::GetCreatureTemplate(), Player::GetPet(), WorldSession::GetPlayer(), ChatHandler::GetSession(), SpellMgr::IsSpellValid(), LANG_COMMAND_LEARN_PET_TALENTS, LANG_NO_PET_FOUND, LANG_WRONG_PET_TYPE, Pet::learnSpellHighRank(), MAX_TALENT_RANK, TalentTabEntry::petTalentMask, CreatureFamilyEntry::petTalentType, TalentEntry::RankID, sCreatureFamilyStore, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), Pet::SetFreeTalentPoints(), sSpellMgr, sTalentStore, sTalentTabStore, and TalentEntry::TalentTab.

Referenced by GetCommands().

HandleLearnAllMyQuestSpells()

static bool learn_commandscript::HandleLearnAllMyQuestSpells ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetPlayer();
        for (auto const& questPair : sObjectMgr->GetQuestTemplates())
        {
            Quest const* quest = questPair.second;
            if (quest->GetRequiredClasses() && player->SatisfyQuestClass(quest, false))
                player->learnQuestRewardedSpells(quest);
        }
 
        return true;
    }

References ChatHandler::GetPlayer(), Quest::GetRequiredClasses(), Player::learnQuestRewardedSpells(), Player::SatisfyQuestClass(), and sObjectMgr.

Referenced by GetCommands(), and HandleLearnAllMyClassCommand().

HandleLearnAllMyTalentsCommand()

static bool learn_commandscript::HandleLearnAllMyTalentsCommand ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        uint32 classMask = player->getClassMask();
 
        for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
        {
            TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
            if (!talentInfo)
                continue;
 
            TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
            if (!talentTabInfo)
                continue;
 
            if ((classMask & talentTabInfo->ClassMask) == 0)
                continue;
 
            // xinef: search highest talent rank
            uint32 spellId = 0;
            uint8 rankId = MAX_TALENT_RANK;
            for (int8 rank = MAX_TALENT_RANK - 1; rank >= 0; --rank)
            {
                if (talentInfo->RankID[rank] != 0)
                {
                    rankId = rank;
                    spellId = talentInfo->RankID[rank];
                    break;
                }
            }
 
            // xinef: some errors?
            if (!spellId || rankId == MAX_TALENT_RANK)
                continue;
 
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
            if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
                continue;
 
            player->LearnTalent(talentInfo->TalentID, rankId, true);
        }
 
        player->SetFreeTalentPoints(0);
        player->SendTalentsInfoData(false);
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_TALENTS);
        return true;
    }

References TalentTabEntry::ClassMask, Unit::getClassMask(), WorldSession::GetPlayer(), ChatHandler::GetSession(), SpellMgr::IsSpellValid(), LANG_COMMAND_LEARN_CLASS_TALENTS, Player::LearnTalent(), MAX_TALENT_RANK, TalentEntry::RankID, ChatHandler::SendSysMessage(), Player::SendTalentsInfoData(), Player::SetFreeTalentPoints(), sSpellMgr, sTalentStore, sTalentTabStore, TalentEntry::TalentID, and TalentEntry::TalentTab.

Referenced by GetCommands(), and HandleLearnAllMyClassCommand().

HandleLearnAllMyTrainerSpellsCommand()

static bool learn_commandscript::HandleLearnAllMyTrainerSpellsCommand ( ChatHandler *  handler )

inlinestatic

    {
        if (!sChrClassesStore.LookupEntry(handler->GetSession()->GetPlayer()->getClass()))
            return true;
 
        Player* player = handler->GetPlayer();
        std::vector<Trainer::Trainer const*> const& trainers = sObjectMgr->GetClassTrainers(player->getClass());
 
        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;
 
                    if (trainerSpell.IsCastable())
                        player->CastSpell(player, trainerSpell.SpellId, true);
                    else
                        player->learnSpell(trainerSpell.SpellId, false);
 
                    // a script can refuse the learn or force the spell's state, so only go around
                    // again when the spell actually stopped being teachable
                    if (!trainer->CanTeachSpell(player, &trainerSpell))
                        hadNew = true;
                }
            }
        } while (hadNew);
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_SPELLS);
        return true;
    }

References Unit::CastSpell(), Unit::getClass(), ChatHandler::GetPlayer(), WorldSession::GetPlayer(), ChatHandler::GetSession(), LANG_COMMAND_LEARN_CLASS_SPELLS, Player::learnSpell(), sChrClassesStore, ChatHandler::SendSysMessage(), and sObjectMgr.

Referenced by GetCommands(), and HandleLearnAllMyClassCommand().

HandleLearnAllRecipesCommand()

static bool learn_commandscript::HandleLearnAllRecipesCommand ( ChatHandler *  handler, WTail  namePart  )

inlinestatic

    {
        //  Learns all recipes of specified profession and sets skill to max
        //  Example: .learn all_recipes enchanting
 
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        if (namePart.empty())
            return false;
 
        // converting string that we try to find to lower case
        wstrToLower(namePart);
 
        SkillLineEntry const* targetSkillInfo = nullptr;
        char const* name = nullptr;
        for (uint32 i = 1; i < sSkillLineStore.GetNumRows(); ++i)
        {
            SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(i);
            if (!skillInfo)
                continue;
 
            if ((skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
                 skillInfo->categoryId != SKILL_CATEGORY_SECONDARY) ||
                !skillInfo->canLink)                            // only prof with recipes have set
                continue;
 
            uint8 locale = 0;
            for (; locale < TOTAL_LOCALES; ++locale)
            {
                name = skillInfo->name[locale];
                if (!name || !*name)
                    continue;
 
                if (Utf8FitTo(name, namePart))
                    break;
            }
 
            if (locale < TOTAL_LOCALES)
            {
                targetSkillInfo = skillInfo;
                break;
            }
        }
 
        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);
        return true;
    }

References SkillLineEntry::canLink, SkillLineEntry::categoryId, Player::GetPureMaxSkillValue(), ChatHandler::getSelectedPlayer(), Player::GetSkillStep(), HandleLearnSkillRecipesHelper(), SkillLineEntry::id, LANG_COMMAND_LEARN_ALL_RECIPES, LANG_PLAYER_NOT_FOUND, SkillLineEntry::name, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), Player::SetSkill(), SKILL_CATEGORY_PROFESSION, SKILL_CATEGORY_SECONDARY, sSkillLineStore, TOTAL_LOCALES, Utf8FitTo(), and wstrToLower().

Referenced by GetCommands().

HandleLearnCommand()

static bool learn_commandscript::HandleLearnCommand ( ChatHandler *  handler, SpellInfo const *  spell, Optional< EXACT_SEQUENCE("all")>  allRanks  )

inlinestatic

    {
        Player* targetPlayer = handler->getSelectedPlayer();
 
        if (!targetPlayer)
        {
            handler->SendErrorMessage(LANG_PLAYER_NOT_FOUND);
            return false;
        }
 
        return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
    }

References ChatHandler::getSelectedPlayer(), Acore::PlayerCommand::HandleLearnSpellCommand(), LANG_PLAYER_NOT_FOUND, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleLearnSkillRecipesHelper()

static void learn_commandscript::HandleLearnSkillRecipesHelper ( Player *  player, uint32  skillId  )

inlinestatic

    {
        // Rank spells (Apprentice -> Grand Master) must be learned so that the
        // skill-cleanup loop in Player::SetSkill (which calls removeSpell on the
        // first spell in each chain) can walk forward and strip every rank on
        // profession unlearn. Without the first rank in the spellbook that loop
        // bails out and the leftover rank spells re-grant the skill after relog
        // (issue #2330).
        for (uint32 rankSpell : sSpellMgr->GetSkillRankSpells(skillId))
            player->learnSpell(rankSpell);
 
        uint32 classmask = player->getClassMask();
 
        for (SkillLineAbilityEntry const* skillLine : GetSkillLineAbilitiesBySkillLine(skillId))
        {
            // not high rank
            if (skillLine->SupercededBySpell)
                continue;
 
            // skip racial skills
            if (skillLine->RaceMask != 0)
                continue;
 
            // skip wrong class skills
            if (skillLine->ClassMask && (skillLine->ClassMask & classmask) == 0)
                continue;
 
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(skillLine->Spell);
            if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
                continue;
 
            player->learnSpell(skillLine->Spell);
        }
    }

References Unit::getClassMask(), GetSkillLineAbilitiesBySkillLine(), SpellMgr::IsSpellValid(), Player::learnSpell(), and sSpellMgr.

Referenced by HandleLearnAllCraftsCommand(), and HandleLearnAllRecipesCommand().

HandleUnLearnCommand()

static bool learn_commandscript::HandleUnLearnCommand ( ChatHandler *  handler, SpellInfo const *  spell, Optional< EXACT_SEQUENCE("all")>  allRanks  )

inlinestatic

    {
        Player* target = handler->getSelectedPlayer();
        if (!target)
        {
            handler->SendErrorMessage(LANG_NO_CHAR_SELECTED);
            return false;
        }
 
        return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spell, allRanks);
    }

References ChatHandler::getSelectedPlayer(), Acore::PlayerCommand::HandleUnlearnSpellCommand(), LANG_NO_CHAR_SELECTED, and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

---

The documentation for this class was generated from the following file:

• azerothcore-wotlk/src/server/scripts/Commands/cs_learn.cpp