SpellHistory Class Reference

#include <SpellHistory.h>

Classes
struct	ChargeEntry
struct	CooldownEntry
struct	PersistenceHelper
struct	PersistenceHelper< Pet >
struct	PersistenceHelper< Player >

Public Types
using	Clock = std::chrono::system_clock
using	Duration = Milliseconds
using	ChargeEntryCollection = std::deque< ChargeEntry >
using	CooldownStorageType = std::unordered_map< uint32, CooldownEntry >
using	CategoryCooldownStorageType = std::unordered_map< uint32, CooldownEntry * >
using	ChargeStorageType = std::unordered_map< uint32, ChargeEntryCollection >
using	GlobalCooldownStorageType = std::unordered_map< uint32, Clock::time_point >

Public Member Functions
	SpellHistory (Unit *owner)
	~SpellHistory ()
	SpellHistory (SpellHistory const &)=delete
	SpellHistory (SpellHistory &&)=delete
SpellHistory &	operator= (SpellHistory const &)=delete
SpellHistory &	operator= (SpellHistory &&)=delete
template<class OwnerType >
void	LoadFromDB (PreparedQueryResult cooldownsResult, PreparedQueryResult chargesResult)
template<class OwnerType >
void	SaveToDB (CharacterDatabaseTransaction trans)
void	Update ()
void	HandleCooldowns (SpellInfo const *spellInfo, Item const *item, Spell *spell=nullptr)
void	HandleCooldowns (SpellInfo const *spellInfo, uint32 itemId, Spell *spell=nullptr)
bool	IsReady (SpellInfo const *spellInfo, uint32 itemId=0) const
template<class PacketType >
void	WritePacket (PacketType *packet) const
void	StartCooldown (SpellInfo const *spellInfo, uint32 itemId, Spell *spell=nullptr, bool onHold=false, Optional< Duration > forcedCooldown={})
void	SendCooldownEvent (SpellInfo const *spellInfo, uint32 itemId=0, Spell *spell=nullptr, bool startCooldown=true)
void	AddCooldown (uint32 spellId, uint32 itemId, Duration cooldownDuration)
void	AddCooldown (uint32 spellId, uint32 itemId, Clock::time_point cooldownEnd, uint32 categoryId, Clock::time_point categoryEnd, bool onHold=false)
void	ModifyCooldown (uint32 spellId, Duration cooldownMod, bool withoutCategoryCooldown=false)
void	ModifyCooldown (SpellInfo const *spellInfo, Duration cooldownMod, bool withoutCategoryCooldown=false)
template<typename Predicate >
void	ModifyCoooldowns (Predicate &&predicate, Duration cooldownMod, bool withoutCategoryCooldown=false)
void	ResetCooldown (uint32 spellId, bool update=false)
template<typename Predicate >
void	ResetCooldowns (Predicate predicate, bool update=false)
void	ResetAllCooldowns ()
bool	HasCooldown (SpellInfo const *spellInfo, uint32 itemId=0) const
bool	HasCooldown (uint32 spellId, uint32 itemId=0) const
Duration	GetRemainingCooldown (SpellInfo const *spellInfo) const
Duration	GetRemainingCategoryCooldown (uint32 categoryId) const
Duration	GetRemainingCategoryCooldown (SpellInfo const *spellInfo) const
void	LockSpellSchool (SpellSchoolMask schoolMask, Duration lockoutTime)
bool	IsSchoolLocked (SpellSchoolMask schoolMask) const
bool	ConsumeCharge (uint32 chargeCategoryId)
void	ModifyChargeRecoveryTime (uint32 chargeCategoryId, Duration cooldownMod)
void	RestoreCharge (uint32 chargeCategoryId)
void	ResetCharges (uint32 chargeCategoryId)
void	ResetAllCharges ()
bool	HasCharge (uint32 chargeCategoryId) const
int32	GetMaxCharges (uint32 chargeCategoryId) const
int32	GetChargeRecoveryTime (uint32 chargeCategoryId) const
bool	HasGlobalCooldown (SpellInfo const *spellInfo) const
void	AddGlobalCooldown (SpellInfo const *spellInfo, Duration duration)
void	CancelGlobalCooldown (SpellInfo const *spellInfo)
void	SaveCooldownStateBeforeDuel ()
void	RestoreCooldownStateAfterDuel ()
template<>
void	WritePacket (WorldPackets::Spells::SendSpellHistory *sendSpellHistory) const
template<>
void	WritePacket (WorldPackets::Spells::SendSpellCharges *sendSpellCharges) const
template<>
void	WritePacket (WorldPackets::Pet::PetSpells *petSpells) const

Static Public Attributes
static Duration const	InfinityCooldownDelay = Seconds(MONTH)

Private Member Functions
Player *	GetPlayerOwner () const
void	ModifySpellCooldown (uint32 spellId, Duration cooldownMod, bool withoutCategoryCooldown)
void	ModifySpellCooldown (CooldownStorageType::iterator &itr, Duration cooldownMod, bool withoutCategoryCooldown)
void	ResetCooldown (CooldownStorageType::iterator &itr, bool update=false)
void	SendClearCooldowns (std::vector< int32 > const &cooldowns) const
CooldownStorageType::iterator	EraseCooldown (CooldownStorageType::iterator itr)
void	SendSetSpellCharges (uint32 chargeCategoryId, ChargeEntryCollection const &chargeCollection)

Static Private Member Functions
static void	GetCooldownDurations (SpellInfo const *spellInfo, uint32 itemId, Duration *cooldown, uint32 *categoryId, Duration *categoryCooldown)

Private Attributes
Unit *	_owner
CooldownStorageType	_spellCooldowns
CooldownStorageType	_spellCooldownsBeforeDuel
CategoryCooldownStorageType	_categoryCooldowns
Clock::time_point	_schoolLockouts [MAX_SPELL_SCHOOL]
ChargeStorageType	_categoryCharges
GlobalCooldownStorageType	_globalCooldowns

Detailed Description

Definition at line 46 of file SpellHistory.h.

Member Typedef Documentation

CategoryCooldownStorageType

using SpellHistory::CategoryCooldownStorageType = std::unordered_map<uint32 , CooldownEntry*>

Definition at line 74 of file SpellHistory.h.

ChargeEntryCollection

using SpellHistory::ChargeEntryCollection = std::deque<ChargeEntry>

Definition at line 72 of file SpellHistory.h.

ChargeStorageType

using SpellHistory::ChargeStorageType = std::unordered_map<uint32 , ChargeEntryCollection>

Definition at line 75 of file SpellHistory.h.

Clock

using SpellHistory::Clock = std::chrono::system_clock

Definition at line 49 of file SpellHistory.h.

CooldownStorageType

using SpellHistory::CooldownStorageType = std::unordered_map<uint32 , CooldownEntry>

Definition at line 73 of file SpellHistory.h.

Duration

using SpellHistory::Duration = Milliseconds

Definition at line 50 of file SpellHistory.h.

GlobalCooldownStorageType

using SpellHistory::GlobalCooldownStorageType = std::unordered_map<uint32 , Clock::time_point>

Definition at line 76 of file SpellHistory.h.

Constructor & Destructor Documentation

SpellHistory() [1/3]

SpellHistory::SpellHistory ( Unit *  owner )

explicit

Definition at line 139 of file SpellHistory.cpp.

 : _owner(owner), _schoolLockouts()
{
}

~SpellHistory()

SpellHistory::~SpellHistory ( )

default

SpellHistory() [2/3]

SpellHistory::SpellHistory ( SpellHistory const &  )

delete

SpellHistory() [3/3]

SpellHistory::SpellHistory ( SpellHistory &&  )

delete

Member Function Documentation

AddCooldown() [1/2]

void SpellHistory::AddCooldown	(	uint32	spellId,
		uint32	itemId,
		Clock::time_point	cooldownEnd,
		uint32	categoryId,
		Clock::time_point	categoryEnd,
		bool	onHold = false
	)

Definition at line 553 of file SpellHistory.cpp.

{
 CooldownEntry& cooldownEntry = _spellCooldowns[spellId];
 // scripts can start multiple cooldowns for a given spell, only store the longest one
 if (cooldownEnd > cooldownEntry.CooldownEnd || categoryEnd > cooldownEntry.CategoryEnd || onHold)
 {
 cooldownEntry.SpellId = spellId;
 cooldownEntry.CooldownEnd = cooldownEnd;
 cooldownEntry.ItemId = itemId;
 cooldownEntry.CategoryId = categoryId;
 cooldownEntry.CategoryEnd = categoryEnd;
 cooldownEntry.OnHold = onHold;
 
 if (categoryId)
 _categoryCooldowns[categoryId] = &cooldownEntry;
 }
}

AddCooldown() [2/2]

void SpellHistory::AddCooldown ( uint32  spellId, uint32  itemId, Duration  cooldownDuration  )

inline

Definition at line 107 of file SpellHistory.h.

 {
 Clock::time_point now = GameTime::GetTime<Clock>();
 AddCooldown(spellId, itemId, now + cooldownDuration, 0, now);
 }

Here is the caller graph for this function:

AddGlobalCooldown()

void SpellHistory::AddGlobalCooldown	(	SpellInfo const *	spellInfo,
		Duration	duration
	)

Definition at line 940 of file SpellHistory.cpp.

{
 _globalCooldowns[spellInfo->StartRecoveryCategory] = Clock::now() + duration;
}

Here is the caller graph for this function:

CancelGlobalCooldown()

void SpellHistory::CancelGlobalCooldown

(

SpellInfo const *

spellInfo

)

Definition at line 945 of file SpellHistory.cpp.

{
 _globalCooldowns[spellInfo->StartRecoveryCategory] = Clock::time_point(Clock::duration(0));
}

Here is the caller graph for this function:

ConsumeCharge()

bool SpellHistory::ConsumeCharge

(

uint32

chargeCategoryId

)

Definition at line 802 of file SpellHistory.cpp.

{
 if (!sSpellCategoryStore.LookupEntry(chargeCategoryId))
 return false;
 
 int32 chargeRecovery = GetChargeRecoveryTime(chargeCategoryId);
 if (chargeRecovery > 0 && GetMaxCharges(chargeCategoryId) > 0)
 {
 Clock::time_point recoveryStart;
 std::deque<ChargeEntry>& charges = _categoryCharges[chargeCategoryId];
 if (charges.empty())
 recoveryStart = GameTime::GetTime<Clock>();
 else
 recoveryStart = charges.back().RechargeEnd;
 
 charges.emplace_back(recoveryStart, Milliseconds(chargeRecovery));
 return true;
 }
 
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EraseCooldown()

CooldownStorageType::iterator SpellHistory::EraseCooldown ( CooldownStorageType::iterator  itr )

inlineprivate

Definition at line 184 of file SpellHistory.h.

 {
 _categoryCooldowns.erase(itr->second.CategoryId);
 return _spellCooldowns.erase(itr);
 }

Here is the caller graph for this function:

GetChargeRecoveryTime()

int32 SpellHistory::GetChargeRecoveryTime

(

uint32

chargeCategoryId

)

const

Definition at line 913 of file SpellHistory.cpp.

{
 SpellCategoryEntry const* chargeCategoryEntry = sSpellCategoryStore.LookupEntry(chargeCategoryId);
 if (!chargeCategoryEntry)
 return 0;
 
 int32 recoveryTime = chargeCategoryEntry->ChargeRecoveryTime;
 recoveryTime += _owner->GetTotalAuraModifierByMiscValue(SPELL_AURA_CHARGE_RECOVERY_MOD, chargeCategoryId);
 
 float recoveryTimeF = float(recoveryTime);
 recoveryTimeF *= _owner->GetTotalAuraMultiplierByMiscValue(SPELL_AURA_CHARGE_RECOVERY_MULTIPLIER, chargeCategoryId);
 
 if (_owner->HasAuraType(SPELL_AURA_CHARGE_RECOVERY_AFFECTED_BY_HASTE))
 recoveryTimeF *= _owner->m_unitData->ModSpellHaste;
 
 if (_owner->HasAuraType(SPELL_AURA_CHARGE_RECOVERY_AFFECTED_BY_HASTE_REGEN))
 recoveryTimeF *= _owner->m_unitData->ModHasteRegen;
 
 return int32(std::floor(recoveryTimeF));
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCooldownDurations()

void SpellHistory::GetCooldownDurations ( SpellInfo const *  spellInfo, uint32  itemId, Duration *  cooldown, uint32 *  categoryId, Duration *  categoryCooldown  )

staticprivate

Definition at line 980 of file SpellHistory.cpp.

{
 ASSERT(cooldown || categoryId || categoryCooldown);
 Duration tmpCooldown = Duration::min();
 uint32 tmpCategoryId = 0;
 Duration tmpCategoryCooldown = Duration::min();
 
 // cooldown information stored in ItemEffect.db2, overriding normal cooldown and category
 if (itemId)
 {
 if (ItemTemplate const* proto = sObjectMgr->GetItemTemplate(itemId))
 {
 for (ItemEffectEntry const* itemEffect : proto->Effects)
 {
 if (uint32(itemEffect->SpellID) == spellInfo->Id)
 {
 tmpCooldown = Milliseconds(itemEffect->CoolDownMSec);
 tmpCategoryId = itemEffect->SpellCategoryID;
 tmpCategoryCooldown = Milliseconds(itemEffect->CategoryCoolDownMSec);
 break;
 }
 }
 }
 }
 
 // if no cooldown found above then base at DBC data
 if (tmpCooldown < Duration::zero() && tmpCategoryCooldown < Duration::zero())
 {
 tmpCooldown = Milliseconds(spellInfo->RecoveryTime);
 tmpCategoryId = spellInfo->GetCategory();
 tmpCategoryCooldown = Milliseconds(spellInfo->CategoryRecoveryTime);
 }
 
 if (cooldown)
 *cooldown = tmpCooldown;
 if (categoryId)
 *categoryId = tmpCategoryId;
 if (categoryCooldown)
 *categoryCooldown = tmpCategoryCooldown;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMaxCharges()

int32 SpellHistory::GetMaxCharges

(

uint32

chargeCategoryId

)

const

Definition at line 902 of file SpellHistory.cpp.

{
 SpellCategoryEntry const* chargeCategoryEntry = sSpellCategoryStore.LookupEntry(chargeCategoryId);
 if (!chargeCategoryEntry)
 return 0;
 
 uint32 charges = chargeCategoryEntry->MaxCharges;
 charges += _owner->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MAX_CHARGES, chargeCategoryId);
 return charges;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetPlayerOwner()

Player * SpellHistory::GetPlayerOwner ( ) const

private

Definition at line 950 of file SpellHistory.cpp.

{
 return _owner->GetCharmerOrOwnerPlayerOrPlayerItself();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetRemainingCategoryCooldown() [1/2]

SpellHistory::Duration SpellHistory::GetRemainingCategoryCooldown

(

SpellInfo const *

spellInfo

)

const

Definition at line 730 of file SpellHistory.cpp.

{
 return GetRemainingCategoryCooldown(spellInfo->GetCategory());
}

Here is the call graph for this function:

GetRemainingCategoryCooldown() [2/2]

SpellHistory::Duration SpellHistory::GetRemainingCategoryCooldown

(

uint32

categoryId

)

const

Definition at line 713 of file SpellHistory.cpp.

{
 Clock::time_point end;
 auto catItr = _categoryCooldowns.find(categoryId);
 if (catItr == _categoryCooldowns.end())
 return Duration::zero();
 
 end = catItr->second->CategoryEnd;
 
 Clock::time_point now = GameTime::GetTime<Clock>();
 if (end < now)
 return Duration::zero();
 
 Clock::duration remaining = end - now;
 return std::chrono::duration_cast<Milliseconds>(remaining);
}

Here is the caller graph for this function:

GetRemainingCooldown()

SpellHistory::Duration SpellHistory::GetRemainingCooldown

(

SpellInfo const *

spellInfo

)

const

Definition at line 690 of file SpellHistory.cpp.

{
 Clock::time_point end;
 auto itr = _spellCooldowns.find(spellInfo->Id);
 if (itr != _spellCooldowns.end())
 end = itr->second.CooldownEnd;
 else
 {
 auto catItr = _categoryCooldowns.find(spellInfo->GetCategory());
 if (catItr == _categoryCooldowns.end())
 return Duration::zero();
 
 end = catItr->second->CategoryEnd;
 }
 
 Clock::time_point now = GameTime::GetTime<Clock>();
 if (end < now)
 return Duration::zero();
 
 Clock::duration remaining = end - now;
 return std::chrono::duration_cast<Milliseconds>(remaining);
}

Here is the call graph for this function:

Here is the caller graph for this function:

HandleCooldowns() [1/2]

void SpellHistory::HandleCooldowns	(	SpellInfo const *	spellInfo,
		Item const *	item,
		Spell *	spell = nullptr
	)

Definition at line 246 of file SpellHistory.cpp.

{
 HandleCooldowns(spellInfo, item ? item->GetEntry() : 0, spell);
}

Here is the call graph for this function:

Here is the caller graph for this function:

HandleCooldowns() [2/2]

void SpellHistory::HandleCooldowns	(	SpellInfo const *	spellInfo,
		uint32	itemId,
		Spell *	spell = nullptr
	)

Definition at line 251 of file SpellHistory.cpp.

{
 if (spell && spell->IsIgnoringCooldowns())
 return;
 
 if (ConsumeCharge(spellInfo->ChargeCategoryId))
 return;
 
 if (Player* player = _owner->ToPlayer())
 {
 // potions start cooldown until exiting combat
 if (ItemTemplate const* itemTemplate = sObjectMgr->GetItemTemplate(itemId))
 {
 if (itemTemplate->IsPotion() || spellInfo->IsCooldownStartedOnEvent())
 {
 player->SetLastPotionId(itemId);
 return;
 }
 }
 }
 
 if (spellInfo->IsCooldownStartedOnEvent() || spellInfo->IsPassive())
 return;
 
 StartCooldown(spellInfo, itemId, spell);
}

Here is the call graph for this function:

HasCharge()

bool SpellHistory::HasCharge

(

uint32

chargeCategoryId

)

const

Definition at line 888 of file SpellHistory.cpp.

{
 if (!sSpellCategoryStore.LookupEntry(chargeCategoryId))
 return true;
 
 // Check if the spell is currently using charges (untalented warlock Dark Soul)
 int32 maxCharges = GetMaxCharges(chargeCategoryId);
 if (maxCharges <= 0)
 return true;
 
 auto itr = _categoryCharges.find(chargeCategoryId);
 return itr == _categoryCharges.end() || int32(itr->second.size()) < maxCharges;
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasCooldown() [1/2]

bool SpellHistory::HasCooldown	(	SpellInfo const *	spellInfo,
		uint32	itemId = 0
	)		const

Definition at line 669 of file SpellHistory.cpp.

{
 if (_spellCooldowns.count(spellInfo->Id) != 0)
 return true;
 
 if (spellInfo->CooldownAuraSpellId && _owner->HasAura(spellInfo->CooldownAuraSpellId))
 return true;
 
 uint32 category = 0;
 GetCooldownDurations(spellInfo, itemId, nullptr, &category, nullptr);
 if (!category)
 return false;
 
 return _categoryCooldowns.count(category) != 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasCooldown() [2/2]

bool SpellHistory::HasCooldown	(	uint32	spellId,
		uint32	itemId = 0
	)		const

Definition at line 685 of file SpellHistory.cpp.

{
 return HasCooldown(sSpellMgr->AssertSpellInfo(spellId, _owner->GetMap()->GetDifficultyID()), itemId);
}

Here is the call graph for this function:

HasGlobalCooldown()

bool SpellHistory::HasGlobalCooldown

(

SpellInfo const *

spellInfo

)

const

Definition at line 934 of file SpellHistory.cpp.

{
 auto itr = _globalCooldowns.find(spellInfo->StartRecoveryCategory);
 return itr != _globalCooldowns.end() && itr->second > Clock::now();
}

Here is the caller graph for this function:

IsReady()

bool SpellHistory::IsReady	(	SpellInfo const *	spellInfo,
		uint32	itemId = 0
	)		const

Definition at line 278 of file SpellHistory.cpp.

{
 if (spellInfo->PreventionType & SPELL_PREVENTION_TYPE_SILENCE)
 if (IsSchoolLocked(spellInfo->GetSchoolMask()))
 return false;
 
 if (HasCooldown(spellInfo, itemId))
 return false;
 
 if (!HasCharge(spellInfo->ChargeCategoryId))
 return false;
 
 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsSchoolLocked()

bool SpellHistory::IsSchoolLocked

(

SpellSchoolMask

schoolMask

)

const

Definition at line 791 of file SpellHistory.cpp.

{
 Clock::time_point now = GameTime::GetTime<Clock>();
 for (uint32 i = 0; i < MAX_SPELL_SCHOOL; ++i)
 if (SpellSchoolMask(1 << i) & schoolMask)
 if (_schoolLockouts[i] > now)
 return true;
 
 return false;
}

Here is the caller graph for this function:

LoadFromDB()

template<class OwnerType >

template void SpellHistory::LoadFromDB< Pet >	(	PreparedQueryResult	cooldownsResult,
		PreparedQueryResult	chargesResult
	)

Definition at line 146 of file SpellHistory.cpp.

{
 using StatementInfo = PersistenceHelper<OwnerType>;
 
 if (cooldownsResult)
 {
 do
 {
 uint32 spellId;
 CooldownEntry cooldown;
 if (StatementInfo::ReadCooldown(cooldownsResult->Fetch(), &spellId, &cooldown))
 {
 _spellCooldowns[spellId] = cooldown;
 if (cooldown.CategoryId)
 _categoryCooldowns[cooldown.CategoryId] = &_spellCooldowns[spellId];
 }
 
 } while (cooldownsResult->NextRow());
 }
 
 if (chargesResult)
 {
 do
 {
 Field* fields = chargesResult->Fetch();
 uint32 categoryId = 0;
 ChargeEntry charges;
 if (StatementInfo::ReadCharge(fields, &categoryId, &charges))
 _categoryCharges[categoryId].push_back(charges);
 
 } while (chargesResult->NextRow());
 }
}

Here is the caller graph for this function:

LockSpellSchool()

void SpellHistory::LockSpellSchool	(	SpellSchoolMask	schoolMask,
		Duration	lockoutTime
	)

Definition at line 735 of file SpellHistory.cpp.

{
 Clock::time_point now = GameTime::GetTime<Clock>();
 Clock::time_point lockoutEnd = now + lockoutTime;
 for (uint32 i = 0; i < MAX_SPELL_SCHOOL; ++i)
 if (SpellSchoolMask(1 << i) & schoolMask)
 _schoolLockouts[i] = lockoutEnd;
 
 std::set<uint32> knownSpells;
 if (Player* plrOwner = _owner->ToPlayer())
 {
 for (auto const& p : plrOwner->GetSpellMap())
 if (p.second.state != PLAYERSPELL_REMOVED)
 knownSpells.insert(p.first);
 }
 else if (Pet* petOwner = _owner->ToPet())
 {
 for (auto const& p : petOwner->m_spells)
 if (p.second.state != PETSPELL_REMOVED)
 knownSpells.insert(p.first);
 }
 else
 {
 Creature* creatureOwner = _owner->ToCreature();
 for (uint32 spell : creatureOwner->m_spells)
 if (spell)
 knownSpells.insert(spell);
 }
 
 WorldPackets::Spells::SpellCooldown spellCooldown;
 spellCooldown.Caster = _owner->GetGUID();
 spellCooldown.Flags = SPELL_COOLDOWN_FLAG_LOSS_OF_CONTROL_UI;
 for (uint32 spellId : knownSpells)
 {
 SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(spellId, _owner->GetMap()->GetDifficultyID());
 if (spellInfo->IsCooldownStartedOnEvent())
 continue;
 
 if (!(spellInfo->PreventionType & SPELL_PREVENTION_TYPE_SILENCE))
 continue;
 
 if (!(schoolMask & spellInfo->GetSchoolMask()))
 continue;
 
 if (GetRemainingCooldown(spellInfo) < lockoutTime)
 AddCooldown(spellId, 0, lockoutEnd, 0, now);
 
 // always send cooldown, even if it will be shorter than already existing cooldown for LossOfControl UI
 spellCooldown.SpellCooldowns.emplace_back(spellId, lockoutTime.count());
 }
 
 if (Player* player = GetPlayerOwner())
 if (!spellCooldown.SpellCooldowns.empty())
 player->SendDirectMessage(spellCooldown.Write());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ModifyChargeRecoveryTime()

void SpellHistory::ModifyChargeRecoveryTime	(	uint32	chargeCategoryId,
		Duration	cooldownMod
	)

Definition at line 824 of file SpellHistory.cpp.

{
 SpellCategoryEntry const* chargeCategoryEntry = sSpellCategoryStore.LookupEntry(chargeCategoryId);
 if (!chargeCategoryEntry)
 return;
 
 auto itr = _categoryCharges.find(chargeCategoryId);
 if (itr == _categoryCharges.end() || itr->second.empty())
 return;
 
 Clock::time_point now = GameTime::GetTime<Clock>();
 
 for (ChargeEntry& entry : itr->second)
 {
 entry.RechargeStart += cooldownMod;
 entry.RechargeEnd += cooldownMod;
 }
 
 while (!itr->second.empty() && itr->second.front().RechargeEnd < now)
 itr->second.pop_front();
 
 SendSetSpellCharges(chargeCategoryId, itr->second);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ModifyCooldown() [1/2]

void SpellHistory::ModifyCooldown	(	SpellInfo const *	spellInfo,
		Duration	cooldownMod,
		bool	withoutCategoryCooldown = false
	)

Definition at line 616 of file SpellHistory.cpp.

{
 if (!cooldownMod.count())
 return;
 
 if (GetChargeRecoveryTime(spellInfo->ChargeCategoryId) > 0 && GetMaxCharges(spellInfo->ChargeCategoryId) > 0)
 ModifyChargeRecoveryTime(spellInfo->ChargeCategoryId, cooldownMod);
 else
 ModifySpellCooldown(spellInfo->Id, cooldownMod, withoutCategoryCooldown);
}

Here is the call graph for this function:

ModifyCooldown() [2/2]

void SpellHistory::ModifyCooldown	(	uint32	spellId,
		Duration	cooldownMod,
		bool	withoutCategoryCooldown = false
	)

Definition at line 610 of file SpellHistory.cpp.

{
 if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId, _owner->GetMap()->GetDifficultyID()))
 ModifyCooldown(spellInfo, cooldownMod, withoutCategoryCooldown);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ModifyCoooldowns()

template<typename Predicate >

void SpellHistory::ModifyCoooldowns ( Predicate &&  predicate, Duration  cooldownMod, bool  withoutCategoryCooldown = false  )

inline

Definition at line 117 of file SpellHistory.h.

 {
 for (auto itr = _spellCooldowns.begin(); itr != _spellCooldowns.end();)
 {
 if (predicate(itr))
 ModifySpellCooldown(itr, cooldownMod, withoutCategoryCooldown);
 else
 ++itr;
 }
 }

Here is the caller graph for this function:

ModifySpellCooldown() [1/2]

void SpellHistory::ModifySpellCooldown ( CooldownStorageType::iterator &  itr, Duration  cooldownMod, bool  withoutCategoryCooldown  )

private

Definition at line 580 of file SpellHistory.cpp.

{
 Clock::time_point now = GameTime::GetTime<Clock>();
 
 itr->second.CooldownEnd += cooldownMod;
 
 if (itr->second.CategoryId)
 {
 if (!withoutCategoryCooldown)
 itr->second.CategoryEnd += cooldownMod;
 
 // Because category cooldown existence is tied to regular cooldown, we cannot allow a situation where regular cooldown is shorter than category
 if (itr->second.CooldownEnd < itr->second.CategoryEnd)
 itr->second.CooldownEnd = itr->second.CategoryEnd;
 }
 
 if (Player* playerOwner = GetPlayerOwner())
 {
 WorldPackets::Spells::ModifyCooldown modifyCooldown;
 modifyCooldown.IsPet = _owner != playerOwner;
 modifyCooldown.SpellID = itr->second.SpellId;
 modifyCooldown.DeltaTime = std::chrono::duration_cast<Milliseconds>(cooldownMod).count();
 modifyCooldown.WithoutCategoryCooldown = withoutCategoryCooldown;
 playerOwner->SendDirectMessage(modifyCooldown.Write());
 }
 
 if (itr->second.CooldownEnd <= now)
 itr = EraseCooldown(itr);
}

Here is the call graph for this function:

ModifySpellCooldown() [2/2]

void SpellHistory::ModifySpellCooldown ( uint32  spellId, Duration  cooldownMod, bool  withoutCategoryCooldown  )

private

Definition at line 571 of file SpellHistory.cpp.

{
 auto itr = _spellCooldowns.find(spellId);
 if (!cooldownMod.count() || itr == _spellCooldowns.end())
 return;
 
 ModifySpellCooldown(itr, cooldownMod, withoutCategoryCooldown);
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

SpellHistory & SpellHistory::operator= ( SpellHistory &&  )

delete

operator=() [2/2]

SpellHistory & SpellHistory::operator= ( SpellHistory const &  )

delete

ResetAllCharges()

void SpellHistory::ResetAllCharges

(

)

Definition at line 876 of file SpellHistory.cpp.

{
 _categoryCharges.clear();
 
 if (Player* player = GetPlayerOwner())
 {
 WorldPackets::Spells::ClearAllSpellCharges clearAllSpellCharges;
 clearAllSpellCharges.IsPet = _owner != player;
 player->SendDirectMessage(clearAllSpellCharges.Write());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetAllCooldowns()

void SpellHistory::ResetAllCooldowns

(

)

Definition at line 653 of file SpellHistory.cpp.

{
 if (GetPlayerOwner())
 {
 std::vector<int32> cooldowns;
 cooldowns.reserve(_spellCooldowns.size());
 for (auto const& p : _spellCooldowns)
 cooldowns.push_back(p.first);
 
 SendClearCooldowns(cooldowns);
 }
 
 _categoryCooldowns.clear();
 _spellCooldowns.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetCharges()

void SpellHistory::ResetCharges

(

uint32

chargeCategoryId

)

Definition at line 859 of file SpellHistory.cpp.

{
 auto itr = _categoryCharges.find(chargeCategoryId);
 if (itr != _categoryCharges.end())
 {
 _categoryCharges.erase(itr);
 
 if (Player* player = GetPlayerOwner())
 {
 WorldPackets::Spells::ClearSpellCharges clearSpellCharges;
 clearSpellCharges.IsPet = _owner != player;
 clearSpellCharges.Category = chargeCategoryId;
 player->SendDirectMessage(clearSpellCharges.Write());
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetCooldown() [1/2]

void SpellHistory::ResetCooldown ( CooldownStorageType::iterator &  itr, bool  update = false  )

private

Definition at line 636 of file SpellHistory.cpp.

{
 if (update)
 {
 if (Player* playerOwner = GetPlayerOwner())
 {
 WorldPackets::Spells::ClearCooldown clearCooldown;
 clearCooldown.IsPet = _owner != playerOwner;
 clearCooldown.SpellID = itr->first;
 clearCooldown.ClearOnHold = false;
 playerOwner->SendDirectMessage(clearCooldown.Write());
 }
 }
 
 itr = EraseCooldown(itr);
}

Here is the call graph for this function:

ResetCooldown() [2/2]

void SpellHistory::ResetCooldown	(	uint32	spellId,
		bool	update = false
	)

Definition at line 627 of file SpellHistory.cpp.

{
 auto itr = _spellCooldowns.find(spellId);
 if (itr == _spellCooldowns.end())
 return;
 
 ResetCooldown(itr, update);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetCooldowns()

template<typename Predicate >

void SpellHistory::ResetCooldowns ( Predicate  predicate, bool  update = false  )

inline

Definition at line 130 of file SpellHistory.h.

 {
 std::vector<int32> resetCooldowns;
 resetCooldowns.reserve(_spellCooldowns.size());
 for (auto itr = _spellCooldowns.begin(); itr != _spellCooldowns.end();)
 {
 if (predicate(itr))
 {
 resetCooldowns.push_back(int32(itr->first));
 ResetCooldown(itr, false);
 }
 else
 ++itr;
 }
 
 if (update && !resetCooldowns.empty())
 SendClearCooldowns(resetCooldowns);
 }

Here is the caller graph for this function:

RestoreCharge()

void SpellHistory::RestoreCharge

(

uint32

chargeCategoryId

)

Definition at line 848 of file SpellHistory.cpp.

{
 auto itr = _categoryCharges.find(chargeCategoryId);
 if (itr != _categoryCharges.end() && !itr->second.empty())
 {
 itr->second.pop_back();
 
 SendSetSpellCharges(chargeCategoryId, itr->second);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RestoreCooldownStateAfterDuel()

void SpellHistory::RestoreCooldownStateAfterDuel

(

)

Definition at line 1026 of file SpellHistory.cpp.

{
 if (Player* player = _owner->ToPlayer())
 {
 // add all profession CDs created while in duel (if any)
 for (auto const& c : _spellCooldowns)
 {
 SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(c.first, DIFFICULTY_NONE);
 
 if (spellInfo->RecoveryTime > 10 * MINUTE * IN_MILLISECONDS ||
 spellInfo->CategoryRecoveryTime > 10 * MINUTE * IN_MILLISECONDS)
 _spellCooldownsBeforeDuel[c.first] = _spellCooldowns[c.first];
 }
 
 // check for spell with onHold active before and during the duel
 for (CooldownStorageType::value_type const& pair : _spellCooldownsBeforeDuel)
 {
 if (!pair.second.OnHold &&
 _spellCooldowns.find(pair.first) != _spellCooldowns.end() &&
 !_spellCooldowns[pair.first].OnHold)
 _spellCooldowns[pair.first] = _spellCooldownsBeforeDuel[pair.first];
 }
 
 // update the client: restore old cooldowns
 WorldPackets::Spells::SpellCooldown spellCooldown;
 spellCooldown.Caster = _owner->GetGUID();
 spellCooldown.Flags = SPELL_COOLDOWN_FLAG_INCLUDE_EVENT_COOLDOWNS;
 
 for (auto const& c : _spellCooldowns)
 {
 Clock::time_point now = GameTime::GetTime<Clock>();
 uint32 cooldownDuration = uint32(c.second.CooldownEnd > now ? std::chrono::duration_cast<Milliseconds>(c.second.CooldownEnd - now).count() : 0);
 
 // cooldownDuration must be between 0 and 10 minutes in order to avoid any visual bugs
 if (cooldownDuration <= 0 || cooldownDuration > 10 * MINUTE * IN_MILLISECONDS || c.second.OnHold)
 continue;
 
 spellCooldown.SpellCooldowns.emplace_back(c.first, cooldownDuration);
 }
 
 player->SendDirectMessage(spellCooldown.Write());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SaveCooldownStateBeforeDuel()

void SpellHistory::SaveCooldownStateBeforeDuel

(

)

Definition at line 1021 of file SpellHistory.cpp.

{
 _spellCooldownsBeforeDuel = _spellCooldowns;
}

Here is the caller graph for this function:

SaveToDB()

template<class OwnerType >

template void SpellHistory::SaveToDB< Pet >

(

CharacterDatabaseTransaction

trans

)

Definition at line 181 of file SpellHistory.cpp.

{
 using StatementInfo = PersistenceHelper<OwnerType>;
 
 uint8 index = 0;
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::CooldownsDeleteStatement);
 StatementInfo::SetIdentifier(stmt, index++, _owner);
 trans->Append(stmt);
 
 for (auto const& p : _spellCooldowns)
 {
 if (!p.second.OnHold)
 {
 index = 0;
 stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::CooldownsInsertStatement);
 StatementInfo::SetIdentifier(stmt, index++, _owner);
 StatementInfo::WriteCooldown(stmt, index, p);
 trans->Append(stmt);
 }
 }
 
 stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::ChargesDeleteStatement);
 StatementInfo::SetIdentifier(stmt, 0, _owner);
 trans->Append(stmt);
 
 for (auto const& p : _categoryCharges)
 {
 for (ChargeEntry const& charge : p.second)
 {
 index = 0;
 stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::ChargesInsertStatement);
 StatementInfo::SetIdentifier(stmt, index++, _owner);
 StatementInfo::WriteCharge(stmt, index, p.first, charge);
 trans->Append(stmt);
 }
 }
}

Here is the caller graph for this function:

SendClearCooldowns()

void SpellHistory::SendClearCooldowns ( std::vector< int32 > const &  cooldowns ) const

private

Definition at line 955 of file SpellHistory.cpp.

{
 if (Player const* playerOwner = GetPlayerOwner())
 {
 WorldPackets::Spells::ClearCooldowns clearCooldowns;
 clearCooldowns.IsPet = _owner != playerOwner;
 clearCooldowns.SpellID = cooldowns;
 playerOwner->SendDirectMessage(clearCooldowns.Write());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SendCooldownEvent()

void SpellHistory::SendCooldownEvent	(	SpellInfo const *	spellInfo,
		uint32	itemId = 0,
		Spell *	spell = nullptr,
		bool	startCooldown = true
	)

Definition at line 528 of file SpellHistory.cpp.

{
 // Send activate cooldown timer (possible 0) at client side
 if (Player* player = GetPlayerOwner())
 {
 uint32 category = spellInfo->GetCategory();
 GetCooldownDurations(spellInfo, itemId, nullptr, &category, nullptr);
 
 auto categoryItr = _categoryCooldowns.find(category);
 if (categoryItr != _categoryCooldowns.end() && categoryItr->second->SpellId != spellInfo->Id)
 {
 player->SendDirectMessage(WorldPackets::Spells::CooldownEvent(player != _owner, categoryItr->second->SpellId).Write());
 
 if (startCooldown)
 StartCooldown(sSpellMgr->AssertSpellInfo(categoryItr->second->SpellId, _owner->GetMap()->GetDifficultyID()), itemId, spell);
 }
 
 player->SendDirectMessage(WorldPackets::Spells::CooldownEvent(player != _owner, spellInfo->Id).Write());
 }
 
 // start cooldowns at server side, if any
 if (startCooldown)
 StartCooldown(spellInfo, itemId, spell);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SendSetSpellCharges()

void SpellHistory::SendSetSpellCharges ( uint32  chargeCategoryId, ChargeEntryCollection const &  chargeCollection  )

private

Definition at line 966 of file SpellHistory.cpp.

{
 if (Player* player = GetPlayerOwner())
 {
 WorldPackets::Spells::SetSpellCharges setSpellCharges;
 setSpellCharges.Category = chargeCategoryId;
 if (!chargeCollection.empty())
 setSpellCharges.NextRecoveryTime = uint32(std::chrono::duration_cast<Milliseconds>(chargeCollection.front().RechargeEnd - Clock::now()).count());
 setSpellCharges.ConsumedCharges = uint8(chargeCollection.size());
 setSpellCharges.IsPet = player != _owner;
 player->SendDirectMessage(setSpellCharges.Write());
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartCooldown()

void SpellHistory::StartCooldown	(	SpellInfo const *	spellInfo,
		uint32	itemId,
		Spell *	spell = nullptr,
		bool	onHold = false,
		Optional< Duration >	forcedCooldown = {}
	)

Definition at line 405 of file SpellHistory.cpp.

{
 // init cooldown values
 uint32 categoryId = 0;
 Duration cooldown = Duration::zero();
 Duration categoryCooldown = Duration::zero();
 
 Clock::time_point curTime = GameTime::GetTime<Clock>();
 Clock::time_point catrecTime;
 Clock::time_point recTime;
 bool needsCooldownPacket = false;
 
 if (!forcedCooldown)
 GetCooldownDurations(spellInfo, itemId, &cooldown, &categoryId, &categoryCooldown);
 else
 cooldown = *forcedCooldown;
 
 // overwrite time for selected category
 if (onHold)
 {
 // use +MONTH as infinite cooldown marker
 catrecTime = categoryCooldown > Duration::zero() ? (curTime + InfinityCooldownDelay) : curTime;
 recTime = cooldown > Duration::zero() ? (curTime + InfinityCooldownDelay) : catrecTime;
 }
 else
 {
 if (!forcedCooldown)
 {
 // Now we have cooldown data (if found any), time to apply mods
 if (Player* modOwner = _owner->GetSpellModOwner())
 {
 auto applySpellMod = [&](Milliseconds& value)
 {
 int32 intValue = value.count();
 modOwner->ApplySpellMod(spellInfo, SpellModOp::Cooldown, intValue, spell);
 value = Milliseconds(intValue);
 };
 
 if (cooldown >= Duration::zero())
 applySpellMod(cooldown);
 
 if (categoryCooldown >= Clock::duration::zero() && !spellInfo->HasAttribute(SPELL_ATTR6_NO_CATEGORY_COOLDOWN_MODS))
 applySpellMod(categoryCooldown);
 }
 
 if (_owner->HasAuraTypeWithAffectMask(SPELL_AURA_MOD_SPELL_COOLDOWN_BY_HASTE, spellInfo))
 {
 cooldown = Duration(int64(cooldown.count() * _owner->m_unitData->ModSpellHaste));
 categoryCooldown = Duration(int64(categoryCooldown.count() * _owner->m_unitData->ModSpellHaste));
 }
 
 if (_owner->HasAuraTypeWithAffectMask(SPELL_AURA_MOD_COOLDOWN_BY_HASTE_REGEN, spellInfo))
 {
 cooldown = Duration(int64(cooldown.count() * _owner->m_unitData->ModHasteRegen));
 categoryCooldown = Duration(int64(categoryCooldown.count() * _owner->m_unitData->ModHasteRegen));
 }
 
 if (int32 cooldownMod = _owner->GetTotalAuraModifier(SPELL_AURA_MOD_COOLDOWN))
 {
 // Apply SPELL_AURA_MOD_COOLDOWN only to own spells
 Player* playerOwner = GetPlayerOwner();
 if (!playerOwner || playerOwner->HasSpell(spellInfo->Id))
 {
 needsCooldownPacket = true;
 cooldown += Milliseconds(cooldownMod); // SPELL_AURA_MOD_COOLDOWN does not affect category cooldows, verified with shaman shocks
 }
 }
 
 // Apply SPELL_AURA_MOD_SPELL_CATEGORY_COOLDOWN modifiers
 // Note: This aura applies its modifiers to all cooldowns of spells with set category, not to category cooldown only
 if (categoryId)
 {
 if (int32 categoryModifier = _owner->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_SPELL_CATEGORY_COOLDOWN, categoryId))
 {
 if (cooldown > Duration::zero())
 cooldown += Milliseconds(categoryModifier);
 
 if (categoryCooldown > Duration::zero())
 categoryCooldown += Milliseconds(categoryModifier);
 }
 
 SpellCategoryEntry const* categoryEntry = sSpellCategoryStore.AssertEntry(categoryId);
 if (categoryEntry->Flags & SPELL_CATEGORY_FLAG_COOLDOWN_EXPIRES_AT_DAILY_RESET)
 categoryCooldown = std::chrono::duration_cast<Milliseconds>(Clock::from_time_t(sWorld->GetNextDailyQuestsResetTime()) - Clock::now());
 }
 }
 else
 needsCooldownPacket = true;
 
 // replace negative cooldowns by 0
 if (cooldown < Duration::zero())
 cooldown = Duration::zero();
 
 if (categoryCooldown < Duration::zero())
 categoryCooldown = Duration::zero();
 
 // no cooldown after applying spell mods
 if (cooldown == Duration::zero() && categoryCooldown == Duration::zero())
 return;
 
 catrecTime = categoryCooldown != Duration::zero() ? curTime + std::chrono::duration_cast<Clock::duration>(Milliseconds(categoryCooldown)) : curTime;
 recTime = cooldown != Duration::zero() ? curTime + std::chrono::duration_cast<Clock::duration>(Milliseconds(cooldown)) : catrecTime;
 }
 
 // self spell cooldown
 if (recTime != curTime)
 {
 AddCooldown(spellInfo->Id, itemId, recTime, categoryId, catrecTime, onHold);
 
 if (needsCooldownPacket)
 {
 if (Player* playerOwner = GetPlayerOwner())
 {
 WorldPackets::Spells::SpellCooldown spellCooldown;
 spellCooldown.Caster = _owner->GetGUID();
 spellCooldown.Flags = SPELL_COOLDOWN_FLAG_NONE;
 spellCooldown.SpellCooldowns.emplace_back(spellInfo->Id, uint32(cooldown.count()));
 playerOwner->SendDirectMessage(spellCooldown.Write());
 }
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Update()

void SpellHistory::Update

(

)

Definition at line 219 of file SpellHistory.cpp.

{
 Clock::time_point now = GameTime::GetTime<Clock>();
 for (auto itr = _categoryCooldowns.begin(); itr != _categoryCooldowns.end();)
 {
 if (itr->second->CategoryEnd < now)
 itr = _categoryCooldowns.erase(itr);
 else
 ++itr;
 }
 
 for (auto itr = _spellCooldowns.begin(); itr != _spellCooldowns.end();)
 {
 if (itr->second.CooldownEnd < now)
 itr = EraseCooldown(itr);
 else
 ++itr;
 }
 
 for (auto& p : _categoryCharges)
 {
 std::deque<ChargeEntry>& chargeRefreshTimes = p.second;
 while (!chargeRefreshTimes.empty() && chargeRefreshTimes.front().RechargeEnd <= now)
 chargeRefreshTimes.pop_front();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

WritePacket() [1/4]

template<class PacketType >

void SpellHistory::WritePacket

(

PacketType *

packet

)

const

Definition at line 294 of file SpellHistory.cpp.

{
 static_assert(!std::is_same<PacketType, PacketType>::value /*static_assert(false)*/, "This packet is not supported.");
}

Here is the caller graph for this function:

WritePacket() [2/4]

template<>

void SpellHistory::WritePacket

(

WorldPackets::Pet::PetSpells *

petSpells

)

const

Definition at line 358 of file SpellHistory.cpp.

{
 Clock::time_point now = GameTime::GetTime<Clock>();
 
 petSpells->Cooldowns.reserve(_spellCooldowns.size());
 for (auto const& p : _spellCooldowns)
 {
 WorldPackets::Pet::PetSpellCooldown petSpellCooldown;
 petSpellCooldown.SpellID = p.first;
 petSpellCooldown.Category = p.second.CategoryId;
 
 if (!p.second.OnHold)
 {
 Milliseconds cooldownDuration = std::chrono::duration_cast<Milliseconds>(p.second.CooldownEnd - now);
 if (cooldownDuration.count() <= 0)
 continue;
 
 petSpellCooldown.Duration = uint32(cooldownDuration.count());
 Milliseconds categoryDuration = std::chrono::duration_cast<Milliseconds>(p.second.CategoryEnd - now);
 if (categoryDuration.count() > 0)
 petSpellCooldown.CategoryDuration = uint32(categoryDuration.count());
 }
 else
 petSpellCooldown.CategoryDuration = 0x80000000;
 
 petSpells->Cooldowns.push_back(petSpellCooldown);
 }
 
 petSpells->SpellHistory.reserve(_categoryCharges.size());
 for (auto const& p : _categoryCharges)
 {
 if (!p.second.empty())
 {
 Milliseconds cooldownDuration = std::chrono::duration_cast<Milliseconds>(p.second.front().RechargeEnd - now);
 if (cooldownDuration.count() <= 0)
 continue;
 
 WorldPackets::Pet::PetSpellHistory petChargeEntry;
 petChargeEntry.CategoryID = p.first;
 petChargeEntry.RecoveryTime = uint32(cooldownDuration.count());
 petChargeEntry.ConsumedCharges = int8(p.second.size());
 
 petSpells->SpellHistory.push_back(petChargeEntry);
 }
 }
}

WritePacket() [3/4]

template<>

void SpellHistory::WritePacket

(

WorldPackets::Spells::SendSpellCharges *

sendSpellCharges

)

const

Definition at line 335 of file SpellHistory.cpp.

{
 sendSpellCharges->Entries.reserve(_categoryCharges.size());
 
 Clock::time_point now = GameTime::GetTime<Clock>();
 for (auto const& p : _categoryCharges)
 {
 if (!p.second.empty())
 {
 Milliseconds cooldownDuration = std::chrono::duration_cast<Milliseconds>(p.second.front().RechargeEnd - now);
 if (cooldownDuration.count() <= 0)
 continue;
 
 WorldPackets::Spells::SpellChargeEntry chargeEntry;
 chargeEntry.Category = p.first;
 chargeEntry.NextRecoveryTime = uint32(cooldownDuration.count());
 chargeEntry.ConsumedCharges = uint8(p.second.size());
 sendSpellCharges->Entries.push_back(chargeEntry);
 }
 }
}

WritePacket() [4/4]

template<>

void SpellHistory::WritePacket

(

WorldPackets::Spells::SendSpellHistory *

sendSpellHistory

)

const

Definition at line 300 of file SpellHistory.cpp.

{
 sendSpellHistory->Entries.reserve(_spellCooldowns.size());
 
 Clock::time_point now = GameTime::GetTime<Clock>();
 for (auto const& p : _spellCooldowns)
 {
 WorldPackets::Spells::SpellHistoryEntry historyEntry;
 historyEntry.SpellID = p.first;
 historyEntry.ItemID = p.second.ItemId;
 
 if (p.second.OnHold)
 historyEntry.OnHold = true;
 else
 {
 Milliseconds cooldownDuration = std::chrono::duration_cast<Milliseconds>(p.second.CooldownEnd - now);
 if (cooldownDuration.count() <= 0)
 continue;
 
 Milliseconds categoryDuration = std::chrono::duration_cast<Milliseconds>(p.second.CategoryEnd - now);
 if (categoryDuration.count() > 0)
 {
 historyEntry.Category = p.second.CategoryId;
 historyEntry.CategoryRecoveryTime = uint32(categoryDuration.count());
 }
 
 if (cooldownDuration.count() > categoryDuration.count())
 historyEntry.RecoveryTime = uint32(cooldownDuration.count());
 }
 
 sendSpellHistory->Entries.push_back(historyEntry);
 }
}

Member Data Documentation

_categoryCharges

ChargeStorageType SpellHistory::_categoryCharges

private

Definition at line 199 of file SpellHistory.h.

_categoryCooldowns

CategoryCooldownStorageType SpellHistory::_categoryCooldowns

private

Definition at line 197 of file SpellHistory.h.

_globalCooldowns

GlobalCooldownStorageType SpellHistory::_globalCooldowns

private

Definition at line 200 of file SpellHistory.h.

_owner

Unit* SpellHistory::_owner

private

Definition at line 194 of file SpellHistory.h.

_schoolLockouts

Clock::time_point SpellHistory::_schoolLockouts[MAX_SPELL_SCHOOL]

private

Definition at line 198 of file SpellHistory.h.

_spellCooldowns

CooldownStorageType SpellHistory::_spellCooldowns

private

Definition at line 195 of file SpellHistory.h.

_spellCooldownsBeforeDuel

CooldownStorageType SpellHistory::_spellCooldownsBeforeDuel

private

Definition at line 196 of file SpellHistory.h.

InfinityCooldownDelay

SpellHistory::Duration const SpellHistory::InfinityCooldownDelay = Seconds(MONTH)

static

Definition at line 102 of file SpellHistory.h.

---

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

• src/server/game/Spells/SpellHistory.h
• src/server/game/Spells/SpellHistory.cpp