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 ()
std::string const &	GetName () const
uint16	GetTotalAvailableHooks ()

Static Private Member Functions
static char const *	StatusTag (bool active)
static SpawnedPoolData const *	GetPoolSpawns (ChatHandler *handler, PoolTemplateData const *tpl)
static void	ListPoolMembers (ChatHandler *handler, char const *typeName, std::vector< PoolObject > const &explicitly, std::vector< PoolObject > const &equal, bool isCreature, SpawnedPoolData const *spawns)
static bool	HandlePoolInfoCommand (ChatHandler *handler, uint32 poolId)
static bool	HandlePoolLookupCommand (ChatHandler *handler)

Additional Inherited Members
Protected Member Functions inherited from CommandScript
	CommandScript (char const *name)
Protected Member Functions inherited from ScriptObject
	ScriptObject (char const *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,    rbac::RBAC_PERM_COMMAND_POOL_INFO,   Console::Yes },
            { "lookup",  HandlePoolLookupCommand,  rbac::RBAC_PERM_COMMAND_POOL_LOOKUP, Console::No  },
        };
        static ChatCommandTable commandTable =
        {
            { "pool", poolCommandTable }
        };
        return commandTable;
    }

References HandlePoolInfoCommand(), HandlePoolLookupCommand(), rbac::RBAC_PERM_COMMAND_POOL_INFO, and rbac::RBAC_PERM_COMMAND_POOL_LOOKUP.

GetPoolSpawns()

static SpawnedPoolData const * pool_commandscript::GetPoolSpawns ( ChatHandler *  handler, PoolTemplateData const *  tpl  )

inlinestaticprivate

    {
        if (tpl->MapId == -1)
            return nullptr;
 
        if (Player* player = handler->GetPlayer())
            if (player->GetMap()->GetId() == uint32(tpl->MapId))
                return &player->GetMap()->GetPoolData();
 
        if (Map* map = sMapMgr->FindMap(uint32(tpl->MapId), 0))
            if (!map->Instanceable())
                return &map->GetPoolData();
 
        return nullptr;
    }

References SpawnedPoolData::GetMap(), ChatHandler::GetPlayer(), Map::GetPoolData(), PoolTemplateData::MapId, and sMapMgr.

Referenced by HandlePoolInfoCommand().

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;
        }
 
        SpawnedPoolData const* spawns = GetPoolSpawns(handler, tpl);
 
        uint32 activeCount = sPoolMgr->GetQuestSpawnedData().GetSpawnedObjects(poolId);
        if (spawns)
            activeCount += spawns->GetSpawnedObjects(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, spawns);
        }
 
        // GameObject members
        if (PoolGroup<GameObject> const* goGroup = sPoolMgr->GetPoolGameObjectGroup(poolId))
        {
            if (!goGroup->IsEmpty())
                ListPoolMembers(handler, "GameObjects",
                    goGroup->GetExplicitlyChanced(), goGroup->GetEqualChanced(), false, spawns);
        }
 
        // 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 = spawns && spawns->IsSpawnedObject<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, GetPoolSpawns(), SpawnedPoolData::GetSpawnedObjects(), SpawnedPoolData::IsSpawnedObject(), 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 = target->GetMap()->GetPoolData().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 = goTarget->GetMap()->GetPoolData().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::GetMap(), WorldObject::GetName(), ChatHandler::GetNearbyGameObject(), WorldSession::GetPlayer(), Map::GetPoolData(), ChatHandler::getSelectedCreature(), ChatHandler::GetSession(), Creature::GetSpawnId(), GameObject::GetSpawnId(), SpawnedPoolData::IsSpawnedObject(), 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, SpawnedPoolData const *  spawns  )

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 = spawns && (isCreature
                ? spawns->IsSpawnedObject<Creature>(obj.guid)
                : spawns->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->id;
                    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 SpawnedPoolData::IsSpawnedObject(), LANG_POOL_INFO_MEMBER, LANG_POOL_INFO_MEMBERS_HEADER, ChatHandler::PSendSysMessage(), sObjectMgr, 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