Public Member Functions
	learn_commandscript ()

std::vector< ChatCommand >	GetCommands () const override

Public Member Functions inherited from ScriptObject
const std::string &	GetName () const

Static Public Member Functions
static bool	HandleLearnCommand (ChatHandler handler, char const args)

static bool	HandleLearnAllGMCommand (ChatHandler handler, char const )

static bool	HandleLearnAllMyClassCommand (ChatHandler handler, char const )

static bool	HandleLearnAllMySpellsCommand (ChatHandler handler, char const )

static bool	HandleLearnAllMyTalentsCommand (ChatHandler handler, char const )

static bool	HandleLearnAllMyPetTalentsCommand (ChatHandler , char const )

static bool	HandleLearnAllLangCommand (ChatHandler handler, char const )

static bool	HandleLearnAllDefaultCommand (ChatHandler handler, char const args)

static bool	HandleLearnAllCraftsCommand (ChatHandler handler, char const args)

static bool	HandleLearnAllRecipesCommand (ChatHandler handler, char const args)

static void	HandleLearnSkillRecipesHelper (Player *player, uint32 skillId)

static bool	HandleUnLearnCommand (ChatHandler handler, char const args)

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

Constructor & Destructor Documentation

learn_commandscript::learn_commandscript ( )

inline

37 : CommandScript("learn_commandscript") { }

CommandScript::CommandScript

CommandScript(const char *name)

Definition: ScriptMgr.cpp:1616

Member Function Documentation

std::vector<ChatCommand> learn_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

  {
  static std::vector<ChatCommand> learnAllMyCommandTable =
  {
  { "class", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_CLASS, false, &HandleLearnAllMyClassCommand, "" },
  { "pettalents", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_PETTALENTS, false, &HandleLearnAllMyPetTalentsCommand, "" },
  { "spells", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_SPELLS, false, &HandleLearnAllMySpellsCommand, "" },
  { "talents", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY_TALENTS, false, &HandleLearnAllMyTalentsCommand, "" },
  };
 
  static std::vector<ChatCommand> learnAllCommandTable =
  {
  { "my", rbac::RBAC_PERM_COMMAND_LEARN_ALL_MY, false, NULL, "", learnAllMyCommandTable },
  { "gm", rbac::RBAC_PERM_COMMAND_LEARN_ALL_GM, false, &HandleLearnAllGMCommand, "" },
  { "crafts", rbac::RBAC_PERM_COMMAND_LEARN_ALL_CRAFTS, false, &HandleLearnAllCraftsCommand, "" },
  { "default", rbac::RBAC_PERM_COMMAND_LEARN_ALL_DEFAULT, false, &HandleLearnAllDefaultCommand, "" },
  { "lang", rbac::RBAC_PERM_COMMAND_LEARN_ALL_LANG, false, &HandleLearnAllLangCommand, "" },
  { "recipes", rbac::RBAC_PERM_COMMAND_LEARN_ALL_RECIPES, false, &HandleLearnAllRecipesCommand, "" },
  };
 
  static std::vector<ChatCommand> learnCommandTable =
  {
  { "all", rbac::RBAC_PERM_COMMAND_LEARN_ALL, false, NULL, "", learnAllCommandTable },
  { "", rbac::RBAC_PERM_COMMAND_LEARN, false, &HandleLearnCommand, "" },
  };
 
  static std::vector<ChatCommand> commandTable =
  {
  { "learn", rbac::RBAC_PERM_COMMAND_LEARN, false, NULL, "", learnCommandTable },
  { "unlearn", rbac::RBAC_PERM_COMMAND_UNLEARN, false, &HandleUnLearnCommand, "" },
  };
  return commandTable;
  }

Here is the call graph for this function:

static bool learn_commandscript::HandleLearnAllCraftsCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  Player* target;
  if (!handler->extractPlayerTarget((char*)args, &target))
  return false;
 
  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);
  }
  }
 
  handler->SendSysMessage(LANG_COMMAND_LEARN_ALL_CRAFT);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllDefaultCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  Player* target;
  if (!handler->extractPlayerTarget((char*)args, &target))
  return false;
 
  target->LearnDefaultSkills();
  target->LearnCustomSpells();
  target->LearnQuestRewardedSpells();
 
  handler->PSendSysMessage(LANG_COMMAND_LEARN_ALL_DEFAULT_AND_QUEST, handler->GetNameLink(target).c_str());
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllGMCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllLangCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllMyClassCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

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

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllMyPetTalentsCommand	(	ChatHandler *	,
		char const *
	)

