PoolMgr Class Reference

#include "PoolMgr.h"

Public Member Functions
void	LoadFromDB ()
void	LoadQuestPools ()
void	SaveQuestsToDB (bool daily, bool weekly, bool other)
void	Initialize ()
template<typename T >
uint32	IsPartOfAPool (uint32 db_guid_or_pool_id) const
template<typename T >
bool	IsSpawnedObject (uint32 db_guid_or_pool_id) const
bool	CheckPool (uint32 pool_id) const
void	SpawnPool (uint32 pool_id)
void	DespawnPool (uint32 pool_id)
template<typename T >
void	UpdatePool (uint32 pool_id, uint32 db_guid_or_pool_id)
void	ChangeDailyQuests ()
void	ChangeWeeklyQuests ()
void	ReSpawnPoolQuests ()
PoolTemplateData const *	GetPoolTemplate (uint32 poolId) const
PoolGroup< Creature > const *	GetPoolCreatureGroup (uint32 poolId) const
PoolGroup< GameObject > const *	GetPoolGameObjectGroup (uint32 poolId) const
PoolGroup< Pool > const *	GetPoolPoolGroup (uint32 poolId) const
ActivePoolData const &	GetSpawnedData () const
uint32	GetCreaturePoolId (uint32 guid) const
uint32	GetGameObjectPoolId (uint32 guid) const
template<>
uint32	IsPartOfAPool (uint32 db_guid) const
template<>
uint32	IsPartOfAPool (uint32 db_guid) const
template<>
uint32	IsPartOfAPool (uint32 questId) const
template<>
uint32	IsPartOfAPool (uint32 pool_id) const

Static Public Member Functions
static PoolMgr *	instance ()

Public Attributes
PooledQuestRelation	mQuestCreatureRelation
PooledQuestRelation	mQuestGORelation

Private Types
typedef std::unordered_map< uint32, PoolTemplateData >	PoolTemplateDataMap
typedef std::unordered_map< uint32, PoolGroup< Creature > >	PoolGroupCreatureMap
typedef std::unordered_map< uint32, PoolGroup< GameObject > >	PoolGroupGameObjectMap
typedef std::unordered_map< uint32, PoolGroup< Pool > >	PoolGroupPoolMap
typedef std::unordered_map< uint32, PoolGroup< Quest > >	PoolGroupQuestMap
typedef std::pair< uint32, uint32 >	SearchPair
typedef std::map< uint32, uint32 >	SearchMap

Private Member Functions
	PoolMgr ()
	~PoolMgr ()
template<typename T >
void	SpawnPool (uint32 pool_id, uint32 db_guid_or_pool_id)
template<>
void	SpawnPool (uint32 pool_id, uint32 db_guid)
template<>
void	SpawnPool (uint32 pool_id, uint32 db_guid)
template<>
void	SpawnPool (uint32 pool_id, uint32 sub_pool_id)
template<>
void	SpawnPool (uint32 pool_id, uint32 quest_id)

Private Attributes
PoolTemplateDataMap	mPoolTemplate
PoolGroupCreatureMap	mPoolCreatureGroups
PoolGroupGameObjectMap	mPoolGameobjectGroups
PoolGroupPoolMap	mPoolPoolGroups
PoolGroupQuestMap	mPoolQuestGroups
SearchMap	mCreatureSearchMap
SearchMap	mGameobjectSearchMap
SearchMap	mPoolSearchMap
SearchMap	mQuestSearchMap
ActivePoolData	mSpawnedData

Friends
class	PoolQuestReloadFixTest

Detailed Description

Member Typedef Documentation

PoolGroupCreatureMap

typedef std::unordered_map<uint32, PoolGroup<Creature> > PoolMgr::PoolGroupCreatureMap

private

PoolGroupGameObjectMap

typedef std::unordered_map<uint32, PoolGroup<GameObject> > PoolMgr::PoolGroupGameObjectMap

private

PoolGroupPoolMap

typedef std::unordered_map<uint32, PoolGroup<Pool> > PoolMgr::PoolGroupPoolMap

private

PoolGroupQuestMap

typedef std::unordered_map<uint32, PoolGroup<Quest> > PoolMgr::PoolGroupQuestMap

private

PoolTemplateDataMap

typedef std::unordered_map<uint32, PoolTemplateData> PoolMgr::PoolTemplateDataMap

private

SearchMap

typedef std::map<uint32, uint32> PoolMgr::SearchMap

private

SearchPair

typedef std::pair<uint32, uint32> PoolMgr::SearchPair

private

