Public Member Functions
	npc_commandscript ()

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

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

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

static bool	HandleNpcAddVendorItemCommand (ChatHandler handler, char const args)

static bool	HandleNpcAddMoveCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetAllowMovementCommand (ChatHandler handler, char const )

static bool	HandleNpcSetEntryCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetLevelCommand (ChatHandler handler, char const args)

static bool	HandleNpcDeleteCommand (ChatHandler handler, char const args)

static bool	HandleNpcDeleteVendorItemCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetFactionIdCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetFlagCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetDataCommand (ChatHandler handler, char const args)

static bool	HandleNpcFollowCommand (ChatHandler handler, char const )

static bool	HandleNpcInfoCommand (ChatHandler handler, char const )

static bool	HandleNpcNearCommand (ChatHandler handler, char const args)

static bool	HandleNpcMoveCommand (ChatHandler handler, char const args)

static bool	HandleNpcPlayEmoteCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetModelCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetMoveTypeCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetPhaseGroup (ChatHandler handler, char const args)

static bool	HandleNpcSetPhaseCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetSpawnDistCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetSpawnTimeCommand (ChatHandler handler, char const args)

static bool	HandleNpcSayCommand (ChatHandler handler, char const args)

static bool	HandleNpcTextEmoteCommand (ChatHandler handler, char const args)

static bool	HandleNpcUnFollowCommand (ChatHandler handler, char const )

static bool	HandleNpcWhisperCommand (ChatHandler handler, char const args)

static bool	HandleNpcYellCommand (ChatHandler handler, char const args)

static bool	HandleNpcAddTempSpawnCommand (ChatHandler handler, char const args)

static bool	HandleNpcTameCommand (ChatHandler handler, char const )

static bool	HandleNpcAddFormationCommand (ChatHandler handler, char const args)

static bool	HandleNpcSetLinkCommand (ChatHandler handler, char const args)

static bool	HandleNpcAddWeaponCommand (ChatHandler , char const )

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

npc_commandscript::npc_commandscript ( )

inline

175 : CommandScript("npc_commandscript") { }

CommandScript::CommandScript

CommandScript(const char *name)

Definition: ScriptMgr.cpp:1616

Member Function Documentation

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

inlineoverridevirtual

Implements CommandScript.

  {
  static std::vector<ChatCommand> npcAddCommandTable =
  {
  { "formation", rbac::RBAC_PERM_COMMAND_NPC_ADD_FORMATION, false, &HandleNpcAddFormationCommand, "" },
  { "item", rbac::RBAC_PERM_COMMAND_NPC_ADD_ITEM, false, &HandleNpcAddVendorItemCommand, "" },
  { "move", rbac::RBAC_PERM_COMMAND_NPC_ADD_MOVE, false, &HandleNpcAddMoveCommand, "" },
  { "temp", rbac::RBAC_PERM_COMMAND_NPC_ADD_TEMP, false, &HandleNpcAddTempSpawnCommand, "" },
  //{ "weapon", rbac::RBAC_PERM_COMMAND_NPC_ADD_WEAPON, false, &HandleNpcAddWeaponCommand, "" },
  { "", rbac::RBAC_PERM_COMMAND_NPC_ADD, false, &HandleNpcAddCommand, "" },
  };
  static std::vector<ChatCommand> npcDeleteCommandTable =
  {
  { "item", rbac::RBAC_PERM_COMMAND_NPC_DELETE_ITEM, false, &HandleNpcDeleteVendorItemCommand, "" },
  { "", rbac::RBAC_PERM_COMMAND_NPC_DELETE, false, &HandleNpcDeleteCommand, "" },
  };
  static std::vector<ChatCommand> npcFollowCommandTable =
  {
  { "stop", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW_STOP, false, &HandleNpcUnFollowCommand, "" },
  { "", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW, false, &HandleNpcFollowCommand, "" },
  };
  static std::vector<ChatCommand> npcSetCommandTable =
  {
  { "allowmove", rbac::RBAC_PERM_COMMAND_NPC_SET_ALLOWMOVE, false, &HandleNpcSetAllowMovementCommand, "" },
  { "entry", rbac::RBAC_PERM_COMMAND_NPC_SET_ENTRY, false, &HandleNpcSetEntryCommand, "" },
  { "factionid", rbac::RBAC_PERM_COMMAND_NPC_SET_FACTIONID, false, &HandleNpcSetFactionIdCommand, "" },
  { "flag", rbac::RBAC_PERM_COMMAND_NPC_SET_FLAG, false, &HandleNpcSetFlagCommand, "" },
  { "level", rbac::RBAC_PERM_COMMAND_NPC_SET_LEVEL, false, &HandleNpcSetLevelCommand, "" },
  { "link", rbac::RBAC_PERM_COMMAND_NPC_SET_LINK, false, &HandleNpcSetLinkCommand, "" },
  { "model", rbac::RBAC_PERM_COMMAND_NPC_SET_MODEL, false, &HandleNpcSetModelCommand, "" },
  { "movetype", rbac::RBAC_PERM_COMMAND_NPC_SET_MOVETYPE, false, &HandleNpcSetMoveTypeCommand, "" },
  { "phase", rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE, false, &HandleNpcSetPhaseCommand, "" },
  { "phasegroup", rbac::RBAC_PERM_COMMAND_NPC_SET_PHASE, false, &HandleNpcSetPhaseGroup, "" },
  { "spawndist", rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNDIST, false, &HandleNpcSetSpawnDistCommand, "" },
  { "spawntime", rbac::RBAC_PERM_COMMAND_NPC_SET_SPAWNTIME, false, &HandleNpcSetSpawnTimeCommand, "" },
  { "data", rbac::RBAC_PERM_COMMAND_NPC_SET_DATA, false, &HandleNpcSetDataCommand, "" },
  };
  static std::vector<ChatCommand> npcCommandTable =
  {
  { "info", rbac::RBAC_PERM_COMMAND_NPC_INFO, false, &HandleNpcInfoCommand, "" },
  { "near", rbac::RBAC_PERM_COMMAND_NPC_NEAR, false, &HandleNpcNearCommand, "" },
  { "move", rbac::RBAC_PERM_COMMAND_NPC_MOVE, false, &HandleNpcMoveCommand, "" },
  { "playemote", rbac::RBAC_PERM_COMMAND_NPC_PLAYEMOTE, false, &HandleNpcPlayEmoteCommand, "" },
  { "say", rbac::RBAC_PERM_COMMAND_NPC_SAY, false, &HandleNpcSayCommand, "" },
  { "textemote", rbac::RBAC_PERM_COMMAND_NPC_TEXTEMOTE, false, &HandleNpcTextEmoteCommand, "" },
  { "whisper", rbac::RBAC_PERM_COMMAND_NPC_WHISPER, false, &HandleNpcWhisperCommand, "" },
  { "yell", rbac::RBAC_PERM_COMMAND_NPC_YELL, false, &HandleNpcYellCommand, "" },
  { "tame", rbac::RBAC_PERM_COMMAND_NPC_TAME, false, &HandleNpcTameCommand, "" },
  { "add", rbac::RBAC_PERM_COMMAND_NPC_ADD, false, NULL, "", npcAddCommandTable },
  { "delete", rbac::RBAC_PERM_COMMAND_NPC_DELETE, false, NULL, "", npcDeleteCommandTable },
  { "follow", rbac::RBAC_PERM_COMMAND_NPC_FOLLOW, false, NULL, "", npcFollowCommandTable },
  { "set", rbac::RBAC_PERM_COMMAND_NPC_SET, false, NULL, "", npcSetCommandTable },
  };
  static std::vector<ChatCommand> commandTable =
  {
  { "npc", rbac::RBAC_PERM_COMMAND_NPC, false, NULL, "", npcCommandTable },
  };
  return commandTable;
  }

