AzerothCore 3.3.5a
OpenSource WoW Emulator
Loading...
Searching...
No Matches
learn_commandscript Class Reference
Inheritance diagram for learn_commandscript:
CommandScript ScriptObject

Public Member Functions

 learn_commandscript ()
 
ChatCommandTable GetCommands () const override
 
virtual std::vector< Acore::ChatCommands::ChatCommandBuilderGetCommands () 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
39: CommandScript("learn_commandscript") { }
Definition: CommandScript.h:25

Member Function Documentation

◆ GetCommands()

ChatCommandTable learn_commandscript::GetCommands ( ) const
inlineoverridevirtual

Implements CommandScript.

42 {
43 static ChatCommandTable learnAllMyCommandTable =
44 {
45 { "class", HandleLearnAllMyClassCommand, SEC_GAMEMASTER, Console::No },
46 { "pettalents", HandleLearnAllMyPetTalentsCommand, SEC_GAMEMASTER, Console::No },
47 { "spells", HandleLearnAllMySpellsCommand, SEC_GAMEMASTER, Console::No },
48 { "talents", HandleLearnAllMyTalentsCommand, SEC_GAMEMASTER, Console::No }
49 };
50
51 static ChatCommandTable learnAllCommandTable =
52 {
53 { "my", learnAllMyCommandTable },
54 { "gm", HandleLearnAllGMCommand, SEC_GAMEMASTER, Console::No },
55 { "crafts", HandleLearnAllCraftsCommand, SEC_GAMEMASTER, Console::No },
56 { "default", HandleLearnAllDefaultCommand, SEC_GAMEMASTER, Console::No },
57 { "lang", HandleLearnAllLangCommand, SEC_GAMEMASTER, Console::No },
58 { "recipes", HandleLearnAllRecipesCommand, SEC_GAMEMASTER, Console::No },
59 };
60
61 static ChatCommandTable learnCommandTable =
62 {
63 { "all", learnAllCommandTable },
64 { "", HandleLearnCommand, SEC_GAMEMASTER, Console::No }
65 };
66
67 static ChatCommandTable commandTable =
68 {
69 { "learn", learnCommandTable },
70 { "unlearn", HandleUnLearnCommand, SEC_GAMEMASTER, Console::No }
71 };
72 return commandTable;
73 }
@ SEC_GAMEMASTER
Definition: Common.h:61
std::vector< ChatCommandBuilder > ChatCommandTable
Definition: ChatCommand.h:49
static bool HandleLearnAllMyPetTalentsCommand(ChatHandler *handler)
Definition: cs_learn.cpp:207
static bool HandleUnLearnCommand(ChatHandler *handler, SpellInfo const *spell, Optional< EXACT_SEQUENCE("all")> allRanks)
Definition: cs_learn.cpp:423
static bool HandleLearnAllRecipesCommand(ChatHandler *handler, WTail namePart)
Definition: cs_learn.cpp:329
static bool HandleLearnAllGMCommand(ChatHandler *handler)
Definition: cs_learn.cpp:88
static bool HandleLearnAllMyClassCommand(ChatHandler *handler)
Definition: cs_learn.cpp:106
static bool HandleLearnAllDefaultCommand(ChatHandler *handler, Optional< PlayerIdentifier > player)
Definition: cs_learn.cpp:294
static bool HandleLearnAllMyTalentsCommand(ChatHandler *handler)
Definition: cs_learn.cpp:158
static bool HandleLearnAllLangCommand(ChatHandler *handler)
Definition: cs_learn.cpp:281
static bool HandleLearnCommand(ChatHandler *handler, SpellInfo const *spell, Optional< EXACT_SEQUENCE("all")> allRanks)
Definition: cs_learn.cpp:75
static bool HandleLearnAllCraftsCommand(ChatHandler *handler)
Definition: cs_learn.cpp:310
static bool HandleLearnAllMySpellsCommand(ChatHandler *handler)
Definition: cs_learn.cpp:113

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

◆ HandleLearnAllCraftsCommand()

static bool learn_commandscript::HandleLearnAllCraftsCommand ( ChatHandler handler)
inlinestatic
311 {
312 for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
313 {
314 SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(i);
315 if (!skillInfo)
316 continue;
317
318 if ((skillInfo->categoryId == SKILL_CATEGORY_PROFESSION || skillInfo->categoryId == SKILL_CATEGORY_SECONDARY) &&
319 skillInfo->canLink) // only prof. with recipes have
320 {
321 HandleLearnSkillRecipesHelper(handler->GetSession()->GetPlayer(), skillInfo->id);
322 }
323 }
324
326 return true;
327 }
std::uint32_t uint32
Definition: Define.h:108
DBCStorage< SkillLineEntry > sSkillLineStore(SkillLinefmt)
@ LANG_COMMAND_LEARN_ALL_CRAFT
Definition: Language.h:448
@ SKILL_CATEGORY_SECONDARY
Definition: SharedDefines.h:3076
@ SKILL_CATEGORY_PROFESSION
Definition: SharedDefines.h:3078
WorldSession * GetSession()
Definition: Chat.h:139
virtual void SendSysMessage(std::string_view str, bool escapeCharacters=false)
Definition: Chat.cpp:101
Player * GetPlayer() const
Definition: WorldSession.h:364
static void HandleLearnSkillRecipesHelper(Player *player, uint32 skillId)
Definition: cs_learn.cpp:389
Definition: DBCStructure.h:1581
uint32 id
Definition: DBCStructure.h:1582
int32 categoryId
Definition: DBCStructure.h:1583
uint32 canLink
Definition: DBCStructure.h:1592

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
295 {
296 if (!player)
297 player = PlayerIdentifier::FromTargetOrSelf(handler);
298 if (!player || !player->IsConnected())
299 return false;
300
301 Player* target = player->GetConnectedPlayer();
302 target->LearnDefaultSkills();
303 target->LearnCustomSpells();
304 target->learnQuestRewardedSpells();
305
306 handler->PSendSysMessage(LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST, handler->GetNameLink(target).c_str());
307 return true;
308 }
@ LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST
Definition: Language.h:622
virtual std::string GetNameLink() const
Definition: Chat.h:101
void PSendSysMessage(char const *fmt, Args &&... args)
Definition: Chat.h:60
static Optional< PlayerIdentifier > FromTargetOrSelf(ChatHandler *handler)
Definition: ChatCommandTags.h:188
Definition: Player.h:1056
void LearnCustomSpells()
Definition: Player.cpp:11752
void learnQuestRewardedSpells()
Definition: Player.cpp:11894
void LearnDefaultSkills()
Definition: Player.cpp:11778

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
89 {
90 for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i)
91 {
92 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(i);
93 if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
94 continue;
95
96 if (!spellInfo->IsAbilityOfSkillType(SKILL_INTERNAL))
97 continue;
98
99 handler->GetSession()->GetPlayer()->learnSpell(i);
100 }
101
103 return true;
104 }
@ LANG_LEARNING_GM_SKILLS
Definition: Language.h:509
#define sSpellMgr
Definition: SpellMgr.h:825
@ SKILL_INTERNAL
Definition: SharedDefines.h:2998
void learnSpell(uint32 spellId, bool temporary=false, bool learnFromSkill=false)
Definition: Player.cpp:3243
Definition: SpellInfo.h:314
bool IsAbilityOfSkillType(uint32 skillType) const
Definition: SpellInfo.cpp:992
static bool IsSpellValid(SpellInfo const *spellInfo)
Definition: SpellMgr.cpp:442

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
282 {
283 for (LanguageDesc const& langDesc : lang_description)
284 if (uint32 langSpellId = langDesc.spell_id)
285 {
286 handler->GetPlayer()->learnSpell(langSpellId);
287 handler->GetPlayer()->SetSkill(langDesc.skill_id, 0, 300, 300);
288 }
289
291 return true;
292 }
LanguageDesc lang_description[LANGUAGES_COUNT]
Definition: ObjectMgr.cpp:284
@ LANG_COMMAND_LEARN_ALL_LANG
Definition: Language.h:447
Player * GetPlayer() const
Definition: Chat.cpp:37
void SetSkill(uint16 id, uint16 step, uint16 currVal, uint16 maxVal)
Definition: Player.cpp:5244
Definition: ObjectMgr.h:699

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
107 {
110 return true;
111 }