Constructor & Destructor Documentation

PoolMgr()

PoolMgr::PoolMgr ( )

private

{
}

~PoolMgr()

PoolMgr::~PoolMgr ( )

inlineprivate

{};

Member Function Documentation

ChangeDailyQuests()

void PoolMgr::ChangeDailyQuests

(

)

{
    for (PoolGroupQuestMap::iterator itr = mPoolQuestGroups.begin(); itr != mPoolQuestGroups.end(); ++itr)
    {
        if (Quest const* quest = sObjectMgr->GetQuestTemplate(itr->second.GetFirstEqualChancedObjectId()))
        {
            if (quest->IsWeekly())
                continue;
 
            UpdatePool<Quest>(itr->second.GetPoolId(), 1);    // anything non-zero means don't load from db
        }
    }
 
    SaveQuestsToDB(true, false, false);
}

References mPoolQuestGroups, SaveQuestsToDB(), and sObjectMgr.

ChangeWeeklyQuests()

void PoolMgr::ChangeWeeklyQuests

(

)

{
    for (PoolGroupQuestMap::iterator itr = mPoolQuestGroups.begin(); itr != mPoolQuestGroups.end(); ++itr)
    {
        if (Quest const* quest = sObjectMgr->GetQuestTemplate(itr->second.GetFirstEqualChancedObjectId()))
        {
            if (quest->IsDaily())
                continue;
 
            UpdatePool<Quest>(itr->second.GetPoolId(), 1);
        }
    }
 
    SaveQuestsToDB(false, true, false);
}

References mPoolQuestGroups, SaveQuestsToDB(), and sObjectMgr.

CheckPool()

bool PoolMgr::CheckPool

(

uint32

pool_id

)

const

{
    {
        auto it = mPoolGameobjectGroups.find(pool_id);
        if (it != mPoolGameobjectGroups.end() && !it->second.CheckPool())
            return false;
    }
    {
        auto it = mPoolCreatureGroups.find(pool_id);
        if (it != mPoolCreatureGroups.end() && !it->second.CheckPool())
            return false;
    }
    {
        auto it = mPoolPoolGroups.find(pool_id);
        if (it != mPoolPoolGroups.end() && !it->second.CheckPool())
            return false;
    }
    {
        auto it = mPoolQuestGroups.find(pool_id);
        if (it != mPoolQuestGroups.end() && !it->second.CheckPool())
            return false;
    }
    return true;
}

References mPoolCreatureGroups, mPoolGameobjectGroups, mPoolPoolGroups, and mPoolQuestGroups.

Referenced by LoadFromDB().

DespawnPool()

void PoolMgr::DespawnPool

(

uint32

pool_id

)

{
    {
        auto it = mPoolCreatureGroups.find(pool_id);
        if (it != mPoolCreatureGroups.end() && !it->second.IsEmpty())
            it->second.DespawnObject(mSpawnedData);
    }
    {
        auto it = mPoolGameobjectGroups.find(pool_id);
        if (it != mPoolGameobjectGroups.end() && !it->second.IsEmpty())
            it->second.DespawnObject(mSpawnedData);
    }
    {
        auto it = mPoolPoolGroups.find(pool_id);
        if (it != mPoolPoolGroups.end() && !it->second.IsEmpty())
            it->second.DespawnObject(mSpawnedData);
    }
    {
        auto it = mPoolQuestGroups.find(pool_id);
        if (it != mPoolQuestGroups.end() && !it->second.IsEmpty())
            it->second.DespawnObject(mSpawnedData);
    }
}

References mPoolCreatureGroups, mPoolGameobjectGroups, mPoolPoolGroups, mPoolQuestGroups, and mSpawnedData.

GetCreaturePoolId()

uint32 PoolMgr::GetCreaturePoolId

(

uint32

guid

)

const

{
    SearchMap::const_iterator itr = mCreatureSearchMap.find(guid);
    return itr != mCreatureSearchMap.end() ? itr->second : 0;
}

References mCreatureSearchMap.

GetGameObjectPoolId()

uint32 PoolMgr::GetGameObjectPoolId

(

uint32

guid

)

const

{
    SearchMap::const_iterator itr = mGameobjectSearchMap.find(guid);
    return itr != mGameobjectSearchMap.end() ? itr->second : 0;
}

References mGameobjectSearchMap.

GetPoolCreatureGroup()

PoolGroup< Creature > const * PoolMgr::GetPoolCreatureGroup

(

uint32

poolId

)

const

{
    auto itr = mPoolCreatureGroups.find(poolId);
    return itr != mPoolCreatureGroups.end() ? &itr->second : nullptr;
}

References mPoolCreatureGroups.

GetPoolGameObjectGroup()

PoolGroup< GameObject > const * PoolMgr::GetPoolGameObjectGroup

(

uint32

poolId

)

const

{
    auto itr = mPoolGameobjectGroups.find(poolId);
    return itr != mPoolGameobjectGroups.end() ? &itr->second : nullptr;
}

References mPoolGameobjectGroups.

GetPoolPoolGroup()

PoolGroup< Pool > const * PoolMgr::GetPoolPoolGroup

(

uint32

poolId

)

const

{
    auto itr = mPoolPoolGroups.find(poolId);
    return itr != mPoolPoolGroups.end() ? &itr->second : nullptr;
}

References mPoolPoolGroups.

GetPoolTemplate()

PoolTemplateData const * PoolMgr::GetPoolTemplate

(

uint32

poolId

)

const

{
    auto itr = mPoolTemplate.find(poolId);
    return itr != mPoolTemplate.end() ? &itr->second : nullptr;
}

References mPoolTemplate.

GetSpawnedData()

ActivePoolData const & PoolMgr::GetSpawnedData ( ) const

inline

{ return mSpawnedData; }

References mSpawnedData.

Initialize()

void PoolMgr::Initialize

(

)

{
    mQuestSearchMap.clear();
    mGameobjectSearchMap.clear();
    mCreatureSearchMap.clear();
}

References mCreatureSearchMap, mGameobjectSearchMap, and mQuestSearchMap.

instance()

PoolMgr * PoolMgr::instance ( )

static

