pooltools_commandscript Class Reference

Inheritance diagram for pooltools_commandscript:

Public Member Functions
	pooltools_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	HandlePoolStart (ChatHandler *handler, std::string description)
static bool	HandlePoolDef (ChatHandler *handler, Tail args)
static bool	HandlePoolAdd (ChatHandler *handler, Optional< float > radiusArg)
static bool	HandlePoolRemove (ChatHandler *handler)
static bool	HandlePoolEnd (ChatHandler *handler)
static bool	HandlePoolClear (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

pooltools_commandscript()

pooltools_commandscript::pooltools_commandscript ( )

inline

: CommandScript("pooltools_commandscript") {}

Member Function Documentation

GetCommands()

ChatCommandTable pooltools_commandscript::GetCommands ( ) const

inlineoverridevirtual

Implements CommandScript.

    {
        static ChatCommandTable poolToolsCommandTable =
        {
            { "start",  HandlePoolStart,  SEC_ADMINISTRATOR, Console::No },
            { "def",    HandlePoolDef,    SEC_ADMINISTRATOR, Console::No },
            { "add",    HandlePoolAdd,    SEC_ADMINISTRATOR, Console::No },
            { "remove", HandlePoolRemove, SEC_ADMINISTRATOR, Console::No },
            { "end",    HandlePoolEnd,    SEC_ADMINISTRATOR, Console::No },
            { "clear",  HandlePoolClear,  SEC_ADMINISTRATOR, Console::No }
        };
 
        static ChatCommandTable commandTable =
        {
            { "pooltools", poolToolsCommandTable }
        };
        return commandTable;
    }

References HandlePoolAdd(), HandlePoolClear(), HandlePoolDef(), HandlePoolEnd(), HandlePoolRemove(), HandlePoolStart(), and SEC_ADMINISTRATOR.

HandlePoolAdd()

static bool pooltools_commandscript::HandlePoolAdd ( ChatHandler *  handler, Optional< float >  radiusArg  )

inlinestatic

    {
        ObjectGuid playerGuid = handler->GetPlayer()->GetGUID();
        if (PoolSessions.find(playerGuid) == PoolSessions.end())
            return false;
 
        PoolSession& session = PoolSessions[playerGuid];
        if (session.CurrentTemplate.empty())
        {
            handler->SendErrorMessage("Define a template first with .pooltools def");
            return false;
        }
 
        Player* player = handler->GetPlayer();
        float const radius = radiusArg.value_or(5.0f);
 
        float searchX = player->GetPositionX();
        float searchY = player->GetPositionY();
        float searchZ = player->GetPositionZ();
 
        GameObject* target = handler->GetNearbyGameObject();
        if (radius <= 10.0f && target)
        {
            searchX = target->GetPositionX();
            searchY = target->GetPositionY();
            searchZ = target->GetPositionZ();
        }
 
        std::list<GameObject*> nearbyGOs;
        Acore::GameObjectInRangeCheck check(searchX, searchY, searchZ, radius);
        Acore::GameObjectListSearcher<Acore::GameObjectInRangeCheck> searcher(player, nearbyGOs, check);
        Cell::VisitObjects(player, searcher, radius);
 
        int addedCount = 0;
        int newGroupsCount = 0;
 
        for (GameObject* go : nearbyGOs)
        {
            if (go->GetDistance(searchX, searchY, searchZ) > radius)
                continue;
 
            bool isTemplateMatch = false;
            for (auto const& tpl : session.CurrentTemplate)
            {
                if (go->GetEntry() == tpl.Entry)
                {
                    isTemplateMatch = true;
                    break;
                }
            }
            if (!isTemplateMatch)
                continue;
 
            uint32 const spawnId = go->GetSpawnId();
 
            bool alreadyCaptured = false;
            for (auto const& group : session.CapturedGroups)
            {
                for (auto const& obj : group.FoundObjects)
                {
                    if (obj.second == spawnId)
                    {
                        alreadyCaptured = true;
                        break;
                    }
                }
                if (alreadyCaptured)
                    break;
            }
            if (alreadyCaptured)
                continue;
 
            // Clustering
            NodeGroup* existingGroup = nullptr;
            for (auto& group : session.CapturedGroups)
            {
                if (go->GetDistance(group.X, group.Y, group.Z) < 0.1f)
                {
                    existingGroup = &group;
                    break;
                }
            }
 
            if (existingGroup)
            {
                existingGroup->FoundObjects.push_back({ go->GetEntry(), spawnId });
                addedCount++;
            }
            else
            {
                NodeGroup newGroup;
                newGroup.X = go->GetPositionX();
                newGroup.Y = go->GetPositionY();
                newGroup.Z = go->GetPositionZ();
                newGroup.FoundObjects.push_back({ go->GetEntry(), spawnId });
 
                session.CapturedGroups.push_back(newGroup);
                newGroupsCount++;
                addedCount++;
            }
        }
 
        if (addedCount == 0)
        {
            handler->SendErrorMessage("No new matching objects found in {}y radius.", radius);
            return false;
        }
 
        handler->PSendSysMessage("|cff00ff00Scan Complete.|r Added {} objects into {} new groups.", addedCount, newGroupsCount);
 
        if (!session.CapturedGroups.empty())
        {
            NodeGroup& lastGroup = session.CapturedGroups.back();
            for (auto& p : lastGroup.FoundObjects)
            {
                handler->PSendSysMessage(" - Entry {} (GUID: {})", p.first, p.second);
            }
        }
        return true;
    }

References PoolSession::CapturedGroups, PoolSession::CurrentTemplate, NodeGroup::FoundObjects, Object::GetGUID(), ChatHandler::GetNearbyGameObject(), ChatHandler::GetPlayer(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), PoolSessions, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), Cell::VisitObjects(), NodeGroup::X, NodeGroup::Y, and NodeGroup::Z.

Referenced by GetCommands().

HandlePoolClear()

static bool pooltools_commandscript::HandlePoolClear ( ChatHandler *  handler )

inlinestatic

    {
        PoolSessions.erase(handler->GetPlayer()->GetGUID());
        handler->PSendSysMessage("Session cleared.");
        return true;
    }

References Object::GetGUID(), ChatHandler::GetPlayer(), PoolSessions, and ChatHandler::PSendSysMessage().

Referenced by GetCommands().

HandlePoolDef()

static bool pooltools_commandscript::HandlePoolDef ( ChatHandler *  handler, Tail  args  )

inlinestatic

    {
        ObjectGuid playerGuid = handler->GetPlayer()->GetGUID();
        if (PoolSessions.find(playerGuid) == PoolSessions.end())
        {
            handler->SendErrorMessage("No active session.");
            return false;
        }
 
        std::vector<std::string_view> tokens = Acore::Tokenize(args, ' ', false);
 
        if (tokens.empty() || tokens.size() % 2 != 0)
        {
            handler->SendErrorMessage("Invalid syntax. Usage: .pooltools def [ID] [Chance] [ID] [Chance]...");
            return false;
        }
 
        std::vector<PoolTemplateItem> newTemplate;
        for (size_t i = 0; i < tokens.size(); i += 2)
        {
            uint32 const entry = Acore::StringTo<uint32>(tokens[i]).value_or(0);
            uint32 const chance = Acore::StringTo<uint32>(tokens[i + 1]).value_or(0);
 
            if (entry == 0)
                continue;
 
            newTemplate.push_back({ entry, chance });
        }
 
        PoolSessions[playerGuid].CurrentTemplate = newTemplate;
        handler->PSendSysMessage("Template Defined ({} items).", newTemplate.size());
        return true;
    }

References Object::GetGUID(), ChatHandler::GetPlayer(), PoolSessions, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and Acore::Tokenize().

Referenced by GetCommands().

HandlePoolEnd()

static bool pooltools_commandscript::HandlePoolEnd ( ChatHandler *  handler )

