Public Member Functions
	lookup_commandscript ()

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

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

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

static bool	HandleLookupCreatureCommand (ChatHandler handler, char const args)

static bool	HandleLookupEventCommand (ChatHandler handler, char const args)

static bool	HandleLookupFactionCommand (ChatHandler handler, char const args)

static bool	HandleLookupItemCommand (ChatHandler handler, char const args)

static bool	HandleLookupItemSetCommand (ChatHandler handler, char const args)

static bool	HandleLookupObjectCommand (ChatHandler handler, char const args)

static bool	HandleLookupQuestCommand (ChatHandler handler, char const args)

static bool	HandleLookupSkillCommand (ChatHandler handler, char const args)

static bool	HandleLookupSpellCommand (ChatHandler handler, char const args)

static bool	HandleLookupSpellIdCommand (ChatHandler handler, char const args)

static bool	HandleLookupTaxiNodeCommand (ChatHandler handler, const char args)

static bool	HandleLookupTeleCommand (ChatHandler handler, char const args)

static bool	HandleLookupTitleCommand (ChatHandler handler, char const args)

static bool	HandleLookupMapCommand (ChatHandler handler, char const args)

static bool	HandleLookupPlayerIpCommand (ChatHandler handler, char const args)

static bool	HandleLookupPlayerAccountCommand (ChatHandler handler, char const args)

static bool	HandleLookupPlayerEmailCommand (ChatHandler handler, char const args)

static bool	LookupPlayerSearchCommand (PreparedQueryResult result, int32 limit, ChatHandler *handler)

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

lookup_commandscript::lookup_commandscript ( )

inline

38 : CommandScript("lookup_commandscript") { }

CommandScript::CommandScript

CommandScript(const char *name)

Definition: ScriptMgr.cpp:1616

Member Function Documentation

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

inlineoverridevirtual

Implements CommandScript.

  {
  static std::vector<ChatCommand> lookupPlayerCommandTable =
  {
  { "ip", rbac::RBAC_PERM_COMMAND_LOOKUP_PLAYER_IP, true, &HandleLookupPlayerIpCommand, "" },
  { "account", rbac::RBAC_PERM_COMMAND_LOOKUP_PLAYER_ACCOUNT, true, &HandleLookupPlayerAccountCommand, "" },
  { "email", rbac::RBAC_PERM_COMMAND_LOOKUP_PLAYER_EMAIL, true, &HandleLookupPlayerEmailCommand, "" },
  };
 
  static std::vector<ChatCommand> lookupSpellCommandTable =
  {
  { "id", rbac::RBAC_PERM_COMMAND_LOOKUP_SPELL_ID, true, &HandleLookupSpellIdCommand, "" },
  { "", rbac::RBAC_PERM_COMMAND_LOOKUP_SPELL, true, &HandleLookupSpellCommand, "" },
  };
 
  static std::vector<ChatCommand> lookupCommandTable =
  {
  { "area", rbac::RBAC_PERM_COMMAND_LOOKUP_AREA, true, &HandleLookupAreaCommand, "" },
  { "creature", rbac::RBAC_PERM_COMMAND_LOOKUP_CREATURE, true, &HandleLookupCreatureCommand, "" },
  { "event", rbac::RBAC_PERM_COMMAND_LOOKUP_EVENT, true, &HandleLookupEventCommand, "" },
  { "faction", rbac::RBAC_PERM_COMMAND_LOOKUP_FACTION, true, &HandleLookupFactionCommand, "" },
  { "item", rbac::RBAC_PERM_COMMAND_LOOKUP_ITEM, true, &HandleLookupItemCommand, "" },
  { "itemset", rbac::RBAC_PERM_COMMAND_LOOKUP_ITEMSET, true, &HandleLookupItemSetCommand, "" },
  { "object", rbac::RBAC_PERM_COMMAND_LOOKUP_OBJECT, true, &HandleLookupObjectCommand, "" },
  { "quest", rbac::RBAC_PERM_COMMAND_LOOKUP_QUEST, true, &HandleLookupQuestCommand, "" },
  { "player", rbac::RBAC_PERM_COMMAND_LOOKUP_PLAYER, true, NULL, "", lookupPlayerCommandTable },
  { "skill", rbac::RBAC_PERM_COMMAND_LOOKUP_SKILL, true, &HandleLookupSkillCommand, "" },
  { "spell", rbac::RBAC_PERM_COMMAND_LOOKUP_SPELL, true, NULL, "", lookupSpellCommandTable },
  { "taxinode", rbac::RBAC_PERM_COMMAND_LOOKUP_TAXINODE, true, &HandleLookupTaxiNodeCommand, "" },
  { "tele", rbac::RBAC_PERM_COMMAND_LOOKUP_TELE, true, &HandleLookupTeleCommand, "" },
  { "title", rbac::RBAC_PERM_COMMAND_LOOKUP_TITLE, true, &HandleLookupTitleCommand, "" },
  { "map", rbac::RBAC_PERM_COMMAND_LOOKUP_MAP, true, &HandleLookupMapCommand, "" },
  };
 
  static std::vector<ChatCommand> commandTable =
  {
  { "lookup", rbac::RBAC_PERM_COMMAND_LOOKUP, true, NULL, "", lookupCommandTable },
  };
  return commandTable;
  }

Here is the call graph for this function:

static bool lookup_commandscript::HandleLookupAreaCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  // converting string that we try to find to lower case
  wstrToLower(wNamePart);
 
  // Search in AreaTable.dbc
  for (uint32 i = 0; i < sAreaTableStore.GetNumRows(); ++i)
  {
  AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(i);
  if (areaEntry)
  {
  std::string name = areaEntry->AreaName_lang;
  if (name.empty())
  continue;
 
  if (!Utf8FitTo(name, wNamePart))
  continue;
 
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  // send area in "id - [name]" format
  std::ostringstream ss;
  if (handler->GetSession())
  ss << i << " - |cffffffff|Harea:" << i << "|h[" << name<< "]|h|r";
  else
  ss << i << " - " << name;
 
  handler->SendSysMessage(ss.str().c_str());
 
  if (!found)
  found = true;
  }
  }
 
  if (!found)
  handler->SendSysMessage(LANG_COMMAND_NOAREAFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupCreatureCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  // converting string that we try to find to lower case
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  wstrToLower(wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  CreatureTemplateContainer const* ctc = sObjectMgr->GetCreatureTemplates();
  for (CreatureTemplateContainer::const_iterator itr = ctc->begin(); itr != ctc->end(); ++itr)
  {
  uint32 id = itr->second.Entry;
  uint8 localeIndex = handler->GetSessionDbLocaleIndex();
  if (CreatureLocale const* creatureLocale = sObjectMgr->GetCreatureLocale(id))
  {
  if (creatureLocale->Name.size() > localeIndex && !creatureLocale->Name[localeIndex].empty())
  {
  std::string name = creatureLocale->Name[localeIndex];
 
  if (Utf8FitTo(name, wNamePart))
  {
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name.c_str());
  else
  handler->PSendSysMessage(LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name.c_str());
 
  if (!found)
  found = true;
 
  continue;
  }
  }
  }
 
  std::string name = itr->second.Name;
  if (name.empty())
  continue;
 
  if (Utf8FitTo(name, wNamePart))
  {
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name.c_str());
  else
  handler->PSendSysMessage(LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name.c_str());
 
  if (!found)
  found = true;
  }
  }
 
  if (!found)
  handler->SendSysMessage(LANG_COMMAND_NOCREATUREFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupEventCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  // converting string that we try to find to lower case
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  wstrToLower(wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  GameEventMgr::GameEventDataMap const& events = sGameEventMgr->GetEventMap();
  GameEventMgr::ActiveEvents const& activeEvents = sGameEventMgr->GetActiveEventList();
 
  for (uint32 id = 0; id < events.size(); ++id)
  {
  GameEventData const& eventData = events[id];
 
  std::string descr = eventData.description;
  if (descr.empty())
  continue;
 
  if (Utf8FitTo(descr, wNamePart))
  {
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  char const* active = activeEvents.find(id) != activeEvents.end() ? handler->GetTrinityString(LANG_ACTIVE) : "";
 
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT, id, id, eventData.description.c_str(), active);
  else
  handler->PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE, id, eventData.description.c_str(), active);
 
  if (!found)
  found = true;
  }
  }
 
  if (!found)
  handler->SendSysMessage(LANG_NOEVENTFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupFactionCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  // Can be NULL at console call
  Player* target = handler->getSelectedPlayer();
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  // converting string that we try to find to lower case
  wstrToLower (wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  for (uint32 id = 0; id < sFactionStore.GetNumRows(); ++id)
  {
  if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(id))
  {
  FactionState const* factionState = target ? target->GetReputationMgr().GetState(factionEntry) : NULL;
 
  std::string name = factionEntry->Name_lang;
  if (name.empty())
  continue;
 
  if (!Utf8FitTo(name, wNamePart))
  continue;
 
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  // send faction in "id - [faction] rank reputation [visible] [at war] [own team] [unknown] [invisible] [inactive]" format
  // or "id - [faction] [no reputation]" format
  std::ostringstream ss;
  if (handler->GetSession())
  ss << id << " - |cffffffff|Hfaction:" << id << "|h[" << name << "]|h|r";
  else
  ss << id << " - " << name;
 
  if (factionState) // and then target != NULL also
  {
  uint32 index = target->GetReputationMgr().GetReputationRankStrIndex(factionEntry);
  std::string rankName = handler->GetTrinityString(index);
 
  ss << ' ' << rankName << "|h|r (" << target->GetReputationMgr().GetReputation(factionEntry) << ')';
 
  if (factionState->Flags & FACTION_FLAG_VISIBLE)
  ss << handler->GetTrinityString(LANG_FACTION_VISIBLE);
  if (factionState->Flags & FACTION_FLAG_AT_WAR)
  ss << handler->GetTrinityString(LANG_FACTION_ATWAR);
  if (factionState->Flags & FACTION_FLAG_PEACE_FORCED)
  ss << handler->GetTrinityString(LANG_FACTION_PEACE_FORCED);
  if (factionState->Flags & FACTION_FLAG_HIDDEN)
  ss << handler->GetTrinityString(LANG_FACTION_HIDDEN);
  if (factionState->Flags & FACTION_FLAG_INVISIBLE_FORCED)
  ss << handler->GetTrinityString(LANG_FACTION_INVISIBLE_FORCED);
  if (factionState->Flags & FACTION_FLAG_INACTIVE)
  ss << handler->GetTrinityString(LANG_FACTION_INACTIVE);
  }
  else
  ss << handler->GetTrinityString(LANG_FACTION_NOREPUTATION);
 
  handler->SendSysMessage(ss.str().c_str());
 
  if (!found)
  found = true;
  }
  }
 
  if (!found)
  handler->SendSysMessage(LANG_COMMAND_FACTION_NOTFOUND);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupItemCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  // converting string that we try to find to lower case
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  wstrToLower(wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  // Search in `item_template`
  ItemTemplateContainer const* its = sObjectMgr->GetItemTemplateStore();
  for (ItemTemplateContainer::const_iterator itr = its->begin(); itr != its->end(); ++itr)
  {
  std::string name = itr->second.GetName(handler->GetSessionDbcLocale());
  if (name.empty())
  continue;
 
  if (Utf8FitTo(name, wNamePart))
  {
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_ITEM_LIST_CHAT, itr->second.GetId(), itr->second.GetId(), name.c_str());
  else
  handler->PSendSysMessage(LANG_ITEM_LIST_CONSOLE, itr->second.GetId(), name.c_str());
 
  if (!found)
  found = true;
  }
  }
 
  if (!found)
  handler->SendSysMessage(LANG_COMMAND_NOITEMFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupItemSetCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  // converting string that we try to find to lower case
  wstrToLower(wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  // Search in ItemSet.dbc
  for (uint32 id = 0; id < sItemSetStore.GetNumRows(); id++)
  {
  ItemSetEntry const* set = sItemSetStore.LookupEntry(id);
  if (set)
  {
  std::string name = set->Name_lang;
  if (name.empty())
  continue;
 
  if (!Utf8FitTo(name, wNamePart))
  continue;
 
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  // send item set in "id - [namedlink locale]" format
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_ITEMSET_LIST_CHAT, id, id, name.c_str(), "");
  else
  handler->PSendSysMessage(LANG_ITEMSET_LIST_CONSOLE, id, name.c_str(), "");
 
  if (!found)
  found = true;
  }
  }
  if (!found)
  handler->SendSysMessage(LANG_COMMAND_NOITEMSETFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupMapCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  wstrToLower(wNamePart);
 
  uint32 counter = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
  uint8 locale = handler->GetSession() ? handler->GetSession()->GetSessionDbcLocale() : sWorld->GetDefaultDbcLocale();
 
  // search in Map.dbc
  for (uint32 id = 0; id < sMapStore.GetNumRows(); id++)
  {
  if (MapEntry const* mapInfo = sMapStore.LookupEntry(id))
  {
  std::string name = mapInfo->MapName_lang;
  if (name.empty())
  continue;
 
  if (Utf8FitTo(name, wNamePart) && locale < TOTAL_LOCALES)
  {
  if (maxResults && counter == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  std::ostringstream ss;
  ss << id << " - [" << name << ']';
 
  if (mapInfo->IsContinent())
  ss << handler->GetTrinityString(LANG_CONTINENT);
 
  switch (mapInfo->InstanceType)
  {
  case MAP_INSTANCE:
  ss << handler->GetTrinityString(LANG_INSTANCE);
  break;
  case MAP_RAID:
  ss << handler->GetTrinityString(LANG_RAID);
  break;
  case MAP_BATTLEGROUND:
  ss << handler->GetTrinityString(LANG_BATTLEGROUND);
  break;
  case MAP_ARENA:
  ss << handler->GetTrinityString(LANG_ARENA);
  break;
  }
 
  handler->SendSysMessage(ss.str().c_str());
 
  ++counter;
  }
  }
  }
 
  if (!counter)
  handler->SendSysMessage(LANG_COMMAND_NOMAPFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupObjectCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  // converting string that we try to find to lower case
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  wstrToLower(wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
  GameObjectTemplateContainer const* gotc = sObjectMgr->GetGameObjectTemplates();
  for (GameObjectTemplateContainer::const_iterator itr = gotc->begin(); itr != gotc->end(); ++itr)
  {
  uint8 localeIndex = handler->GetSessionDbLocaleIndex();
  if (GameObjectLocale const* objectLocalte = sObjectMgr->GetGameObjectLocale(itr->second.entry))
  {
  if (objectLocalte->Name.size() > localeIndex && !objectLocalte->Name[localeIndex].empty())
  {
  std::string name = objectLocalte->Name[localeIndex];
 
  if (Utf8FitTo(name, wNamePart))
  {
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, itr->second.entry, itr->second.entry, name.c_str());
  else
  handler->PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, itr->second.entry, name.c_str());
 
  if (!found)
  found = true;
 
  continue;
  }
  }
  }
 
  std::string name = itr->second.name;
  if (name.empty())
  continue;
 
  if (Utf8FitTo(name, wNamePart))
  {
  if (maxResults && count++ == maxResults)
  {
  handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
  return true;
  }
 
  if (handler->GetSession())
  handler->PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, itr->second.entry, itr->second.entry, name.c_str());
  else
  handler->PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, itr->second.entry, name.c_str());
 
  if (!found)
  found = true;
  }
  }
 
  if (!found)
  handler->SendSysMessage(LANG_COMMAND_NOGAMEOBJECTFOUND);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupPlayerAccountCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string account = strtok((char*)args, " ");
  char* limitStr = strtok(NULL, " ");
  int32 limit = limitStr ? atoi(limitStr) : -1;
 
  if (!Utf8ToUpperOnlyLatin(account))
  return false;
 
  PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_LIST_BY_NAME);
  stmt->setString(0, account);
  PreparedQueryResult result = LoginDatabase.Query(stmt);
 
  return LookupPlayerSearchCommand(result, limit, handler);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupPlayerEmailCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  std::string email = strtok((char*)args, " ");
  char* limitStr = strtok(NULL, " ");
  int32 limit = limitStr ? atoi(limitStr) : -1;
 
  PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_LIST_BY_EMAIL);
  stmt->setString(0, email);
  PreparedQueryResult result = LoginDatabase.Query(stmt);
 
  return LookupPlayerSearchCommand(result, limit, handler);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupPlayerIpCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  std::string ip;
  int32 limit;
  char* limitStr;
 
  Player* target = handler->getSelectedPlayer();
  if (!*args)
  {
  // NULL only if used from console
  if (!target || target == handler->GetSession()->GetPlayer())
  return false;
 
  ip = target->GetSession()->GetRemoteAddress();
  limit = -1;
  }
  else
  {
  ip = strtok((char*)args, " ");
  limitStr = strtok(NULL, " ");
  limit = limitStr ? atoi(limitStr) : -1;
  }
 
  PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_IP);
  stmt->setString(0, ip);
  PreparedQueryResult result = LoginDatabase.Query(stmt);
 
  return LookupPlayerSearchCommand(result, limit, handler);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupQuestCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  // can be NULL at console call
  Player* target = handler->getSelectedPlayerOrSelf();
 
  std::string namePart = args;
  std::wstring wNamePart;
 
  // converting string that we try to find to lower case
  if (!Utf8toWStr(namePart, wNamePart))
  return false;
 
  wstrToLower(wNamePart);
 
  bool found = false;
  uint32 count = 0;
  uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
         ObjectMgr::QuestMap const& qTemplates = sObjectMgr->GetQuestTemplates();
         for (ObjectMgr::QuestMap::const_iterator iter = qTemplates.begin(); iter != qTemplates.end(); ++iter)
         {
             Quest* qInfo = iter->second;
 
             int localeIndex = handler->GetSessionDbLocaleIndex();
             if (localeIndex >= 0)
             {
                 uint8 ulocaleIndex = uint8(localeIndex);
                 if (QuestTemplateLocale const* questLocale = sObjectMgr->GetQuestLocale(qInfo->GetQuestId()))
                 {
                     if (questLocale->LogTitle.size() > ulocaleIndex && !questLocale->LogTitle[ulocaleIndex].empty())
                     {
                         std::string title = questLocale->LogTitle[ulocaleIndex];
 
                         if (Utf8FitTo(title, wNamePart))
                         {
                             if (maxResults && count++ == maxResults)
                             {
                                 handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                                 return true;
                             }
 
                             char const* statusStr = "";
 
                             if (target)
                             {
                                 QuestStatus status = target->GetQuestStatus(qInfo->GetQuestId());
 
                                 switch (status)
                                 {
                                     case QUEST_STATUS_COMPLETE:
                                         statusStr = handler->GetTrinityString(LANG_COMMAND_QUEST_COMPLETE);
                                         break;
                                     case QUEST_STATUS_INCOMPLETE:
                                         statusStr = handler->GetTrinityString(LANG_COMMAND_QUEST_ACTIVE);
                                         break;
                                     case QUEST_STATUS_REWARDED:
                                         statusStr = handler->GetTrinityString(LANG_COMMAND_QUEST_REWARDED);
                                         break;
                                     default:
                                         break;
                                 }
                             }
 
                             if (handler->GetSession())
                                 handler->PSendSysMessage(LANG_QUEST_LIST_CHAT, qInfo->GetQuestId(), qInfo->GetQuestId(), qInfo->GetQuestLevel(), title.c_str(), statusStr);
                             else
                                 handler->PSendSysMessage(LANG_QUEST_LIST_CONSOLE, qInfo->GetQuestId(), title.c_str(), statusStr);
 
                             if (!found)
                                 found = true;
 
                             continue;
                         }
                     }
                 }
             }
 
             std::string title = qInfo->GetLogTitle();
             if (title.empty())
                 continue;
 
             if (Utf8FitTo(title, wNamePart))
             {
                 if (maxResults && count++ == maxResults)
                 {
                     handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                     return true;
                 }
 
                 char const* statusStr = "";
 
                 if (target)
                 {
                     QuestStatus status = target->GetQuestStatus(qInfo->GetQuestId());
 
                     switch (status)
                     {
                         case QUEST_STATUS_COMPLETE:
                             statusStr = handler->GetTrinityString(LANG_COMMAND_QUEST_COMPLETE);
                             break;
                         case QUEST_STATUS_INCOMPLETE:
                             statusStr = handler->GetTrinityString(LANG_COMMAND_QUEST_ACTIVE);
                             break;
                         case QUEST_STATUS_REWARDED:
                             statusStr = handler->GetTrinityString(LANG_COMMAND_QUEST_REWARDED);
                             break;
                         default:
                             break;
                     }
                 }
 
                 if (handler->GetSession())
                     handler->PSendSysMessage(LANG_QUEST_LIST_CHAT, qInfo->GetQuestId(), qInfo->GetQuestId(), qInfo->GetQuestLevel(), title.c_str(), statusStr);
                 else
                     handler->PSendSysMessage(LANG_QUEST_LIST_CONSOLE, qInfo->GetQuestId(), title.c_str(), statusStr);
 
                 if (!found)
                     found = true;
             }
         }
 
         if (!found)
             handler->SendSysMessage(LANG_COMMAND_NOQUESTFOUND);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupSkillCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         // can be NULL in console call
         Player* target = handler->getSelectedPlayer();
 
         std::string namePart = args;
         std::wstring wNamePart;
 
         if (!Utf8toWStr(namePart, wNamePart))
             return false;
 
         // converting string that we try to find to lower case
         wstrToLower(wNamePart);
 
         bool found = false;
         uint32 count = 0;
         uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
         // Search in SkillLine.dbc
         for (uint32 id = 0; id < sSkillLineStore.GetNumRows(); id++)
         {
             SkillLineEntry const* skillInfo = sSkillLineStore.LookupEntry(id);
             if (skillInfo)
             {
                 std::string name = skillInfo->DisplayName_lang;
                 if (name.empty())
                     continue;
 
                 if (!Utf8FitTo(name, wNamePart))
                     continue;
 
                 if (maxResults && count++ == maxResults)
                 {
                     handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                     return true;
                 }
 
                 char valStr[50] = "";
                 char const* knownStr = "";
                 if (target && target->HasSkill(id))
                 {
                     knownStr = handler->GetTrinityString(LANG_KNOWN);
                     uint32 curValue = target->GetPureSkillValue(id);
                     uint32 maxValue  = target->GetPureMaxSkillValue(id);
                     uint32 permValue = target->GetSkillPermBonusValue(id);
                     uint32 tempValue = target->GetSkillTempBonusValue(id);
 
                     char const* valFormat = handler->GetTrinityString(LANG_SKILL_VALUES);
                     snprintf(valStr, 50, valFormat, curValue, maxValue, permValue, tempValue);
                 }
 
                 // send skill in "id - [namedlink locale]" format
                 if (handler->GetSession())
                     handler->PSendSysMessage(LANG_SKILL_LIST_CHAT, id, id, name.c_str(), "", knownStr, valStr);
                 else
                     handler->PSendSysMessage(LANG_SKILL_LIST_CONSOLE, id, name.c_str(), "", knownStr, valStr);
 
                 if (!found)
                     found = true;
             }
         }
         if (!found)
             handler->SendSysMessage(LANG_COMMAND_NOSKILLFOUND);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupSpellCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         // can be NULL at console call
         Player* target = handler->getSelectedPlayer();
 
         std::string namePart = args;
         std::wstring wNamePart;
 
         if (!Utf8toWStr(namePart, wNamePart))
             return false;
 
         // converting string that we try to find to lower case
         wstrToLower(wNamePart);
 
         bool found = false;
         uint32 count = 0;
         uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
         // Search in Spell.dbc
         for (uint32 id = 0; id < sSpellMgr->GetSpellInfoStoreSize(); id++)
         {
             SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(id);
             if (spellInfo)
             {
                 std::string name = spellInfo->SpellName;
                 if (name.empty())
                     continue;
 
                 if (!Utf8FitTo(name, wNamePart))
                     continue;
 
                 if (maxResults && count++ == maxResults)
                 {
                     handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                     return true;
                 }
 
                 bool known = target && target->HasSpell(id);
 
                 SpellEffectInfo const* effect = spellInfo->GetEffect(EFFECT_0);
                 bool learn = effect ? (effect->Effect == SPELL_EFFECT_LEARN_SPELL) : false;
 
                 SpellInfo const* learnSpellInfo = effect ? sSpellMgr->GetSpellInfo(effect->TriggerSpell) : NULL;
 
                 bool talent = spellInfo->HasAttribute(SPELL_ATTR0_CU_IS_TALENT);
                 bool passive = spellInfo->IsPassive();
                 bool active = target && target->HasAura(id);
 
                 // unit32 used to prevent interpreting uint8 as char at output
                 // find rank of learned spell for learning spell, or talent rank
                 uint32 rank = learn && learnSpellInfo ? learnSpellInfo->GetRank() : spellInfo->GetRank();
 
                 // send spell in "id - [name, rank N] [talent] [passive] [learn] [known]" format
                 std::ostringstream ss;
                 if (handler->GetSession())
                     ss << id << " - |cffffffff|Hspell:" << id << "|h[" << name;
                 else
                     ss << id << " - " << name;
 
                 // include rank in link name
                 if (rank)
                     ss << handler->GetTrinityString(LANG_SPELL_RANK) << rank;
 
                 if (handler->GetSession())
                     ss << "]|h|r";
 
                 if (talent)
                     ss << handler->GetTrinityString(LANG_TALENT);
                 if (passive)
                     ss << handler->GetTrinityString(LANG_PASSIVE);
                 if (learn)
                     ss << handler->GetTrinityString(LANG_LEARN);
                 if (known)
                     ss << handler->GetTrinityString(LANG_KNOWN);
                 if (active)
                     ss << handler->GetTrinityString(LANG_ACTIVE);
 
                 handler->SendSysMessage(ss.str().c_str());
 
                 if (!found)
                     found = true;
             }
         }
         if (!found)
             handler->SendSysMessage(LANG_COMMAND_NOSPELLFOUND);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupSpellIdCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         // can be NULL at console call
         Player* target = handler->getSelectedPlayer();
 
         uint32 id = atoi((char*)args);
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(id))
         {
             int locale = handler->GetSessionDbcLocale();
             std::string name = spellInfo->SpellName;
             if (name.empty())
             {
                 handler->SendSysMessage(LANG_COMMAND_NOSPELLFOUND);
                 return true;
             }
 
                 bool known = target && target->HasSpell(id);
 
                 SpellEffectInfo const* effect = spellInfo->GetEffect(EFFECT_0);
                 bool learn = effect? (effect->Effect == SPELL_EFFECT_LEARN_SPELL) : false;
 
                 SpellInfo const* learnSpellInfo = effect ? sSpellMgr->GetSpellInfo(effect->TriggerSpell) : NULL;
 
                 bool talent = spellInfo->HasAttribute(SPELL_ATTR0_CU_IS_TALENT);
                 bool passive = spellInfo->IsPassive();
                 bool active = target && target->HasAura(id);
 
                 // unit32 used to prevent interpreting uint8 as char at output
                 // find rank of learned spell for learning spell, or talent rank
                 uint32 rank = learn && learnSpellInfo ? learnSpellInfo->GetRank() : spellInfo->GetRank();
 
                 // send spell in "id - [name, rank N] [talent] [passive] [learn] [known]" format
                 std::ostringstream ss;
                 if (handler->GetSession())
                     ss << id << " - |cffffffff|Hspell:" << id << "|h[" << name;
                 else
                     ss << id << " - " << name;
 
                 // include rank in link name
                 if (rank)
                     ss << handler->GetTrinityString(LANG_SPELL_RANK) << rank;
 
                 if (handler->GetSession())
                     ss << ' ' << localeNames[locale] << "]|h|r";
                 else
                     ss << ' ' << localeNames[locale];
 
                 if (talent)
                     ss << handler->GetTrinityString(LANG_TALENT);
                 if (passive)
                     ss << handler->GetTrinityString(LANG_PASSIVE);
                 if (learn)
                     ss << handler->GetTrinityString(LANG_LEARN);
                 if (known)
                     ss << handler->GetTrinityString(LANG_KNOWN);
                 if (active)
                     ss << handler->GetTrinityString(LANG_ACTIVE);
 
                 handler->SendSysMessage(ss.str().c_str());
         }
         else
             handler->SendSysMessage(LANG_COMMAND_NOSPELLFOUND);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupTaxiNodeCommand	(	ChatHandler *	handler,
		const char *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         std::string namePart = args;
         std::wstring wNamePart;
 
         if (!Utf8toWStr(namePart, wNamePart))
             return false;
 
         // converting string that we try to find to lower case
         wstrToLower(wNamePart);
 
         bool found = false;
         uint32 count = 0;
         uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
         int32 locale = handler->GetSessionDbcLocale();
 
         // Search in TaxiNodes.dbc
         for (TaxiNodesEntry const* nodeEntry : sTaxiNodesStore)
         {
             std::string name = nodeEntry->Name->Str[locale];
             if (name.empty())
                 continue;
 
             if (!Utf8FitTo(name, wNamePart))
                 continue;
 
             if (maxResults && count++ == maxResults)
             {
                 handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                 return true;
             }
 
             // send taxinode in "id - [name] (Map:m X:x Y:y Z:z)" format
             if (handler->GetSession())
                 handler->PSendSysMessage(LANG_TAXINODE_ENTRY_LIST_CHAT, nodeEntry->ID, nodeEntry->ID, name.c_str(), "",
                     nodeEntry->MapID, nodeEntry->Pos.X, nodeEntry->Pos.Y, nodeEntry->Pos.Z);
             else
                 handler->PSendSysMessage(LANG_TAXINODE_ENTRY_LIST_CONSOLE, nodeEntry->ID, name.c_str(), "",
                     nodeEntry->MapID, nodeEntry->Pos.X, nodeEntry->Pos.Y, nodeEntry->Pos.Z);
 
             if (!found)
                 found = true;
         }
         if (!found)
             handler->SendSysMessage(LANG_COMMAND_NOTAXINODEFOUND);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupTeleCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
         {
             handler->SendSysMessage(LANG_COMMAND_TELE_PARAMETER);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         char const* str = strtok((char*)args, " ");
         if (!str)
             return false;
 
         std::string namePart = str;
         std::wstring wNamePart;
 
         if (!Utf8toWStr(namePart, wNamePart))
             return false;
 
         // converting string that we try to find to lower case
         wstrToLower(wNamePart);
 
         std::ostringstream reply;
         uint32 count = 0;
         uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
         bool limitReached = false;
 
         GameTeleContainer const & teleMap = sObjectMgr->GetGameTeleMap();
         for (GameTeleContainer::const_iterator itr = teleMap.begin(); itr != teleMap.end(); ++itr)
         {
             GameTele const* tele = &itr->second;
 
             if (tele->wnameLow.find(wNamePart) == std::wstring::npos)
                 continue;
 
             if (maxResults && count++ == maxResults)
             {
                 limitReached = true;
                 break;
             }
 
             if (handler->GetSession())
                 reply << "  |cffffffff|Htele:" << itr->first << "|h[" << tele->name << "]|h|r\n";
             else
                 reply << "  " << itr->first << ' ' << tele->name << "\n";
         }
 
         if (reply.str().empty())
             handler->SendSysMessage(LANG_COMMAND_TELE_NOLOCATION);
         else
             handler->PSendSysMessage(LANG_COMMAND_TELE_LOCATION, reply.str().c_str());
 
         if (limitReached)
             handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::HandleLookupTitleCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         // can be NULL in console call
         Player* target = handler->getSelectedPlayer();
 
         // title name have single string arg for player name
         char const* targetName = target ? target->GetName().c_str() : "NAME";
 
         std::string namePart = args;
         std::wstring wNamePart;
 
         if (!Utf8toWStr(namePart, wNamePart))
             return false;
 
         // converting string that we try to find to lower case
         wstrToLower(wNamePart);
 
         uint32 counter = 0;                                     // Counter for figure out that we found smth.
         uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
         // Search in CharTitles.dbc
         for (uint32 id = 0; id < sCharTitlesStore.GetNumRows(); id++)
         {
             if (CharTitlesEntry const* titleInfo = sCharTitlesStore.LookupEntry(id))
             {
                 for (uint8 gender = GENDER_MALE; gender <= GENDER_FEMALE; ++gender)
                 {
                     if (target && target->getGender() != gender)
                         continue;
 
                     std::string name = gender == GENDER_MALE ? titleInfo->NameMale_lang : titleInfo->NameFemale_lang;
 
                     if (name.empty())
                         continue;
 
                     if (!Utf8FitTo(name, wNamePart))
                         continue;
 
                     if (maxResults && counter == maxResults)
                     {
                         handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                         return true;
                     }
 
                     char const* knownStr = target && target->HasTitle(titleInfo) ? handler->GetTrinityString(LANG_KNOWN) : "";
 
                     char const* activeStr = target && target->GetUInt32Value(PLAYER_CHOSEN_TITLE) == titleInfo->MaskID
                         ? handler->GetTrinityString(LANG_ACTIVE)
                         : "";
 
                     char titleNameStr[80];
                     snprintf(titleNameStr, 80, name.c_str(), targetName);
 
                     // send title in "id (idx:idx) - [namedlink locale]" format
                     if (handler->GetSession())
                         handler->PSendSysMessage(LANG_TITLE_LIST_CHAT, id, titleInfo->MaskID, id, titleNameStr, "", knownStr, activeStr);
                     else
                         handler->PSendSysMessage(LANG_TITLE_LIST_CONSOLE, id, titleInfo->MaskID, titleNameStr, "", knownStr, activeStr);
 
                     ++counter;
                 }
             }
         }
         if (counter == 0)  // if counter == 0 then we found nth
             handler->SendSysMessage(LANG_COMMAND_NOTITLEFOUND);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool lookup_commandscript::LookupPlayerSearchCommand	(	PreparedQueryResult	result,
		int32	limit,
		ChatHandler *	handler
	)

inlinestatic

     {
         if (!result)
         {
             handler->PSendSysMessage(LANG_NO_PLAYERS_FOUND);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         int32 counter = 0;
         uint32 count = 0;
         uint32 maxResults = sWorld->getIntConfig(CONFIG_MAX_RESULTS_LOOKUP_COMMANDS);
 
         do
         {
             if (maxResults && count++ == maxResults)
             {
                 handler->PSendSysMessage(LANG_COMMAND_LOOKUP_MAX_RESULTS, maxResults);
                 return true;
             }
 
             Field* fields           = result->Fetch();
             uint32 accountId        = fields[0].GetUInt32();
             std::string accountName = fields[1].GetString();
 
             PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_GUID_NAME_BY_ACC);
             stmt->setUInt32(0, accountId);
             PreparedQueryResult result2 = CharacterDatabase.Query(stmt);
 
             if (result2)
             {
                 handler->PSendSysMessage(LANG_LOOKUP_PLAYER_ACCOUNT, accountName.c_str(), accountId);
 
                 do
                 {
                     Field* characterFields  = result2->Fetch();
                     ObjectGuid guid         = ObjectGuid::Create<HighGuid::Player>(characterFields[0].GetUInt64());
                     std::string name        = characterFields[1].GetString();
 
                     handler->PSendSysMessage(LANG_LOOKUP_PLAYER_CHARACTER, name.c_str(), guid.ToString().c_str());
                     ++counter;
                 }
                 while (result2->NextRow() && (limit == -1 || counter < limit));
             }
         }
         while (result->NextRow());
 
         if (counter == 0) // empty accounts only
         {
             handler->PSendSysMessage(LANG_NO_PLAYERS_FOUND);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         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_lookup.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation