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

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.

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 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>();
 
            ++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

(

)

{
}

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);
}

Member Data Documentation

mCreatureSearchMap

SearchMap PoolMgr::mCreatureSearchMap

private

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

mGameobjectSearchMap

SearchMap PoolMgr::mGameobjectSearchMap

private

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

mPoolCreatureGroups

PoolGroupCreatureMap PoolMgr::mPoolCreatureGroups

private

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

mPoolGameobjectGroups

PoolGroupGameObjectMap PoolMgr::mPoolGameobjectGroups

private

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

mPoolPoolGroups

PoolGroupPoolMap PoolMgr::mPoolPoolGroups

private

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

mPoolQuestGroups

PoolGroupQuestMap PoolMgr::mPoolQuestGroups

private

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

mPoolSearchMap

SearchMap PoolMgr::mPoolSearchMap

private

Referenced by IsPartOfAPool(), and LoadFromDB().

mPoolTemplate

PoolTemplateDataMap PoolMgr::mPoolTemplate

private

Referenced by LoadFromDB(), 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(), and SaveQuestsToDB().

mSpawnedData

ActivePoolData PoolMgr::mSpawnedData

private

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