inlinestatic

    {
        ObjectGuid playerGuid = handler->GetPlayer()->GetGUID();
        auto it = PoolSessions.find(playerGuid);
        if (it == PoolSessions.end())
            return false;
 
        PoolSession& session = it->second; // Use reference from iterator
 
        auto EscapeSQL = [](std::string_view input) -> std::string {
            std::string safe;
            safe.reserve(input.size());
            for (char c : input)
            {
                if (c == '\'')
                    safe += "\\'";
                else
                    safe += c;
            }
            return safe;
        };
 
        bool const complexPool = (session.CurrentTemplate.size() > 1);
 
        // SQL Variables and Header
        LOG_DEBUG("sql.dev", "-- Pool Dump: {}", session.ZoneName);
        LOG_DEBUG("sql.dev", "SET @mother_pool := @mother_pool+1;");
 
        if (complexPool)
            LOG_DEBUG("sql.dev", "SET @pool_node := @pool_node+1;");
 
        LOG_DEBUG("sql.dev", "SET @max_limit   := {};", (session.CapturedGroups.size() + 3) / 4);
 
        // DELETEs section
        if (!session.CapturedGroups.empty())
        {
            LOG_DEBUG("sql.dev", "-- Cleanup specific object links");
            LOG_DEBUG("sql.dev", "DELETE FROM `pool_gameobject` WHERE `guid` IN (");
 
            std::vector<std::string> guidList;
            for (auto const& group : session.CapturedGroups)
                for (auto const& obj : group.FoundObjects)
                    guidList.push_back(std::to_string(obj.second));
 
            LOG_DEBUG("sql.dev", fmt::format("{}", fmt::join(guidList, ", ")));
            LOG_DEBUG("sql.dev", ");\n");
        }
 
        LOG_DEBUG("sql.dev", "DELETE FROM `pool_template` WHERE `entry`=@mother_pool;");
        LOG_DEBUG("sql.dev", "INSERT INTO `pool_template` (`entry`, `max_limit`, `description`) VALUES (@mother_pool, @max_limit, '{} - Mother Pool');", EscapeSQL(session.ZoneName));
 
        int groupCounter = 0;
 
        // We can buffer the simple bulk inserts here
        std::vector<std::string> bulkInserts;
 
        for (auto const& group : session.CapturedGroups)
        {
            groupCounter++;
 
            // Generate Description
            std::set<std::string> uniqueNames;
            for (auto const& obj : group.FoundObjects)
            {
                GameObjectTemplate const* goInfo = sObjectMgr->GetGameObjectTemplate(obj.first);
                uniqueNames.insert(goInfo ? goInfo->name : std::to_string(obj.first));
            }
 
            std::string groupDesc = fmt::format("{}", fmt::join(uniqueNames, " / "));
            std::string safeGroupDesc = EscapeSQL(groupDesc);
 
            // Simple pooling
            if (!complexPool)
            {
                for (auto const& obj : group.FoundObjects)
                {
                    float chance = 0.0f;
                    for (auto const& tpl : session.CurrentTemplate)
                        if (tpl.Entry == obj.first)
                            chance = (float)tpl.Chance;
 
                    bulkInserts.push_back(fmt::format("({}, @mother_pool, {}, '{} - {}')",
                        obj.second, chance, EscapeSQL(session.ZoneName), safeGroupDesc));
                }
            }
            // Pool_pool integration
            else
            {
                LOG_DEBUG("sql.dev", "-- Group {}", groupCounter);
                LOG_DEBUG("sql.dev", "SET @pool_node := @pool_node + 1;");
 
                // Create the Sub-Pool Node
                LOG_DEBUG("sql.dev", "INSERT INTO `pool_template` (`entry`, `max_limit`, `description`) VALUES (@pool_node, 1, '{} - Node {}');", EscapeSQL(session.ZoneName), groupCounter);
 
                // Link Node to Mother Pool
                LOG_DEBUG("sql.dev", "INSERT INTO `pool_pool` (`pool_id`, `mother_pool`, `chance`, `description`) VALUES (@pool_node, @mother_pool, 0, '{} - {}');", EscapeSQL(session.ZoneName), safeGroupDesc);
 
                // Link Objects to Sub-Pool Node
                LOG_DEBUG("sql.dev", "INSERT INTO `pool_gameobject` (`guid`, `pool_entry`, `chance`, `description`) VALUES");
 
                std::vector<std::string> nodeInserts;
                for (auto const& obj : group.FoundObjects)
                {
                    GameObjectTemplate const* goInfo = sObjectMgr->GetGameObjectTemplate(obj.first);
                    std::string objName = goInfo ? goInfo->name : "Unknown";
 
                    float chance = 0.0f;
                    for (auto const& tpl : session.CurrentTemplate)
                        if (tpl.Entry == obj.first) chance = (float)tpl.Chance;
 
                    nodeInserts.push_back(fmt::format("({}, @pool_node, {}, '{} - {}')",
                        obj.second, chance, EscapeSQL(session.ZoneName), EscapeSQL(objName)));
                }
                LOG_DEBUG("sql.dev", "{};", fmt::join(nodeInserts, ",\n"));
            }
        }
 
        if (!complexPool && !bulkInserts.empty())
        {
            LOG_DEBUG("sql.dev", "INSERT INTO `pool_gameobject` (`guid`, `pool_entry`, `chance`, `description`) VALUES");
            LOG_DEBUG("sql.dev", "{};", fmt::join(bulkInserts, ",\n"));
        }
 
        handler->PSendSysMessage("Dumped {} groups.", groupCounter);
 
        // Cleanup
        PoolSessions.erase(it);
        return true;
    }