Here is the call graph for this function:

static bool npc_commandscript::HandleNpcAddCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  char* charID = handler->extractKeyFromLink((char*)args, "Hcreature_entry");
  if (!charID)
  return false;
 
  uint32 id = atoi(charID);
  if (!sObjectMgr->GetCreatureTemplate(id))
  return false;
 
  Player* chr = handler->GetSession()->GetPlayer();
  float x = chr->GetPositionX();
  float y = chr->GetPositionY();
  float z = chr->GetPositionZ();
  float o = chr->GetOrientation();
  Map* map = chr->GetMap();
 
  if (Transport* trans = chr->GetTransport())
  {
  ObjectGuid::LowType guid = map->GenerateLowGuid<HighGuid::Creature>();
  CreatureData& data = sObjectMgr->NewOrExistCreatureData(guid);
  data.id = id;
  data.phaseMask = chr->GetPhaseMask();
  data.posX = chr->GetTransOffsetX();
  data.posY = chr->GetTransOffsetY();
  data.posZ = chr->GetTransOffsetZ();
  data.orientation = chr->GetTransOffsetO();
 
  Creature* creature = trans->CreateNPCPassenger(guid, &data);
 
  creature->SaveToDB(trans->GetGOInfo()->moTransport.mapID, 1 << map->GetSpawnMode(), chr->GetPhaseMask());
 
  sObjectMgr->AddCreatureToGrid(guid, &data);
  return true;
  }
 
  Creature* creature = new Creature();
  if (!creature->Create(map->GenerateLowGuid<HighGuid::Creature>(), map, chr->GetPhaseMask(), id, x, y, z, o))
  {
  delete creature;
  return false;
  }
 
  creature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), chr->GetPhaseMask());
 
  ObjectGuid::LowType db_guid = creature->GetSpawnId();
 
  // To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells()
  // current "creature" variable is deleted and created fresh new, otherwise old values might trigger asserts or cause undefined behavior
  creature->CleanupsBeforeDelete();
  delete creature;
  creature = new Creature();
  if (!creature->LoadCreatureFromDB(db_guid, map))
  {
  delete creature;
  return false;
  }
 
  sObjectMgr->AddCreatureToGrid(db_guid, sObjectMgr->GetCreatureData(db_guid));
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcAddFormationCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  ObjectGuid::LowType leaderGUID = strtoull(args, nullptr, 10);
  Creature* creature = handler->getSelectedCreature();
 
  if (!creature || !creature->GetSpawnId())
  {
  handler->SendSysMessage(LANG_SELECT_CREATURE);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  ObjectGuid::LowType lowguid = creature->GetSpawnId();
  if (creature->GetFormation())
  {
  handler->PSendSysMessage("Selected creature is already member of group " UI64FMTD, creature->GetFormation()->GetId());
  return false;
  }
 
  if (!lowguid)
  return false;
 
  Player* chr = handler->GetSession()->GetPlayer();
  FormationInfo* group_member;
 
  group_member = new FormationInfo;
  group_member->follow_angle = (creature->GetAngle(chr) - chr->GetOrientation()) * 180 / float(M_PI);
  group_member->follow_dist = std::sqrt(std::pow(chr->GetPositionX() - creature->GetPositionX(), 2.f) + std::pow(chr->GetPositionY() - creature->GetPositionY(), 2.f));
  group_member->leaderGUID = leaderGUID;
  group_member->groupAI = 0;
 
  sFormationMgr->CreatureGroupMap[lowguid] = group_member;
  creature->SearchFormation();
 
  PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_CREATURE_FORMATION);
 
  stmt->setUInt64(0, leaderGUID);
  stmt->setUInt64(1, lowguid);
  stmt->setFloat(2, group_member->follow_dist);
  stmt->setFloat(3, group_member->follow_angle);
  stmt->setUInt32(4, uint32(group_member->groupAI));
 
  WorldDatabase.Execute(stmt);
 
  handler->PSendSysMessage("Creature " UI64FMTD " added to formation with leader " UI64FMTD, lowguid, leaderGUID);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcAddMoveCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  char* guidStr = strtok((char*)args, " ");
  char* waitStr = strtok((char*)NULL, " ");
 
  ObjectGuid::LowType lowGuid = strtoull(guidStr, nullptr, 10);
 
  // attempt check creature existence by DB data
  CreatureData const* data = sObjectMgr->GetCreatureData(lowGuid);
  if (!data)
  {
  handler->PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowGuid);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  int wait = waitStr ? atoi(waitStr) : 0;
 
  if (wait < 0)
  wait = 0;
 
  // Update movement type
  PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_MOVEMENT_TYPE);
 
  stmt->setUInt8(0, uint8(WAYPOINT_MOTION_TYPE));
  stmt->setUInt64(1, lowGuid);
 
  WorldDatabase.Execute(stmt);
 
  handler->SendSysMessage(LANG_WAYPOINT_ADDED);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcAddTempSpawnCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  char* charID = handler->extractKeyFromLink((char*)args, "Hcreature_entry");
  if (!charID)
  return false;
 
  Player* chr = handler->GetSession()->GetPlayer();
 
  uint32 id = atoi(charID);
  if (!id)
  return false;
 
  if (!sObjectMgr->GetCreatureTemplate(id))
  return false;
 
  chr->SummonCreature(id, *chr, TEMPSUMMON_CORPSE_DESPAWN, 120);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcAddVendorItemCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  const uint8 type = 1; // FIXME: make type (1 item, 2 currency) an argument
 
  char* pitem = handler->extractKeyFromLink((char*)args, "Hitem");
  if (!pitem)
  {
  handler->SendSysMessage(LANG_COMMAND_NEEDITEMSEND);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  int32 item_int = atol(pitem);
  if (item_int <= 0)
  return false;
 
  uint32 itemId = item_int;
 
  char* fmaxcount = strtok(NULL, " "); //add maxcount, default: 0
  uint32 maxcount = 0;
  if (fmaxcount)
  maxcount = atoul(fmaxcount);
 
  char* fincrtime = strtok(NULL, " "); //add incrtime, default: 0
  uint32 incrtime = 0;
  if (fincrtime)
  incrtime = atoul(fincrtime);
 
  char* fextendedcost = strtok(NULL, " "); //add ExtendedCost, default: 0
  uint32 extendedcost = fextendedcost ? atoul(fextendedcost) : 0;
  Creature* vendor = handler->getSelectedCreature();
  if (!vendor)
  {
  handler->SendSysMessage(LANG_SELECT_CREATURE);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  uint32 vendor_entry = vendor->GetEntry();
 
  if (!sObjectMgr->IsVendorItemValid(vendor_entry, itemId, maxcount, incrtime, extendedcost, type, handler->GetSession()->GetPlayer()))
  {
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  sObjectMgr->AddVendorItem(vendor_entry, itemId, maxcount, incrtime, extendedcost, type);
 
  ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(itemId);
 
  handler->PSendSysMessage(LANG_ITEM_ADDED_TO_LIST, itemId, itemTemplate->GetDefaultLocaleName(), maxcount, incrtime, extendedcost);
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcAddWeaponCommand	(	ChatHandler *	,
		char const *
	)

inlinestatic

Todo:: NpcCommands that need to be fixed :

  {
  /*if (!*args)
  return false;
 
  uint64 guid = handler->GetSession()->GetPlayer()->GetSelection();
  if (guid == 0)
  {
  handler->SendSysMessage(LANG_NO_SELECTION);
  return true;
  }
 
  Creature* creature = ObjectAccessor::GetCreature(*handler->GetSession()->GetPlayer(), guid);
 
  if (!creature)
  {
  handler->SendSysMessage(LANG_SELECT_CREATURE);
  return true;
  }
 
  char* pSlotID = strtok((char*)args, " ");
  if (!pSlotID)
  return false;
 
  char* pItemID = strtok(NULL, " ");
  if (!pItemID)
  return false;
 
  uint32 ItemID = atoi(pItemID);
  uint32 SlotID = atoi(pSlotID);
 
  ItemTemplate* tmpItem = sObjectMgr->GetItemTemplate(ItemID);
 
  bool added = false;
  if (tmpItem)
  {
  switch (SlotID)
  {
  case 1:
  creature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY, ItemID);
  added = true;
  break;
  case 2:
  creature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY_01, ItemID);
  added = true;
  break;
  case 3:
  creature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_DISPLAY_02, ItemID);
  added = true;
  break;
  default:
  handler->PSendSysMessage(LANG_ITEM_SLOT_NOT_EXIST, SlotID);
  added = false;
  break;
  }
 
  if (added)
  handler->PSendSysMessage(LANG_ITEM_ADDED_TO_SLOT, ItemID, tmpItem->Name1, SlotID);
  }
  else
  {
  handler->PSendSysMessage(LANG_ITEM_NOT_FOUND, ItemID);
  return true;
  }
  */
  return true;
  }

static bool npc_commandscript::HandleNpcDeleteCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  Creature* unit = NULL;
 
  if (*args)
  {
  // number or [name] Shift-click form |color|Hcreature:creature_guid|h[name]|h|r
  char* cId = handler->extractKeyFromLink((char*)args, "Hcreature");
  if (!cId)
  return false;
 
  ObjectGuid::LowType lowguid = strtoull(cId, nullptr, 10);
  if (!lowguid)
  return false;
 
  if (CreatureData const* cr_data = sObjectMgr->GetCreatureData(lowguid))
  unit = handler->GetSession()->GetPlayer()->GetMap()->GetCreature(ObjectGuid::Create<HighGuid::Creature>(cr_data->mapid, cr_data->id, lowguid));
  }
  else
  unit = handler->getSelectedCreature();
 
  if (!unit || unit->IsPet() || unit->IsTotem())
  {
  handler->SendSysMessage(LANG_SELECT_CREATURE);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  // Delete the creature
  unit->CombatStop();
  unit->DeleteFromDB();
  unit->AddObjectToRemoveList();
 
  handler->SendSysMessage(LANG_COMMAND_DELCREATMESSAGE);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcDeleteVendorItemCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

  {
  if (!*args)
  return false;
 
  Creature* vendor = handler->getSelectedCreature();
  if (!vendor || !vendor->IsVendor())
  {
  handler->SendSysMessage(LANG_COMMAND_VENDORSELECTION);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  char* pitem = handler->extractKeyFromLink((char*)args, "Hitem");
  if (!pitem)
  {
  handler->SendSysMessage(LANG_COMMAND_NEEDITEMSEND);
  handler->SetSentErrorMessage(true);
  return false;
  }
  uint32 itemId = atoul(pitem);
 
  const uint8 type = 1; // FIXME: make type (1 item, 2 currency) an argument
 
  if (!sObjectMgr->RemoveVendorItem(vendor->GetEntry(), itemId, type))
  {
  handler->PSendSysMessage(LANG_ITEM_NOT_IN_LIST, itemId);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(itemId);
 
  handler->PSendSysMessage(LANG_ITEM_DELETED_FROM_LIST, itemId, itemTemplate->GetDefaultLocaleName());
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcFollowCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  Player* player = handler->GetSession()->GetPlayer();
  Creature* creature = handler->getSelectedCreature();
 
  if (!creature)
  {
  handler->PSendSysMessage(LANG_SELECT_CREATURE);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  // Follow player - Using pet's default dist and angle
  creature->GetMotionMaster()->MoveFollow(player, PET_FOLLOW_DIST, creature->GetFollowAngle());
 
  handler->PSendSysMessage(LANG_CREATURE_FOLLOW_YOU_NOW, creature->GetName().c_str());
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcInfoCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

  {
  Creature* target = handler->getSelectedCreature();
 
  if (!target)
  {
  handler->SendSysMessage(LANG_SELECT_CREATURE);
  handler->SetSentErrorMessage(true);
  return false;
  }
 
  CreatureTemplate const* cInfo = target->GetCreatureTemplate();
 
  uint32 faction = target->getFaction();
  uint64 npcflags = target->GetUInt64Value(UNIT_NPC_FLAGS);
  uint32 mechanicImmuneMask = cInfo->MechanicImmuneMask;
  uint32 displayid = target->GetDisplayId();
  uint32 nativeid = target->GetNativeDisplayId();
  uint32 Entry = target->GetEntry();
 
  int64 curRespawnDelay = target->GetRespawnTimeEx()-time(NULL);
  if (curRespawnDelay < 0)
  curRespawnDelay = 0;
  std::string curRespawnDelayStr = secsToTimeString(uint64(curRespawnDelay), true);
  std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(), true);
 
  handler->PSendSysMessage(LANG_NPCINFO_CHAR, target->GetSpawnId(), target->GetGUID().ToString().c_str(), faction, npcflags, Entry, displayid, nativeid);
  handler->PSendSysMessage(LANG_NPCINFO_LEVEL, target->getLevel());
  handler->PSendSysMessage(LANG_NPCINFO_EQUIPMENT, target->GetCurrentEquipmentId(), target->GetOriginalEquipmentId());
  handler->PSendSysMessage(LANG_NPCINFO_HEALTH, target->GetCreateHealth(), target->GetMaxHealth(), target->GetHealth());
  handler->PSendSysMessage(LANG_NPCINFO_INHABIT_TYPE, cInfo->InhabitType);
 
  handler->PSendSysMessage(LANG_NPCINFO_UNIT_FIELD_FLAGS, target->GetUInt32Value(UNIT_FIELD_FLAGS));
  for (uint8 i = 0; i < MAX_UNIT_FLAGS; ++i)
  if (target->GetUInt32Value(UNIT_FIELD_FLAGS) & unitFlags[i].Value)
  handler->PSendSysMessage("%s (0x%X)", unitFlags[i].Name, unitFlags[i].Value);
 
  handler->PSendSysMessage(LANG_NPCINFO_FLAGS, target->GetUInt32Value(UNIT_FIELD_FLAGS_2), target->GetUInt32Value(OBJECT_DYNAMIC_FLAGS), target->getFaction());
  handler->PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(), curRespawnDelayStr.c_str());
  handler->PSendSysMessage(LANG_NPCINFO_LOOT, cInfo->lootid, cInfo->pickpocketLootId, cInfo->SkinLootId);
  handler->PSendSysMessage(LANG_NPCINFO_DUNGEON_ID, target->GetInstanceId());
 
  if (CreatureData const* data = sObjectMgr->GetCreatureData(target->GetSpawnId()))
  {
  handler->PSendSysMessage(LANG_NPCINFO_PHASES, data->phaseid, data->phaseGroup);
  if (data->phaseGroup)
  {
  std::set<uint32> _phases = target->GetPhases();
 
  if (!_phases.empty())
  {
  handler->PSendSysMessage(LANG_NPCINFO_PHASE_IDS);
  for (uint32 phaseId : _phases)
  handler->PSendSysMessage("%u", phaseId);
  }
  }
  }
 
  handler->PSendSysMessage(LANG_NPCINFO_ARMOR, target->GetArmor());
  handler->PSendSysMessage(LANG_NPCINFO_POSITION, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ());
  handler->PSendSysMessage(LANG_NPCINFO_AIINFO, target->GetAIName().c_str(), target->GetScriptName().c_str());
  handler->PSendSysMessage(LANG_NPCINFO_FLAGS_EXTRA, cInfo->flags_extra);
  for (uint8 i = 0; i < FLAGS_EXTRA_COUNT; ++i)
  if (cInfo->flags_extra & flagsExtra[i].Value)
  handler->PSendSysMessage("%s (0x%X)", flagsExtra[i].Name, flagsExtra[i].Value);
 
  for (uint8 i = 0; i < NPCFLAG_COUNT; i++)
  if (npcflags & npcFlagTexts[i].Value)
  handler->PSendSysMessage(npcFlagTexts[i].Name, npcFlagTexts[i].Value);
 
  handler->PSendSysMessage(LANG_NPCINFO_MECHANIC_IMMUNE, mechanicImmuneMask);
  for (uint8 i = 1; i < MAX_MECHANIC; ++i)
  if (mechanicImmuneMask & (1 << (mechanicImmunes[i].Value - 1)))
  handler->PSendSysMessage("%s (0x%X)", mechanicImmunes[i].Name, mechanicImmunes[i].Value);
 
  return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcMoveCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         ObjectGuid::LowType lowguid = UI64LIT(0);
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             // number or [name] Shift-click form |color|Hcreature:creature_guid|h[name]|h|r
             char* cId = handler->extractKeyFromLink((char*)args, "Hcreature");
             if (!cId)
                 return false;
 
             lowguid = strtoull(cId, nullptr, 10);
 
             // Attempting creature load from DB data
             CreatureData const* data = sObjectMgr->GetCreatureData(lowguid);
             if (!data)
             {
                 handler->PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
                 handler->SetSentErrorMessage(true);
                 return false;
             }
 
             uint32 map_id = data->mapid;
 
             if (handler->GetSession()->GetPlayer()->GetMapId() != map_id)
             {
                 handler->PSendSysMessage(LANG_COMMAND_CREATUREATSAMEMAP, lowguid);
                 handler->SetSentErrorMessage(true);
                 return false;
             }
         }
         else
         {
             lowguid = creature->GetSpawnId();
         }
 
         float x = handler->GetSession()->GetPlayer()->GetPositionX();
         float y = handler->GetSession()->GetPlayer()->GetPositionY();
         float z = handler->GetSession()->GetPlayer()->GetPositionZ();
         float o = handler->GetSession()->GetPlayer()->GetOrientation();
 
         if (creature)
         {
             if (CreatureData const* data = sObjectMgr->GetCreatureData(creature->GetSpawnId()))
             {
                 const_cast<CreatureData*>(data)->posX = x;
                 const_cast<CreatureData*>(data)->posY = y;
                 const_cast<CreatureData*>(data)->posZ = z;
                 const_cast<CreatureData*>(data)->orientation = o;
             }
             creature->SetPosition(x, y, z, o);
             creature->GetMotionMaster()->Initialize();
             if (creature->IsAlive())                            // dead creature will reset movement generator at respawn
             {
                 creature->setDeathState(JUST_DIED);
                 creature->Respawn();
             }
         }
 
         PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_POSITION);
 
         stmt->setFloat(0, x);
         stmt->setFloat(1, y);
         stmt->setFloat(2, z);
         stmt->setFloat(3, o);
         stmt->setUInt64(4, lowguid);
 
         WorldDatabase.Execute(stmt);
 
         handler->PSendSysMessage(LANG_COMMAND_CREATUREMOVED);
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcNearCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         float distance = (!*args) ? 10.0f : float((atof(args)));
         uint32 count = 0;
 
         Player* player = handler->GetSession()->GetPlayer();
 
         PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_CREATURE_NEAREST);
         stmt->setFloat(0, player->GetPositionX());
         stmt->setFloat(1, player->GetPositionY());
         stmt->setFloat(2, player->GetPositionZ());
         stmt->setUInt32(3, player->GetMapId());
         stmt->setFloat(4, player->GetPositionX());
         stmt->setFloat(5, player->GetPositionY());
         stmt->setFloat(6, player->GetPositionZ());
         stmt->setFloat(7, distance * distance);
         PreparedQueryResult result = WorldDatabase.Query(stmt);
 
         if (result)
         {
             do
             {
                 Field* fields = result->Fetch();
                 ObjectGuid::LowType guid = fields[0].GetUInt64();
                 uint32 entry = fields[1].GetUInt32();
                 float x = fields[2].GetFloat();
                 float y = fields[3].GetFloat();
                 float z = fields[4].GetFloat();
                 uint16 mapId = fields[5].GetUInt16();
 
                 CreatureTemplate const* creatureTemplate = sObjectMgr->GetCreatureTemplate(entry);
                 if (!creatureTemplate)
                     continue;
 
                 handler->PSendSysMessage(LANG_CREATURE_LIST_CHAT, guid, guid, creatureTemplate->Name.c_str(), x, y, z, mapId);
 
                 ++count;
             }
             while (result->NextRow());
         }
 
         handler->PSendSysMessage(LANG_COMMAND_NEAR_NPC_MESSAGE, distance, count);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcPlayEmoteCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         uint32 emote = atoi((char*)args);
 
         Creature* target = handler->getSelectedCreature();
         if (!target)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         target->SetUInt32Value(UNIT_NPC_EMOTESTATE, emote);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSayCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         Creature* creature = handler->getSelectedCreature();
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->Say(args, LANG_UNIVERSAL);
 
         // make some emotes
         char lastchar = args[strlen(args) - 1];
         switch (lastchar)
         {
         case '?':   creature->HandleEmoteCommand(EMOTE_ONESHOT_QUESTION);      break;
         case '!':   creature->HandleEmoteCommand(EMOTE_ONESHOT_EXCLAMATION);   break;
         default:    creature->HandleEmoteCommand(EMOTE_ONESHOT_TALK);          break;
         }
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetAllowMovementCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

     {
         if (sWorld->getAllowMovement())
         {
             sWorld->SetAllowMovement(false);
             handler->SendSysMessage(LANG_CREATURE_MOVE_DISABLED);
         }
         else
         {
             sWorld->SetAllowMovement(true);
             handler->SendSysMessage(LANG_CREATURE_MOVE_ENABLED);
         }
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetDataCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         char* arg1 = strtok((char*)args, " ");
         char* arg2 = strtok((char*)NULL, "");
 
         if (!arg1 || !arg2)
             return false;
 
         uint32 data_1 = (uint32)atoi(arg1);
         uint32 data_2 = (uint32)atoi(arg2);
 
         if (!data_1 || !data_2)
             return false;
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->AI()->SetData(data_1, data_2);
         std::string AIorScript = !creature->GetAIName().empty() ? "AI type: " + creature->GetAIName() : (!creature->GetScriptName().empty() ? "Script Name: " + creature->GetScriptName() : "No AI or Script Name Set");
         handler->PSendSysMessage(LANG_NPC_SETDATA, creature->GetGUID().ToString().c_str(), creature->GetName().c_str(), data_1, data_2, AIorScript.c_str());
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetEntryCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint32 newEntryNum = atoi(args);
         if (!newEntryNum)
             return false;
 
         Unit* unit = handler->getSelectedUnit();
         if (!unit || unit->GetTypeId() != TYPEID_UNIT)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
         Creature* creature = unit->ToCreature();
         if (creature->UpdateEntry(newEntryNum))
             handler->SendSysMessage(LANG_DONE);
         else
             handler->SendSysMessage(LANG_ERROR);
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetFactionIdCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint32 factionId = (uint32) atoi((char*)args);
 
         if (!sFactionTemplateStore.LookupEntry(factionId))
         {
             handler->PSendSysMessage(LANG_WRONG_FACTION, factionId);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->setFaction(factionId);
 
         // Faction is set in creature_template - not inside creature
 
         // Update in memory..
         if (CreatureTemplate const* cinfo = creature->GetCreatureTemplate())
             const_cast<CreatureTemplate*>(cinfo)->faction = factionId;
 
         // ..and DB
         PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_FACTION);
 
         stmt->setUInt16(0, uint16(factionId));
         stmt->setUInt32(1, creature->GetEntry());
 
         WorldDatabase.Execute(stmt);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetFlagCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint64 npcFlags = std::strtoull(args, nullptr, 10);
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->SetUInt64Value(UNIT_NPC_FLAGS, npcFlags);
 
         PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_NPCFLAG);
 
         stmt->setUInt64(0, npcFlags);
         stmt->setUInt32(1, creature->GetEntry());
 
         WorldDatabase.Execute(stmt);
 
         handler->SendSysMessage(LANG_VALUE_SAVED_REJOIN);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetLevelCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint8 lvl = (uint8) atoi((char*)args);
         if (lvl < 1 || lvl > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) + 3)
         {
             handler->SendSysMessage(LANG_BAD_VALUE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         Creature* creature = handler->getSelectedCreature();
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         if (creature->IsPet())
         {
             if (((Pet*)creature)->getPetType() == HUNTER_PET)
             {
                 creature->SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP, sObjectMgr->GetXPForLevel(lvl)/4);
                 creature->SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, 0);
             }
             ((Pet*)creature)->GivePetLevel(lvl);
         }
         else
         {
             creature->SetMaxHealth(100 + 30*lvl);
             creature->SetHealth(100 + 30*lvl);
             creature->SetLevel(lvl);
             creature->SaveToDB();
         }
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetLinkCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         ObjectGuid::LowType linkguid = strtoull(args, nullptr, 10);
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         if (!creature->GetSpawnId())
         {
             handler->PSendSysMessage("Selected %s isn't in creature table", creature->GetGUID().ToString().c_str());
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         if (!sObjectMgr->SetCreatureLinkedRespawn(creature->GetSpawnId(), linkguid))
         {
             handler->PSendSysMessage("Selected creature can't link with guid '" UI64FMTD "'", linkguid);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         handler->PSendSysMessage("LinkGUID '" UI64FMTD "' added to creature with DBTableGUID: '" UI64FMTD "'", linkguid, creature->GetSpawnId());
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetModelCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint32 displayId = (uint32) atoi((char*)args);
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature || creature->IsPet())
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->SetDisplayId(displayId);
         creature->SetNativeDisplayId(displayId);
 
         creature->SaveToDB();
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetMoveTypeCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

HandleNpcSetMoveTypeCommand Set the movement type for an NPC.

Valid movement types are:

stay - NPC wont move
random - NPC will move randomly according to the spawndist
way - NPC will move with given waypoints set

additional parameter: NODEL - so no waypoints are deleted, if you change the movement type

     {
         if (!*args)
             return false;
 
         // 3 arguments:
         // GUID (optional - you can also select the creature)
         // stay|random|way (determines the kind of movement)
         // NODEL (optional - tells the system NOT to delete any waypoints)
         //        this is very handy if you want to do waypoints, that are
         //        later switched on/off according to special events (like escort
         //        quests, etc)
         char* guid_str = strtok((char*)args, " ");
         char* type_str = strtok((char*)NULL, " ");
         char* dontdel_str = strtok((char*)NULL, " ");
 
         bool doNotDelete = false;
 
         if (!guid_str)
             return false;
 
         ObjectGuid::LowType lowguid = UI64LIT(0);
         Creature* creature = NULL;
 
         if (dontdel_str)
         {
             //TC_LOG_ERROR("misc", "DEBUG: All 3 params are set");
 
             // All 3 params are set
             // GUID
             // type
             // doNotDEL
             if (stricmp(dontdel_str, "NODEL") == 0)
             {
                 //TC_LOG_ERROR("misc", "DEBUG: doNotDelete = true;");
                 doNotDelete = true;
             }
         }
         else
         {
             // Only 2 params - but maybe NODEL is set
             if (type_str)
             {
                 TC_LOG_ERROR("misc", "DEBUG: Only 2 params ");
                 if (stricmp(type_str, "NODEL") == 0)
                 {
                     //TC_LOG_ERROR("misc", "DEBUG: type_str, NODEL ");
                     doNotDelete = true;
                     type_str = NULL;
                 }
             }
         }
 
         if (!type_str)                                           // case .setmovetype $move_type (with selected creature)
         {
             type_str = guid_str;
             creature = handler->getSelectedCreature();
             if (!creature || creature->IsPet())
                 return false;
             lowguid = creature->GetSpawnId();
         }
         else                                                    // case .setmovetype #creature_guid $move_type (with selected creature)
         {
             lowguid = strtoull(guid_str, nullptr, 10);
 
             /* impossible without entry
             if (lowguid)
                 creature = ObjectAccessor::GetCreature(*handler->GetSession()->GetPlayer(), MAKE_GUID(lowguid, HIGHGUID_UNIT));
             */
 
             // attempt check creature existence by DB data
             if (!creature)
             {
                 CreatureData const* data = sObjectMgr->GetCreatureData(lowguid);
                 if (!data)
                 {
                     handler->PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
                     handler->SetSentErrorMessage(true);
                     return false;
                 }
             }
             else
             {
                 lowguid = creature->GetSpawnId();
             }
         }
 
         // now lowguid is low guid really existed creature
         // and creature point (maybe) to this creature or NULL
 
         MovementGeneratorType move_type;
 
         std::string type = type_str;
 
         if (type == "stay")
             move_type = IDLE_MOTION_TYPE;
         else if (type == "random")
             move_type = RANDOM_MOTION_TYPE;
         else if (type == "way")
             move_type = WAYPOINT_MOTION_TYPE;
         else
             return false;
 
         // update movement type
         //if (doNotDelete == false)
         //    WaypointMgr.DeletePath(lowguid);
 
         if (creature)
         {
             // update movement type
             if (doNotDelete == false)
                 creature->LoadPath(0);
 
             creature->SetDefaultMovementType(move_type);
             creature->GetMotionMaster()->Initialize();
             if (creature->IsAlive())                            // dead creature will reset movement generator at respawn
             {
                 creature->setDeathState(JUST_DIED);
                 creature->Respawn();
             }
             creature->SaveToDB();
         }
         if (doNotDelete == false)
         {
             handler->PSendSysMessage(LANG_MOVE_TYPE_SET, type_str);
         }
         else
         {
             handler->PSendSysMessage(LANG_MOVE_TYPE_SET_NODEL, type_str);
         }
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetPhaseCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint32 phase = (uint32) atoi((char*)args);
 
         Creature* creature = handler->getSelectedCreature();
         if (!creature || creature->IsPet())
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->ClearPhases();
         creature->SetInPhase(phase, true, true);
         creature->SetDBPhase(phase);
 
         creature->SaveToDB();
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetPhaseGroup	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         uint32 phaseGroupId = (uint32)atoi((char*)args);
 
         Creature* creature = handler->getSelectedCreature();
         if (!creature || creature->IsPet())
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->ClearPhases();
 
         for (uint32 id : sDB2Manager.GetPhasesForGroup(phaseGroupId))
             creature->SetInPhase(id, false, true); // don't send update here for multiple phases, only send it once after adding all phases
 
         creature->UpdateObjectVisibility();
         creature->SetDBPhase(-int(phaseGroupId));
 
         creature->SaveToDB();
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetSpawnDistCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         float option = (float)(atof((char*)args));
         if (option < 0.0f)
         {
             handler->SendSysMessage(LANG_BAD_VALUE);
             return false;
         }
 
         MovementGeneratorType mtype = IDLE_MOTION_TYPE;
         if (option >0.0f)
             mtype = RANDOM_MOTION_TYPE;
 
         Creature* creature = handler->getSelectedCreature();
         ObjectGuid::LowType guidLow = UI64LIT(0);
 
         if (creature)
             guidLow = creature->GetSpawnId();
         else
             return false;
 
         creature->SetRespawnRadius(option);
         creature->SetDefaultMovementType(mtype);
         creature->GetMotionMaster()->Initialize();
         if (creature->IsAlive())                                // dead creature will reset movement generator at respawn
         {
             creature->setDeathState(JUST_DIED);
             creature->Respawn();
         }
 
         PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_SPAWN_DISTANCE);
 
         stmt->setFloat(0, option);
         stmt->setUInt8(1, uint8(mtype));
         stmt->setUInt64(2, guidLow);
 
         WorldDatabase.Execute(stmt);
 
         handler->PSendSysMessage(LANG_COMMAND_SPAWNDIST, option);
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcSetSpawnTimeCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         char* stime = strtok((char*)args, " ");
 
         if (!stime)
             return false;
 
         int spawnTime = atoi((char*)stime);
 
         if (spawnTime < 0)
         {
             handler->SendSysMessage(LANG_BAD_VALUE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         Creature* creature = handler->getSelectedCreature();
         ObjectGuid::LowType guidLow = UI64LIT(0);
 
         if (creature)
             guidLow = creature->GetSpawnId();
         else
             return false;
 
         PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_SPAWN_TIME_SECS);
 
         stmt->setUInt32(0, uint32(spawnTime));
         stmt->setUInt64(1, guidLow);
 
         WorldDatabase.Execute(stmt);
 
         creature->SetRespawnDelay((uint32)spawnTime);
         handler->PSendSysMessage(LANG_COMMAND_SPAWNTIME, spawnTime);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcTameCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

     {
         Creature* creatureTarget = handler->getSelectedCreature();
         if (!creatureTarget || creatureTarget->IsPet())
         {
             handler->PSendSysMessage (LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage (true);
             return false;
         }
 
         Player* player = handler->GetSession()->GetPlayer();
 
         if (!player->GetPetGUID().IsEmpty())
         {
             handler->SendSysMessage (LANG_YOU_ALREADY_HAVE_PET);
             handler->SetSentErrorMessage (true);
             return false;
         }
 
         CreatureTemplate const* cInfo = creatureTarget->GetCreatureTemplate();
 
         if (!cInfo->IsTameable (player->CanTameExoticPets()))
         {
             handler->PSendSysMessage (LANG_CREATURE_NON_TAMEABLE, cInfo->Entry);
             handler->SetSentErrorMessage (true);
             return false;
         }
 
         // Everything looks OK, create new pet
         Pet* pet = player->CreateTamedPetFrom(creatureTarget);
         if (!pet)
         {
             handler->PSendSysMessage (LANG_CREATURE_NON_TAMEABLE, cInfo->Entry);
             handler->SetSentErrorMessage (true);
             return false;
         }
 
         // place pet before player
         float x, y, z;
         player->GetClosePoint (x, y, z, creatureTarget->GetObjectSize(), CONTACT_DISTANCE);
         pet->Relocate(x, y, z, float(M_PI) - player->GetOrientation());
 
         // set pet to defensive mode by default (some classes can't control controlled pets in fact).
         pet->SetReactState(REACT_DEFENSIVE);
 
         // calculate proper level
         uint8 level = (creatureTarget->getLevel() < (player->getLevel() - 5)) ? (player->getLevel() - 5) : creatureTarget->getLevel();
 
         // prepare visual effect for levelup
         pet->SetUInt32Value(UNIT_FIELD_LEVEL, level - 1);
 
         // add to world
         pet->GetMap()->AddToMap(pet->ToCreature());
 
         // visual effect for levelup
         pet->SetUInt32Value(UNIT_FIELD_LEVEL, level);
 
         // caster have pet now
         player->SetMinion(pet, true);
 
         pet->SavePetToDB(PET_SAVE_AS_CURRENT);
         player->PetSpellInitialize();
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcTextEmoteCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
             return false;
 
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->TextEmote(args);
 
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcUnFollowCommand	(	ChatHandler *	handler,
		char const *
	)

inlinestatic

     {
         Player* player = handler->GetSession()->GetPlayer();
         Creature* creature = handler->getSelectedCreature();
 
         if (!creature)
         {
             handler->PSendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         if (/*creature->GetMotionMaster()->empty() ||*/
             creature->GetMotionMaster()->GetCurrentMovementGeneratorType() != FOLLOW_MOTION_TYPE)
         {
             handler->PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU, creature->GetName().c_str());
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         FollowMovementGenerator<Creature> const* mgen = static_cast<FollowMovementGenerator<Creature> const*>((creature->GetMotionMaster()->top()));
 
         if (mgen->GetTarget() != player)
         {
             handler->PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU, creature->GetName().c_str());
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         // reset movement
         creature->GetMotionMaster()->MovementExpired(true);
 
         handler->PSendSysMessage(LANG_CREATURE_NOT_FOLLOW_YOU_NOW, creature->GetName().c_str());
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcWhisperCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
         {
             handler->SendSysMessage(LANG_CMD_SYNTAX);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         char* receiver_str = strtok((char*)args, " ");
         char* text = strtok(NULL, "");
 
         if (!receiver_str || !text)
         {
             handler->SendSysMessage(LANG_CMD_SYNTAX);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         Creature* creature = handler->getSelectedCreature();
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         ObjectGuid receiver_guid = ObjectGuid::Create<HighGuid::Player>(strtoull(receiver_str, nullptr, 10));
 
         // check online security
         Player* receiver = ObjectAccessor::FindPlayer(receiver_guid);
         if (handler->HasLowerSecurity(receiver, ObjectGuid::Empty))
             return false;
 
         creature->Whisper(text, LANG_UNIVERSAL, receiver);
         return true;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool npc_commandscript::HandleNpcYellCommand	(	ChatHandler *	handler,
		char const *	args
	)

inlinestatic

     {
         if (!*args)
         {
             handler->SendSysMessage(LANG_CMD_SYNTAX);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         Creature* creature = handler->getSelectedCreature();
         if (!creature)
         {
             handler->SendSysMessage(LANG_SELECT_CREATURE);
             handler->SetSentErrorMessage(true);
             return false;
         }
 
         creature->Yell(args, LANG_UNIVERSAL);
 
         // make an emote
         creature->HandleEmoteCommand(EMOTE_ONESHOT_SHOUT);
 
         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_npc.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation