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 quest_id) const
bool	IsEmpty (uint32 pool_id) const
bool	CheckPool (uint32 pool_id) const
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id)
void	DespawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id)
template<typename T >
void	UpdatePool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 db_guid_or_pool_id)
void	SpawnEventPool (uint32 pool_id)
void	DespawnEventPool (uint32 pool_id)
std::unique_ptr< SpawnedPoolData >	InitPoolsForMap (Map *map)
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
SpawnedPoolData const &	GetQuestSpawnedData () 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 (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 db_guid_or_pool_id)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 db_guid)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 db_guid)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 sub_pool_id)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 quest_id)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 sub_pool_id)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 db_guid)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, uint32 pool_id, uint32 db_guid)
template<>
void	SpawnPool (SpawnedPoolData &spawnedPoolData, 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
std::unordered_map< uint32, std::vector< uint32 > >	mAutoSpawnPoolsPerMap
std::unordered_set< uint32 >	mActiveEventPools
SpawnedPoolData	mQuestSpawnedData

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

                 : mQuestSpawnedData(nullptr)
{
}

~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>(mQuestSpawnedData, itr->second.GetPoolId(), 1);    // anything non-zero means don't load from db
        }
    }
 
    SaveQuestsToDB(true, false, false);
}

References mPoolQuestGroups, mQuestSpawnedData, 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>(mQuestSpawnedData, itr->second.GetPoolId(), 1);
        }
    }
 
    SaveQuestsToDB(false, true, false);
}

References mPoolQuestGroups, mQuestSpawnedData, 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().

DespawnEventPool()

void PoolMgr::DespawnEventPool

(

uint32

pool_id

)

{
    mActiveEventPools.erase(pool_id);
 
    PoolTemplateData const* poolTemplate = GetPoolTemplate(pool_id);
    if (!poolTemplate || poolTemplate->MapId == -1)
        return;
 
    sMapMgr->DoForAllMapsWithMapId(uint32(poolTemplate->MapId), [pool_id](Map* map)
    {
        sPoolMgr->DespawnPool(map->GetPoolData(), pool_id);
    });
}

References GetPoolTemplate(), mActiveEventPools, PoolTemplateData::MapId, and sMapMgr.

DespawnPool()

void PoolMgr::DespawnPool	(	SpawnedPoolData &	spawnedPoolData,
		uint32	pool_id
	)

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

References mPoolCreatureGroups, mPoolGameobjectGroups, and mPoolPoolGroups.

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.

Referenced by DespawnEventPool(), InitPoolsForMap(), and SpawnEventPool().

GetQuestSpawnedData()

SpawnedPoolData const & PoolMgr::GetQuestSpawnedData ( ) const

inline

{ return mQuestSpawnedData; }

References mQuestSpawnedData.

Initialize()

void PoolMgr::Initialize

(

)

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

References mActiveEventPools, mAutoSpawnPoolsPerMap, mCreatureSearchMap, mGameobjectSearchMap, and mQuestSearchMap.

InitPoolsForMap()

std::unique_ptr< SpawnedPoolData > PoolMgr::InitPoolsForMap

(

Map *

map

)

{
    std::unique_ptr<SpawnedPoolData> spawnedPoolData = std::make_unique<SpawnedPoolData>(map);
 
    // The MapInstanced container never holds spawns itself, only its child instances do
    if (map->Instanceable() && !map->GetInstanceId())
        return spawnedPoolData;
 
    if (std::vector<uint32> const* poolIds = Acore::Containers::MapGetValuePtr(mAutoSpawnPoolsPerMap, map->GetId()))
    {
        for (uint32 poolId : *poolIds)
            SpawnPool(*spawnedPoolData, poolId);
    }
 
    for (uint32 poolId : mActiveEventPools)
    {
        PoolTemplateData const* poolTemplate = GetPoolTemplate(poolId);
        if (poolTemplate && poolTemplate->MapId == int32(map->GetId()))
            SpawnPool(*spawnedPoolData, poolId);
    }
 
    return spawnedPoolData;
}

References Map::GetId(), Map::GetInstanceId(), GetPoolTemplate(), Map::Instanceable(), mActiveEventPools, Acore::Containers::MapGetValuePtr(), PoolTemplateData::MapId, mAutoSpawnPoolsPerMap, and SpawnPool.

instance()

PoolMgr * PoolMgr::instance ( )

static

{
    static PoolMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

IsEmpty()

bool PoolMgr::IsEmpty

(

uint32

pool_id

)

const

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

References mPoolCreatureGroups, mPoolGameobjectGroups, mPoolPoolGroups, and mPoolQuestGroups.

Referenced by LoadFromDB().

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  quest_id ) const

inline

    {
        static_assert(std::is_same_v<T, Quest>, "only quest pool state is global; query the owning Map's SpawnedPoolData instead");
        return mQuestSpawnedData.IsSpawnedObject<Quest>(quest_id);
    }

References SpawnedPoolData::IsSpawnedObject(), and mQuestSpawnedData.

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.MapId       = -1;
            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];
                if (pPoolTemplate->MapId == -1)
                    pPoolTemplate->MapId = int32(data->mapid);
 
                if (pPoolTemplate->MapId != int32(data->mapid))
                {
                    LOG_ERROR("sql.sql", "`pool_creature` has creature spawns on multiple different maps for creature guid ({}) in pool id ({}), skipped.", guid, pool_id);
                    continue;
                }
 
                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];
                if (pPoolTemplate->MapId == -1)
                    pPoolTemplate->MapId = int32(data->mapid);
 
                if (pPoolTemplate->MapId != int32(data->mapid))
                {
                    LOG_ERROR("sql.sql", "`pool_gameobject` has gameobject spawns on multiple different maps for gameobject guid ({}) in pool id ({}), skipped.", guid, pool_id);
                    continue;
                }
 
                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))
                {
                    // A mother pool spawns in one map's pool data, so the whole chain must stay on that map
                    if (mPoolTemplate[poolItr->first].MapId != -1)
                    {
                        if (mPoolTemplate[poolItr->second].MapId == -1)
                            mPoolTemplate[poolItr->second].MapId = mPoolTemplate[poolItr->first].MapId;
 
                        if (mPoolTemplate[poolItr->second].MapId != mPoolTemplate[poolItr->first].MapId)
                        {
                            LOG_ERROR("sql.sql", "`pool_pool` has child pools on multiple maps in pool id ({}), skipped.", poolItr->second);
                            mPoolPoolGroups[poolItr->second].RemoveOneRelation(poolItr->first);
                            mPoolSearchMap.erase(poolItr);
                            --count;
                            break;
                        }
                    }
 
                    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;
                }
 
                // Quest pool state is global while mother pools spawn into one map's
                // pool data, so a quest pool can never be a mother pool's child
                if (uint32 motherPoolId = IsPartOfAPool<Pool>(pool_id))
                {
                    LOG_ERROR("sql.sql", "`pool_quest` pool id ({}) is a child of mother pool ({}), quest pools cannot be part of mother pools, skipped.", pool_id, motherPoolId);
                    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", " ");
        }
    }
 
    for (auto const& [poolId, templateData] : mPoolTemplate)
    {
        if (IsEmpty(poolId))
            LOG_ERROR("sql.sql", "Pool Id {} is empty (has no creatures, no gameobjects, no quests and no valid child pools). The pool will not be spawned.", poolId);
    }
 
    // 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 (IsEmpty(pool_entry))
                    continue;
 
                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)
                {
                    // Quest pools are global and not map-bound: spawn them now
                    // (restores the previously saved state from the characters DB)
                    if (mPoolQuestGroups.find(pool_entry) != mPoolQuestGroups.end())
                        SpawnPool<Quest>(mQuestSpawnedData, pool_entry, 0);
 
                    PoolTemplateData const& templateData = mPoolTemplate[pool_entry];
                    if (templateData.MapId != -1)
                        mAutoSpawnPoolsPerMap[uint32(templateData.MapId)].push_back(pool_entry);
 
                    count++;
                }
            } while (result->NextRow());
 
            LOG_INFO("server.loading", ">> Pool handling system initialized, {} pools will be spawned by default 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(), IsEmpty(), LOG_ERROR, LOG_INFO, LOG_WARN, PoolTemplateData::MapId, mAutoSpawnPoolsPerMap, PoolTemplateData::MaxLimit, mCreatureSearchMap, mGameobjectSearchMap, mPoolCreatureGroups, mPoolGameobjectGroups, mPoolPoolGroups, mPoolQuestGroups, mPoolSearchMap, mPoolTemplate, mQuestCreatureRelation, mQuestGORelation, mQuestSearchMap, mQuestSpawnedData, PoolGroup< T >::SetPoolId(), sObjectMgr, 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(mQuestSpawnedData, &tempObj);
        }
    }
}

References mPoolQuestGroups, mQuestSearchMap, and mQuestSpawnedData.

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().

SpawnEventPool()

void PoolMgr::SpawnEventPool

(

uint32

pool_id

)

{
    PoolTemplateData const* poolTemplate = GetPoolTemplate(pool_id);
    if (!poolTemplate || poolTemplate->MapId == -1)
        return;
 
    // Remembered while the event runs so maps created later spawn it on creation
    mActiveEventPools.insert(pool_id);
 
    sMapMgr->DoForAllMapsWithMapId(uint32(poolTemplate->MapId), [pool_id](Map* map)
    {
        sPoolMgr->SpawnPool(map->GetPoolData(), pool_id);
    });
}

References GetPoolTemplate(), mActiveEventPools, PoolTemplateData::MapId, and sMapMgr.

SpawnPool() [1/10]

void PoolMgr::SpawnPool	(	SpawnedPoolData &	spawnedPoolData,
		uint32	pool_id
	)

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

SpawnPool() [2/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  db_guid  )

private

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

References mPoolCreatureGroups, and mPoolTemplate.

SpawnPool() [3/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  db_guid  )

private

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

References mPoolGameobjectGroups, and mPoolTemplate.

SpawnPool() [4/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  db_guid  )

private

SpawnPool() [5/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  db_guid  )

private

SpawnPool() [6/10]

template<typename T >

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  db_guid_or_pool_id  )

private

SpawnPool() [7/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  quest_id  )

private

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

References mPoolQuestGroups, and mPoolTemplate.

SpawnPool() [8/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  quest_id  )

private

SpawnPool() [9/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  sub_pool_id  )

private

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

References mPoolPoolGroups, and mPoolTemplate.

SpawnPool() [10/10]

template<>

void PoolMgr::SpawnPool ( SpawnedPoolData &  spawnedPoolData, uint32  pool_id, uint32  sub_pool_id  )

private

UpdatePool()

template<typename T >

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

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

Friends And Related Symbol Documentation

PoolQuestReloadFixTest

friend class PoolQuestReloadFixTest

friend

Member Data Documentation

mActiveEventPools

std::unordered_set<uint32> PoolMgr::mActiveEventPools

private

Referenced by DespawnEventPool(), Initialize(), InitPoolsForMap(), and SpawnEventPool().

mAutoSpawnPoolsPerMap

std::unordered_map<uint32, std::vector<uint32> > PoolMgr::mAutoSpawnPoolsPerMap

private

Referenced by Initialize(), InitPoolsForMap(), and LoadFromDB().

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(), IsEmpty(), LoadFromDB(), and SpawnPool().

mPoolGameobjectGroups

PoolGroupGameObjectMap PoolMgr::mPoolGameobjectGroups

private

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

mPoolPoolGroups

PoolGroupPoolMap PoolMgr::mPoolPoolGroups

private

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

mPoolQuestGroups

PoolGroupQuestMap PoolMgr::mPoolQuestGroups

private

Referenced by ChangeDailyQuests(), ChangeWeeklyQuests(), CheckPool(), IsEmpty(), 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().

mQuestSpawnedData

SpawnedPoolData PoolMgr::mQuestSpawnedData

private

Referenced by ChangeDailyQuests(), ChangeWeeklyQuests(), GetQuestSpawnedData(), IsSpawnedObject(), LoadFromDB(), and ReSpawnPoolQuests().

---

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