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
PoolObject *	RollOne (ActivePoolData &spawns, uint64 triggerFrom)
void	DespawnObject (ActivePoolData &spawns, uint64 guid=0)
void	Despawn1Object (uint64 guid)
void	SpawnObject (ActivePoolData &spawns, uint32 limit, uint64 triggerFrom)
void	Spawn1Object (PoolObject *obj)
void	ReSpawn1Object (PoolObject *obj)
void	RemoveOneRelation (uint32 child_pool_id)
uint64	GetFirstEqualChancedObjectId ()
uint32	GetPoolId () const

Private Types
typedef std::vector< PoolObject >	PoolObjectList

Private Attributes
uint32	poolId
PoolObjectList	ExplicitlyChanced
PoolObjectList	EqualChanced

Member Typedef Documentation

template<class T>

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

private

Constructor & Destructor Documentation

template<class T>

PoolGroup< T >::PoolGroup ( )

inlineexplicit

: poolId(0) { }

template<class T>

PoolGroup< T >::~PoolGroup ( )

inline

{ };

Member Function Documentation

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

Here is the caller graph for this function:

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

template<class T>

void PoolGroup< T >::Despawn1Object

(

uint64

guid

)

template<class T >

void PoolGroup< T >::DespawnObject	(	ActivePoolData &	spawns,
		uint64	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);
 }
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T>

uint64 PoolGroup< T >::GetFirstEqualChancedObjectId ( )

inline

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

template<class T>

uint32 PoolGroup< T >::GetPoolId ( ) const

inline

{ return poolId; }

template<class T>

bool PoolGroup< T >::isEmpty ( ) const

inline

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

template<class T>

void PoolGroup< T >::RemoveOneRelation

(

uint32

child_pool_id

)

template<class T>

void PoolGroup< T >::ReSpawn1Object

(

PoolObject *

obj

)

template<class T >

PoolObject * PoolGroup< T >::RollOne	(	ActivePoolData &	spawns,
		uint64	triggerFrom
	)

{
 if (!ExplicitlyChanced.empty())
 {
 float roll = (float)rand_chance();

 for (uint32 i = 0; i < ExplicitlyChanced.size(); ++i)
 {
 roll -= ExplicitlyChanced[i].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 && (ExplicitlyChanced[i].guid == triggerFrom || !spawns.IsActiveObject<T>(ExplicitlyChanced[i].guid)))
 return &ExplicitlyChanced[i];
 }
 }
 if (!EqualChanced.empty())
 {
 uint32 index = urand(0, EqualChanced.size()-1);
 // 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 (EqualChanced[index].guid == triggerFrom || !spawns.IsActiveObject<T>(EqualChanced[index].guid))
 return &EqualChanced[index];
 }

 return NULL;
}

Here is the call graph for this function:

template<class T>

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

inline

{ poolId = pool_id; }

Here is the caller graph for this function:

template<class T>

void PoolGroup< T >::Spawn1Object

(

PoolObject *

obj

)

Here is the caller graph for this function:

template<class T >

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

{
 uint32 lastDespawned = 0;
 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;

 // This will try to spawn the rest of pool, not guaranteed
 for (int i = 0; i < count; ++i)
 {
 PoolObject* obj = RollOne(spawns, triggerFrom);
 if (!obj)
 continue;
 if (obj->guid == lastDespawned)
 continue;

 if (obj->guid == triggerFrom)
 {
 ReSpawn1Object(obj);
 triggerFrom = 0;
 continue;
 }
 spawns.ActivateObject<T>(obj->guid, poolId);
 Spawn1Object(obj);

 if (triggerFrom)
 {
 // One spawn one despawn no count increase
 DespawnObject(spawns, triggerFrom);
 lastDespawned = triggerFrom;
 triggerFrom = 0;
 }
 }
}

Here is the call graph for this function:

Member Data Documentation

template<class T>

PoolObjectList PoolGroup< T >::EqualChanced

private

template<class T>

PoolObjectList PoolGroup< T >::ExplicitlyChanced

private

template<class T>

uint32 PoolGroup< T >::poolId

private

---

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

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