PoolMgr Class Reference

#include <PoolMgr.h>

Public Member Functions
void	LoadFromDB ()
void	LoadQuestPools ()
void	SaveQuestsToDB ()
void	Initialize ()
template<typename T >
uint32	IsPartOfAPool (uint64 db_guid_or_pool_id) const
template<typename T >
bool	IsSpawnedObject (uint64 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, uint64 db_guid_or_pool_id)
void	ChangeDailyQuests ()
void	ChangeWeeklyQuests ()
template<>
uint32	IsPartOfAPool (uint64 db_guid) const
template<>
uint32	IsPartOfAPool (uint64 db_guid) const
template<>
uint32	IsPartOfAPool (uint64 pool_id) const
template<>
uint32	IsPartOfAPool (uint64 pool_id) const

Static Public Member Functions
static PoolMgr *	instance ()

Public Attributes
PooledQuestRelation	mQuestCreatureRelation
PooledQuestRelation	mQuestGORelation

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

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

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

Member Typedef Documentation

typedef std::vector<PoolGroup<Creature> > PoolMgr::PoolGroupCreatureMap

private

typedef std::vector<PoolGroup<GameObject> > PoolMgr::PoolGroupGameObjectMap

private

typedef std::vector<PoolGroup<Pool> > PoolMgr::PoolGroupPoolMap

private

typedef std::vector<PoolGroup<Quest> > PoolMgr::PoolGroupQuestMap

private

typedef std::vector<PoolTemplateData> PoolMgr::PoolTemplateDataMap

private

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

private

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

private

Constructor & Destructor Documentation

PoolMgr::PoolMgr ( )

private

: max_pool_id(0) { }

PoolMgr::~PoolMgr ( )

inlineprivate

{ };

Member Function Documentation

void PoolMgr::ChangeDailyQuests

(

)

{
 for (PoolGroupQuestMap::iterator itr = mPoolQuestGroups.begin(); itr != mPoolQuestGroups.end(); ++itr)
 {
 if (Quest const* quest = sObjectMgr->GetQuestTemplate(itr->GetFirstEqualChancedObjectId()))
 {
 if (quest->IsWeekly())
 continue;

 UpdatePool<Quest>(itr->GetPoolId(), 1); // anything non-zero means don't load from db
 }
 }

 SaveQuestsToDB();
}

Here is the call graph for this function:

void PoolMgr::ChangeWeeklyQuests

(

)

{
 for (PoolGroupQuestMap::iterator itr = mPoolQuestGroups.begin(); itr != mPoolQuestGroups.end(); ++itr)
 {
 if (Quest const* quest = sObjectMgr->GetQuestTemplate(itr->GetFirstEqualChancedObjectId()))
 {
 if (quest->IsDaily())
 continue;

 UpdatePool<Quest>(itr->GetPoolId(), 1);
 }
 }

 SaveQuestsToDB();
}

Here is the call graph for this function:

bool PoolMgr::CheckPool

(

uint32

pool_id

)

const

{
 return pool_id <= max_pool_id &&
 mPoolGameobjectGroups[pool_id].CheckPool() &&
 mPoolCreatureGroups[pool_id].CheckPool() &&
 mPoolPoolGroups[pool_id].CheckPool() &&
 mPoolQuestGroups[pool_id].CheckPool();
}

Here is the caller graph for this function:

void PoolMgr::DespawnPool

(

uint32

pool_id

)

{
 if (!mPoolCreatureGroups[pool_id].isEmpty())
 mPoolCreatureGroups[pool_id].DespawnObject(mSpawnedData);

 if (!mPoolGameobjectGroups[pool_id].isEmpty())
 mPoolGameobjectGroups[pool_id].DespawnObject(mSpawnedData);

 if (!mPoolPoolGroups[pool_id].isEmpty())
 mPoolPoolGroups[pool_id].DespawnObject(mSpawnedData);

 if (!mPoolQuestGroups[pool_id].isEmpty())
 mPoolQuestGroups[pool_id].DespawnObject(mSpawnedData);
}

void PoolMgr::Initialize

(

void

)

