Trainer::Trainer Class Reference

#include "Trainer.h"

Public Member Functions
	Trainer (uint32 trainerId, Type type, uint32 requirement, std::string greeting, std::vector< Spell > spells)
Spell const *	GetSpell (uint32 spellId) const
std::vector< Spell > const &	GetSpells () const
void	SendSpells (Creature *npc, Player *player, LocaleConstant locale) const
bool	CanTeachSpell (Player const *player, Spell const *trainerSpell) const
void	TeachSpell (Creature *npc, Player *player, uint32 spellId)
Type	GetTrainerType () const
uint32	GetTrainerRequirement () const
bool	IsTrainerValidForPlayer (Player const *player) const

Private Member Functions
SpellState	GetSpellState (Player const *player, Spell const *trainerSpell) const
SpellState	GetDefaultSpellState (Player const *player, Spell const *trainerSpell) const
void	SendTeachFailure (Creature const *npc, Player const *player, uint32 spellId, FailReason reason) const
void	SendTeachSucceeded (Creature const *npc, Player const *player, uint32 spellId) const
std::string const &	GetGreeting (LocaleConstant locale) const
void	AddGreetingLocale (LocaleConstant locale, std::string greeting)

Private Attributes
friend	ObjectMgr
uint32	_trainerId
Type	_type
uint32	_requirement
std::vector< Spell >	_spells
std::array< std::string, TOTAL_LOCALES >	_greeting

Detailed Description

Constructor & Destructor Documentation

Trainer()

Trainer::Trainer::Trainer	(	uint32	trainerId,
		Type	type,
		uint32	requirement,
		std::string	greeting,
		std::vector< Spell >	spells
	)

                                                                                                                 : _trainerId(trainerId), _type(type), _requirement(requirement), _spells(std::move(spells))
    {
        _greeting[DEFAULT_LOCALE] = std::move(greeting);
    }

References DEFAULT_LOCALE.

Member Function Documentation

AddGreetingLocale()

void Trainer::Trainer::AddGreetingLocale ( LocaleConstant  locale, std::string  greeting  )

private

    {
        _greeting[locale] = std::move(greeting);
    }

CanTeachSpell()

bool Trainer::Trainer::CanTeachSpell	(	Player const *	player,
		Spell const *	trainerSpell
	)		const

    {
        SpellState state = GetSpellState(player, trainerSpell);
        if (state != SpellState::Available)
            return false;
 
        SpellInfo const* trainerSpellInfo = sSpellMgr->AssertSpellInfo(trainerSpell->SpellId);
 
        for (SpellEffectInfo const& spellEffectInfo : trainerSpellInfo->GetEffects())
        {
            if (!spellEffectInfo.IsEffect(SPELL_EFFECT_LEARN_SPELL))
                continue;
 
            SpellInfo const* learnedSpellInfo = sSpellMgr->GetSpellInfo(spellEffectInfo.TriggerSpell);
            if (learnedSpellInfo && learnedSpellInfo->IsPrimaryProfessionFirstRank() && !player->GetFreePrimaryProfessionPoints())
                return false;
        }
 
        return true;
    }

References Trainer::Available, SpellInfo::GetEffects(), Player::GetFreePrimaryProfessionPoints(), SpellInfo::IsPrimaryProfessionFirstRank(), SPELL_EFFECT_LEARN_SPELL, Trainer::Spell::SpellId, and sSpellMgr.

GetDefaultSpellState()

SpellState Trainer::Trainer::GetDefaultSpellState ( Player const *  player, Spell const *  trainerSpell  ) const

private

    {
        if (player->HasSpell(trainerSpell->SpellId))
            return SpellState::Known;
 
        // check race/class requirement
        if (!player->IsSpellFitByClassAndRace(trainerSpell->SpellId))
            return SpellState::Unavailable;
 
        // check skill requirement
        if (trainerSpell->ReqSkillLine && player->GetBaseSkillValue(trainerSpell->ReqSkillLine) < trainerSpell->ReqSkillRank)
            return SpellState::Unavailable;
 
        for (int32 reqAbility : trainerSpell->ReqAbility)
            if (reqAbility && !player->HasSpell(reqAbility))
                return SpellState::Unavailable;
 
        // check level requirement
        if (player->GetLevel() < trainerSpell->ReqLevel)
            return SpellState::Unavailable;
 
        // check ranks
        bool hasLearnSpellEffect = false;
        bool knowsAllLearnedSpells = true;
        for (SpellEffectInfo const& spellEffectInfo : sSpellMgr->AssertSpellInfo(trainerSpell->SpellId)->GetEffects())
        {
            if (!spellEffectInfo.IsEffect(SPELL_EFFECT_LEARN_SPELL))
                continue;
 
            hasLearnSpellEffect = true;
            if (!player->HasSpell(spellEffectInfo.TriggerSpell))
                knowsAllLearnedSpells = false;
 
            if (uint32 previousRankSpellId = sSpellMgr->GetPrevSpellInChain(spellEffectInfo.TriggerSpell))
                if (!player->HasSpell(previousRankSpellId))
                    return SpellState::Unavailable;
        }
 
        if (!hasLearnSpellEffect)
        {
            if (uint32 previousRankSpellId = sSpellMgr->GetPrevSpellInChain(trainerSpell->SpellId))
                if (!player->HasSpell(previousRankSpellId))
                    return SpellState::Unavailable;
        }
        else if (knowsAllLearnedSpells)
            return SpellState::Known;
 
        // check additional spell requirement
        for (auto const& requirePair : sSpellMgr->GetSpellsRequiredForSpellBounds(trainerSpell->SpellId))
            if (!player->HasSpell(requirePair.second))
                return SpellState::Unavailable;
 
        return SpellState::Available;
    }

References Trainer::Available, Player::GetBaseSkillValue(), Unit::GetLevel(), Player::HasSpell(), Player::IsSpellFitByClassAndRace(), Trainer::Known, Trainer::Spell::ReqAbility, Trainer::Spell::ReqLevel, Trainer::Spell::ReqSkillLine, Trainer::Spell::ReqSkillRank, SPELL_EFFECT_LEARN_SPELL, Trainer::Spell::SpellId, sSpellMgr, and Trainer::Unavailable.

GetGreeting()

std::string const & Trainer::Trainer::GetGreeting ( LocaleConstant  locale ) const

private

    {
        if (_greeting[locale].empty())
            return _greeting[DEFAULT_LOCALE];
 
        return _greeting[locale];
    }

References DEFAULT_LOCALE.

GetSpell()

Spell const * Trainer::Trainer::GetSpell

(

uint32

spellId

)

const

    {
        auto itr = std::find_if(_spells.begin(), _spells.end(), [spellId](Spell const& trainerSpell)
        {
            return trainerSpell.SpellId == spellId;
        });
 
        if (itr != _spells.end())
            return &(*itr);
 
        return nullptr;
    }

GetSpells()

std::vector< Spell > const & Trainer::Trainer::GetSpells ( ) const

inline

{ return _spells; }

GetSpellState()

SpellState Trainer::Trainer::GetSpellState ( Player const *  player, Spell const *  trainerSpell  ) const

private

    {
        SpellState state = GetDefaultSpellState(player, trainerSpell);
        sScriptMgr->OnPlayerGetTrainerSpellState(player, _trainerId, trainerSpell->SpellId, state);
        return state;
    }

References Trainer::Spell::SpellId, and sScriptMgr.

GetTrainerRequirement()

uint32 Trainer::Trainer::GetTrainerRequirement ( ) const

inline

{ return _requirement; }

GetTrainerType()

Type Trainer::Trainer::GetTrainerType ( ) const

inline

{ return _type; }

IsTrainerValidForPlayer()

bool Trainer::Trainer::IsTrainerValidForPlayer

(

Player const *

player

)

const

    {
        if (!GetTrainerRequirement())
            return true;
 
        switch (GetTrainerType())
        {
            case Type::Class:
            case Type::Pet:
                // check class for class trainers
                return player->getClass() == GetTrainerRequirement();
            case Type::Mount:
                // check race for mount trainers
                return player->getRace() == GetTrainerRequirement();
            case Type::Tradeskill:
                // check spell for profession trainers
                return player->HasSpell(GetTrainerRequirement());
            default:
                break;
        }
 
        return true;
    }

References Trainer::Class, Unit::getClass(), Unit::getRace(), Player::HasSpell(), Trainer::Mount, Trainer::Pet, and Trainer::Tradeskill.