References HandleLearnAllMySpellsCommand(), and HandleLearnAllMyTalentsCommand().

Referenced by GetCommands().

◆ HandleLearnAllMyPetTalentsCommand()

static bool learn_commandscript::HandleLearnAllMyPetTalentsCommand ( ChatHandler handler)
inlinestatic
208 {
209 Player* player = handler->GetSession()->GetPlayer();
210
211 Pet* pet = player->GetPet();
212 if (!pet)
213 {
215 return false;
216 }
217
218 CreatureTemplate const* creatureInfo = pet->GetCreatureTemplate();
219 if (!creatureInfo)
220 {
222 return false;
223 }
224
225 CreatureFamilyEntry const* petFamily = sCreatureFamilyStore.LookupEntry(creatureInfo->family);
226 if (!petFamily)
227 {
229 return false;
230 }
231
232 if (petFamily->petTalentType < 0) // not hunter pet
233 {
235 return false;
236 }
237
238 for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
239 {
240 TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
241 if (!talentInfo)
242 continue;
243
244 TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
245 if (!talentTabInfo)
246 continue;
247
248 // prevent learn talent for different family (cheating)
249 if (((1 << petFamily->petTalentType) & talentTabInfo->petTalentMask) == 0)
250 continue;
251
252 // search highest talent rank
253 uint32 spellId = 0;
254
255 for (int8 rank = MAX_TALENT_RANK - 1; rank >= 0; --rank)
256 {
257 if (talentInfo->RankID[rank] != 0)
258 {
259 spellId = talentInfo->RankID[rank];
260 break;
261 }
262 }
263
264 if (!spellId) // ??? none spells in talent
265 continue;
266
267 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
268 if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
269 continue;
270
271 // learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
272 pet->learnSpellHighRank(spellId);
273 }
274
275 pet->SetFreeTalentPoints(0);
276
278 return true;
279 }
std::int8_t int8
Definition: Define.h:106
DBCStorage< TalentTabEntry > sTalentTabStore(TalentTabEntryfmt)
DBCStorage< CreatureFamilyEntry > sCreatureFamilyStore(CreatureFamilyfmt)
DBCStorage< TalentEntry > sTalentStore(TalentEntryfmt)
@ LANG_WRONG_PET_TYPE
Definition: Language.h:895
@ LANG_COMMAND_LEARN_PET_TALENTS
Definition: Language.h:896
@ LANG_NO_PET_FOUND
Definition: Language.h:894
#define MAX_TALENT_RANK
Definition: DBCStructure.h:1919
void SendErrorMessage(uint32 entry)
Definition: Chat.cpp:152
CreatureTemplate const * GetCreatureTemplate() const
Definition: Creature.h:199
Definition: CreatureData.h:176
uint32 family
Definition: CreatureData.h:210
Definition: Pet.h:40
void learnSpellHighRank(uint32 spellid)
Definition: Pet.cpp:2383
void SetFreeTalentPoints(uint8 points)
Definition: Pet.h:131
Pet * GetPet() const
Definition: Player.cpp:8819
Definition: DBCStructure.h:754
int32 petTalentType
Definition: DBCStructure.h:762
Definition: DBCStructure.h:1924
std::array< uint32, MAX_TALENT_RANK > RankID
Definition: DBCStructure.h:1929
uint32 TalentTab
Definition: DBCStructure.h:1926
Definition: DBCStructure.h:1941
uint32 petTalentMask
Definition: DBCStructure.h:1948

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

◆ HandleLearnAllMySpellsCommand()