{
 QueryResult result = WorldDatabase.Query("SELECT MAX(entry) FROM pool_template");
 if (result)
 {
 Field* fields = result->Fetch();
 max_pool_id = fields[0].GetUInt32();
 }

 mPoolTemplate.resize(max_pool_id + 1);
 mPoolCreatureGroups.resize(max_pool_id + 1);
 mPoolGameobjectGroups.resize(max_pool_id + 1);
 mPoolPoolGroups.resize(max_pool_id + 1);
 mPoolQuestGroups.resize(max_pool_id + 1);

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

Here is the call graph for this function:

PoolMgr * PoolMgr::instance ( )

static

{
 static PoolMgr instance;
 return &instance;
}

template<typename T >

uint32 PoolMgr::IsPartOfAPool

(

uint64

db_guid_or_pool_id

)

const

template<>

uint32 PoolMgr::IsPartOfAPool ( uint64  db_guid ) const

inline

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

 return 0;
}

template<>

uint32 PoolMgr::IsPartOfAPool ( uint64  db_guid ) const

inline

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

 return 0;
}

template<>

uint32 PoolMgr::IsPartOfAPool ( uint64  pool_id ) const

inline

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

 return 0;
}

template<>

uint32 PoolMgr::IsPartOfAPool ( uint64  pool_id ) const

inline

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

 return 0;
}

template<typename T >

bool PoolMgr::IsSpawnedObject ( uint64  db_guid_or_pool_id ) const

inline

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

void PoolMgr::LoadFromDB

(

)