{
    static PoolMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

IsPartOfAPool() [1/5]

template<>

uint32 PoolMgr::IsPartOfAPool ( uint32  db_guid ) const

inline

{
    SearchMap::const_iterator itr = mCreatureSearchMap.find(db_guid);
    if (itr != mCreatureSearchMap.end())
        return itr->second;
 
    return 0;
}

References mCreatureSearchMap.

IsPartOfAPool() [2/5]

template<>

uint32 PoolMgr::IsPartOfAPool ( uint32  db_guid ) const

inline

{
    SearchMap::const_iterator itr = mGameobjectSearchMap.find(db_guid);
    if (itr != mGameobjectSearchMap.end())
        return itr->second;
 
    return 0;
}

References mGameobjectSearchMap.

IsPartOfAPool() [3/5]

template<typename T >

uint32 PoolMgr::IsPartOfAPool

(

uint32

db_guid_or_pool_id

)

const

IsPartOfAPool() [4/5]

template<>

uint32 PoolMgr::IsPartOfAPool ( uint32  pool_id ) const

inline

{
    SearchMap::const_iterator itr = mPoolSearchMap.find(pool_id);
    if (itr != mPoolSearchMap.end())
        return itr->second;
 
    return 0;
}

References mPoolSearchMap.

IsPartOfAPool() [5/5]

template<>

uint32 PoolMgr::IsPartOfAPool ( uint32  questId ) const

inline

{
    SearchMap::const_iterator itr = mQuestSearchMap.find(questId);
    if (itr != mQuestSearchMap.end())
        return itr->second;
 
    return 0;
}

References mQuestSearchMap.

IsSpawnedObject()

template<typename T >

bool PoolMgr::IsSpawnedObject ( uint32  db_guid_or_pool_id ) const

inline

{ return mSpawnedData.IsActiveObject<T>(db_guid_or_pool_id); }

References ActivePoolData::IsActiveObject(), and mSpawnedData.

LoadFromDB()

void PoolMgr::LoadFromDB

(

)

{
    // Pool templates
    {
        uint32 oldMSTime = getMSTime();
 
        QueryResult result = WorldDatabase.Query("SELECT entry, max_limit, description FROM pool_template");
        if (!result)
        {
            mPoolTemplate.clear();
            LOG_WARN("server.loading", ">> Loaded 0 object pools. DB table `pool_template` is empty.");
            LOG_INFO("server.loading", " ");
            return;
        }
 
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint32 pool_id = fields[0].Get<uint32>();
 
            PoolTemplateData& pPoolTemplate = mPoolTemplate[pool_id];
            pPoolTemplate.MaxLimit    = fields[1].Get<uint32>();
            pPoolTemplate.Description = fields[2].Get<std::string>();
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Objects Pools In {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
 
    // Creatures
 
    LOG_INFO("server.loading", "Loading Creatures Pooling Data...");
    {
        uint32 oldMSTime = getMSTime();
 
        //                                                 1       2         3
        QueryResult result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_creature");
 
        if (!result)
        {
            LOG_WARN("server.loading", ">> Loaded 0 creatures in  pools. DB table `pool_creature` is empty.");
            LOG_INFO("server.loading", " ");
        }
        else
        {
            uint32 count = 0;
            do
            {
                Field* fields = result->Fetch();
 
                ObjectGuid::LowType guid = fields[0].Get<uint32>();
                uint32 pool_id = fields[1].Get<uint32>();
                float chance = fields[2].Get<float>();
 
                CreatureData const* data = sObjectMgr->GetCreatureData(guid);
                if (!data)
                {
                    LOG_ERROR("sql.sql", "`pool_creature` has a non existing creature spawn (GUID: {}) defined for pool id ({}), skipped.", guid, pool_id);
                    continue;
                }
                auto it = mPoolTemplate.find(pool_id);
                if (it == mPoolTemplate.end())
                {
                    LOG_ERROR("sql.sql", "`pool_creature` pool id ({}) is not in `pool_template`, skipped.", pool_id);
                    continue;
                }
                if (chance < 0 || chance > 100)
                {
                    LOG_ERROR("sql.sql", "`pool_creature` has an invalid chance ({}) for creature guid ({}) in pool id ({}), skipped.", chance, guid, pool_id);
                    continue;
                }
                PoolTemplateData* pPoolTemplate = &mPoolTemplate[pool_id];
                PoolObject plObject = PoolObject(guid, chance);
                PoolGroup<Creature>& cregroup = mPoolCreatureGroups[pool_id];
                cregroup.SetPoolId(pool_id);
                cregroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
                SearchPair p(guid, pool_id);
                mCreatureSearchMap.insert(p);
 
                ++count;
            } while (result->NextRow());
 
            LOG_INFO("server.loading", ">> Loaded {} Creatures In Pools in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
            LOG_INFO("server.loading", " ");
        }
    }
 
    // Gameobjects
 
    LOG_INFO("server.loading", "Loading Gameobjects Pooling Data...");
    {
        uint32 oldMSTime = getMSTime();
 
        //                                                 1        2         3
        QueryResult result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_gameobject");
 
        if (!result)
        {
            LOG_WARN("server.loading", ">> Loaded 0 gameobjects in  pools. DB table `pool_gameobject` is empty.");
            LOG_INFO("server.loading", " ");
        }
        else
        {
            uint32 count = 0;
            do
            {
                Field* fields = result->Fetch();
 
                ObjectGuid::LowType guid = fields[0].Get<uint32>();
                uint32 pool_id = fields[1].Get<uint32>();
                float chance = fields[2].Get<float>();
 
                GameObjectData const* data = sObjectMgr->GetGameObjectData(guid);
                if (!data)
                {
                    LOG_ERROR("sql.sql", "`pool_gameobject` has a non existing gameobject spawn (GUID: {}) defined for pool id ({}), skipped.", guid, pool_id);
                    continue;
                }
 
                GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(data->id);
                if (goinfo->type != GAMEOBJECT_TYPE_CHEST &&
                        goinfo->type != GAMEOBJECT_TYPE_GOOBER &&
                        goinfo->type != GAMEOBJECT_TYPE_FISHINGHOLE)
                {
                    LOG_ERROR("sql.sql", "`pool_gameobject` has a not lootable gameobject spawn (GUID: {}, type: {}) defined for pool id ({}), skipped.", guid, goinfo->type, pool_id);
                    continue;
                }
 
                auto it = mPoolTemplate.find(pool_id);
                if (it == mPoolTemplate.end())
                {
                    LOG_ERROR("sql.sql", "`pool_gameobject` pool id ({}) is not in `pool_template`, skipped.", pool_id);
                    continue;
                }
 
                if (chance < 0 || chance > 100)
                {
                    LOG_ERROR("sql.sql", "`pool_gameobject` has an invalid chance ({}) for gameobject guid ({}) in pool id ({}), skipped.", chance, guid, pool_id);
                    continue;
                }
 
                PoolTemplateData* pPoolTemplate = &mPoolTemplate[pool_id];
                PoolObject plObject = PoolObject(guid, chance);
                PoolGroup<GameObject>& gogroup = mPoolGameobjectGroups[pool_id];
                gogroup.SetPoolId(pool_id);
                gogroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
                SearchPair p(guid, pool_id);
                mGameobjectSearchMap.insert(p);
 
                ++count;
            } while (result->NextRow());
 
            LOG_INFO("server.loading", ">> Loaded {} Gameobjects In Pools in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
            LOG_INFO("server.loading", " ");
        }
    }
 
    // Pool of pools
 
    LOG_INFO("server.loading", "Loading Mother Pooling Data...");
    {
        uint32 oldMSTime = getMSTime();
 
        //                                                  1        2            3
        QueryResult result = WorldDatabase.Query("SELECT pool_id, mother_pool, chance FROM pool_pool");
 
        if (!result)
        {
            LOG_WARN("server.loading", ">> Loaded 0 pools in pools");
            LOG_INFO("server.loading", " ");
        }
        else
        {
            uint32 count = 0;
            do
            {
                Field* fields = result->Fetch();
 
                uint32 child_pool_id  = fields[0].Get<uint32>();
                uint32 mother_pool_id = fields[1].Get<uint32>();
                float chance          = fields[2].Get<float>();
 
                {
                    auto it = mPoolTemplate.find(mother_pool_id);
                    if (it == mPoolTemplate.end())
                    {
                        LOG_ERROR("sql.sql", "`pool_pool` mother_pool id ({}) is not in `pool_template`, skipped.", mother_pool_id);
                        continue;
                    }
                }
                {
                    auto it = mPoolTemplate.find(child_pool_id);
                    if (it == mPoolTemplate.end())
                    {
                        LOG_ERROR("sql.sql", "`pool_pool` included pool_id ({}) is not in `pool_template`, skipped.", child_pool_id);
                        continue;
                    }
                }
                if (mother_pool_id == child_pool_id)
                {
                    LOG_ERROR("sql.sql", "`pool_pool` pool_id ({}) includes itself, dead-lock detected, skipped.", child_pool_id);
                    continue;
                }
                if (chance < 0 || chance > 100)
                {
                    LOG_ERROR("sql.sql", "`pool_pool` has an invalid chance ({}) for pool id ({}) in mother pool id ({}), skipped.", chance, child_pool_id, mother_pool_id);
                    continue;
                }
                PoolTemplateData* pPoolTemplateMother = &mPoolTemplate[mother_pool_id];
                PoolObject plObject = PoolObject(child_pool_id, chance);
                PoolGroup<Pool>& plgroup = mPoolPoolGroups[mother_pool_id];
                plgroup.SetPoolId(mother_pool_id);
                plgroup.AddEntry(plObject, pPoolTemplateMother->MaxLimit);
                SearchPair p(child_pool_id, mother_pool_id);
                mPoolSearchMap.insert(p);
 
                ++count;
            } while (result->NextRow());
 
            // Now check for circular reference
            // All pool_ids are in pool_template
            for (auto const& it : mPoolTemplate)
            {
                std::set<uint32> checkedPools;
                for (SearchMap::iterator poolItr = mPoolSearchMap.find(it.first); poolItr != mPoolSearchMap.end(); poolItr = mPoolSearchMap.find(poolItr->second))
                {
                    checkedPools.insert(poolItr->first);
                    if (checkedPools.find(poolItr->second) != checkedPools.end())
                    {
                        std::ostringstream ss;
                        ss << "The pool(s) ";
                        for (std::set<uint32>::const_iterator itr = checkedPools.begin(); itr != checkedPools.end(); ++itr)
                            ss << *itr << ' ';
                        ss << "create(s) a circular reference, which can cause the server to freeze.\nRemoving the last link between mother pool "
                           << poolItr->first << " and child pool " << poolItr->second;
                        LOG_ERROR("sql.sql", "{}", ss.str());
                        mPoolPoolGroups[poolItr->second].RemoveOneRelation(poolItr->first);
                        mPoolSearchMap.erase(poolItr);
                        --count;
                        break;
                    }
                }
            }
 
            LOG_INFO("server.loading", ">> Loaded {} Pools In Mother Pools in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
            LOG_INFO("server.loading", " ");
        }
    }
 
    LOG_INFO("server.loading", "Loading Quest Pooling Data...");
    {
        uint32 oldMSTime = getMSTime();
 
        WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_QUEST_POOLS);
        PreparedQueryResult result = WorldDatabase.Query(stmt);
 
        if (!result)
        {
            LOG_WARN("server.loading", ">> Loaded 0 quests in pools");
            LOG_INFO("server.loading", " ");
        }
        else
        {
            PooledQuestRelationBounds creBounds;
            PooledQuestRelationBounds goBounds;
 
            enum eQuestTypes
            {
                QUEST_NONE   = 0,
                QUEST_DAILY  = 1,
                QUEST_WEEKLY = 2
            };
 
            std::map<uint32, int32> poolTypeMap;
            uint32 count = 0;
            do
            {
                Field* fields = result->Fetch();
 
                uint32 entry   = fields[0].Get<uint32>();
                uint32 pool_id = fields[1].Get<uint32>();
 
                Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
                if (!quest)
                {
                    LOG_ERROR("sql.sql", "`pool_quest` has a non existing quest template (Entry: {}) defined for pool id ({}), skipped.", entry, pool_id);
                    continue;
                }
 
                auto it = mPoolTemplate.find(pool_id);
                if (it == mPoolTemplate.end())
                {
                    LOG_ERROR("sql.sql", "`pool_quest` pool id ({}) is not in `pool_template`, skipped.", pool_id);
                    continue;
                }
 
                if (!quest->IsDailyOrWeekly())
                {
                    LOG_ERROR("sql.sql", "`pool_quest` has an quest ({}) which is not daily or weekly in pool id ({}), use ExclusiveGroup instead, skipped.", entry, pool_id);
                    continue;
                }
 
                if (poolTypeMap[pool_id] == QUEST_NONE)
                    poolTypeMap[pool_id] = quest->IsDaily() ? QUEST_DAILY : QUEST_WEEKLY;
 
                int32 currType = quest->IsDaily() ? QUEST_DAILY : QUEST_WEEKLY;
 
                if (poolTypeMap[pool_id] != currType)
                {
                    LOG_ERROR("sql.sql", "`pool_quest` quest {} is {} but pool ({}) is specified for {}, mixing not allowed, skipped.",
                                     entry, currType == QUEST_DAILY ? "QUEST_DAILY" : "QUEST_WEEKLY", pool_id, poolTypeMap[pool_id] == QUEST_DAILY ? "QUEST_DAILY" : "QUEST_WEEKLY");
                    continue;
                }
 
                creBounds = mQuestCreatureRelation.equal_range(entry);
                goBounds = mQuestGORelation.equal_range(entry);
 
                if (creBounds.first == creBounds.second && goBounds.first == goBounds.second)
                {
                    LOG_ERROR("sql.sql", "`pool_quest` lists entry ({}) as member of pool ({}) but is not started anywhere, skipped.", entry, pool_id);
                    continue;
                }
 
                PoolTemplateData* pPoolTemplate = &mPoolTemplate[pool_id];
                PoolObject plObject = PoolObject(entry, 0.0f);
                PoolGroup<Quest>& questgroup = mPoolQuestGroups[pool_id];
                questgroup.SetPoolId(pool_id);
                questgroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
                SearchPair p(entry, pool_id);
                mQuestSearchMap.insert(p);
 
                ++count;
            } while (result->NextRow());
 
            LOG_INFO("server.loading", ">> Loaded {} Quests In Pools in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
            LOG_INFO("server.loading", " ");
        }
    }
 
    // The initialize method will spawn all pools not in an event and not in another pool, this is why there is 2 left joins with 2 null checks
    LOG_INFO("server.loading", "Starting Objects Pooling System...");
    {
        uint32 oldMSTime = getMSTime();
 
        QueryResult result = WorldDatabase.Query("SELECT DISTINCT pool_template.entry, pool_pool.pool_id, pool_pool.mother_pool FROM pool_template"
                             " LEFT JOIN game_event_pool ON pool_template.entry=game_event_pool.pool_entry"
                             " LEFT JOIN pool_pool ON pool_template.entry=pool_pool.pool_id WHERE game_event_pool.pool_entry IS NULL");
 
        if (!result)
        {
            LOG_INFO("server.loading", ">> Pool handling system initialized, 0 pools spawned.");
            LOG_INFO("server.loading", " ");
        }
        else
        {
            uint32 count = 0;
            do
            {
                Field* fields = result->Fetch();
                uint32 pool_entry = fields[0].Get<uint32>();
                uint32 pool_pool_id = fields[1].Get<uint32>();
 
                if (!CheckPool(pool_entry))
                {
                    if (pool_pool_id)
                        // The pool is a child pool in pool_pool table. Ideally we should remove it from the pool handler to ensure it never gets spawned,
                        // however that could recursively invalidate entire chain of mother pools. It can be done in the future but for now we'll do nothing.
                        LOG_ERROR("sql.sql", "Pool Id {} has no equal chance pooled entites defined and explicit chance sum is not 100. This broken pool is a child pool of Id {} and cannot be safely removed.", pool_entry, fields[2].Get<uint32>());
                    else
                        LOG_ERROR("sql.sql", "Pool Id {} has no equal chance pooled entites defined and explicit chance sum is not 100. The pool will not be spawned.", pool_entry);
                    continue;
                }
 
                // Don't spawn child pools, they are spawned recursively by their parent pools
                if (!pool_pool_id)
                {
                    SpawnPool(pool_entry);
                    count++;
                }
            } while (result->NextRow());
 
            LOG_INFO("pool", "Pool handling system initialized, {} pools spawned in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
            LOG_INFO("server.loading", " ");
        }
    }
}

References PoolGroup< T >::AddEntry(), CheckPool(), GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_FISHINGHOLE, GAMEOBJECT_TYPE_GOOBER, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, PoolTemplateData::MaxLimit, mCreatureSearchMap, mGameobjectSearchMap, mPoolCreatureGroups, mPoolGameobjectGroups, mPoolPoolGroups, mPoolQuestGroups, mPoolSearchMap, mPoolTemplate, mQuestCreatureRelation, mQuestGORelation, mQuestSearchMap, PoolGroup< T >::SetPoolId(), sObjectMgr, SpawnPool, GameObjectTemplate::type, WORLD_SEL_QUEST_POOLS, and WorldDatabase.

LoadQuestPools()

void PoolMgr::LoadQuestPools

(

)

{
}

ReSpawnPoolQuests()

void PoolMgr::ReSpawnPoolQuests

(

)

{
    for (auto& [questId, poolId] : mQuestSearchMap)
    {
        if (IsSpawnedObject<Quest>(questId))
        {
            PoolObject tempObj(questId, 0.0f);
            auto it = mPoolQuestGroups.find(poolId);
            if (it != mPoolQuestGroups.end())
                it->second.Spawn1Object(&tempObj);
        }
    }
}

References mPoolQuestGroups, and mQuestSearchMap.

SaveQuestsToDB()

void PoolMgr::SaveQuestsToDB	(	bool	daily,
		bool	weekly,
		bool	other
	)

{
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    // pussywizard: mysql thread races, change only what is meant to be changed
    std::set<uint32> deletedPools;
    for (PoolGroupQuestMap::iterator itr = mPoolQuestGroups.begin(); itr != mPoolQuestGroups.end(); ++itr)
    {
        if (itr->second.IsEmpty())
            continue;
        if (Quest const* quest = sObjectMgr->GetQuestTemplate(itr->second.GetFirstEqualChancedObjectId()))
        {
            if (!daily && quest->IsDaily())
                continue;
            if (!weekly && quest->IsWeekly())
                continue;
            if (!other && !quest->IsDaily() && !quest->IsWeekly())
                continue;
        }
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_QUEST_POOL_SAVE);
        stmt->SetData(0, itr->second.GetPoolId());
        trans->Append(stmt);
        deletedPools.insert(itr->second.GetPoolId());
    }
 
    for (SearchMap::iterator itr = mQuestSearchMap.begin(); itr != mQuestSearchMap.end(); ++itr)
        if (deletedPools.find(itr->second) != deletedPools.end())
            if (IsSpawnedObject<Quest>(itr->first))
            {
                CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_QUEST_POOL_SAVE);
                stmt->SetData(0, itr->second);
                stmt->SetData(1, itr->first);
                trans->Append(stmt);
            }
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_DEL_QUEST_POOL_SAVE, CHAR_INS_QUEST_POOL_SAVE, CharacterDatabase, mPoolQuestGroups, mQuestSearchMap, PreparedStatementBase::SetData(), and sObjectMgr.

Referenced by ChangeDailyQuests(), and ChangeWeeklyQuests().

SpawnPool() [1/6]

void PoolMgr::SpawnPool

(

uint32

pool_id

)

{
    SpawnPool<Pool>(pool_id, 0);
    SpawnPool<GameObject>(pool_id, 0);
    SpawnPool<Creature>(pool_id, 0);
    SpawnPool<Quest>(pool_id, 0);
}

SpawnPool() [2/6]

template<>

void PoolMgr::SpawnPool ( uint32  pool_id, uint32  db_guid  )

private

{
    auto it = mPoolCreatureGroups.find(pool_id);
    if (it != mPoolCreatureGroups.end() && !it->second.IsEmpty())
        it->second.SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, db_guid);
}

References mPoolCreatureGroups, mPoolTemplate, and mSpawnedData.

SpawnPool() [3/6]

template<>

void PoolMgr::SpawnPool ( uint32  pool_id, uint32  db_guid  )

private

{
    auto it = mPoolGameobjectGroups.find(pool_id);
    if (it != mPoolGameobjectGroups.end() && !it->second.IsEmpty())
        it->second.SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, db_guid);
}

References mPoolGameobjectGroups, mPoolTemplate, and mSpawnedData.

SpawnPool() [4/6]

template<typename T >

void PoolMgr::SpawnPool ( uint32  pool_id, uint32  db_guid_or_pool_id  )

private

SpawnPool() [5/6]

template<>

void PoolMgr::SpawnPool ( uint32  pool_id, uint32  quest_id  )

private

{
    auto it = mPoolQuestGroups.find(pool_id);
    if (it != mPoolQuestGroups.end() && !it->second.IsEmpty())
        it->second.SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, quest_id);
}

References mPoolQuestGroups, mPoolTemplate, and mSpawnedData.

SpawnPool() [6/6]

template<>

void PoolMgr::SpawnPool ( uint32  pool_id, uint32  sub_pool_id  )

private

{
    auto it = mPoolPoolGroups.find(pool_id);
    if (it != mPoolPoolGroups.end() && !it->second.IsEmpty())
        it->second.SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, sub_pool_id);
}

References mPoolPoolGroups, mPoolTemplate, and mSpawnedData.

UpdatePool()

template<typename T >

template void PoolMgr::UpdatePool< Quest >	(	uint32	pool_id,
		uint32	db_guid_or_pool_id
	)

{
    if (uint32 motherpoolid = IsPartOfAPool<Pool>(pool_id))
        SpawnPool<Pool>(motherpoolid, pool_id);
    else
        SpawnPool<T>(pool_id, db_guid_or_pool_id);
}

Friends And Related Symbol Documentation

PoolQuestReloadFixTest

friend class PoolQuestReloadFixTest

friend

Member Data Documentation

mCreatureSearchMap

SearchMap PoolMgr::mCreatureSearchMap

private

Referenced by GetCreaturePoolId(), Initialize(), IsPartOfAPool(), and LoadFromDB().

mGameobjectSearchMap

SearchMap PoolMgr::mGameobjectSearchMap

private

Referenced by GetGameObjectPoolId(), Initialize(), IsPartOfAPool(), and LoadFromDB().

mPoolCreatureGroups

PoolGroupCreatureMap PoolMgr::mPoolCreatureGroups

private

Referenced by CheckPool(), DespawnPool(), GetPoolCreatureGroup(), LoadFromDB(), and SpawnPool().

mPoolGameobjectGroups

PoolGroupGameObjectMap PoolMgr::mPoolGameobjectGroups

private

Referenced by CheckPool(), DespawnPool(), GetPoolGameObjectGroup(), LoadFromDB(), and SpawnPool().

mPoolPoolGroups

PoolGroupPoolMap PoolMgr::mPoolPoolGroups

private

Referenced by CheckPool(), DespawnPool(), GetPoolPoolGroup(), LoadFromDB(), and SpawnPool().

mPoolQuestGroups

PoolGroupQuestMap PoolMgr::mPoolQuestGroups

private

Referenced by ChangeDailyQuests(), ChangeWeeklyQuests(), CheckPool(), DespawnPool(), LoadFromDB(), ReSpawnPoolQuests(), SaveQuestsToDB(), and SpawnPool().

mPoolSearchMap

SearchMap PoolMgr::mPoolSearchMap

private

Referenced by IsPartOfAPool(), and LoadFromDB().

mPoolTemplate

PoolTemplateDataMap PoolMgr::mPoolTemplate

private

Referenced by GetPoolTemplate(), LoadFromDB(), SpawnPool(), SpawnPool(), and SpawnPool().

mQuestCreatureRelation

PooledQuestRelation PoolMgr::mQuestCreatureRelation

Referenced by LoadFromDB().

mQuestGORelation

PooledQuestRelation PoolMgr::mQuestGORelation

Referenced by LoadFromDB().

mQuestSearchMap

SearchMap PoolMgr::mQuestSearchMap

private

Referenced by Initialize(), IsPartOfAPool(), LoadFromDB(), ReSpawnPoolQuests(), and SaveQuestsToDB().

mSpawnedData

ActivePoolData PoolMgr::mSpawnedData

private

Referenced by DespawnPool(), GetSpawnedData(), IsSpawnedObject(), SpawnPool(), SpawnPool(), and SpawnPool().

---

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

• azerothcore-wotlk/src/server/game/Pools/PoolMgr.h
• azerothcore-wotlk/src/server/game/Pools/PoolMgr.cpp