npc_commandscript Class Reference

Inheritance diagram for npc_commandscript:

Public Member Functions
	npc_commandscript ()
ChatCommandTable	GetCommands () const override
Public Member Functions inherited from ScriptObject
virtual bool	IsDatabaseBound () const
virtual bool	isAfterLoadScript () const
virtual void	checkValidity ()
const std::string &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Public Member Functions
static bool	HandleNpcAddCommand (ChatHandler *handler, CreatureEntry id)
static bool	HandleNpcLoadCommand (ChatHandler *handler, CreatureSpawnId spawnId)
static bool	HandleNpcAddVendorItemCommand (ChatHandler *handler, ItemTemplate const *item, Optional< uint32 > mc, Optional< uint32 > it, Optional< uint32 > ec, Optional< bool > addMulti)
static bool	HandleNpcAddMoveCommand (ChatHandler *handler, CreatureSpawnId lowGuid)
static bool	HandleNpcSetAllowMovementCommand (ChatHandler *handler)
static bool	HandleNpcSetEntryCommand (ChatHandler *handler, CreatureEntry newEntryNum)
static bool	HandleNpcSetLevelCommand (ChatHandler *handler, uint8 lvl)
static bool	HandleNpcDeleteCommand (ChatHandler *handler, Optional< ObjectGuid::LowType > lowGuid)
static bool	HandleNpcDeleteVendorItemCommand (ChatHandler *handler, ItemTemplate const *item, Optional< bool > addMulti)
static bool	HandleNpcSetFactionIdCommand (ChatHandler *handler, uint32 factionId)
static bool	HandleNpcSetFactionTempIdCommand (ChatHandler *handler, uint32 tempfaction)
static bool	HandleNpcSetOriginalFaction (ChatHandler *handler)
static bool	HandleNpcSetFlagCommand (ChatHandler *handler, uint32 npcFlags)
static bool	HandleNpcSetDataCommand (ChatHandler *handler, uint32 data_1, uint32 data_2)
static bool	HandleNpcFollowCommand (ChatHandler *handler)
static bool	HandleNpcInfoCommand (ChatHandler *handler)
static bool	HandleNpcGuidCommand (ChatHandler *handler)
static bool	HandleNpcNearCommand (ChatHandler *handler, Optional< float > dist)
static bool	HandleNpcMoveCommand (ChatHandler *handler, Optional< ObjectGuid::LowType > guid)
static bool	HandleNpcPlayEmoteCommand (ChatHandler *handler, uint32 emote)
static bool	HandleNpcSetModelCommand (ChatHandler *handler, uint32 displayId)
static bool	HandleNpcSetMoveTypeCommand (ChatHandler *handler, Optional< CreatureSpawnId > lowGuid, Variant< EXACT_SEQUENCE("stay"), EXACT_SEQUENCE("random"), EXACT_SEQUENCE("way")> type, Optional< EXACT_SEQUENCE("nodel")> nodel)
static bool	HandleNpcSetPhaseCommand (ChatHandler *handler, uint32 phasemask)
static bool	HandleNpcSetWanderDistanceCommand (ChatHandler *handler, float option)
static bool	HandleNpcSetSpawnTimeCommand (ChatHandler *handler, std::string spawnTimeStr)
static bool	HandleNpcSayCommand (ChatHandler *handler, Tail text)
static bool	HandleNpcTextEmoteCommand (ChatHandler *handler, Tail text)
static bool	HandleNpcUnFollowCommand (ChatHandler *handler)
static bool	HandleNpcWhisperCommand (ChatHandler *handler, std::string const &recv, Tail text)
static bool	HandleNpcYellCommand (ChatHandler *handler, Tail text)
static bool	HandleNpcAddTempSpawnCommand (ChatHandler *handler, CreatureEntry id)
static bool	HandleNpcTameCommand (ChatHandler *handler)
static bool	HandleNpcDoActionCommand (ChatHandler *handler, uint32 actionId)
static bool	HandleNpcAddFormationCommand (ChatHandler *handler, ObjectGuid::LowType leaderGUID)
static bool	HandleNpcSetLinkCommand (ChatHandler *handler, ObjectGuid::LowType linkguid)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (const char *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (const char *name, uint16 totalAvailableHooks=0)
virtual	~ScriptObject ()=default

Detailed Description

Constructor & Destructor Documentation

npc_commandscript()

npc_commandscript::npc_commandscript ( )

inline

: CommandScript("npc_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable npc_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable npcAddCommandTable =
        {
            { "formation",      HandleNpcAddFormationCommand,      SEC_ADMINISTRATOR, Console::No },
            { "item",           HandleNpcAddVendorItemCommand,     SEC_ADMINISTRATOR, Console::No },
            { "move",           HandleNpcAddMoveCommand,           SEC_ADMINISTRATOR, Console::No },
            { "temp",           HandleNpcAddTempSpawnCommand,      SEC_ADMINISTRATOR, Console::No },
            { "",               HandleNpcAddCommand,               SEC_ADMINISTRATOR, Console::No }
        };
        static ChatCommandTable npcDeleteCommandTable =
        {
            { "item",           HandleNpcDeleteVendorItemCommand,  SEC_ADMINISTRATOR, Console::No },
            { "",               HandleNpcDeleteCommand,            SEC_ADMINISTRATOR, Console::No }
        };
        static ChatCommandTable npcFollowCommandTable =
        {
            { "stop",           HandleNpcUnFollowCommand,          SEC_GAMEMASTER, Console::No },
            { "",               HandleNpcFollowCommand,            SEC_GAMEMASTER, Console::No }
        };
 
        static ChatCommandTable npcFactionCommandTable =
        {
            { "permanent",      HandleNpcSetFactionIdCommand,      SEC_ADMINISTRATOR, Console::No },
            { "temp",           HandleNpcSetFactionTempIdCommand,  SEC_ADMINISTRATOR, Console::No },
            { "original",       HandleNpcSetOriginalFaction,       SEC_ADMINISTRATOR, Console::No }
        };
 
        static ChatCommandTable npcSetCommandTable =
        {
            { "allowmove",      HandleNpcSetAllowMovementCommand,  SEC_ADMINISTRATOR, Console::No },
            { "entry",          HandleNpcSetEntryCommand,          SEC_ADMINISTRATOR, Console::No },
            { "faction",        npcFactionCommandTable},
            { "flag",           HandleNpcSetFlagCommand,           SEC_ADMINISTRATOR, Console::No },
            { "level",          HandleNpcSetLevelCommand,          SEC_ADMINISTRATOR, Console::No },
            { "link",           HandleNpcSetLinkCommand,           SEC_ADMINISTRATOR, Console::No },
            { "model",          HandleNpcSetModelCommand,          SEC_ADMINISTRATOR, Console::No },
            { "movetype",       HandleNpcSetMoveTypeCommand,       SEC_ADMINISTRATOR, Console::No },
            { "phase",          HandleNpcSetPhaseCommand,          SEC_ADMINISTRATOR, Console::No },
            { "wanderdistance", HandleNpcSetWanderDistanceCommand, SEC_ADMINISTRATOR, Console::No },
            { "spawntime",      HandleNpcSetSpawnTimeCommand,      SEC_ADMINISTRATOR, Console::No },
            { "data",           HandleNpcSetDataCommand,           SEC_ADMINISTRATOR, Console::No }
        };
        static ChatCommandTable npcCommandTable =
        {
            { "info",           HandleNpcInfoCommand,              SEC_GAMEMASTER, Console::No },
            { "guid",           HandleNpcGuidCommand,              SEC_GAMEMASTER, Console::No },
            { "near",           HandleNpcNearCommand,              SEC_GAMEMASTER, Console::No },
            { "move",           HandleNpcMoveCommand,              SEC_GAMEMASTER, Console::No },
            { "playemote",      HandleNpcPlayEmoteCommand,         SEC_GAMEMASTER, Console::No },
            { "say",            HandleNpcSayCommand,               SEC_GAMEMASTER, Console::No },
            { "textemote",      HandleNpcTextEmoteCommand,         SEC_GAMEMASTER, Console::No },
            { "whisper",        HandleNpcWhisperCommand,           SEC_GAMEMASTER, Console::No },
            { "yell",           HandleNpcYellCommand,              SEC_GAMEMASTER, Console::No },
            { "tame",           HandleNpcTameCommand,              SEC_GAMEMASTER, Console::No },
            { "do",             HandleNpcDoActionCommand,          SEC_GAMEMASTER, Console::No },
            { "add",            npcAddCommandTable },
            { "delete",         npcDeleteCommandTable },
            { "follow",         npcFollowCommandTable },
            { "load",           HandleNpcLoadCommand,              SEC_ADMINISTRATOR, Console::Yes },
            { "set",            npcSetCommandTable }
        };
        static ChatCommandTable commandTable =
        {
            { "npc", npcCommandTable }
        };
        return commandTable;
    }

References HandleNpcAddCommand(), HandleNpcAddFormationCommand(), HandleNpcAddMoveCommand(), HandleNpcAddTempSpawnCommand(), HandleNpcAddVendorItemCommand(), HandleNpcDeleteCommand(), HandleNpcDeleteVendorItemCommand(), HandleNpcDoActionCommand(), HandleNpcFollowCommand(), HandleNpcGuidCommand(), HandleNpcInfoCommand(), HandleNpcLoadCommand(), HandleNpcMoveCommand(), HandleNpcNearCommand(), HandleNpcPlayEmoteCommand(), HandleNpcSayCommand(), HandleNpcSetAllowMovementCommand(), HandleNpcSetDataCommand(), HandleNpcSetEntryCommand(), HandleNpcSetFactionIdCommand(), HandleNpcSetFactionTempIdCommand(), HandleNpcSetFlagCommand(), HandleNpcSetLevelCommand(), HandleNpcSetLinkCommand(), HandleNpcSetModelCommand(), HandleNpcSetMoveTypeCommand(), HandleNpcSetOriginalFaction(), HandleNpcSetPhaseCommand(), HandleNpcSetSpawnTimeCommand(), HandleNpcSetWanderDistanceCommand(), HandleNpcTameCommand(), HandleNpcTextEmoteCommand(), HandleNpcUnFollowCommand(), HandleNpcWhisperCommand(), HandleNpcYellCommand(), SEC_ADMINISTRATOR, and SEC_GAMEMASTER.

HandleNpcAddCommand()

static bool npc_commandscript::HandleNpcAddCommand ( ChatHandler *  handler, CreatureEntry  id  )

inlinestatic

    {
        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* tt = chr->GetTransport())
            if (MotionTransport* trans = tt->ToMotionTransport())
            {
                ObjectGuid::LowType guid = sObjectMgr->GenerateCreatureSpawnId();
                CreatureData& data = sObjectMgr->NewOrExistCreatureData(guid);
                data.id1 = id;
                data.phaseMask = chr->GetPhaseMaskForSpawn();
                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->GetPhaseMaskForSpawn());
 
                sObjectMgr->AddCreatureToGrid(guid, &data);
                return true;
            }
 
        Creature* creature = new Creature();
        if (!creature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, chr->GetPhaseMaskForSpawn(), id, 0, x, y, z, o))
        {
            delete creature;
            return false;
        }
 
        creature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), chr->GetPhaseMaskForSpawn());
 
        ObjectGuid::LowType spawnId = 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(spawnId, map, true, true))
        {
            delete creature;
            return false;
        }
 
        sObjectMgr->AddCreatureToGrid(spawnId, sObjectMgr->GetCreatureData(spawnId));
        return true;
    }