{
 // Pool templates
 {
 uint32 oldMSTime = getMSTime();

 QueryResult result = WorldDatabase.Query("SELECT entry, max_limit FROM pool_template");
 if (!result)
 {
 mPoolTemplate.clear();
 TC_LOG_INFO("server.loading", ">> Loaded 0 object pools. DB table `pool_template` is empty.");
 return;
 }

 uint32 count = 0;
 do
 {
 Field* fields = result->Fetch();

 uint32 pool_id = fields[0].GetUInt32();

 PoolTemplateData& pPoolTemplate = mPoolTemplate[pool_id];
 pPoolTemplate.MaxLimit = fields[1].GetUInt32();

 ++count;
 }
 while (result->NextRow());

 TC_LOG_INFO("server.loading", ">> Loaded %u objects pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }

 // Creatures

 TC_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)
 {
 TC_LOG_INFO("server.loading", ">> Loaded 0 creatures in pools. DB table `pool_creature` is empty.");
 }
 else
 {
 uint32 count = 0;
 do
 {
 Field* fields = result->Fetch();

 uint64 guid = fields[0].GetUInt64();
 uint32 pool_id = fields[1].GetUInt32();
 float chance = fields[2].GetFloat();

 CreatureData const* data = sObjectMgr->GetCreatureData(guid);
 if (!data)
 {
 TC_LOG_ERROR("sql.sql", "`pool_creature` has a non existing creature spawn (GUID: " UI64FMTD ") defined for pool id (%u), skipped.", guid, pool_id);
 continue;
 }
 if (pool_id > max_pool_id)
 {
 TC_LOG_ERROR("sql.sql", "`pool_creature` pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", pool_id);
 continue;
 }
 if (chance < 0 || chance > 100)
 {
 TC_LOG_ERROR("sql.sql", "`pool_creature` has an invalid chance (%f) for creature guid (" UI64FMTD ") in pool id (%u), 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());

 TC_LOG_INFO("server.loading", ">> Loaded %u creatures in pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }
 }

 // Gameobjects

 TC_LOG_INFO("server.loading", "Loading Gameobject Pooling Data...");
 {
 uint32 oldMSTime = getMSTime();

 // 1 2 3
 QueryResult result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_gameobject");

 if (!result)
 {
 TC_LOG_INFO("server.loading", ">> Loaded 0 gameobjects in pools. DB table `pool_gameobject` is empty.");
 }
 else
 {
 uint32 count = 0;
 do
 {
 Field* fields = result->Fetch();

 uint64 guid = fields[0].GetUInt64();
 uint32 pool_id = fields[1].GetUInt32();
 float chance = fields[2].GetFloat();

 GameObjectData const* data = sObjectMgr->GetGOData(guid);
 if (!data)
 {
 TC_LOG_ERROR("sql.sql", "`pool_gameobject` has a non existing gameobject spawn (GUID: " UI64FMTD ") defined for pool id (%u), 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)
 {
 TC_LOG_ERROR("sql.sql", "`pool_gameobject` has a not lootable gameobject spawn (GUID: " UI64FMTD ", type: %u) defined for pool id (%u), skipped.", guid, goinfo->type, pool_id);
 continue;
 }

 if (pool_id > max_pool_id)
 {
 TC_LOG_ERROR("sql.sql", "`pool_gameobject` pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", pool_id);
 continue;
 }

 if (chance < 0 || chance > 100)
 {
 TC_LOG_ERROR("sql.sql", "`pool_gameobject` has an invalid chance (%f) for gameobject guid (" UI64FMTD ") in pool id (%u), 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());

 TC_LOG_INFO("server.loading", ">> Loaded %u gameobject in pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }
 }

 // Pool of pools

 TC_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)
 {
 TC_LOG_INFO("server.loading", ">> Loaded 0 pools in pools");
 }
 else
 {
 uint32 count = 0;
 do
 {
 Field* fields = result->Fetch();

 uint32 child_pool_id = fields[0].GetUInt32();
 uint32 mother_pool_id = fields[1].GetUInt32();
 float chance = fields[2].GetFloat();

 if (mother_pool_id > max_pool_id)
 {
 TC_LOG_ERROR("sql.sql", "`pool_pool` mother_pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", mother_pool_id);
 continue;
 }
 if (child_pool_id > max_pool_id)
 {
 TC_LOG_ERROR("sql.sql", "`pool_pool` included pool_id (%u) is out of range compared to max pool id in `pool_template`, skipped.", child_pool_id);
 continue;
 }
 if (mother_pool_id == child_pool_id)
 {
 TC_LOG_ERROR("sql.sql", "`pool_pool` pool_id (%u) includes itself, dead-lock detected, skipped.", child_pool_id);
 continue;
 }
 if (chance < 0 || chance > 100)
 {
 TC_LOG_ERROR("sql.sql", "`pool_pool` has an invalid chance (%f) for pool id (%u) in mother pool id (%u), 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
 for (uint32 i=0; i < max_pool_id; ++i)
 {
 std::set<uint32> checkedPools;
 for (SearchMap::iterator poolItr = mPoolSearchMap.find(i); 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;
 TC_LOG_ERROR("sql.sql", "%s", ss.str().c_str());
 mPoolPoolGroups[poolItr->second].RemoveOneRelation(poolItr->first);
 mPoolSearchMap.erase(poolItr);
 --count;
 break;
 }
 }
 }

 TC_LOG_INFO("server.loading", ">> Loaded %u pools in mother pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }
 }

 TC_LOG_INFO("server.loading", "Loading Quest Pooling Data...");
 {
 uint32 oldMSTime = getMSTime();

 PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_QUEST_POOLS);
 PreparedQueryResult result = WorldDatabase.Query(stmt);

 if (!result)
 {
 TC_LOG_INFO("server.loading", ">> Loaded 0 quests in pools");
 }
 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].GetUInt32();
 uint32 pool_id = fields[1].GetUInt32();

 Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
 if (!quest)
 {
 TC_LOG_ERROR("sql.sql", "`pool_quest` has a non existing quest template (Entry: %u) defined for pool id (%u), skipped.", entry, pool_id);
 continue;
 }

 if (pool_id > max_pool_id)
 {
 TC_LOG_ERROR("sql.sql", "`pool_quest` pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", pool_id);
 continue;
 }

 if (!quest->IsDailyOrWeekly())
 {
 TC_LOG_ERROR("sql.sql", "`pool_quest` has an quest (%u) which is not daily or weekly in pool id (%u), 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)
 {
 TC_LOG_ERROR("sql.sql", "`pool_quest` quest %u is %s but pool (%u) is specified for %s, 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)
 {
 TC_LOG_ERROR("sql.sql", "`pool_quest` lists entry (%u) as member of pool (%u) 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());

 TC_LOG_INFO("server.loading", ">> Loaded %u quests in pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }
 }

 // 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
 TC_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)
 {
 TC_LOG_INFO("server.loading", ">> Pool handling system initialized, 0 pools spawned.");
 }
 else
 {
 uint32 count = 0;
 do
 {
 Field* fields = result->Fetch();
 uint32 pool_entry = fields[0].GetUInt32();
 uint32 pool_pool_id = fields[1].GetUInt32();

 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.
 TC_LOG_ERROR("sql.sql", "Pool Id %u has no equal chance pooled entites defined and explicit chance sum is not 100. This broken pool is a child pool of Id %u and cannot be safely removed.", pool_entry, fields[2].GetUInt32());
 else
 TC_LOG_ERROR("sql.sql", "Pool Id %u 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());

 TC_LOG_DEBUG("pool", "Pool handling system initialized, %u pools spawned in %u ms", count, GetMSTimeDiffToNow(oldMSTime));

 }
 }
}

Here is the call graph for this function:

void PoolMgr::LoadQuestPools

(

)

{

}

void PoolMgr::SaveQuestsToDB

(

)

{
 SQLTransaction trans = CharacterDatabase.BeginTransaction();

 for (PoolGroupQuestMap::iterator itr = mPoolQuestGroups.begin(); itr != mPoolQuestGroups.end(); ++itr)
 {
 if (itr->isEmpty())
 continue;
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_QUEST_POOL_SAVE);
 stmt->setUInt32(0, itr->GetPoolId());
 trans->Append(stmt);
 }

 for (SearchMap::iterator itr = mQuestSearchMap.begin(); itr != mQuestSearchMap.end(); ++itr)
 {
 if (IsSpawnedObject<Quest>(itr->first))
 {
 PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_QUEST_POOL_SAVE);
 stmt->setUInt32(0, itr->second);
 stmt->setUInt32(1, itr->first);
 trans->Append(stmt);
 }
 }

 CharacterDatabase.CommitTransaction(trans);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

template<typename T >

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

private

template<>

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

private

{
 if (!mPoolCreatureGroups[pool_id].isEmpty())
 mPoolCreatureGroups[pool_id].SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, db_guid);
}

template<>

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

private

{
 if (!mPoolGameobjectGroups[pool_id].isEmpty())
 mPoolGameobjectGroups[pool_id].SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, db_guid);
}

template<>

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

private

{
 if (!mPoolPoolGroups[pool_id].isEmpty())
 mPoolPoolGroups[pool_id].SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, sub_pool_id);
}

template<>

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

private

{
 if (!mPoolQuestGroups[pool_id].isEmpty())
 mPoolQuestGroups[pool_id].SpawnObject(mSpawnedData, mPoolTemplate[pool_id].MaxLimit, quest_id);
}

template<typename T >

template void PoolMgr::UpdatePool< Quest >	(	uint32	pool_id,
		uint64	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

uint32 PoolMgr::max_pool_id

private

SearchMap PoolMgr::mCreatureSearchMap

private

SearchMap PoolMgr::mGameobjectSearchMap

private

PoolGroupCreatureMap PoolMgr::mPoolCreatureGroups

private

PoolGroupGameObjectMap PoolMgr::mPoolGameobjectGroups

private

PoolGroupPoolMap PoolMgr::mPoolPoolGroups

private

PoolGroupQuestMap PoolMgr::mPoolQuestGroups

private

SearchMap PoolMgr::mPoolSearchMap

private

PoolTemplateDataMap PoolMgr::mPoolTemplate

private

PooledQuestRelation PoolMgr::mQuestCreatureRelation

PooledQuestRelation PoolMgr::mQuestGORelation

SearchMap PoolMgr::mQuestSearchMap

private

ActivePoolData PoolMgr::mSpawnedData

private

---

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

• src/server/game/Pools/PoolMgr.h
• src/server/game/Pools/PoolMgr.cpp