PoolGroup< T > Class Template Reference

#include "PoolMgr.h"

Public Member Functions
	PoolGroup ()
void	SetPoolId (uint32 pool_id)
	~PoolGroup ()
bool	IsEmpty () const
void	AddEntry (PoolObject &poolitem, uint32 maxentries)
bool	CheckPool () const
void	DespawnObject (ActivePoolData &spawns, ObjectGuid::LowType guid=0)
void	Despawn1Object (ObjectGuid::LowType guid)
void	SpawnObject (ActivePoolData &spawns, uint32 limit, uint32 triggerFrom)
void	Spawn1Object (PoolObject *obj)
void	ReSpawn1Object (PoolObject *obj)
void	RemoveOneRelation (uint32 child_pool_id)
uint32	GetFirstEqualChancedObjectId ()
uint32	GetPoolId () const
void	Despawn1Object (ObjectGuid::LowType guid)
void	Despawn1Object (ObjectGuid::LowType guid)
void	Despawn1Object (uint32 child_pool_id)
void	Despawn1Object (uint32 quest_id)
void	RemoveOneRelation (uint32 child_pool_id)
void	Spawn1Object (PoolObject *obj)
void	Spawn1Object (PoolObject *obj)
void	Spawn1Object (PoolObject *obj)
void	Spawn1Object (PoolObject *obj)
void	SpawnObject (ActivePoolData &spawns, uint32 limit, uint32 triggerFrom)
void	ReSpawn1Object (PoolObject *)
void	ReSpawn1Object (PoolObject *)
void	ReSpawn1Object (PoolObject *)
void	ReSpawn1Object (PoolObject *)

Private Types
typedef std::vector< PoolObject >	PoolObjectList

Private Attributes
uint32	poolId
PoolObjectList	ExplicitlyChanced
PoolObjectList	EqualChanced

Detailed Description

template<class T>
class PoolGroup< T >

Member Typedef Documentation

PoolObjectList

template<class T >

typedef std::vector<PoolObject> PoolGroup< T >::PoolObjectList

private

Constructor & Destructor Documentation

PoolGroup()

template<class T >

PoolGroup< T >::PoolGroup ( )

inlineexplicit

: poolId(0) { }

~PoolGroup()

template<class T >

PoolGroup< T >::~PoolGroup ( )

inline

{};

Member Function Documentation

AddEntry()

template<class T >

void PoolGroup< T >::AddEntry	(	PoolObject &	poolitem,
		uint32	maxentries
	)

{
    if (poolitem.chance != 0 && maxentries == 1)
        ExplicitlyChanced.push_back(poolitem);
    else
        EqualChanced.push_back(poolitem);
}

References PoolObject::chance.

Referenced by PoolMgr::LoadFromDB().

CheckPool()

template<class T >

bool PoolGroup< T >::CheckPool

{
    if (EqualChanced.empty())
    {
        float chance = 0;
        for (uint32 i = 0; i < ExplicitlyChanced.size(); ++i)
            chance += ExplicitlyChanced[i].chance;
        if (chance != 100 && chance != 0)
            return false;
    }
    return true;
}

Despawn1Object() [1/5]

void PoolGroup< Creature >::Despawn1Object

(

ObjectGuid::LowType

guid

)

{
    if (CreatureData const* data = sObjectMgr->GetCreatureData(guid))
    {
        sObjectMgr->RemoveCreatureFromGrid(guid, data);
 
        Map* map = sMapMgr->CreateBaseMap(data->mapid);
        if (!map->Instanceable())
        {
            auto creatureBounds = map->GetCreatureBySpawnIdStore().equal_range(guid);
            for (auto itr = creatureBounds.first; itr != creatureBounds.second;)
            {
                Creature* creature = itr->second;
                ++itr;
                creature->AddObjectToRemoveList();
            }
        }
    }
}

References WorldObject::AddObjectToRemoveList(), Map::GetCreatureBySpawnIdStore(), Map::Instanceable(), sMapMgr, and sObjectMgr.

Despawn1Object() [2/5]

