pool_commandscript Class Reference

Inheritance diagram for pool_commandscript:

Public Member Functions
	pool_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 Private Member Functions
static char const *	StatusTag (bool active)
static void	ListPoolMembers (ChatHandler *handler, char const *typeName, std::vector< PoolObject > const &explicitly, std::vector< PoolObject > const &equal, bool isCreature)
static bool	HandlePoolInfoCommand (ChatHandler *handler, uint32 poolId)
static bool	HandlePoolLookupCommand (ChatHandler *handler)

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

Detailed Description

Constructor & Destructor Documentation

pool_commandscript()

pool_commandscript::pool_commandscript ( )

inline

: CommandScript("pool_commandscript") { }

Member Function Documentation

GetCommands()

ChatCommandTable pool_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable poolCommandTable =
        {
            { "info",    HandlePoolInfoCommand,    SEC_GAMEMASTER, Console::Yes },
            { "lookup",  HandlePoolLookupCommand,  SEC_GAMEMASTER, Console::No  },
        };
        static ChatCommandTable commandTable =
        {
            { "pool", poolCommandTable }
        };
        return commandTable;
    }

References HandlePoolInfoCommand(), HandlePoolLookupCommand(), and SEC_GAMEMASTER.

HandlePoolInfoCommand()

static bool pool_commandscript::HandlePoolInfoCommand ( ChatHandler *  handler, uint32  poolId  )

inlinestaticprivate

    {
        PoolTemplateData const* tpl = sPoolMgr->GetPoolTemplate(poolId);
        if (!tpl)
        {
            handler->PSendSysMessage(LANG_POOL_NOT_FOUND, poolId);
            handler->SetSentErrorMessage(true);
            return false;
        }
 
        uint32 activeCount = sPoolMgr->GetSpawnedData().GetActiveObjectCount(poolId);
        handler->PSendSysMessage(LANG_POOL_INFO_HEADER, poolId,
            tpl->Description.empty() ? "(none)" : tpl->Description,
            tpl->MaxLimit, activeCount);
 
        // Show parent pool if nested
        uint32 parentPool = sPoolMgr->IsPartOfAPool<Pool>(poolId);
        if (parentPool)
            handler->PSendSysMessage("  Parent pool: {}", parentPool);
 
        // Creature members
        if (PoolGroup<Creature> const* creGroup = sPoolMgr->GetPoolCreatureGroup(poolId))
        {
            if (!creGroup->IsEmpty())
                ListPoolMembers(handler, "Creatures",
                    creGroup->GetExplicitlyChanced(), creGroup->GetEqualChanced(), true);
        }
 
        // GameObject members
        if (PoolGroup<GameObject> const* goGroup = sPoolMgr->GetPoolGameObjectGroup(poolId))
        {
            if (!goGroup->IsEmpty())
                ListPoolMembers(handler, "GameObjects",
                    goGroup->GetExplicitlyChanced(), goGroup->GetEqualChanced(), false);
        }
 
        // Sub-pool members
        if (PoolGroup<Pool> const* poolGroup = sPoolMgr->GetPoolPoolGroup(poolId))
        {
            auto const& explicitly = poolGroup->GetExplicitlyChanced();
            auto const& equal = poolGroup->GetEqualChanced();
            if (!explicitly.empty() || !equal.empty())
            {
                uint32 total = explicitly.size() + equal.size();
                handler->PSendSysMessage(LANG_POOL_INFO_SUBPOOLS_HEADER, total);
 
                auto printSubPool = [&](PoolObject const& obj)
                {
                    bool active = sPoolMgr->GetSpawnedData().IsActiveObject<Pool>(obj.guid);
                    PoolTemplateData const* subTpl = sPoolMgr->GetPoolTemplate(obj.guid);
                    std::string desc = subTpl ? subTpl->Description : "Unknown";
 
                    handler->PSendSysMessage(LANG_POOL_INFO_SUBPOOL,
                        StatusTag(active), obj.guid, desc);
                };
 
                for (auto const& obj : explicitly)
                    printSubPool(obj);
                for (auto const& obj : equal)
                    printSubPool(obj);
            }
        }
 
        return true;
    }

References PoolTemplateData::Description, LANG_POOL_INFO_HEADER, LANG_POOL_INFO_SUBPOOL, LANG_POOL_INFO_SUBPOOLS_HEADER, LANG_POOL_NOT_FOUND, ListPoolMembers(), PoolTemplateData::MaxLimit, ChatHandler::PSendSysMessage(), ChatHandler::SetSentErrorMessage(), sPoolMgr, and StatusTag().

Referenced by GetCommands().

HandlePoolLookupCommand()

static bool pool_commandscript::HandlePoolLookupCommand ( ChatHandler *  handler )

