SpellHistory Class Reference

#include <SpellHistory.h>

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

Public Types
typedef std::chrono::system_clock	Clock
typedef std::unordered_map < uint32, CooldownEntry >	CooldownStorageType
typedef std::unordered_map < uint32, CooldownEntry * >	CategoryCooldownStorageType
typedef std::unordered_map < uint32, std::deque < ChargeEntry > >	ChargeStorageType
typedef std::unordered_map < uint32, Clock::time_point >	GlobalCooldownStorageType

Public Member Functions
	SpellHistory (Unit *owner)
template<class OwnerType >
void	LoadFromDB (PreparedQueryResult cooldownsResult, PreparedQueryResult chargesResult)
template<class OwnerType >
void	SaveToDB (SQLTransaction &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, bool ignoreCategoryCooldown=false) const
template<class PacketType >
void	WritePacket (PacketType *packet) const
void	StartCooldown (SpellInfo const *spellInfo, uint32 itemId, Spell *spell=nullptr, bool onHold=false)
void	SendCooldownEvent (SpellInfo const *spellInfo, uint32 itemId=0, Spell *spell=nullptr, bool startCooldown=true)
template<class Type , class Period >
void	AddCooldown (uint32 spellId, uint32 itemId, std::chrono::duration< Type, Period > cooldownDuration)
void	AddCooldown (uint32 spellId, uint32 itemId, Clock::time_point cooldownEnd, uint32 categoryId, Clock::time_point categoryEnd, bool onHold=false)
void	ModifyCooldown (uint32 spellId, int32 cooldownModMs)
void	ResetCooldown (uint32 spellId, bool update=false)
void	ResetCooldown (CooldownStorageType::iterator &itr, bool update=false)
template<typename Predicate >
void	ResetCooldowns (Predicate predicate, bool update=false)
void	ResetAllCooldowns ()
bool	HasCooldown (SpellInfo const *spellInfo, uint32 itemId=0, bool ignoreCategoryCooldown=false) const
bool	HasCooldown (uint32 spellId, uint32 itemId=0, bool ignoreCategoryCooldown=false) const
uint32	GetRemainingCooldown (SpellInfo const *spellInfo) const
void	LockSpellSchool (SpellSchoolMask schoolMask, uint32 lockoutTime)
bool	IsSchoolLocked (SpellSchoolMask schoolMask) const
bool	ConsumeCharge (SpellCategoryEntry const *chargeCategoryEntry)
void	RestoreCharge (SpellCategoryEntry const *chargeCategoryEntry)
void	ResetCharges (SpellCategoryEntry const *chargeCategoryEntry)
void	ResetAllCharges ()
bool	HasCharge (SpellCategoryEntry const *chargeCategoryEntry) const
int32	GetMaxCharges (SpellCategoryEntry const *chargeCategoryEntry) const
int32	GetChargeRecoveryTime (SpellCategoryEntry const *chargeCategoryEntry) const
bool	HasGlobalCooldown (SpellInfo const *spellInfo) const
void	AddGlobalCooldown (SpellInfo const *spellInfo, uint32 duration)
void	CancelGlobalCooldown (SpellInfo const *spellInfo)
uint16	GetArenaCooldownsSize ()
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 Clock::duration const	InfinityCooldownDelay = std::chrono::duration_cast<SpellHistory::Clock::duration>(std::chrono::seconds(MONTH))

Private Member Functions
Player *	GetPlayerOwner () const
void	SendClearCooldowns (std::vector< int32 > const &cooldowns) const
CooldownStorageType::iterator	EraseCooldown (CooldownStorageType::iterator itr)

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

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

Member Typedef Documentation

typedef std::unordered_map<uint32 , CooldownEntry*> SpellHistory::CategoryCooldownStorageType

typedef std::unordered_map<uint32 , std::deque<ChargeEntry> > SpellHistory::ChargeStorageType

typedef std::chrono::system_clock SpellHistory::Clock

typedef std::unordered_map<uint32 , CooldownEntry> SpellHistory::CooldownStorageType

typedef std::unordered_map<uint32 , Clock::time_point> SpellHistory::GlobalCooldownStorageType

Constructor & Destructor Documentation

SpellHistory::SpellHistory ( Unit *  owner )

inlineexplicit

: _owner(owner), _schoolLockouts() { }

Member Function Documentation

template<class Type , class Period >

void SpellHistory::AddCooldown ( uint32  spellId, uint32  itemId, std::chrono::duration< Type, Period >  cooldownDuration  )

inline

 {
 Clock::time_point now = Clock::now();
 AddCooldown(spellId, itemId, now + std::chrono::duration_cast<Clock::duration>(cooldownDuration), 0, now);
 }

Here is the caller graph for this function:

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

{
 CooldownEntry& cooldownEntry = _spellCooldowns[spellId];
 cooldownEntry.SpellId = spellId;
 cooldownEntry.CooldownEnd = cooldownEnd;
 cooldownEntry.ItemId = itemId;
 cooldownEntry.CategoryId = categoryId;
 cooldownEntry.CategoryEnd = categoryEnd;
 cooldownEntry.OnHold = onHold;

 if (categoryId)
 _categoryCooldowns[categoryId] = &cooldownEntry;
}

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

{
 _globalCooldowns[spellInfo->StartRecoveryCategory] = Clock::now() + std::chrono::duration_cast<Clock::duration>(std::chrono::milliseconds(duration));
}

Here is the call graph for this function:

void SpellHistory::CancelGlobalCooldown

(

SpellInfo const *

spellInfo

)

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

bool SpellHistory::ConsumeCharge

(

SpellCategoryEntry const *

chargeCategoryEntry

)

{
 if (!chargeCategoryEntry)
 return false;

 int32 chargeRecovery = GetChargeRecoveryTime(chargeCategoryEntry);
 if (chargeRecovery > 0 && GetMaxCharges(chargeCategoryEntry) > 0)
 {
 Clock::time_point recoveryStart;
 std::deque<ChargeEntry>& charges = _categoryCharges[chargeCategoryEntry->ID];
 if (charges.empty())
 recoveryStart = Clock::now();
 else
 recoveryStart = charges.back().RechargeEnd;

 charges.emplace_back(recoveryStart, std::chrono::milliseconds(chargeRecovery));
 return true;
 }

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

inlineprivate

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

Here is the caller graph for this function:

uint16 SpellHistory::GetArenaCooldownsSize

(

)

int32 SpellHistory::GetChargeRecoveryTime

(

SpellCategoryEntry const *

chargeCategoryEntry

)

const

{
 if (!chargeCategoryEntry)
 return 0;

 int32 recoveryTime = chargeCategoryEntry->ChargeRecoveryTime;
 recoveryTime += _owner->GetTotalAuraModifierByMiscValue(SPELL_AURA_CHARGE_RECOVERY_MOD, chargeCategoryEntry->ID);

 float recoveryTimeF = recoveryTime;
 recoveryTimeF *= _owner->GetTotalAuraMultiplierByMiscValue(SPELL_AURA_CHARGE_RECOVERY_MULTIPLIER, chargeCategoryEntry->ID);

 if (_owner->HasAuraType(SPELL_AURA_CHARGE_RECOVERY_AFFECTED_BY_HASTE))
 recoveryTimeF *= _owner->GetFloatValue(UNIT_MOD_CAST_HASTE);

 if (_owner->HasAuraType(SPELL_AURA_CHARGE_RECOVERY_AFFECTED_BY_HASTE_REGEN))
 recoveryTimeF *= _owner->GetFloatValue(UNIT_FIELD_MOD_HASTE_REGEN);

 return int32(std::floor(recoveryTimeF));
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

staticprivate

{
 ASSERT(cooldown || categoryId || categoryCooldown);
 int32 tmpCooldown = -1;
 uint32 tmpCategoryId = 0;
 int32 tmpCategoryCooldown = -1;

 // 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 (itemEffect->SpellID == spellInfo->Id)
 {
 tmpCooldown = itemEffect->Cooldown;
 tmpCategoryId = itemEffect->Category;
 tmpCategoryCooldown = itemEffect->CategoryCooldown;
 break;
 }
 }
 }
 }

 // if no cooldown found above then base at DBC data
 if (tmpCooldown < 0 && tmpCategoryCooldown < 0)
 {
 tmpCooldown = spellInfo->RecoveryTime;
 tmpCategoryId = spellInfo->GetCategory();
 tmpCategoryCooldown = 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:

int32 SpellHistory::GetMaxCharges

(

SpellCategoryEntry const *

chargeCategoryEntry

)

const

{
 if (!chargeCategoryEntry)
 return 0;

 uint32 charges = chargeCategoryEntry->MaxCharges;
 charges += _owner->GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_MAX_CHARGES, chargeCategoryEntry->ID);
 return charges;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Player * SpellHistory::GetPlayerOwner ( ) const

private

{
 return _owner->GetCharmerOrOwnerPlayerOrPlayerItself();
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 SpellHistory::GetRemainingCooldown

(

SpellInfo const *

spellInfo

)

const

{
 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 0;

 end = catItr->second->CategoryEnd;
 }

 Clock::time_point now = Clock::now();
 if (end < now)
 return 0;

 Clock::duration remaining = end - now;
 return uint32(std::chrono::duration_cast<std::chrono::milliseconds>(remaining).count());
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

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

{
 if (ConsumeCharge(spellInfo->ChargeCategoryEntry))
 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() || (spell && spell->IsIgnoringCooldowns()))
 return;

 StartCooldown(spellInfo, itemID, spell);
}

Here is the call graph for this function:

bool SpellHistory::HasCharge

(

SpellCategoryEntry const *

chargeCategoryEntry

)

const

{
 if (!chargeCategoryEntry)
 return true;

 // Check if the spell is currently using charges (untalented warlock Dark Soul)
 int32 maxCharges = GetMaxCharges(chargeCategoryEntry);
 if (maxCharges <= 0)
 return true;

 auto itr = _categoryCharges.find(chargeCategoryEntry->ID);
 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:

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

{
 if (_spellCooldowns.count(spellInfo->Id) != 0)
 return true;

 if (ignoreCategoryCooldown)
 return false;

 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:

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

{
 return HasCooldown(sSpellMgr->AssertSpellInfo(spellId), itemId, ignoreCategoryCooldown);
}

Here is the call graph for this function:

bool SpellHistory::HasGlobalCooldown

(

SpellInfo const *

spellInfo

)

const

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

Here is the caller graph for this function:

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

{
 if (spellInfo->PreventionType == SPELL_PREVENTION_TYPE_SILENCE)
 if (IsSchoolLocked(spellInfo->GetSchoolMask()))
 return false;

 if (HasCooldown(spellInfo->Id, itemId, ignoreCategoryCooldown))
 return false;

 if (!HasCharge(spellInfo->ChargeCategoryEntry))
 return false;

 return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool SpellHistory::IsSchoolLocked

(

SpellSchoolMask

schoolMask

)

const

{
 Clock::time_point now = Clock::now();
 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:

template<class OwnerType >

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

{
 typedef PersistenceHelper<OwnerType> StatementInfo;

 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:

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

{
 Clock::time_point now = Clock::now();
 Clock::time_point lockoutEnd = now + std::chrono::duration_cast<Clock::duration>(std::chrono::milliseconds(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 (uint8 i = 0; i < CREATURE_MAX_SPELLS; ++i)
 if (creatureOwner->m_spells[i])
 knownSpells.insert(creatureOwner->m_spells[i]);
 }

 WorldPackets::Spells::SpellCooldown spellCooldown;
 spellCooldown.Caster = _owner->GetGUID();
 spellCooldown.Flags = SPELL_COOLDOWN_FLAG_NONE;
 for (uint32 spellId : knownSpells)
 {
 SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(spellId);
 if (spellInfo->IsCooldownStartedOnEvent())
 continue;

 if (spellInfo->PreventionType != SPELL_PREVENTION_TYPE_SILENCE)
 continue;

 if ((schoolMask & spellInfo->GetSchoolMask()) && GetRemainingCooldown(spellInfo) < lockoutTime)
 {
 spellCooldown.SpellCooldowns.emplace_back(spellId, lockoutTime);
 AddCooldown(spellId, 0, lockoutEnd, 0, now);
 }
 }

 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:

void SpellHistory::ModifyCooldown	(	uint32	spellId,
		int32	cooldownModMs
	)

{
 auto itr = _spellCooldowns.find(spellId);
 if (!cooldownModMs || itr == _spellCooldowns.end())
 return;

 Clock::time_point now = Clock::now();
 Clock::duration offset = std::chrono::duration_cast<Clock::duration>(std::chrono::milliseconds(cooldownModMs));
 if (itr->second.CooldownEnd + offset > now)
 itr->second.CooldownEnd += offset;
 else
 EraseCooldown(itr);

 if (Player* playerOwner = GetPlayerOwner())
 {
 WorldPackets::Spells::ModifyCooldown modifyCooldown;
 modifyCooldown.IsPet = _owner != playerOwner;
 modifyCooldown.SpellID = spellId;
 modifyCooldown.DeltaTime = cooldownModMs;
 playerOwner->SendDirectMessage(modifyCooldown.Write());
 }
}

Here is the call graph for this function:

void SpellHistory::ResetAllCharges

(

)

{
 _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:

void SpellHistory::ResetAllCooldowns

(

)

{
 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:

void SpellHistory::ResetCharges

(

SpellCategoryEntry const *

chargeCategoryEntry

)

{
 if (!chargeCategoryEntry)
 return;

 auto itr = _categoryCharges.find(chargeCategoryEntry->ID);
 if (itr != _categoryCharges.end())
 {
 _categoryCharges.erase(itr);

 if (Player* player = GetPlayerOwner())
 {
 WorldPackets::Spells::ClearSpellCharges clearSpellCharges;
 clearSpellCharges.IsPet = _owner != player;
 clearSpellCharges.Category = chargeCategoryEntry->ID;
 player->SendDirectMessage(clearSpellCharges.Write());
 }
 }
}

Here is the call graph for this function:

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

{
 auto itr = _spellCooldowns.find(spellId);
 if (itr == _spellCooldowns.end())
 return;

 ResetCooldown(itr, update);
}

Here is the caller graph for this function:

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

{
 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:

template<typename Predicate >

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

inline

 {
 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:

void SpellHistory::RestoreCharge

(

SpellCategoryEntry const *

chargeCategoryEntry

)

{
 if (!chargeCategoryEntry)
 return;

 auto itr = _categoryCharges.find(chargeCategoryEntry->ID);
 if (itr != _categoryCharges.end() && !itr->second.empty())
 {
 itr->second.pop_back();

 if (Player* player = GetPlayerOwner())
 {
 WorldPackets::Spells::SetSpellCharges setSpellCharges;
 setSpellCharges.Category = chargeCategoryEntry->ID;
 if (!itr->second.empty())
 setSpellCharges.NextRecoveryTime = uint32(std::chrono::duration_cast<std::chrono::milliseconds>(itr->second.front().RechargeEnd - Clock::now()).count());
 setSpellCharges.ConsumedCharges = itr->second.size();
 setSpellCharges.IsPet = player != _owner;

 player->SendDirectMessage(setSpellCharges.Write());
 }
 }
}

Here is the call graph for this function:

void SpellHistory::RestoreCooldownStateAfterDuel

(

)

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

 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 (auto itr = _spellCooldownsBeforeDuel.begin(); itr != _spellCooldownsBeforeDuel.end(); ++itr)
 {
 if (!itr->second.OnHold &&
 _spellCooldowns.find(itr->first) != _spellCooldowns.end() &&
 !_spellCooldowns[itr->first].OnHold)
 _spellCooldowns[itr->first] = _spellCooldownsBeforeDuel[itr->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 = Clock::now();
 uint32 cooldownDuration = c.second.CooldownEnd > now ? std::chrono::duration_cast<std::chrono::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:

void SpellHistory::SaveCooldownStateBeforeDuel

(

)

{
    _spellCooldownsBeforeDuel = _spellCooldowns;
}

template<class OwnerType >

template void SpellHistory::SaveToDB< Pet >

(

SQLTransaction &

trans

)

{
    typedef PersistenceHelper<OwnerType> StatementInfo;

    uint8 index = 0;
    PreparedStatement* 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 call graph for this function:

Here is the caller graph for this function:

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

private

{
    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:

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

{
    // 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), 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:

void SpellHistory::StartCooldown	(	SpellInfo const *	spellInfo,
		uint32	itemId,
		Spell *	spell = nullptr,
		bool	onHold = false
	)

{
    // init cooldown values
    uint32 categoryId = 0;
    int32 cooldown = -1;
    int32 categoryCooldown = -1;

    GetCooldownDurations(spellInfo, itemId, &cooldown, &categoryId, &categoryCooldown);

    Clock::time_point curTime = Clock::now();
    Clock::time_point catrecTime;
    Clock::time_point recTime;
    bool needsCooldownPacket = false;

    // overwrite time for selected category
    if (onHold)
    {
        // use +MONTH as infinite cooldown marker
        catrecTime = categoryCooldown > 0 ? (curTime + InfinityCooldownDelay) : curTime;
        recTime = cooldown > 0 ? (curTime + InfinityCooldownDelay) : catrecTime;
    }
    else
    {
        // shoot spells used equipped item cooldown values already assigned in GetAttackTime(RANGED_ATTACK)
        // prevent 0 cooldowns set by another way
        if (cooldown <= 0 && categoryCooldown <= 0 && (categoryId == 76 || (spellInfo->IsAutoRepeatRangedSpell() && spellInfo->Id != 75)))
            cooldown = _owner->GetAttackTime(RANGED_ATTACK);

        // Now we have cooldown data (if found any), time to apply mods
        if (Player* modOwner = _owner->GetSpellModOwner())
        {
            if (cooldown > 0)
                modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_COOLDOWN, cooldown, spell);

            if (categoryCooldown > 0 && !spellInfo->HasAttribute(SPELL_ATTR6_IGNORE_CATEGORY_COOLDOWN_MODS))
                modOwner->ApplySpellMod(spellInfo->Id, SPELLMOD_COOLDOWN, categoryCooldown, spell);
        }

        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 += cooldownMod * IN_MILLISECONDS;   // 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 > 0)
                    cooldown += categoryModifier;

                if (categoryCooldown > 0)
                    categoryCooldown += categoryModifier;
            }

            SpellCategoryEntry const* categoryEntry = sSpellCategoryStore.AssertEntry(categoryId);
            if (categoryEntry->Flags & SPELL_CATEGORY_FLAG_COOLDOWN_EXPIRES_AT_DAILY_RESET)
                categoryCooldown = int32(std::chrono::duration_cast<std::chrono::milliseconds>(Clock::from_time_t(sWorld->GetNextDailyQuestsResetTime()) - Clock::now()).count());
        }

        // replace negative cooldowns by 0
        if (cooldown < 0)
            cooldown = 0;

        if (categoryCooldown < 0)
            categoryCooldown = 0;

        // no cooldown after applying spell mods
        if (cooldown == 0 && categoryCooldown == 0)
            return;

        catrecTime = categoryCooldown ? curTime + std::chrono::duration_cast<Clock::duration>(std::chrono::milliseconds(categoryCooldown)) : curTime;
        recTime = cooldown ? curTime + std::chrono::duration_cast<Clock::duration>(std::chrono::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));
                playerOwner->SendDirectMessage(spellCooldown.Write());
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SpellHistory::Update

(

)

{
    SQLTransaction t;
    Clock::time_point now = Clock::now();
    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:

template<class PacketType >

void SpellHistory::WritePacket

(

PacketType *

packet

)

const

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

template<>

void SpellHistory::WritePacket

(

WorldPackets::Spells::SendSpellHistory *

sendSpellHistory

)

const

{
    sendSpellHistory->Entries.reserve(_spellCooldowns.size());

    Clock::time_point now = Clock::now();
    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
        {
            std::chrono::milliseconds cooldownDuration = std::chrono::duration_cast<std::chrono::milliseconds>(p.second.CooldownEnd - now);
            if (cooldownDuration.count() <= 0)
                continue;

            historyEntry.RecoveryTime = uint32(cooldownDuration.count());
            std::chrono::milliseconds categoryDuration = std::chrono::duration_cast<std::chrono::milliseconds>(p.second.CategoryEnd - now);
            if (categoryDuration.count() > 0)
            {
                historyEntry.Category = p.second.CategoryId;
                historyEntry.CategoryRecoveryTime = uint32(categoryDuration.count());
            }
        }

        sendSpellHistory->Entries.push_back(historyEntry);
    }
}

Here is the call graph for this function:

template<>

void SpellHistory::WritePacket

(

WorldPackets::Spells::SendSpellCharges *

sendSpellCharges

)

const

{
    sendSpellCharges->Entries.reserve(_categoryCharges.size());

    Clock::time_point now = Clock::now();
    for (auto const& p : _categoryCharges)
    {
        if (!p.second.empty())
        {
            std::chrono::milliseconds cooldownDuration = std::chrono::duration_cast<std::chrono::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 = p.second.size();
            sendSpellCharges->Entries.push_back(chargeEntry);
        }
    }
}

Here is the call graph for this function:

template<>

void SpellHistory::WritePacket

(

WorldPackets::Pet::PetSpells *

petSpells

)

const

{
    Clock::time_point now = Clock::now();

    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)
        {
            std::chrono::milliseconds cooldownDuration = std::chrono::duration_cast<std::chrono::milliseconds>(p.second.CooldownEnd - now);
            if (cooldownDuration.count() <= 0)
                continue;

            petSpellCooldown.Duration = uint32(cooldownDuration.count());
            std::chrono::milliseconds categoryDuration = std::chrono::duration_cast<std::chrono::milliseconds>(p.second.CategoryEnd - now);
            if (categoryDuration.count() > 0)
                petSpellCooldown.CategoryDuration = uint32(categoryDuration.count());
        }

        petSpells->Cooldowns.push_back(petSpellCooldown);
    }

    petSpells->SpellHistory.reserve(_categoryCharges.size());
    for (auto const& p : _categoryCharges)
    {
        if (!p.second.empty())
        {
            std::chrono::milliseconds cooldownDuration = std::chrono::duration_cast<std::chrono::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 = p.second.size();

            petSpells->SpellHistory.push_back(petChargeEntry);
        }
    }
}

Here is the call graph for this function:

Member Data Documentation

ChargeStorageType SpellHistory::_categoryCharges

private

CategoryCooldownStorageType SpellHistory::_categoryCooldowns

private

GlobalCooldownStorageType SpellHistory::_globalCooldowns

private

Unit* SpellHistory::_owner

private

Clock::time_point SpellHistory::_schoolLockouts[MAX_SPELL_SCHOOL]

private

CooldownStorageType SpellHistory::_spellCooldowns

private

CooldownStorageType SpellHistory::_spellCooldownsBeforeDuel

private

SpellHistory::Clock::duration const SpellHistory::InfinityCooldownDelay = std::chrono::duration_cast<SpellHistory::Clock::duration>(std::chrono::seconds(MONTH))

static

---

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

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