Referenced by Creature::CanResetTalents(), Player::PrepareGossipMenu(), and WorldSession::SendTrainerList().

SendSpells()

void Trainer::Trainer::SendSpells	(	Creature *	npc,
		Player *	player,
		LocaleConstant	locale
	)		const

    {
        float reputationDiscount = player->GetReputationPriceDiscount(npc);
 
        WorldPackets::NPC::TrainerList trainerList;
        trainerList.TrainerGUID = npc->GetGUID();
        trainerList.TrainerType = AsUnderlyingType(_type);
        trainerList.Greeting = GetGreeting(locale);
        trainerList.Spells.reserve(_spells.size());
        for (Spell const& trainerSpell : _spells)
        {
            if (!player->IsSpellFitByClassAndRace(trainerSpell.SpellId))
                continue;
 
            SpellInfo const* trainerSpellInfo = sSpellMgr->AssertSpellInfo(trainerSpell.SpellId);
 
            bool primaryProfessionFirstRank = false;
            for (SpellEffectInfo const& spellEffectInfo : trainerSpellInfo->GetEffects())
            {
                if (!spellEffectInfo.IsEffect(SPELL_EFFECT_LEARN_SPELL))
                    continue;
 
                SpellInfo const* learnedSpellInfo = sSpellMgr->GetSpellInfo(spellEffectInfo.TriggerSpell);
                if (learnedSpellInfo && learnedSpellInfo->IsPrimaryProfessionFirstRank())
                    primaryProfessionFirstRank = true;
            }
 
            trainerList.Spells.emplace_back();
            WorldPackets::NPC::TrainerListSpell& trainerListSpell = trainerList.Spells.back();
            trainerListSpell.SpellID = trainerSpell.SpellId;
            trainerListSpell.Usable = AsUnderlyingType(GetSpellState(player, &trainerSpell));
            trainerListSpell.MoneyCost = int32(trainerSpell.MoneyCost * reputationDiscount);
            trainerListSpell.PointCost[0] = 0; // spells don't cost talent points
            trainerListSpell.PointCost[1] = (primaryProfessionFirstRank ? 1 : 0);
            trainerListSpell.ReqLevel = trainerSpell.ReqLevel;
            trainerListSpell.ReqSkillLine = trainerSpell.ReqSkillLine;
            trainerListSpell.ReqSkillRank = trainerSpell.ReqSkillRank;
            std::copy(trainerSpell.ReqAbility.begin(), trainerSpell.ReqAbility.end(), trainerListSpell.ReqAbility.begin());
        }
 
        sScriptMgr->OnPlayerBeforeReceiveSpellListFromTrainer(player, npc, trainerList);
 
        player->SendDirectMessage(trainerList.Write());
    }

References AsUnderlyingType(), SpellInfo::GetEffects(), Player::GetReputationPriceDiscount(), WorldPackets::NPC::TrainerList::Greeting, SpellInfo::IsPrimaryProfessionFirstRank(), Player::IsSpellFitByClassAndRace(), WorldPackets::NPC::TrainerListSpell::MoneyCost, WorldPackets::NPC::TrainerListSpell::PointCost, WorldPackets::NPC::TrainerListSpell::ReqAbility, WorldPackets::NPC::TrainerListSpell::ReqLevel, WorldPackets::NPC::TrainerListSpell::ReqSkillLine, WorldPackets::NPC::TrainerListSpell::ReqSkillRank, Player::SendDirectMessage(), SPELL_EFFECT_LEARN_SPELL, WorldPackets::NPC::TrainerListSpell::SpellID, WorldPackets::NPC::TrainerList::Spells, sScriptMgr, sSpellMgr, WorldPackets::NPC::TrainerList::TrainerGUID, WorldPackets::NPC::TrainerList::TrainerType, WorldPackets::NPC::TrainerListSpell::Usable, and WorldPackets::NPC::TrainerList::Write().

Referenced by WorldSession::SendTrainerList().

SendTeachFailure()

void Trainer::Trainer::SendTeachFailure ( Creature const *  npc, Player const *  player, uint32  spellId, FailReason  reason  ) const