inlinestaticprivate

    {
        Player* player = handler->GetSession()->GetPlayer();
        if (!player)
            return false;
 
        // Check targeted creature
        Creature* target = handler->getSelectedCreature();
        if (target && target->GetSpawnId())
        {
            uint32 spawnId = target->GetSpawnId();
            uint32 poolId = sPoolMgr->GetCreaturePoolId(spawnId);
            if (poolId)
            {
                bool spawned = sPoolMgr->IsSpawnedObject<Creature>(spawnId);
                handler->PSendSysMessage(LANG_POOL_LOOKUP_IN_POOL,
                    target->GetName(), spawnId, poolId, StatusTag(spawned));
                handler->PSendSysMessage(LANG_POOL_LOOKUP_USE_INFO, poolId);
            }
            else
                handler->PSendSysMessage(LANG_POOL_LOOKUP_NOT_IN_POOL,
                    target->GetName(), spawnId);
 
            return true;
        }
 
        // Check nearby gameobject
        GameObject* goTarget = handler->GetNearbyGameObject();
        if (goTarget && goTarget->GetSpawnId())
        {
            uint32 spawnId = goTarget->GetSpawnId();
            uint32 poolId = sPoolMgr->GetGameObjectPoolId(spawnId);
            if (poolId)
            {
                bool spawned = sPoolMgr->IsSpawnedObject<GameObject>(spawnId);
                handler->PSendSysMessage(LANG_POOL_LOOKUP_IN_POOL,
                    goTarget->GetName(), spawnId, poolId, StatusTag(spawned));
                handler->PSendSysMessage(LANG_POOL_LOOKUP_USE_INFO, poolId);
            }
            else
                handler->PSendSysMessage(LANG_POOL_LOOKUP_NOT_IN_POOL,
                    goTarget->GetName(), spawnId);
 
            return true;
        }
 
        handler->SendSysMessage(LANG_POOL_LOOKUP_NOTARGET);
        handler->SetSentErrorMessage(true);
        return false;
    }

References WorldObject::GetName(), ChatHandler::GetNearbyGameObject(), WorldSession::GetPlayer(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetSpawnId(), GameObject::GetSpawnId(), LANG_POOL_LOOKUP_IN_POOL, LANG_POOL_LOOKUP_NOT_IN_POOL, LANG_POOL_LOOKUP_NOTARGET, LANG_POOL_LOOKUP_USE_INFO, ChatHandler::PSendSysMessage(), ChatHandler::SendSysMessage(), ChatHandler::SetSentErrorMessage(), sPoolMgr, and StatusTag().

Referenced by GetCommands().

ListPoolMembers()

static void pool_commandscript::ListPoolMembers ( ChatHandler *  handler, char const *  typeName, std::vector< PoolObject > const &  explicitly, std::vector< PoolObject > const &  equal, bool  isCreature  )

inlinestaticprivate

    {
        if (explicitly.empty() && equal.empty())
            return;
 
        uint32 total = explicitly.size() + equal.size();
        handler->PSendSysMessage(LANG_POOL_INFO_MEMBERS_HEADER, typeName, total);
 
        auto printMember = [&](PoolObject const& obj)
        {
            bool spawned = isCreature
                ? sPoolMgr->IsSpawnedObject<Creature>(obj.guid)
                : sPoolMgr->IsSpawnedObject<GameObject>(obj.guid);
 
            std::string name = "Unknown";
            uint32 entry = 0;
            uint32 mapId = 0;
            float x = 0, y = 0, z = 0;
 
            if (isCreature)
            {
                if (CreatureData const* data = sObjectMgr->GetCreatureData(obj.guid))
                {
                    entry = data->id1;
                    mapId = data->mapid;
                    x = data->posX;
                    y = data->posY;
                    z = data->posZ;
                    if (CreatureTemplate const* tpl = sObjectMgr->GetCreatureTemplate(entry))
                        name = tpl->Name;
                }
            }
            else
            {
                if (GameObjectData const* data = sObjectMgr->GetGameObjectData(obj.guid))
                {
                    entry = data->id;
                    mapId = data->mapid;
                    x = data->posX;
                    y = data->posY;
                    z = data->posZ;
                    if (GameObjectTemplate const* tpl = sObjectMgr->GetGameObjectTemplate(entry))
                        name = tpl->name;
                }
            }
 
            handler->PSendSysMessage(LANG_POOL_INFO_MEMBER,
                StatusTag(spawned), obj.guid, name, entry, mapId, x, y, z);
        };
 
        for (auto const& obj : explicitly)
            printMember(obj);
        for (auto const& obj : equal)
            printMember(obj);
    }

References LANG_POOL_INFO_MEMBER, LANG_POOL_INFO_MEMBERS_HEADER, ChatHandler::PSendSysMessage(), sObjectMgr, sPoolMgr, and StatusTag().

Referenced by HandlePoolInfoCommand().

StatusTag()

static char const * pool_commandscript::StatusTag ( bool  active )

inlinestaticprivate

    {
        return active ? "ACTIVE" : "inactive";
    }

Referenced by HandlePoolInfoCommand(), HandlePoolLookupCommand(), and ListPoolMembers().

---

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

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