References PoolSession::CapturedGroups, PoolSession::CurrentTemplate, Object::GetGUID(), ChatHandler::GetPlayer(), LOG_DEBUG, GameObjectTemplate::name, PoolSessions, ChatHandler::PSendSysMessage(), sObjectMgr, and PoolSession::ZoneName.

Referenced by GetCommands().

HandlePoolRemove()

static bool pooltools_commandscript::HandlePoolRemove ( ChatHandler *  handler )

inlinestatic

    {
        ObjectGuid const playerGuid = handler->GetPlayer()->GetGUID();
        if (PoolSessions.find(playerGuid) == PoolSessions.end())
        {
            handler->SendErrorMessage("No active session.");
            return false;
        }
 
        PoolSession& session = PoolSessions[playerGuid];
 
        if (session.CapturedGroups.empty())
        {
            handler->SendErrorMessage("No groups captured.");
            return false;
        }
 
        NodeGroup removed = session.CapturedGroups.back();
        session.CapturedGroups.pop_back();
 
        handler->PSendSysMessage("|cffff0000Undo Successful.|r Removed last group containing {} objects.", removed.FoundObjects.size());
        return true;
    }

References PoolSession::CapturedGroups, NodeGroup::FoundObjects, Object::GetGUID(), ChatHandler::GetPlayer(), PoolSessions, ChatHandler::PSendSysMessage(), and ChatHandler::SendErrorMessage().

Referenced by GetCommands().

HandlePoolStart()

static bool pooltools_commandscript::HandlePoolStart ( ChatHandler *  handler, std::string  description  )

inlinestatic

    {
        ObjectGuid const playerGuid = handler->GetPlayer()->GetGUID();
 
        if (PoolSessions.find(playerGuid) != PoolSessions.end())
        {
            handler->SendErrorMessage("Session already active. Use .pooltools clear first.");
            return false;
        }
 
        PoolSession session;
        session.ZoneName = description;
 
        PoolSessions[playerGuid] = session;
 
        handler->PSendSysMessage("|cff00ff00Pool Session Started.|r Description: {}", description);
        return true;
    }

References Object::GetGUID(), ChatHandler::GetPlayer(), PoolSessions, ChatHandler::PSendSysMessage(), ChatHandler::SendErrorMessage(), and PoolSession::ZoneName.

Referenced by GetCommands().

---

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

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