References Unit::CleanupsBeforeDelete(), Creature::Create(), Map::GenerateLowGuid(), Map::GetId(), WorldObject::GetMap(), Position::GetOrientation(), Player::GetPhaseMaskForSpawn(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), Creature::GetSpawnId(), Map::GetSpawnMode(), WorldObject::GetTransOffsetO(), WorldObject::GetTransOffsetX(), WorldObject::GetTransOffsetY(), WorldObject::GetTransOffsetZ(), WorldObject::GetTransport(), CreatureData::id1, Creature::LoadCreatureFromDB(), CreatureData::orientation, CreatureData::phaseMask, CreatureData::posX, CreatureData::posY, CreatureData::posZ, Creature::SaveToDB(), sObjectMgr, GameObject::ToMotionTransport(), and Unit.

Referenced by GetCommands().

HandleNpcAddFormationCommand()

static bool npc_commandscript::HandleNpcAddFormationCommand ( ChatHandler *  handler, ObjectGuid::LowType  leaderGUID  )

inlinestatic

    {
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature || !creature->GetSpawnId())
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        ObjectGuid::LowType lowguid = creature->GetSpawnId();
        if (creature->GetFormation())
        {
            handler->PSendSysMessage("Selected creature is already member of group {}", creature->GetFormation()->GetId());
            return false;
        }
 
        if (!lowguid)
            return false;
 
        Player* chr = handler->GetSession()->GetPlayer();
        FormationInfo group_member;
        group_member.follow_angle   = (creature->GetAngle(chr) - chr->GetOrientation()) * 180 / M_PI;
        group_member.follow_dist    = sqrtf(pow(chr->GetPositionX() - creature->GetPositionX(), int(2)) + pow(chr->GetPositionY() - creature->GetPositionY(), int(2)));
        group_member.leaderGUID     = leaderGUID;
        group_member.groupAI        = 0;
 
        sFormationMgr->CreatureGroupMap[lowguid] = group_member;
        creature->SearchFormation();
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_CREATURE_FORMATION);
        stmt->SetData(0, leaderGUID);
        stmt->SetData(1, lowguid);
        stmt->SetData(2, group_member.follow_dist);
        stmt->SetData(3, group_member.follow_angle);
        stmt->SetData(4, uint32(group_member.groupAI));
 
        WorldDatabase.Execute(stmt);
 
        handler->PSendSysMessage("Creature {} added to formation with leader {}", lowguid, leaderGUID);
 
        return true;
    }