void PoolGroup< GameObject >::Despawn1Object

(

ObjectGuid::LowType

guid

)

{
    if (GameObjectData const* data = sObjectMgr->GetGameObjectData(guid))
    {
        sObjectMgr->RemoveGameobjectFromGrid(guid, data);
 
        Map* map = sMapMgr->CreateBaseMap(data->mapid);
        if (!map->Instanceable())
        {
            auto gameobjectBounds = map->GetGameObjectBySpawnIdStore().equal_range(guid);
            for (auto itr = gameobjectBounds.first; itr != gameobjectBounds.second;)
            {
                GameObject* go = itr->second;
                ++itr;
                go->AddObjectToRemoveList();
            }
        }
    }
}

References WorldObject::AddObjectToRemoveList(), Map::GetGameObjectBySpawnIdStore(), Map::Instanceable(), sMapMgr, and sObjectMgr.

Despawn1Object() [3/5]

template<class T >

void PoolGroup< T >::Despawn1Object

(

ObjectGuid::LowType

guid

)

Despawn1Object() [4/5]

void PoolGroup< Pool >::Despawn1Object

(

uint32

child_pool_id

)

{
    sPoolMgr->DespawnPool(child_pool_id);
}

References sPoolMgr.

Despawn1Object() [5/5]

void PoolGroup< Quest >::Despawn1Object

(

uint32

quest_id

)

{
    // Creatures
    QuestRelations* questMap = sObjectMgr->GetCreatureQuestRelationMap();
    PooledQuestRelationBoundsNC qr = sPoolMgr->mQuestCreatureRelation.equal_range(quest_id);
    for (PooledQuestRelation::iterator itr = qr.first; itr != qr.second; ++itr)
    {
        QuestRelations::iterator qitr = questMap->find(itr->second);
        if (qitr == questMap->end())
            continue;
        QuestRelations::iterator lastElement = questMap->upper_bound(itr->second);
        for (; qitr != lastElement; ++qitr)
        {
            if (qitr->first == itr->second && qitr->second == itr->first)
            {
                questMap->erase(qitr);                  // iterator is now no more valid
                break;                                  // but we can exit loop since the element is found
            }
        }
    }
 
    // Gameobjects
    questMap = sObjectMgr->GetGOQuestRelationMap();
    qr = sPoolMgr->mQuestGORelation.equal_range(quest_id);
    for (PooledQuestRelation::iterator itr = qr.first; itr != qr.second; ++itr)
    {
        QuestRelations::iterator qitr = questMap->find(itr->second);
        if (qitr == questMap->end())
            continue;
        QuestRelations::iterator lastElement = questMap->upper_bound(itr->second);
        for (; qitr != lastElement; ++qitr)
        {
            if (qitr->first == itr->second && qitr->second == itr->first)
            {
                questMap->erase(qitr);                  // iterator is now no more valid
                break;                                  // but we can exit loop since the element is found
            }
        }
    }
}

References sObjectMgr, and sPoolMgr.

DespawnObject()

template<class T >

void PoolGroup< T >::DespawnObject	(	ActivePoolData &	spawns,
		ObjectGuid::LowType	guid = 0
	)

{
    for (size_t i = 0; i < EqualChanced.size(); ++i)
    {
        // if spawned
        if (spawns.IsActiveObject<T>(EqualChanced[i].guid))
        {
            if (!guid || EqualChanced[i].guid == guid)
            {
                Despawn1Object(EqualChanced[i].guid);
                spawns.RemoveObject<T>(EqualChanced[i].guid, poolId);
            }
        }
    }
 
    for (size_t i = 0; i < ExplicitlyChanced.size(); ++i)
    {
        // spawned
        if (spawns.IsActiveObject<T>(ExplicitlyChanced[i].guid))
        {
            if (!guid || ExplicitlyChanced[i].guid == guid)
            {
                Despawn1Object(ExplicitlyChanced[i].guid);
                spawns.RemoveObject<T>(ExplicitlyChanced[i].guid, poolId);
            }
        }
    }
}

References ActivePoolData::IsActiveObject(), and ActivePoolData::RemoveObject().

GetFirstEqualChancedObjectId()

template<class T >

uint32 PoolGroup< T >::GetFirstEqualChancedObjectId ( )

inline

    {
        if (EqualChanced.empty())
            return 0;
        return EqualChanced.front().guid;
    }

References PoolGroup< T >::EqualChanced.

GetPoolId()

template<class T >

uint32 PoolGroup< T >::GetPoolId ( ) const

inline

{ return poolId; }

References PoolGroup< T >::poolId.

IsEmpty()

template<class T >

bool PoolGroup< T >::IsEmpty ( ) const

inline

{ return ExplicitlyChanced.empty() && EqualChanced.empty(); }

References PoolGroup< T >::EqualChanced, and PoolGroup< T >::ExplicitlyChanced.

RemoveOneRelation() [1/2]

void PoolGroup< Pool >::RemoveOneRelation

(

uint32

child_pool_id

)

{
    for (PoolObjectList::iterator itr = ExplicitlyChanced.begin(); itr != ExplicitlyChanced.end(); ++itr)
    {
        if (itr->guid == child_pool_id)
        {
            ExplicitlyChanced.erase(itr);
            break;
        }
    }
    for (PoolObjectList::iterator itr = EqualChanced.begin(); itr != EqualChanced.end(); ++itr)
    {
        if (itr->guid == child_pool_id)
        {
            EqualChanced.erase(itr);
            break;
        }
    }
}

RemoveOneRelation() [2/2]

template<class T >

void PoolGroup< T >::RemoveOneRelation

(

uint32

child_pool_id

)

ReSpawn1Object() [1/5]

void PoolGroup< Creature >::ReSpawn1Object

(

PoolObject *

)

{
    // Creature is still on map, nothing to do
}

ReSpawn1Object() [2/5]

void PoolGroup< GameObject >::ReSpawn1Object

(

PoolObject *

)

{
    // Gameobject is still on map, nothing to do
}

ReSpawn1Object() [3/5]

void PoolGroup< Pool >::ReSpawn1Object

(

PoolObject *

)

{
}

ReSpawn1Object() [4/5]

void PoolGroup< Quest >::ReSpawn1Object

(

PoolObject *

)

{
}

ReSpawn1Object() [5/5]

template<class T >

void PoolGroup< T >::ReSpawn1Object

(

PoolObject *

obj

)

SetPoolId()

template<class T >

void PoolGroup< T >::SetPoolId ( uint32  pool_id )

inline

{ poolId = pool_id; }

References PoolGroup< T >::poolId.

Referenced by PoolMgr::LoadFromDB().

Spawn1Object() [1/5]

void PoolGroup< Creature >::Spawn1Object

(

PoolObject *

obj

)

{
    if (CreatureData const* data = sObjectMgr->GetCreatureData(obj->guid))
    {
        sObjectMgr->AddCreatureToGrid(obj->guid, data);
 
        // Spawn if necessary (loaded grids only)
        Map* map = sMapMgr->CreateBaseMap(data->mapid);
        // We use spawn coords to spawn
        if (!map->Instanceable() && map->IsGridLoaded(data->posX, data->posY))
        {
            Creature* creature = new Creature;
            //LOG_DEBUG("pool", "Spawning creature {}", guid);
            if (!creature->LoadCreatureFromDB(obj->guid, map))
            {
                delete creature;
                return;
            }
        }
    }
}

References PoolObject::guid, Map::Instanceable(), Map::IsGridLoaded(), Creature::LoadCreatureFromDB(), sMapMgr, and sObjectMgr.

Spawn1Object() [2/5]

void PoolGroup< GameObject >::Spawn1Object

(

PoolObject *

obj

)

{
    if (GameObjectData const* data = sObjectMgr->GetGameObjectData(obj->guid))
    {
        sObjectMgr->AddGameobjectToGrid(obj->guid, data);
        // Spawn if necessary (loaded grids only)
        // this base map checked as non-instanced and then only existed
        Map* map = sMapMgr->CreateBaseMap(data->mapid);
        // We use current coords to unspawn, not spawn coords since creature can have changed grid
        if (!map->Instanceable() && map->IsGridLoaded(data->posX, data->posY))
        {
            GameObject* pGameobject = sObjectMgr->IsGameObjectStaticTransport(data->id) ? new StaticTransport() : new GameObject();
            //LOG_DEBUG("pool", "Spawning gameobject {}", guid);
            if (!pGameobject->LoadGameObjectFromDB(obj->guid, map, false))
            {
                delete pGameobject;
                return;
            }
            else
            {
                if (pGameobject->isSpawnedByDefault())
                    map->AddToMap(pGameobject);
            }
        }
    }
}

References Map::AddToMap(), PoolObject::guid, Map::Instanceable(), Map::IsGridLoaded(), GameObject::isSpawnedByDefault(), GameObject::LoadGameObjectFromDB(), sMapMgr, and sObjectMgr.

Spawn1Object() [3/5]

void PoolGroup< Pool >::Spawn1Object

(

PoolObject *

obj

)

{
    sPoolMgr->SpawnPool(obj->guid);
}

References PoolObject::guid, and sPoolMgr.

Spawn1Object() [4/5]

void PoolGroup< Quest >::Spawn1Object

(

PoolObject *

obj

)

{
    // Creatures
    QuestRelations* questMap = sObjectMgr->GetCreatureQuestRelationMap();
    PooledQuestRelationBoundsNC qr = sPoolMgr->mQuestCreatureRelation.equal_range(obj->guid);
    for (PooledQuestRelation::iterator itr = qr.first; itr != qr.second; ++itr)
    {
        LOG_DEBUG("pool", "PoolGroup<Quest>: Adding quest {} to creature {}", itr->first, itr->second);
        questMap->insert(QuestRelations::value_type(itr->second, itr->first));
    }
 
    // Gameobjects
    questMap = sObjectMgr->GetGOQuestRelationMap();
    qr = sPoolMgr->mQuestGORelation.equal_range(obj->guid);
    for (PooledQuestRelation::iterator itr = qr.first; itr != qr.second; ++itr)
    {
        LOG_DEBUG("pool", "PoolGroup<Quest>: Adding quest {} to GO {}", itr->first, itr->second);
        questMap->insert(QuestRelations::value_type(itr->second, itr->first));
    }
}

References PoolObject::guid, LOG_DEBUG, sObjectMgr, and sPoolMgr.

Spawn1Object() [5/5]

template<class T >

void PoolGroup< T >::Spawn1Object

(

PoolObject *

obj

)

SpawnObject() [1/2]

void PoolGroup< Quest >::SpawnObject	(	ActivePoolData &	spawns,
		uint32	limit,
		uint32	triggerFrom
	)

{
    LOG_DEBUG("pool", "PoolGroup<Quest>: Spawning pool {}", poolId);
    // load state from db
    if (!triggerFrom)
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_POOL_QUEST_SAVE);
 
        stmt->SetData(0, poolId);
 
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
        if (result)
        {
            do
            {
                uint32 questId = result->Fetch()[0].Get<uint32>();
                spawns.ActivateObject<Quest>(questId, poolId);
                PoolObject tempObj(questId, 0.0f);
                Spawn1Object(&tempObj);
                --limit;
            } while (result->NextRow() && limit);
            return;
        }
    }
 
    ActivePoolObjects currentQuests = spawns.GetActiveQuests();
    ActivePoolObjects newQuests;
 
    // always try to select different quests
    for (PoolObjectList::iterator itr = EqualChanced.begin(); itr != EqualChanced.end(); ++itr)
    {
        if (spawns.IsActiveObject<Quest>(itr->guid))
            continue;
        newQuests.insert(itr->guid);
    }
 
    // clear the pool
    DespawnObject(spawns);
 
    // recycle minimal amount of quests if possible count is lower than limit
    if (limit > newQuests.size() && !currentQuests.empty())
    {
        do
        {
            uint32 questId = Acore::Containers::SelectRandomContainerElement(currentQuests);
            newQuests.insert(questId);
            currentQuests.erase(questId);
        } while (newQuests.size() < limit && !currentQuests.empty()); // failsafe
    }
 
    if (newQuests.empty())
        return;
 
    // activate <limit> random quests
    do
    {
        uint32 questId = Acore::Containers::SelectRandomContainerElement(newQuests);
        spawns.ActivateObject<Quest>(questId, poolId);
        PoolObject tempObj(questId, 0.0f);
        Spawn1Object(&tempObj);
        newQuests.erase(questId);
        --limit;
    } while (limit && !newQuests.empty());
 
    // if we are here it means the pool is initialized at startup and did not have previous saved state
    if (!triggerFrom)
        sPoolMgr->SaveQuestsToDB(false, false, true);
}

References ActivePoolData::ActivateObject(), CHAR_SEL_POOL_QUEST_SAVE, CharacterDatabase, ActivePoolData::GetActiveQuests(), ActivePoolData::IsActiveObject(), LOG_DEBUG, Acore::Containers::SelectRandomContainerElement(), PreparedStatementBase::SetData(), and sPoolMgr.

SpawnObject() [2/2]

template<class T >

void PoolGroup< T >::SpawnObject	(	ActivePoolData &	spawns,
		uint32	limit,
		uint32	triggerFrom
	)

{
    int count = limit - spawns.GetActiveObjectCount(poolId);
 
    // If triggered from some object respawn this object is still marked as spawned
    // and also counted into m_SpawnedPoolAmount so we need increase count to be
    // spawned by 1
    if (triggerFrom)
    {
        ++count;
    }
 
    if (count > 0)
    {
        PoolObjectList rolledObjects;
        rolledObjects.reserve(count);
 
        // roll objects to be spawned
        if (!ExplicitlyChanced.empty())
        {
            float roll = (float)rand_chance();
 
            for (PoolObject& obj : ExplicitlyChanced)
            {
                roll -= obj.chance;
 
                // Triggering object is marked as spawned at this time and can be also rolled (respawn case)
                // so this need explicit check for this case
                if (roll < 0 && (/*obj.guid == triggerFrom ||*/ !spawns.IsActiveObject<T>(obj.guid)))
                {
                    rolledObjects.push_back(obj);
                    break;
                }
            }
        }
 
        if (!EqualChanced.empty() && rolledObjects.empty())
        {
            std::copy_if(EqualChanced.begin(), EqualChanced.end(), std::back_inserter(rolledObjects), [/*triggerFrom, */&spawns](PoolObject const& object)
            {
                 return /*object.guid == triggerFrom ||*/ !spawns.IsActiveObject<T>(object.guid);
            });
 
            Acore::Containers::RandomResize(rolledObjects, count);
        }
 
        // try to spawn rolled objects
        for (PoolObject& obj : rolledObjects)
        {
            if (obj.guid == triggerFrom)
            {
                ReSpawn1Object(&obj);
                triggerFrom = 0;
            }
            else
            {
                spawns.ActivateObject<T>(obj.guid, poolId);
                Spawn1Object(&obj);
            }
        }
    }
 
    // One spawn one despawn no count increase
    if (triggerFrom)
    {
        DespawnObject(spawns, triggerFrom);
    }
}

References ActivePoolData::ActivateObject(), ActivePoolData::GetActiveObjectCount(), ActivePoolData::IsActiveObject(), rand_chance(), and Acore::Containers::RandomResize().

Member Data Documentation

EqualChanced

template<class T >

PoolObjectList PoolGroup< T >::EqualChanced

private

Referenced by PoolGroup< T >::GetFirstEqualChancedObjectId(), and PoolGroup< T >::IsEmpty().

ExplicitlyChanced

template<class T >

PoolObjectList PoolGroup< T >::ExplicitlyChanced

private

Referenced by PoolGroup< T >::IsEmpty().

poolId

template<class T >

uint32 PoolGroup< T >::poolId

private

Referenced by PoolGroup< T >::GetPoolId(), and PoolGroup< T >::SetPoolId().