static bool learn_commandscript::HandleLearnAllMySpellsCommand ( ChatHandler handler)
inlinestatic
114 {
115 ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(handler->GetSession()->GetPlayer()->getClass());
116 if (!classEntry)
117 return true;
118 uint32 family = classEntry->spellfamily;
119
120 for (uint32 i = 0; i < sSkillLineAbilityStore.GetNumRows(); ++i)
121 {
122 SkillLineAbilityEntry const* entry = sSkillLineAbilityStore.LookupEntry(i);
123 if (!entry)
124 continue;
125
126 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Spell);
127 if (!spellInfo)
128 continue;
129
130 // skip server-side/triggered spells
131 if (spellInfo->SpellLevel == 0)
132 continue;
133
134 // skip wrong class/race skills
135 if (!handler->GetSession()->GetPlayer()->IsSpellFitByClassAndRace(spellInfo->Id))
136 continue;
137
138 // skip other spell families
139 if (spellInfo->SpellFamilyName != family)
140 continue;
141
142 // skip spells with first rank learned as talent (and all talents then also)
143 uint32 firstRank = sSpellMgr->GetFirstSpellInChain(spellInfo->Id);
144 if (GetTalentSpellCost(firstRank) > 0)
145 continue;
146
147 // skip broken spells
148 if (!SpellMgr::IsSpellValid(spellInfo))
149 continue;
150
151 handler->GetSession()->GetPlayer()->learnSpell(spellInfo->Id);
152 }
153
155 return true;
156 }
uint32 GetTalentSpellCost(uint32 spellId)
Definition: DBCStores.cpp:682
DBCStorage< SkillLineAbilityEntry > sSkillLineAbilityStore(SkillLineAbilityfmt)
DBCStorage< ChrClassesEntry > sChrClassesStore(ChrClassesEntryfmt)
@ LANG_COMMAND_LEARN_CLASS_SPELLS
Definition: Language.h:445
bool IsSpellFitByClassAndRace(uint32 spell_id) const
Definition: Player.cpp:12278
uint8 getClass() const
Definition: Unit.h:1438
uint32 SpellLevel
Definition: SpellInfo.h:358
uint32 Id
Definition: SpellInfo.h:318
uint32 SpellFamilyName
Definition: SpellInfo.h:385
Definition: DBCStructure.h:653
uint32 spellfamily
Definition: DBCStructure.h:665
Definition: DBCStructure.h:1596
uint32 Spell
Definition: DBCStructure.h:1599

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
159 {
160 Player* player = handler->GetSession()->GetPlayer();
161 uint32 classMask = player->getClassMask();
162
163 for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
164 {
165 TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
166 if (!talentInfo)
167 continue;
168
169 TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
170 if (!talentTabInfo)
171 continue;
172
173 if ((classMask & talentTabInfo->ClassMask) == 0)
174 continue;
175
176 // xinef: search highest talent rank
177 uint32 spellId = 0;
178 uint8 rankId = MAX_TALENT_RANK;
179 for (int8 rank = MAX_TALENT_RANK - 1; rank >= 0; --rank)
180 {
181 if (talentInfo->RankID[rank] != 0)
182 {
183 rankId = rank;
184 spellId = talentInfo->RankID[rank];
185 break;
186 }
187 }
188
189 // xinef: some errors?
190 if (!spellId || rankId == MAX_TALENT_RANK)
191 continue;
192
193 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
194 if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
195 continue;
196
197 player->LearnTalent(talentInfo->TalentID, rankId, true);
198 }
199
200 player->SetFreeTalentPoints(0);
201 player->SendTalentsInfoData(false);
202
204 return true;
205 }
std::uint8_t uint8
Definition: Define.h:110
@ LANG_COMMAND_LEARN_CLASS_TALENTS
Definition: Language.h:446
void SendTalentsInfoData(bool pet)
Definition: Player.cpp:14338
void LearnTalent(uint32 talentId, uint32 talentRank, bool command=false)
Definition: Player.cpp:13856
void SetFreeTalentPoints(uint32 points)
Definition: Player.cpp:3751
uint32 getClassMask() const
Definition: Unit.h:1439
uint32 TalentID
Definition: DBCStructure.h:1925
uint32 ClassMask
Definition: DBCStructure.h:1947

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
330 {
331 // Learns all recipes of specified profession and sets skill to max
332 // Example: .learn all_recipes enchanting
333
334 Player* target = handler->getSelectedPlayer();
335 if (!target)
336 {
338 return false;
339 }
340
341 if (namePart.empty())
342 return false;
343
344 // converting string that we try to find to lower case
345 wstrToLower(namePart);
346
347 SkillLineEntry const* targetSkillInfo = nullptr;
348 char const* name = nullptr;
349 for (uint32 i = 1; i < sSkillLineStore.GetNumRows(); ++i)
350 {
351 SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(i);
352 if (!skillInfo)
353 continue;
354
355 if ((skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
356 skillInfo->categoryId != SKILL_CATEGORY_SECONDARY) ||
357 !skillInfo->canLink) // only prof with recipes have set
358 continue;
359
360 uint8 locale = 0;
361 for (; locale < TOTAL_LOCALES; ++locale)
362 {
363 name = skillInfo->name[locale];
364 if (!name || !*name)
365 continue;
366
367 if (Utf8FitTo(name, namePart))
368 break;
369 }
370
371 if (locale < TOTAL_LOCALES)
372 {
373 targetSkillInfo = skillInfo;
374 break;
375 }
376 }
377
378 if (!(name && targetSkillInfo))
379 return false;
380
381 HandleLearnSkillRecipesHelper(target, targetSkillInfo->id);
382
383 uint16 maxLevel = target->GetPureMaxSkillValue(targetSkillInfo->id);
384 target->SetSkill(targetSkillInfo->id, target->GetSkillStep(targetSkillInfo->id), maxLevel, maxLevel);
386 return true;
387 }
@ TOTAL_LOCALES
Definition: Common.h:78
std::uint16_t uint16
Definition: Define.h:109
void wstrToLower(std::wstring &str)
Definition: Util.cpp:382
bool Utf8FitTo(std::string_view str, std::wstring_view search)
Definition: Util.cpp:476
@ LANG_COMMAND_LEARN_ALL_RECIPES
Definition: Language.h:637
@ LANG_PLAYER_NOT_FOUND
Definition: Language.h:522
Player * getSelectedPlayer() const
Definition: Chat.cpp:310
uint16 GetSkillStep(uint16 skill) const
Definition: Player.cpp:5355
uint16 GetPureMaxSkillValue(uint32 skill) const
Definition: Player.cpp:5402
char const * name[16]
Definition: DBCStructure.h:1585

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
76 {
77 Player* targetPlayer = handler->getSelectedPlayer();
78
79 if (!targetPlayer)
80 {
82 return false;
83 }
84
85 return Acore::PlayerCommand::HandleLearnSpellCommand(handler, targetPlayer, spell, allRanks);
86 }
bool HandleLearnSpellCommand(ChatHandler *handler, Player *targetPlayer, SpellInfo const *spell, Optional< EXACT_SEQUENCE("all")> allRanks)
Definition: PlayerCommand.cpp:24

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
390 {
391 uint32 classmask = player->getClassMask();
392
393 for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
394 {
395 SkillLineAbilityEntry const* skillLine = sSkillLineAbilityStore.LookupEntry(j);
396 if (!skillLine)
397 continue;
398
399 // wrong skill
400 if (skillLine->SkillLine != skillId)
401 continue;
402
403 // not high rank
404 if (skillLine->SupercededBySpell)
405 continue;
406
407 // skip racial skills
408 if (skillLine->RaceMask != 0)
409 continue;
410
411 // skip wrong class skills
412 if (skillLine->ClassMask && (skillLine->ClassMask & classmask) == 0)
413 continue;
414
415 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(skillLine->Spell);
416 if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo))
417 continue;
418
419 player->learnSpell(skillLine->Spell);
420 }
421 }
uint32 SkillLine
Definition: DBCStructure.h:1598
uint32 SupercededBySpell
Definition: DBCStructure.h:1605
uint32 ClassMask
Definition: DBCStructure.h:1601
uint32 RaceMask
Definition: DBCStructure.h:1600

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
424 {
425 Player* target = handler->getSelectedPlayer();
426 if (!target)
427 {
429 return false;
430 }
431
432 return Acore::PlayerCommand::HandleUnlearnSpellCommand(handler, target, spell, allRanks);
433 }
@ LANG_NO_CHAR_SELECTED
Definition: Language.h:148
bool HandleUnlearnSpellCommand(ChatHandler *handler, Player *targetPlayer, SpellInfo const *spell, Optional< EXACT_SEQUENCE("all")> allRanks)
Definition: PlayerCommand.cpp:66

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

Referenced by GetCommands().