References FormationInfo::follow_angle, FormationInfo::follow_dist, Position::GetAngle(), Creature::GetFormation(), CreatureGroup::GetId(), Position::GetOrientation(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetSpawnId(), FormationInfo::groupAI, LANG_SELECT_CREATURE, FormationInfo::leaderGUID, ChatHandler::PSendSysMessage(), Creature::SearchFormation(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), sFormationMgr, WORLD_INS_CREATURE_FORMATION, and WorldDatabase.

Referenced by GetCommands().

HandleNpcAddMoveCommand()

static bool npc_commandscript::HandleNpcAddMoveCommand ( ChatHandler *  handler, CreatureSpawnId  lowGuid  )

inlinestatic

    {
        // attempt check creature existence by DB data
        CreatureData const* data = sObjectMgr->GetCreatureData(lowGuid);
        if (!data)
        {
            handler->SendErrorMessage(LANG_COMMAND_CREATGUIDNOTFOUND, uint32(lowGuid));
            return false;
        }
 
        // Update movement type
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_MOVEMENT_TYPE);
        stmt->SetData(0, uint8(WAYPOINT_MOTION_TYPE));
        stmt->SetData(1, uint32(lowGuid));
        WorldDatabase.Execute(stmt);
 
        handler->SendSysMessage(LANG_WAYPOINT_ADDED);
 
        return true;
    }

References LANG_COMMAND_CREATGUIDNOTFOUND, LANG_WAYPOINT_ADDED, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), sObjectMgr, WAYPOINT_MOTION_TYPE, WORLD_UPD_CREATURE_MOVEMENT_TYPE, and WorldDatabase.

Referenced by GetCommands().

HandleNpcAddTempSpawnCommand()

static bool npc_commandscript::HandleNpcAddTempSpawnCommand ( ChatHandler *  handler, CreatureEntry  id  )

inlinestatic

    {
        Player* chr = handler->GetSession()->GetPlayer();
 
        if (!id)
            return false;
 
        chr->SummonCreature(id, *chr, TEMPSUMMON_CORPSE_DESPAWN, 120);
 
        return true;
    }

References WorldSession::GetPlayer(), ChatHandler::GetSession(), WorldObject::SummonCreature(), and TEMPSUMMON_CORPSE_DESPAWN.

Referenced by GetCommands().

HandleNpcAddVendorItemCommand()

static bool npc_commandscript::HandleNpcAddVendorItemCommand ( ChatHandler *  handler, ItemTemplate const *  item, Optional< uint32 >  mc, Optional< uint32 >  it, Optional< uint32 >  ec, Optional< bool >  addMulti  )

inlinestatic

    {
        if (!item)
        {
            handler->SendErrorMessage(LANG_COMMAND_NEEDITEMSEND);
            return false;
        }
 
        Creature* vendor = handler->getSelectedCreature();
        if (!vendor)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        uint32 itemId = item->ItemId;
        uint32 maxcount = mc.value_or(0);
        uint32 incrtime = it.value_or(0);
        uint32 extendedcost = ec.value_or(0);
        uint32 vendor_entry = addMulti.value_or(false) ? handler->GetSession()->GetCurrentVendor() : vendor->GetEntry();
 
        if (!sObjectMgr->IsVendorItemValid(vendor_entry, itemId, maxcount, incrtime, extendedcost, handler->GetSession()->GetPlayer()))
        {
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        sObjectMgr->AddVendorItem(vendor_entry, itemId, maxcount, incrtime, extendedcost);
 
        handler->PSendSysMessage(LANG_ITEM_ADDED_TO_LIST, itemId, item->Name1, maxcount, incrtime, extendedcost);
        return true;
    }

References WorldSession::GetCurrentVendor(), Object::GetEntry(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), ItemTemplate::ItemId, LANG_COMMAND_NEEDITEMSEND, LANG_ITEM_ADDED_TO_LIST, LANG_SELECT_CREATURE, ItemTemplate::Name1, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), ChatHandler::SetSentErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandleNpcDeleteCommand()

static bool npc_commandscript::HandleNpcDeleteCommand ( ChatHandler *  handler, Optional< ObjectGuid::LowType >  lowGuid  )

inlinestatic

    {
        Creature* creature;
        if (lowGuid.has_value())
            creature = handler->GetCreatureFromPlayerMapByDbGuid(*lowGuid);
        else
            creature = handler->getSelectedCreature();
 
        if (!creature || creature->IsPet() || creature->IsTotem())
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        // Delete the creature
        creature->CombatStop();
        creature->DeleteFromDB();
        creature->AddObjectToRemoveList();
 
        handler->SendSysMessage(LANG_COMMAND_DELCREATMESSAGE);
 
        return true;
    }

References WorldObject::AddObjectToRemoveList(), Unit::CombatStop(), Creature::DeleteFromDB(), ChatHandler::GetCreatureFromPlayerMapByDbGuid(), ChatHandler::getSelectedCreature(), Unit::IsPet(), Unit::IsTotem(), LANG_COMMAND_DELCREATMESSAGE, LANG_SELECT_CREATURE, ChatHandler::SendErrorMessage(), and ChatHandler::SendSysMessage().

Referenced by GetCommands().

HandleNpcDeleteVendorItemCommand()

static bool npc_commandscript::HandleNpcDeleteVendorItemCommand ( ChatHandler *  handler, ItemTemplate const *  item, Optional< bool >  addMulti  )

inlinestatic

    {
        Creature* vendor = handler->getSelectedCreature();
        if (!vendor || !vendor->IsVendor())
        {
            handler->SendErrorMessage(LANG_COMMAND_VENDORSELECTION);
            return false;
        }
 
        if (!item)
        {
            handler->SendErrorMessage(LANG_COMMAND_NEEDITEMSEND);
            return false;
        }
 
        uint32 itemId = item->ItemId;
        if (!sObjectMgr->RemoveVendorItem(addMulti.value_or(false) ? handler->GetSession()->GetCurrentVendor() : vendor->GetEntry(), itemId))
        {
            handler->SendErrorMessage(LANG_ITEM_NOT_IN_LIST, itemId);
            return false;
        }
 
        handler->PSendSysMessage(LANG_ITEM_DELETED_FROM_LIST, itemId, item->Name1);
        return true;
    }

References WorldSession::GetCurrentVendor(), Object::GetEntry(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Unit::IsVendor(), ItemTemplate::ItemId, LANG_COMMAND_NEEDITEMSEND, LANG_COMMAND_VENDORSELECTION, LANG_ITEM_DELETED_FROM_LIST, LANG_ITEM_NOT_IN_LIST, ItemTemplate::Name1, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and sObjectMgr.

Referenced by GetCommands().

HandleNpcDoActionCommand()

static bool npc_commandscript::HandleNpcDoActionCommand ( ChatHandler *  handler, uint32  actionId  )

inlinestatic

    {
        Creature* creature = handler->getSelectedCreature();
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->AI()->DoAction(actionId);
        handler->PSendSysMessage(LANG_NPC_DO_ACTION, creature->GetGUID().ToString(), creature->GetEntry(), creature->GetName(), actionId);
        return true;
    }

References Creature::AI(), UnitAI::DoAction(), Object::GetEntry(), Object::GetGUID(), WorldObject::GetName(), ChatHandler::getSelectedCreature(), LANG_NPC_DO_ACTION, LANG_SELECT_CREATURE, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and ObjectGuid::ToString().

Referenced by GetCommands().

HandleNpcFollowCommand()

static bool npc_commandscript::HandleNpcFollowCommand ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            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());
        return true;
    }

References Unit::GetFollowAngle(), Unit::GetMotionMaster(), WorldObject::GetName(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), LANG_CREATURE_FOLLOW_YOU_NOW, LANG_SELECT_CREATURE, MotionMaster::MoveFollow(), PET_FOLLOW_DIST, ChatHandler::PSendSysMessage(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleNpcGuidCommand()

static bool npc_commandscript::HandleNpcGuidCommand ( ChatHandler *  handler )

inlinestatic

    {
        Creature* target = handler->getSelectedCreature();
 
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        uint32 faction = target->GetFaction();
        uint32 npcflags = target->GetNpcFlags();
        uint32 displayid = target->GetDisplayId();
        uint32 nativeid = target->GetNativeDisplayId();
        uint32 entry = target->GetEntry();
        uint32 id1 = 0;
        uint32 id2 = 0;
        uint32 id3 = 0;
        if (CreatureData const* cData = target->GetCreatureData())
        {
            id1 = cData->id1;
            id2 = cData->id2;
            id3 = cData->id3;
        }
 
        handler->PSendSysMessage(LANG_NPCINFO_CHAR, target->GetSpawnId(), target->GetGUID().ToString(), entry, id1, id2, id3, displayid, nativeid, faction, npcflags);
 
        return true;
    }

References Creature::GetCreatureData(), Unit::GetDisplayId(), Object::GetEntry(), Unit::GetFaction(), Object::GetGUID(), Unit::GetNativeDisplayId(), Unit::GetNpcFlags(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), LANG_NPCINFO_CHAR, LANG_SELECT_CREATURE, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and ObjectGuid::ToString().

Referenced by GetCommands().

HandleNpcInfoCommand()

static bool npc_commandscript::HandleNpcInfoCommand ( ChatHandler *  handler )

inlinestatic

    {
        Creature* target = handler->getSelectedCreature();
 
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        CreatureTemplate const* cInfo = target->GetCreatureTemplate();
        uint32 faction = target->GetFaction();
        uint32 npcflags = target->GetNpcFlags();
        uint32 mechanicImmuneMask = cInfo->MechanicImmuneMask;
        uint32 spellSchoolImmuneMask = cInfo->SpellSchoolImmuneMask;
        uint32 displayid = target->GetDisplayId();
        uint32 nativeid = target->GetNativeDisplayId();
        uint32 entry = target->GetEntry();
        uint32 id1 = 0;
        uint32 id2 = 0;
        uint32 id3 = 0;
        if (CreatureData const* cData = target->GetCreatureData())
        {
            id1 = cData->id1;
            id2 = cData->id2;
            id3 = cData->id3;
        }
 
        int64 curRespawnDelay = target->GetRespawnTimeEx() - GameTime::GetGameTime().count();
        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(), entry, id1, id2, id3, displayid, nativeid, faction, npcflags);
        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_FLAGS, target->GetUnitFlags(), target->GetUnitFlags2(), target->GetDynamicFlags(), target->GetFaction());
        handler->PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr, curRespawnDelayStr);
        handler->PSendSysMessage(LANG_NPCINFO_LOOT,  cInfo->lootid, cInfo->pickpocketLootId, cInfo->SkinLootId);
        handler->PSendSysMessage(LANG_NPCINFO_DUNGEON_ID, target->GetInstanceId());
        handler->PSendSysMessage(LANG_NPCINFO_PHASEMASK, target->GetPhaseMask());
        handler->PSendSysMessage(LANG_NPCINFO_ARMOR, target->GetArmor());
        handler->PSendSysMessage(LANG_NPCINFO_POSITION, float(target->GetPositionX()), float(target->GetPositionY()), float(target->GetPositionZ()));
        handler->PSendSysMessage(LANG_NPCINFO_AIINFO, target->GetAIName(), target->GetScriptName());
 
        for (uint8 i = 0; i < NPCFLAG_COUNT; i++)
        {
            if (npcflags & npcFlagTexts[i].flag)
            {
                handler->PSendSysMessage(npcFlagTexts[i].text, npcFlagTexts[i].flag);
            }
        }
 
        handler->PSendSysMessage(LANG_NPCINFO_MECHANIC_IMMUNE, mechanicImmuneMask);
        for (uint8 i = 1; i < MAX_MECHANIC; ++i)
        {
            if (mechanicImmuneMask & (1 << (mechanicImmunes[i].flag - 1)))
            {
                handler->PSendSysMessage(mechanicImmunes[i].text, mechanicImmunes[i].flag);
            }
        }
 
        handler->PSendSysMessage(LANG_NPCINFO_SPELL_SCHOOL_IMMUNE, spellSchoolImmuneMask);
        for (uint8 i = 0; i < MAX_SPELL_SCHOOL; ++i)
        {
            if (spellSchoolImmuneMask & (1 << spellSchoolImmunes[i].flag))
            {
                handler->PSendSysMessage(spellSchoolImmunes[i].text, spellSchoolImmunes[i].flag);
            }
        }
 
        return true;
    }

References Creature::GetAIName(), Unit::GetArmor(), Unit::GetCreateHealth(), Creature::GetCreatureData(), Creature::GetCreatureTemplate(), Creature::GetCurrentEquipmentId(), Unit::GetDisplayId(), Unit::GetDynamicFlags(), Object::GetEntry(), Unit::GetFaction(), GameTime::GetGameTime(), Object::GetGUID(), Unit::GetHealth(), WorldObject::GetInstanceId(), Unit::GetLevel(), Unit::GetMaxHealth(), Unit::GetNativeDisplayId(), Unit::GetNpcFlags(), Creature::GetOriginalEquipmentId(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Creature::GetRespawnDelay(), Creature::GetRespawnTimeEx(), Creature::GetScriptName(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), Unit::GetUnitFlags(), Unit::GetUnitFlags2(), LANG_COMMAND_RAWPAWNTIMES, LANG_NPCINFO_AIINFO, LANG_NPCINFO_ARMOR, LANG_NPCINFO_CHAR, LANG_NPCINFO_DUNGEON_ID, LANG_NPCINFO_EQUIPMENT, LANG_NPCINFO_FLAGS, LANG_NPCINFO_HEALTH, LANG_NPCINFO_LEVEL, LANG_NPCINFO_LOOT, LANG_NPCINFO_MECHANIC_IMMUNE, LANG_NPCINFO_PHASEMASK, LANG_NPCINFO_POSITION, LANG_NPCINFO_SPELL_SCHOOL_IMMUNE, LANG_SELECT_CREATURE, CreatureTemplate::lootid, MAX_MECHANIC, MAX_SPELL_SCHOOL, CreatureTemplate::MechanicImmuneMask, mechanicImmunes, NPCFLAG_COUNT, npcFlagTexts, CreatureTemplate::pickpocketLootId, ChatHandler::PSendSysMessage(), secsToTimeString(), ChatHandler::SendErrorMessage(), CreatureTemplate::SkinLootId, CreatureTemplate::SpellSchoolImmuneMask, spellSchoolImmunes, and ObjectGuid::ToString().

Referenced by GetCommands().

HandleNpcLoadCommand()

static bool npc_commandscript::HandleNpcLoadCommand ( ChatHandler *  handler, CreatureSpawnId  spawnId  )

inlinestatic

    {
        if (!spawnId)
            return false;
 
        if (sObjectMgr->GetCreatureData(spawnId))
        {
            handler->SendErrorMessage("Creature spawn {} is already loaded.", uint32(spawnId));
            return false;
        }
 
        CreatureData const* data = sObjectMgr->LoadCreatureDataFromDB(spawnId);
        if (!data)
        {
            handler->SendErrorMessage("Creature spawn {} not found in the database.", uint32(spawnId));
            return false;
        }
 
        if (sPoolMgr->IsPartOfAPool<Creature>(spawnId))
        {
            handler->SendErrorMessage("Creature spawn {} is part of a pool and cannot be manually loaded.", uint32(spawnId));
            return false;
        }
 
        QueryResult eventResult = WorldDatabase.Query("SELECT guid FROM game_event_creature WHERE guid = {}", uint32(spawnId));
        if (eventResult)
        {
            handler->SendErrorMessage("Creature spawn {} is managed by the game event system and cannot be manually loaded.", uint32(spawnId));
            return false;
        }
 
        Map* map = sMapMgr->FindBaseNonInstanceMap(data->mapid);
        if (!map)
        {
            handler->SendErrorMessage("Creature spawn {} is on a non-continent map (ID: {}). Only continent maps are supported.", uint32(spawnId), data->mapid);
            return false;
        }
 
        Creature* creature = new Creature();
        if (!creature->LoadCreatureFromDB(spawnId, map, true, true))
        {
            delete creature;
            handler->SendErrorMessage("Failed to load creature spawn {}.", uint32(spawnId));
            return false;
        }
 
        sObjectMgr->AddCreatureToGrid(spawnId, data);
        handler->PSendSysMessage("Creature spawn {} loaded successfully.", uint32(spawnId));
        return true;
    }

References Creature::LoadCreatureFromDB(), CreatureData::mapid, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), sMapMgr, sObjectMgr, sPoolMgr, and WorldDatabase.

Referenced by GetCommands().

HandleNpcMoveCommand()

static bool npc_commandscript::HandleNpcMoveCommand ( ChatHandler *  handler, Optional< ObjectGuid::LowType >  guid  )

inlinestatic

    {
        Creature* creature;
        if (guid.has_value())
            creature = handler->GetCreatureFromPlayerMapByDbGuid(*guid);
        else
            creature = handler->getSelectedCreature();
 
        if (!creature)
            return false;
 
        ObjectGuid::LowType lowGuid;
        if (guid.has_value())
            lowGuid = *guid;
        else
            lowGuid = creature->GetSpawnId();
 
        CreatureData const* data = sObjectMgr->GetCreatureData(lowGuid);
        if (!data)
        {
            handler->SendErrorMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowGuid);
            return false;
        }
 
        if (handler->GetSession()->GetPlayer()->GetMapId() != data->mapid)
        {
            handler->SendErrorMessage(LANG_COMMAND_CREATUREATSAMEMAP, lowGuid);
            return false;
        }
 
        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(DeathState::JustDied);
                creature->Respawn();
            }
        }
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_POSITION);
        stmt->SetData(0, x);
        stmt->SetData(1, y);
        stmt->SetData(2, z);
        stmt->SetData(3, o);
        stmt->SetData(4, lowGuid);
 
        WorldDatabase.Execute(stmt);
 
        handler->PSendSysMessage(LANG_COMMAND_CREATUREMOVED);
        return true;
    }

References ChatHandler::GetCreatureFromPlayerMapByDbGuid(), WorldLocation::GetMapId(), Unit::GetMotionMaster(), Position::GetOrientation(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetSpawnId(), MotionMaster::Initialize(), Unit::IsAlive(), JustDied, LANG_COMMAND_CREATGUIDNOTFOUND, LANG_COMMAND_CREATUREATSAMEMAP, LANG_COMMAND_CREATUREMOVED, CreatureData::mapid, ChatHandler::PSendSysMessage(), Creature::Respawn(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), Creature::setDeathState(), Creature::SetPosition(), sObjectMgr, WORLD_UPD_CREATURE_POSITION, and WorldDatabase.

Referenced by GetCommands().

HandleNpcNearCommand()

static bool npc_commandscript::HandleNpcNearCommand ( ChatHandler *  handler, Optional< float >  dist  )

inlinestatic

    {
        float distance = dist.value_or(10.0f);
        uint32 count = 0;
 
        Player* player = handler->GetSession()->GetPlayer();
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_CREATURE_NEAREST);
        stmt->SetData(0, player->GetPositionX());
        stmt->SetData(1, player->GetPositionY());
        stmt->SetData(2, player->GetPositionZ());
        stmt->SetData(3, player->GetMapId());
        stmt->SetData(4, player->GetPositionX());
        stmt->SetData(5, player->GetPositionY());
        stmt->SetData(6, player->GetPositionZ());
        stmt->SetData(7, distance * distance);
        stmt->SetData(8, player->GetPhaseMask());
        PreparedQueryResult result = WorldDatabase.Query(stmt);
 
        if (result)
        {
            do
            {
                Field* fields = result->Fetch();
                ObjectGuid::LowType guid = fields[0].Get<uint32>();
                uint32 entry = fields[1].Get<uint32>();
                //uint32 entry2 = fields[2].Get<uint32>();
                //uint32 entry3 = fields[3].Get<uint32>();
                float x = fields[4].Get<float>();
                float y = fields[5].Get<float>();
                float z = fields[6].Get<float>();
                uint16 mapId = fields[7].Get<uint16>();
 
                CreatureTemplate const* creatureTemplate = sObjectMgr->GetCreatureTemplate(entry);
                if (!creatureTemplate)
                    continue;
 
                handler->PSendSysMessage(LANG_CREATURE_LIST_CHAT, guid, entry, guid, creatureTemplate->Name, x, y, z, mapId, "", "");
 
                ++count;
            } while (result->NextRow());
        }
 
        handler->PSendSysMessage(LANG_COMMAND_NEAR_NPC_MESSAGE, distance, count);
 
        return true;
    }

References Field::Get(), WorldLocation::GetMapId(), WorldObject::GetPhaseMask(), WorldSession::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), ChatHandler::GetSession(), LANG_COMMAND_NEAR_NPC_MESSAGE, LANG_CREATURE_LIST_CHAT, ChatHandler::PSendSysMessage(), PreparedStatementBase::SetData(), sObjectMgr, WORLD_SEL_CREATURE_NEAREST, and WorldDatabase.

Referenced by GetCommands().

HandleNpcPlayEmoteCommand()

static bool npc_commandscript::HandleNpcPlayEmoteCommand ( ChatHandler *  handler, uint32  emote  )

inlinestatic

    {
        Creature* target = handler->getSelectedCreature();
        if (!target)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        target->SetUInt32Value(UNIT_NPC_EMOTESTATE, emote);
 
        return true;
    }

References ChatHandler::getSelectedCreature(), LANG_SELECT_CREATURE, ChatHandler::SendErrorMessage(), Unit::SetUInt32Value(), and UNIT_NPC_EMOTESTATE.

Referenced by GetCommands().

HandleNpcSayCommand()

static bool npc_commandscript::HandleNpcSayCommand ( ChatHandler *  handler, Tail  text  )

inlinestatic

    {
        if (text.empty())
            return false;
 
        Creature* creature = handler->getSelectedCreature();
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->Say(text, LANG_UNIVERSAL);
 
        // make some emotes
        switch (text.back())
        {
            case '?':   creature->HandleEmoteCommand(EMOTE_ONESHOT_QUESTION);      break;
            case '!':   creature->HandleEmoteCommand(EMOTE_ONESHOT_EXCLAMATION);   break;
            default:    creature->HandleEmoteCommand(EMOTE_ONESHOT_TALK);          break;
        }
 
        return true;
    }

References EMOTE_ONESHOT_EXCLAMATION, EMOTE_ONESHOT_QUESTION, EMOTE_ONESHOT_TALK, ChatHandler::getSelectedCreature(), Unit::HandleEmoteCommand(), LANG_SELECT_CREATURE, LANG_UNIVERSAL, Unit::Say(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandleNpcSetAllowMovementCommand()

static bool npc_commandscript::HandleNpcSetAllowMovementCommand ( ChatHandler *  handler )

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;
    }

References LANG_CREATURE_MOVE_DISABLED, LANG_CREATURE_MOVE_ENABLED, ChatHandler::SendSysMessage(), and sWorld.

Referenced by GetCommands().

HandleNpcSetDataCommand()

static bool npc_commandscript::HandleNpcSetDataCommand ( ChatHandler *  handler, uint32  data_1, uint32  data_2  )

inlinestatic

    {
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            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(), creature->GetEntry(), creature->GetName(), data_1, data_2, AIorScript);
        return true;
    }

References Creature::AI(), Creature::GetAIName(), Object::GetEntry(), Object::GetGUID(), WorldObject::GetName(), Creature::GetScriptName(), ChatHandler::getSelectedCreature(), LANG_NPC_SETDATA, LANG_SELECT_CREATURE, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), UnitAI::SetData(), and ObjectGuid::ToString().

Referenced by GetCommands().

HandleNpcSetEntryCommand()

static bool npc_commandscript::HandleNpcSetEntryCommand ( ChatHandler *  handler, CreatureEntry  newEntryNum  )

inlinestatic

    {
        if (!newEntryNum)
            return false;
 
        Unit* unit = handler->getSelectedUnit();
        if (!unit || !unit->IsCreature())
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
        Creature* creature = unit->ToCreature();
        if (creature->UpdateEntry(newEntryNum))
            handler->SendSysMessage(LANG_DONE);
        else
            handler->SendSysMessage(LANG_ERROR);
        return true;
    }

References ChatHandler::getSelectedUnit(), Object::IsCreature(), LANG_DONE, LANG_ERROR, LANG_SELECT_CREATURE, ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), Object::ToCreature(), and Creature::UpdateEntry().

Referenced by GetCommands().

HandleNpcSetFactionIdCommand()

static bool npc_commandscript::HandleNpcSetFactionIdCommand ( ChatHandler *  handler, uint32  factionId  )

inlinestatic

    {
        if (!sFactionTemplateStore.LookupEntry(factionId))
        {
            handler->SendErrorMessage(LANG_WRONG_FACTION, factionId);
            return false;
        }
 
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            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
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_FACTION);
 
        stmt->SetData(0, uint16(factionId));
        stmt->SetData(1, creature->GetEntry());
 
        WorldDatabase.Execute(stmt);
 
        return true;
    }

References Creature::GetCreatureTemplate(), Object::GetEntry(), ChatHandler::getSelectedCreature(), LANG_SELECT_CREATURE, LANG_WRONG_FACTION, ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), Unit::SetFaction(), sFactionTemplateStore, WORLD_UPD_CREATURE_FACTION, and WorldDatabase.

Referenced by GetCommands().

HandleNpcSetFactionTempIdCommand()

static bool npc_commandscript::HandleNpcSetFactionTempIdCommand ( ChatHandler *  handler, uint32  tempfaction  )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
        Unit* unit = player->GetSelectedUnit();
 
        if (!unit)
            return false;
 
        Creature* creature = unit->ToCreature();
 
        if (!creature)
            return false;
 
        creature->SetFaction(tempfaction);
 
        return true;
    }

References WorldSession::GetPlayer(), Player::GetSelectedUnit(), ChatHandler::GetSession(), Unit::SetFaction(), and Object::ToCreature().

Referenced by GetCommands().

HandleNpcSetFlagCommand()

static bool npc_commandscript::HandleNpcSetFlagCommand ( ChatHandler *  handler, uint32  npcFlags  )

inlinestatic

    {
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->ReplaceAllNpcFlags(NPCFlags(npcFlags));
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_NPCFLAG);
 
        stmt->SetData(0, NPCFlags(npcFlags));
        stmt->SetData(1, creature->GetEntry());
 
        WorldDatabase.Execute(stmt);
 
        handler->SendSysMessage(LANG_VALUE_SAVED_REJOIN);
 
        return true;
    }

References Object::GetEntry(), ChatHandler::getSelectedCreature(), LANG_SELECT_CREATURE, LANG_VALUE_SAVED_REJOIN, Unit::ReplaceAllNpcFlags(), ChatHandler::SendErrorMessage(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), WORLD_UPD_CREATURE_NPCFLAG, and WorldDatabase.

Referenced by GetCommands().

HandleNpcSetLevelCommand()

static bool npc_commandscript::HandleNpcSetLevelCommand ( ChatHandler *  handler, uint8  lvl  )

inlinestatic

    {
        if (lvl < 1 || lvl > sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL) + 3)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        Creature* creature = handler->getSelectedCreature();
        if (!creature || creature->IsPet())
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->SetMaxHealth(100 + 30*lvl);
        creature->SetHealth(100 + 30*lvl);
        creature->SetLevel(lvl);
        creature->SaveToDB();
 
        return true;
    }

References CONFIG_MAX_PLAYER_LEVEL, ChatHandler::getSelectedCreature(), Unit::IsPet(), LANG_BAD_VALUE, LANG_SELECT_CREATURE, Creature::SaveToDB(), ChatHandler::SendErrorMessage(), Unit::SetHealth(), Unit::SetLevel(), Unit::SetMaxHealth(), and sWorld.

Referenced by GetCommands().

HandleNpcSetLinkCommand()

static bool npc_commandscript::HandleNpcSetLinkCommand ( ChatHandler *  handler, ObjectGuid::LowType  linkguid  )

inlinestatic

    {
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        if (!creature->GetSpawnId())
        {
            handler->SendErrorMessage("Selected creature {} isn't in creature table", creature->GetGUID().ToString());
            return false;
        }
 
        if (!sObjectMgr->SetCreatureLinkedRespawn(creature->GetSpawnId(), linkguid))
        {
            handler->SendErrorMessage("Selected creature can't link with guid '{}'", linkguid);
            return false;
        }
 
        handler->PSendSysMessage("LinkGUID '{}' added to creature with DBTableGUID: '{}'", linkguid, creature->GetSpawnId());
        return true;
    }

References Object::GetGUID(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), LANG_SELECT_CREATURE, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), sObjectMgr, and ObjectGuid::ToString().

Referenced by GetCommands().

HandleNpcSetModelCommand()

static bool npc_commandscript::HandleNpcSetModelCommand ( ChatHandler *  handler, uint32  displayId  )

inlinestatic

    {
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature || creature->IsPet())
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        if (!sCreatureDisplayInfoStore.LookupEntry(displayId))
        {
            handler->SendErrorMessage(LANG_COMMAND_FACTION_INVPARAM, Acore::ToString(displayId).c_str());
            return false;
        }
 
        creature->SetDisplayId(displayId);
        creature->SetNativeDisplayId(displayId);
        creature->SaveToDB();
 
        return true;
    }

References ChatHandler::getSelectedCreature(), Unit::IsPet(), LANG_COMMAND_FACTION_INVPARAM, LANG_SELECT_CREATURE, Creature::SaveToDB(), sCreatureDisplayInfoStore, ChatHandler::SendErrorMessage(), Creature::SetDisplayId(), Unit::SetNativeDisplayId(), and Acore::ToString().

Referenced by GetCommands().

HandleNpcSetMoveTypeCommand()

static bool npc_commandscript::HandleNpcSetMoveTypeCommand ( ChatHandler *  handler, Optional< CreatureSpawnId >  lowGuid, Variant< EXACT_SEQUENCE("stay"), EXACT_SEQUENCE("random"), EXACT_SEQUENCE("way")>  type, Optional< EXACT_SEQUENCE("nodel")>  nodel  )

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 wander_distance
• way - NPC will move with given waypoints set

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

    {
        // 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)
 
        bool doNotDelete = nodel.has_value();
 
        ObjectGuid::LowType lowguid = 0;
        Creature* creature = nullptr;
 
        if (!lowGuid)                                           // case .setmovetype $move_type (with selected creature)
        {
            creature = handler->getSelectedCreature();
            if (!creature || creature->IsPet())
                return false;
            lowguid = creature->GetSpawnId();
        }
        else                                                    // case .setmovetype #creature_guid $move_type (with selected creature)
        {
            lowguid = *lowGuid;
 
            if (lowguid)
                creature = handler->GetCreatureFromPlayerMapByDbGuid(lowguid);
 
            // attempt check creature existence by DB data
            if (!creature)
            {
                CreatureData const* data = sObjectMgr->GetCreatureData(lowguid);
                if (!data)
                {
                    handler->SendErrorMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
                    return false;
                }
            }
            else
            {
                lowguid = creature->GetSpawnId();
            }
        }
 
        // now lowguid is low guid really existed creature
        // and creature point (maybe) to this creature or nullptr
 
        MovementGeneratorType move_type;
        switch (type.index())
        {
            case 0:
                move_type = IDLE_MOTION_TYPE;
                break;
            case 1:
                move_type = RANDOM_MOTION_TYPE;
                break;
            case 2:
                move_type = WAYPOINT_MOTION_TYPE;
                break;
            default:
                return false;
        }
 
        // update movement type
        //if (doNotDelete == false)
        //    WaypointMgr.DeletePath(lowguid);
 
        if (creature)
        {
            // update movement type
            if (!doNotDelete)
                creature->LoadPath(0);
 
            creature->SetDefaultMovementType(move_type);
            creature->GetMotionMaster()->Initialize();
 
            if (creature->IsAlive())                            // dead creature will reset movement generator at respawn
            {
                creature->setDeathState(DeathState::JustDied);
                creature->Respawn();
            }
 
            creature->SaveToDB();
        }
 
        if (!doNotDelete)
        {
            handler->PSendSysMessage(LANG_MOVE_TYPE_SET, move_type);
        }
        else
        {
            handler->PSendSysMessage(LANG_MOVE_TYPE_SET_NODEL, move_type);
        }
 
        return true;
    }

References ChatHandler::GetCreatureFromPlayerMapByDbGuid(), Unit::GetMotionMaster(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), IDLE_MOTION_TYPE, MotionMaster::Initialize(), Unit::IsAlive(), Unit::IsPet(), JustDied, LANG_COMMAND_CREATGUIDNOTFOUND, LANG_MOVE_TYPE_SET, LANG_MOVE_TYPE_SET_NODEL, Creature::LoadPath(), ChatHandler::PSendSysMessage(), RANDOM_MOTION_TYPE, Creature::Respawn(), Creature::SaveToDB(), ChatHandler::SendErrorMessage(), Creature::setDeathState(), Creature::SetDefaultMovementType(), sObjectMgr, and WAYPOINT_MOTION_TYPE.

Referenced by GetCommands().

HandleNpcSetOriginalFaction()

static bool npc_commandscript::HandleNpcSetOriginalFaction ( ChatHandler *  handler )

inlinestatic

    {
        Player* player = handler->GetSession()->GetPlayer();
 
        if (!player)
            return false;
 
        if (!player->GetSelectedUnit())
            return false;
 
        Creature* creature = player->GetSelectedUnit()->ToCreature();
 
        if (!creature)
            return false;
 
        creature->RestoreFaction();
 
        return true;
    }

References WorldSession::GetPlayer(), Player::GetSelectedUnit(), ChatHandler::GetSession(), Unit::RestoreFaction(), and Object::ToCreature().

Referenced by GetCommands().

HandleNpcSetPhaseCommand()

static bool npc_commandscript::HandleNpcSetPhaseCommand ( ChatHandler *  handler, uint32  phasemask  )

inlinestatic

    {
        if (phasemask == 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        Creature* creature = handler->getSelectedCreature();
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->SetPhaseMask(phasemask, true);
 
        if (!creature->IsPet())
            creature->SaveToDB();
 
        return true;
    }

References ChatHandler::getSelectedCreature(), Unit::IsPet(), LANG_BAD_VALUE, LANG_SELECT_CREATURE, Creature::SaveToDB(), ChatHandler::SendErrorMessage(), and Unit::SetPhaseMask().

Referenced by GetCommands().

HandleNpcSetSpawnTimeCommand()

static bool npc_commandscript::HandleNpcSetSpawnTimeCommand ( ChatHandler *  handler, std::string  spawnTimeStr  )

inlinestatic

    {
        if (spawnTimeStr.empty())
        {
            return false;
        }
 
        if (Acore::StringTo<int32>(spawnTimeStr).value_or(0) < 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        Creature* creature = handler->getSelectedCreature();
        if (!creature)
            return false;
 
        int32 spawnTime = TimeStringToSecs(spawnTimeStr);
        if (spawnTime <= 0)
        {
            spawnTime = Acore::StringTo<int32>(spawnTimeStr).value_or(0);
        }
 
        if (spawnTime <= 0)
        {
            handler->SendErrorMessage(LANG_BAD_VALUE);
            return false;
        }
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_SPAWN_TIME_SECS);
        stmt->SetData(0, spawnTime);
        stmt->SetData(1, creature->GetSpawnId());
        WorldDatabase.Execute(stmt);
 
        creature->SetRespawnDelay(spawnTime);
        handler->PSendSysMessage(LANG_COMMAND_SPAWNTIME, secsToTimeString(spawnTime, true));
 
        return true;
    }

References ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), LANG_BAD_VALUE, LANG_COMMAND_SPAWNTIME, ChatHandler::PSendSysMessage(), secsToTimeString(), ChatHandler::SendErrorMessage(), PreparedStatementBase::SetData(), Creature::SetRespawnDelay(), TimeStringToSecs(), WORLD_UPD_CREATURE_SPAWN_TIME_SECS, and WorldDatabase.

Referenced by GetCommands().

HandleNpcSetWanderDistanceCommand()

static bool npc_commandscript::HandleNpcSetWanderDistanceCommand ( ChatHandler *  handler, float  option  )

inlinestatic

    {
        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 = 0;
 
        if (creature)
            guidLow = creature->GetSpawnId();
        else
            return false;
 
        creature->SetWanderDistance((float)option);
        creature->SetDefaultMovementType(mtype);
        creature->GetMotionMaster()->Initialize();
 
        if (creature->IsAlive())                                // dead creature will reset movement generator at respawn
        {
            creature->setDeathState(DeathState::JustDied);
            creature->Respawn();
        }
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_UPD_CREATURE_WANDER_DISTANCE);
 
        stmt->SetData(0, option);
        stmt->SetData(1, uint8(mtype));
        stmt->SetData(2, guidLow);
 
        WorldDatabase.Execute(stmt);
 
        handler->PSendSysMessage(LANG_COMMAND_WANDER_DISTANCE, option);
        return true;
    }

References Unit::GetMotionMaster(), ChatHandler::getSelectedCreature(), Creature::GetSpawnId(), IDLE_MOTION_TYPE, MotionMaster::Initialize(), Unit::IsAlive(), JustDied, LANG_BAD_VALUE, LANG_COMMAND_WANDER_DISTANCE, ChatHandler::PSendSysMessage(), RANDOM_MOTION_TYPE, Creature::Respawn(), ChatHandler::SendSysMessage(), PreparedStatementBase::SetData(), Creature::setDeathState(), Creature::SetDefaultMovementType(), Creature::SetWanderDistance(), WORLD_UPD_CREATURE_WANDER_DISTANCE, and WorldDatabase.

Referenced by GetCommands().

HandleNpcTameCommand()

static bool npc_commandscript::HandleNpcTameCommand ( ChatHandler *  handler )

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->IsExistPet())
        {
            handler->SendErrorMessage(LANG_YOU_ALREADY_HAVE_PET);
            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;
        }
 
        if (!player->CreatePet(creatureTarget))
        {
            handler->SendErrorMessage(LANG_CREATURE_NON_TAMEABLE, cInfo->Entry);
            return false;
        }
 
        return true;
    }

References Player::CanTameExoticPets(), Player::CreatePet(), CreatureTemplate::Entry, Creature::GetCreatureTemplate(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Player::IsExistPet(), Unit::IsPet(), CreatureTemplate::IsTameable(), LANG_CREATURE_NON_TAMEABLE, LANG_SELECT_CREATURE, LANG_YOU_ALREADY_HAVE_PET, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and ChatHandler::SetSentErrorMessage().

Referenced by GetCommands().

HandleNpcTextEmoteCommand()

static bool npc_commandscript::HandleNpcTextEmoteCommand ( ChatHandler *  handler, Tail  text  )

inlinestatic

    {
        if (text.empty())
            return false;
 
        Creature* creature = handler->getSelectedCreature();
 
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->TextEmote(text);
 
        return true;
    }

References ChatHandler::getSelectedCreature(), LANG_SELECT_CREATURE, ChatHandler::SendErrorMessage(), and Unit::TextEmote().

Referenced by GetCommands().

HandleNpcUnFollowCommand()

static bool npc_commandscript::HandleNpcUnFollowCommand ( ChatHandler *  handler )

inlinestatic

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

References FOLLOW_MOTION_TYPE, MotionMaster::GetCurrentMovementGeneratorType(), Unit::GetMotionMaster(), WorldObject::GetName(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), FollowMovementGenerator< T >::GetTarget(), LANG_CREATURE_NOT_FOLLOW_YOU, LANG_CREATURE_NOT_FOLLOW_YOU_NOW, LANG_SELECT_CREATURE, MotionMaster::MovementExpired(), ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and MotionMaster::top().

Referenced by GetCommands().

HandleNpcWhisperCommand()

static bool npc_commandscript::HandleNpcWhisperCommand ( ChatHandler *  handler, std::string const &  recv, Tail  text  )

inlinestatic

    {
        if (text.empty())
            return false;
 
        Creature* creature = handler->getSelectedCreature();
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        // check online security
        Player* receiver = ObjectAccessor::FindPlayerByName(recv);
        if (handler->HasLowerSecurity(receiver, ObjectGuid::Empty))
            return false;
 
        creature->Whisper(text, LANG_UNIVERSAL, receiver);
        return true;
    }

References ObjectGuid::Empty, ObjectAccessor::FindPlayerByName(), ChatHandler::getSelectedCreature(), ChatHandler::HasLowerSecurity(), LANG_SELECT_CREATURE, LANG_UNIVERSAL, ChatHandler::SendErrorMessage(), and Unit::Whisper().

Referenced by GetCommands().

HandleNpcYellCommand()

static bool npc_commandscript::HandleNpcYellCommand ( ChatHandler *  handler, Tail  text  )

inlinestatic

    {
        if (text.empty())
            return false;
 
        Creature* creature = handler->getSelectedCreature();
        if (!creature)
        {
            handler->SendErrorMessage(LANG_SELECT_CREATURE);
            return false;
        }
 
        creature->Yell(text, LANG_UNIVERSAL);
 
        // make an emote
        creature->HandleEmoteCommand(EMOTE_ONESHOT_SHOUT);
 
        return true;
    }

References EMOTE_ONESHOT_SHOUT, ChatHandler::getSelectedCreature(), Unit::HandleEmoteCommand(), LANG_SELECT_CREATURE, LANG_UNIVERSAL, ChatHandler::SendErrorMessage(), and Unit::Yell().

Referenced by GetCommands().

---

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

• azerothcore-wotlk/src/server/scripts/Commands/cs_npc.cpp