inlinestatic

  {
  /* TODO: 6.x remove pet talents
  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, handler->GetSession()->GetPlayer(), false))
  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;
  }

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllMySpellsCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(handler->GetSession()->GetPlayer()->getClass());
  if (!classEntry)
  return true;
  uint32 family = classEntry->SpellClassSet;
 
  for (uint32 i = 0; i < sSkillLineAbilityStore.GetNumRows(); ++i)
  {
  SkillLineAbilityEntry const* entry = sSkillLineAbilityStore.LookupEntry(i);
  if (!entry)
  continue;
 
  SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->SpellID);
  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 broken spells
  if (!SpellMgr::IsSpellValid(spellInfo, handler->GetSession()->GetPlayer(), false))
  continue;
 
  handler->GetSession()->GetPlayer()->LearnSpell(spellInfo->Id, false);
  }
 
  handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_SPELLS);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllMyTalentsCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  Player* player = handler->GetSession()->GetPlayer();
  uint32 playerClass = player->getClass();
 
  for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
  {
  TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
  if (!talentInfo)
  continue;
 
  if (playerClass != talentInfo->ClassID)
  continue;
 
  SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(talentInfo->SpellID);
  if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, handler->GetSession()->GetPlayer(), false))
  continue;
 
  // learn highest rank of talent and learn all non-talent spell ranks (recursive by tree)
  player->LearnSpellHighestRank(talentInfo->SpellID);
  player->AddTalent(talentInfo, player->GetActiveTalentGroup(), true);
  }
 
  handler->SendSysMessage(LANG_COMMAND_LEARN_CLASS_TALENTS);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnAllRecipesCommand	(	ChatHandler *	handler,
		char const *	args
	)

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 (!*args)
  return false;
 
  std::wstring namePart;
 
  if (!Utf8toWStr(args, namePart))
  return false;
 
  // converting string that we try to find to lower case
  wstrToLower(namePart);
 
  std::string name;
 
  SkillLineEntry const* targetSkillInfo = NULL;
  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;
 
  name = skillInfo->DisplayName_lang;
  if (name.empty())
  continue;
 
  if (!Utf8FitTo(name, namePart))
  continue;
 
  targetSkillInfo = skillInfo;
  }
 
  if (!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());
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleLearnCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  Player* targetPlayer = handler->getSelectedPlayerOrSelf();
 
  if (!targetPlayer)
  {
  handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
  handler->SetSentErrorMessage(true);
  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);
  if (!spell || !sSpellMgr->GetSpellInfo(spell))
  return false;
 
  char const* all = strtok(NULL, " ");
  bool allRanks = all ? (strncmp(all, "all", strlen(all)) == 0) : false;
 
  SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
  if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, handler->GetSession()->GetPlayer()))
  {
  handler->PSendSysMessage(LANG_COMMAND_SPELL_BROKEN, spell);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  if (!allRanks && targetPlayer->HasSpell(spell))
  {
  if (targetPlayer == handler->GetSession()->GetPlayer())
  handler->SendSysMessage(LANG_YOU_KNOWN_SPELL);
  else
  handler->PSendSysMessage(LANG_TARGET_KNOWN_SPELL, handler->GetNameLink(targetPlayer).c_str());
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  if (allRanks)
  targetPlayer->LearnSpellHighestRank(spell);
  else
  targetPlayer->LearnSpell(spell, false);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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->SupercedesSpell)
  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->SpellID);
  if (!spellInfo || !SpellMgr::IsSpellValid(spellInfo, player, false))
  continue;
 
  player->LearnSpell(skillLine->SpellID, false);
  }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool learn_commandscript::HandleUnLearnCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  // number or [name] Shift-click form |color|Hspell:spell_id|h[name]|h|r
  uint32 spellId = handler->extractSpellIdFromLink((char*)args);
  if (!spellId)
  return false;
 
  char const* allStr = strtok(NULL, " ");
  bool allRanks = allStr ? (strncmp(allStr, "all", strlen(allStr)) == 0) : false;
 
  Player* target = handler->getSelectedPlayer();
  if (!target)
  {
  handler->SendSysMessage(LANG_NO_CHAR_SELECTED);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  if (allRanks)
  spellId = sSpellMgr->GetFirstSpellInChain(spellId);
 
  if (target->HasSpell(spellId))
  target->RemoveSpell(spellId, false, !allRanks);
  else
  handler->SendSysMessage(LANG_FORGET_SPELL);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

src/server/scripts/Commands/cs_learn.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation