learn_commandscript Class Reference

Inheritance diagram for learn_commandscript:

Public Member Functions
	learn_commandscript ()
ChatCommandTable	GetCommands () const override
virtual std::vector< Acore::ChatCommands::ChatCommandBuilder >	GetCommands () const =0
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const

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	HandleLearnAllMySpellsCommand (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 (const char *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name)
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,      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", 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", learnAllCommandTable },
            { "",     HandleLearnCommand,                      SEC_GAMEMASTER, Console::No }
        };
 
        static ChatCommandTable commandTable =
        {
            { "learn", learnCommandTable },
            { "unlearn",     HandleUnLearnCommand,             SEC_GAMEMASTER, Console::No }
        };
        return commandTable;
    }

References HandleLearnAllCraftsCommand(), HandleLearnAllDefaultCommand(), HandleLearnAllGMCommand(), HandleLearnAllLangCommand(), HandleLearnAllMyClassCommand(), HandleLearnAllMyPetTalentsCommand(), HandleLearnAllMySpellsCommand(), HandleLearnAllMyTalentsCommand(), HandleLearnAllRecipesCommand(), HandleLearnCommand(), HandleUnLearnCommand(), and SEC_GAMEMASTER.

HandleLearnAllCraftsCommand()

static bool learn_commandscript::HandleLearnAllCraftsCommand ( ChatHandler *  handler )

inlinestatic

    {
        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(handler->GetSession()->GetPlayer(), skillInfo->id);
            }
        }
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_ALL_CRAFT);
        return true;
    }

References SkillLineEntry::canLink, SkillLineEntry::categoryId, WorldSession::GetPlayer(), ChatHandler::GetSession(), HandleLearnSkillRecipesHelper(), SkillLineEntry::id, LANG_COMMAND_LEARN_ALL_CRAFT, ChatHandler::SendSysMessage(), 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).c_str());
        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

    {
        // skipping UNIVERSAL language (0)
        for (uint8 i = 1; i < LANGUAGES_COUNT; ++i)
            handler->GetSession()->GetPlayer()->learnSpell(lang_description[i].spell_id);
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_ALL_LANG);
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), LANG_COMMAND_LEARN_ALL_LANG, lang_description, LANGUAGES_COUNT, Player::learnSpell(), and ChatHandler::SendSysMessage().

Referenced by GetCommands().

HandleLearnAllMyClassCommand()

static bool learn_commandscript::HandleLearnAllMyClassCommand ( ChatHandler *  handler )

inlinestatic

    {
        HandleLearnAllMySpellsCommand(handler);
        HandleLearnAllMyTalentsCommand(handler);
        return true;
    }

References HandleLearnAllMySpellsCommand(), and HandleLearnAllMyTalentsCommand().

Referenced by GetCommands().

HandleLearnAllMyPetTalentsCommand()

static bool learn_commandscript::HandleLearnAllMyPetTalentsCommand ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        Pet* pet = player->GetPet();
        if (!pet)
        {
            handler->SendSysMessage(LANG_NO_PET_FOUND);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        CreatureTemplate const* creatureInfo = pet->GetCreatureTemplate();
        if (!creatureInfo)
        {
            handler->SendSysMessage(LANG_WRONG_PET_TYPE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        CreatureFamilyEntry const* petFamily = sCreatureFamilyStore.LookupEntry(creatureInfo->family);
        if (!petFamily)
        {
            handler->SendSysMessage(LANG_WRONG_PET_TYPE);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        if (petFamily->petTalentType < 0)                       // not hunter pet
        {
            handler->SendSysMessage(LANG_WRONG_PET_TYPE);
            handler->SetSentErrorMessage(true);
            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::SendSysMessage(), Pet::SetFreeTalentPoints(), ChatHandler::SetSentErrorMessage(), sSpellMgr, sTalentStore, sTalentTabStore, and TalentEntry::TalentTab.

Referenced by GetCommands().

HandleLearnAllMySpellsCommand()

static bool learn_commandscript::HandleLearnAllMySpellsCommand ( ChatHandler *  handler )

inlinestatic

    {
        ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(handler->GetSession()->GetPlayer()->getClass());
        if (!classEntry)
            return true;
        uint32 family = classEntry->spellfamily;
 
        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;
 
            // 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)
            uint32 firstRank = sSpellMgr->GetFirstSpellInChain(spellInfo->Id);
            if (GetTalentSpellCost(firstRank) > 0)
                continue;
 
            // skip broken spells
            if (!SpellMgr::IsSpellValid(spellInfo))
                continue;
 
            handler->GetSession()->GetPlayer()->learnSpell(spellInfo->Id);
        }
 
        handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_SPELLS);
        return true;
    }

References Unit::getClass(), WorldSession::GetPlayer(), ChatHandler::GetSession(), GetTalentSpellCost(), SpellInfo::Id, Player::IsSpellFitByClassAndRace(), SpellMgr::IsSpellValid(), LANG_COMMAND_LEARN_CLASS_SPELLS, Player::learnSpell(), sChrClassesStore, ChatHandler::SendSysMessage(), SkillLineAbilityEntry::Spell, ChrClassesEntry::spellfamily, SpellInfo::SpellFamilyName, SpellInfo::SpellLevel, sSkillLineAbilityStore, and sSpellMgr.

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().

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->SendSysMessage(LANG_PLAYER_NOT_FOUND);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
    }

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

Referenced by GetCommands().

HandleLearnSkillRecipesHelper()

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

inlinestatic

    {
        uint32 classmask = player->getClassMask();
 
        for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
        {
            SkillLineAbilityEntry const* skillLine = sSkillLineAbilityStore.LookupEntry(j);
            if (!skillLine)
                continue;
 
            // wrong skill
            if (skillLine->SkillLine != skillId)
                continue;
 
            // 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 SkillLineAbilityEntry::ClassMask, Unit::getClassMask(), SpellMgr::IsSpellValid(), Player::learnSpell(), SkillLineAbilityEntry::RaceMask, SkillLineAbilityEntry::SkillLine, SkillLineAbilityEntry::Spell, sSkillLineAbilityStore, sSpellMgr, and SkillLineAbilityEntry::SupercededBySpell.

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->SendSysMessage(LANG_NO_CHAR_SELECTED);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spell, allRanks);
    }

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

Referenced by GetCommands().