PoolGroup< T > Class Template Reference

#include "PoolMgr.h"

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

Private Types
typedef std::vector< PoolObject >	PoolObjectList

Static Private Member Functions
static bool	IsSpawnableOnMap (uint32 db_guid_or_pool_id, Map *map)

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

(

)

const

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

template<class T >

void PoolGroup< T >::Despawn1Object	(	SpawnedPoolData &	spawns,
		ObjectGuid::LowType	guid
	)

DespawnObject()

template<class T >

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

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

References SpawnedPoolData::IsSpawnedObject(), and SpawnedPoolData::RemoveSpawn().

GetEqualChanced()

template<class T >

std::vector< PoolObject > const & PoolGroup< T >::GetEqualChanced ( ) const

inline

{ return EqualChanced; }

References PoolGroup< T >::EqualChanced.

GetExplicitlyChanced()

template<class T >

std::vector< PoolObject > const & PoolGroup< T >::GetExplicitlyChanced ( ) const

inline

{ return ExplicitlyChanced; }

References PoolGroup< T >::ExplicitlyChanced.

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.

IsEmptyDeepCheck()

template<class T >

bool PoolGroup< T >::IsEmptyDeepCheck

(

)

const

{
    return IsEmpty();
}

IsSpawnableOnMap()

template<class T >

bool PoolGroup< T >::IsSpawnableOnMap ( uint32  db_guid_or_pool_id, Map *  map  )

staticprivate

{
    return true;
}

RemoveOneRelation()

template<class T >

void PoolGroup< T >::RemoveOneRelation

(

uint32

child_pool_id

)

ReSpawn1Object()

template<typename T >

void PoolGroup< T >::ReSpawn1Object	(	SpawnedPoolData &	spawns,
		PoolObject *	obj
	)

{
    Despawn1Object(spawns, obj->guid);
    Spawn1Object(spawns, obj);
}

References PoolObject::guid.

SetPoolId()

template<class T >

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

inline

{ poolId = pool_id; }

References PoolGroup< T >::poolId.

Referenced by PoolMgr::LoadFromDB().

Spawn1Object()

template<class T >

void PoolGroup< T >::Spawn1Object	(	SpawnedPoolData &	spawns,
		PoolObject *	obj
	)

Referenced by TEST_F().

SpawnObject()

template<class T >

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

{
    int count = limit - spawns.GetSpawnedObjects(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.IsSpawnedObject<T>(obj.guid) && IsSpawnableOnMap(obj.guid, spawns.GetMap()))))
                {
                    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.IsSpawnedObject<T>(object.guid) && IsSpawnableOnMap(object.guid, spawns.GetMap()));
            });
 
            Acore::Containers::RandomResize(rolledObjects, count);
        }
 
        // try to spawn rolled objects
        for (PoolObject& obj : rolledObjects)
        {
            if (obj.guid == triggerFrom)
            {
                ReSpawn1Object(spawns, &obj);
                triggerFrom = 0;
            }
            else
            {
                spawns.AddSpawn<T>(obj.guid, poolId);
                Spawn1Object(spawns, &obj);
            }
        }
    }
 
    // One spawn one despawn no count increase
    if (triggerFrom)
    {
        DespawnObject(spawns, triggerFrom);
    }
}

References SpawnedPoolData::AddSpawn(), SpawnedPoolData::GetMap(), SpawnedPoolData::GetSpawnedObjects(), SpawnedPoolData::IsSpawnedObject(), rand_chance(), and Acore::Containers::RandomResize().

Member Data Documentation

EqualChanced

template<class T >

PoolObjectList PoolGroup< T >::EqualChanced

private

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

ExplicitlyChanced

template<class T >

PoolObjectList PoolGroup< T >::ExplicitlyChanced

private

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

poolId

template<class T >

uint32 PoolGroup< T >::poolId

private

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

---

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