private

    {
        WorldPackets::NPC::TrainerBuyFailed trainerBuyFailed;
        trainerBuyFailed.TrainerGUID = npc->GetGUID();
        trainerBuyFailed.SpellID = spellId;
        trainerBuyFailed.TrainerFailedReason = AsUnderlyingType(reason);
        player->SendDirectMessage(trainerBuyFailed.Write());
    }

References AsUnderlyingType(), Player::SendDirectMessage(), WorldPackets::NPC::TrainerBuyFailed::SpellID, WorldPackets::NPC::TrainerBuyFailed::TrainerFailedReason, WorldPackets::NPC::TrainerBuyFailed::TrainerGUID, and WorldPackets::NPC::TrainerBuyFailed::Write().

SendTeachSucceeded()

void Trainer::Trainer::SendTeachSucceeded ( Creature const *  npc, Player const *  player, uint32  spellId  ) const

private

    {
        WorldPackets::NPC::TrainerBuySucceeded trainerBuySucceeded;
        trainerBuySucceeded.TrainerGUID = npc->GetGUID();
        trainerBuySucceeded.SpellID = spellId;
        player->SendDirectMessage(trainerBuySucceeded.Write());
    }

References Player::SendDirectMessage(), WorldPackets::NPC::TrainerBuySucceeded::SpellID, WorldPackets::NPC::TrainerBuySucceeded::TrainerGUID, and WorldPackets::NPC::TrainerBuySucceeded::Write().

TeachSpell()

void Trainer::Trainer::TeachSpell	(	Creature *	npc,
		Player *	player,
		uint32	spellId
	)

    {
        if (!IsTrainerValidForPlayer(player))
            return;
 
        Spell const* trainerSpell = GetSpell(spellId);
        if (!trainerSpell)
        {
            SendTeachFailure(npc, player, spellId, FailReason::Unavailable);
            return;
        }
 
        if (!CanTeachSpell(player, trainerSpell))
        {
            SendTeachFailure(npc, player, spellId, FailReason::NotEnoughSkill);
            return;
        }
 
        float reputationDiscount = player->GetReputationPriceDiscount(npc);
        int32 moneyCost = int32(trainerSpell->MoneyCost * reputationDiscount);
        if (!player->HasEnoughMoney(moneyCost))
        {
            SendTeachFailure(npc, player, spellId, FailReason::NotEnoughMoney);
            return;
        }
 
        player->ModifyMoney(-moneyCost);
 
        npc->SendPlaySpellVisual(179); // 53 SpellCastDirected
        npc->SendPlaySpellImpact(player->GetGUID(), 362); // 113 EmoteSalute
 
        // learn explicitly or cast explicitly. A cast puts each wrapped spell through learnSpell and
        // its hook, but also runs whatever else the entry does (a class mount steps the Riding skill),
        // so the entry itself is put to the hook first and a refusal skips the cast as a whole
        if (!trainerSpell->IsCastable())
            player->learnSpell(trainerSpell->SpellId, false);
        else if (sScriptMgr->OnPlayerCanLearnSpell(player, trainerSpell->SpellId))
            player->CastSpell(player, trainerSpell->SpellId, true);
 
        SendTeachSucceeded(npc, player, spellId);
 
        sScriptMgr->OnPlayerAfterTrainSpell(player, npc, spellId);
    }

References Unit::CastSpell(), Object::GetGUID(), Player::GetReputationPriceDiscount(), Player::HasEnoughMoney(), Trainer::Spell::IsCastable(), Player::learnSpell(), Player::ModifyMoney(), Trainer::Spell::MoneyCost, Trainer::NotEnoughMoney, Trainer::NotEnoughSkill, Trainer::Spell::SpellId, sScriptMgr, and Trainer::Unavailable.

Referenced by WorldSession::HandleTrainerBuySpellOpcode().

Member Data Documentation

_greeting

std::array<std::string, TOTAL_LOCALES> Trainer::Trainer::_greeting

private

_requirement

uint32 Trainer::Trainer::_requirement

private

_spells

std::vector<Spell> Trainer::Trainer::_spells

private

_trainerId

uint32 Trainer::Trainer::_trainerId

private

_type

Type Trainer::Trainer::_type

private

ObjectMgr

friend Trainer::Trainer::ObjectMgr

private

---

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

• azerothcore-wotlk/src/server/game/Entities/Creature/Trainer.h
• azerothcore-wotlk/src/server/game/Entities/Creature/Trainer.cpp