SpellHistory.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "SpellHistory.h"
#include "CharmInfo.h"
#include "DB2Stores.h"
#include "DatabaseEnv.h"
#include "Duration.h"
#include "Item.h"
#include "Map.h"
#include "ObjectMgr.h"
#include "Pet.h"
#include "PetPackets.h"
#include "Player.h"
#include "Spell.h"
#include "SpellAuraEffects.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "SpellPackets.h"
#include "World.h"
#include <boost/container/small_vector.hpp>
 
template<>
struct SpellHistory::PersistenceHelper<Player>
{
    static constexpr CharacterDatabaseStatements CooldownsDeleteStatement = CHAR_DEL_CHAR_SPELL_COOLDOWNS;
    static constexpr CharacterDatabaseStatements CooldownsInsertStatement = CHAR_INS_CHAR_SPELL_COOLDOWN;
    static constexpr CharacterDatabaseStatements ChargesDeleteStatement = CHAR_DEL_CHAR_SPELL_CHARGES;
    static constexpr CharacterDatabaseStatements ChargesInsertStatement = CHAR_INS_CHAR_SPELL_CHARGES;
 
    static void SetIdentifier(PreparedStatementBase* stmt, uint8 index, Unit const* owner) { stmt->setUInt64(index, owner->GetGUID().GetCounter()); }
 
    static bool ReadCooldown(Field const* fields, uint32* spellId, CooldownEntry* cooldownEntry)
    {
        *spellId = fields[0].GetUInt32();
        if (!sSpellMgr->GetSpellInfo(*spellId, DIFFICULTY_NONE))
            return false;
 
        cooldownEntry->SpellId = *spellId;
        cooldownEntry->CooldownEnd = time_point_cast<Duration>(Clock::from_time_t(fields[2].GetInt64()));
        cooldownEntry->ItemId = fields[1].GetUInt32();
        cooldownEntry->CategoryId = fields[3].GetUInt32();
        cooldownEntry->CategoryEnd = time_point_cast<Duration>(Clock::from_time_t(fields[4].GetInt64()));
        return true;
    }
 
    static bool ReadCharge(Field const* fields, uint32* categoryId, ChargeEntry* chargeEntry)
    {
        *categoryId = fields[0].GetUInt32();
        if (!sSpellCategoryStore.LookupEntry(*categoryId))
            return false;
 
        chargeEntry->RechargeStart = time_point_cast<Duration>(Clock::from_time_t(fields[1].GetInt64()));
        chargeEntry->RechargeEnd = time_point_cast<Duration>(Clock::from_time_t(fields[2].GetInt64()));
        return true;
    }
 
    static void WriteCooldown(PreparedStatementBase* stmt, uint8& index, CooldownEntry const& cooldown)
    {
        stmt->setUInt32(index++, cooldown.SpellId);
        stmt->setUInt32(index++, cooldown.ItemId);
        stmt->setInt64(index++, Clock::to_time_t(cooldown.CooldownEnd));
        stmt->setUInt32(index++, cooldown.CategoryId);
        stmt->setInt64(index++, Clock::to_time_t(cooldown.CategoryEnd));
    }
 
    static void WriteCharge(PreparedStatementBase* stmt, uint8& index, uint32 chargeCategory, ChargeEntry const& charge)
    {
        stmt->setUInt32(index++, chargeCategory);
        stmt->setInt64(index++, Clock::to_time_t(charge.RechargeStart));
        stmt->setInt64(index++, Clock::to_time_t(charge.RechargeEnd));
    }
};
 
template<>
struct SpellHistory::PersistenceHelper<Pet>
{
    static constexpr CharacterDatabaseStatements CooldownsDeleteStatement = CHAR_DEL_PET_SPELL_COOLDOWNS;
    static constexpr CharacterDatabaseStatements CooldownsInsertStatement = CHAR_INS_PET_SPELL_COOLDOWN;
    static constexpr CharacterDatabaseStatements ChargesDeleteStatement = CHAR_DEL_PET_SPELL_CHARGES;
    static constexpr CharacterDatabaseStatements ChargesInsertStatement = CHAR_INS_PET_SPELL_CHARGES;
 
    static void SetIdentifier(PreparedStatementBase* stmt, uint8 index, Unit* owner) { stmt->setUInt32(index, owner->GetCharmInfo()->GetPetNumber()); }
 
    static bool ReadCooldown(Field const* fields, uint32* spellId, CooldownEntry* cooldownEntry)
    {
        *spellId = fields[0].GetUInt32();
        if (!sSpellMgr->GetSpellInfo(*spellId, DIFFICULTY_NONE))
            return false;
 
        cooldownEntry->SpellId = *spellId;
        cooldownEntry->CooldownEnd = time_point_cast<Duration>(Clock::from_time_t(fields[1].GetInt64()));
        cooldownEntry->ItemId = 0;
        cooldownEntry->CategoryId = fields[2].GetUInt32();
        cooldownEntry->CategoryEnd = time_point_cast<Duration>(Clock::from_time_t(fields[3].GetInt64()));
        return true;
    }
 
    static bool ReadCharge(Field const* fields, uint32* categoryId, ChargeEntry* chargeEntry)
    {
        *categoryId = fields[0].GetUInt32();
        if (!sSpellCategoryStore.LookupEntry(*categoryId))
            return false;
 
        chargeEntry->RechargeStart = time_point_cast<Duration>(Clock::from_time_t(fields[1].GetInt64()));
        chargeEntry->RechargeEnd = time_point_cast<Duration>(Clock::from_time_t(fields[2].GetInt64()));
        return true;
    }
 
    static void WriteCooldown(PreparedStatementBase* stmt, uint8& index, CooldownEntry const& cooldown)
    {
        stmt->setUInt32(index++, cooldown.SpellId);
        stmt->setInt64(index++, Clock::to_time_t(cooldown.CooldownEnd));
        stmt->setUInt32(index++, cooldown.CategoryId);
        stmt->setInt64(index++, Clock::to_time_t(cooldown.CategoryEnd));
    }
 
    static void WriteCharge(PreparedStatementBase* stmt, uint8& index, uint32 chargeCategory, ChargeEntry const& charge)
    {
        stmt->setUInt32(index++, chargeCategory);
        stmt->setInt64(index++, Clock::to_time_t(charge.RechargeStart));
        stmt->setInt64(index++, Clock::to_time_t(charge.RechargeEnd));
    }
};
 
SpellHistory::SpellHistory(Unit* owner) : _owner(owner), _schoolLockouts()
{
}
 
SpellHistory::~SpellHistory() = default;
 
template<class OwnerType>
void SpellHistory::LoadFromDB(PreparedQueryResult cooldownsResult, PreparedQueryResult chargesResult)
{
    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());
    }
}
 
template<class OwnerType>
void SpellHistory::SaveToDB(CharacterDatabaseTransaction trans)
{
    using StatementInfo = PersistenceHelper<OwnerType>;
 
    uint8 index = 0;
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::CooldownsDeleteStatement);
    StatementInfo::SetIdentifier(stmt, index++, _owner);
    trans->Append(stmt);
 
    for (auto const& [spellId, cooldown] : _spellCooldowns)
    {
        if (!cooldown.OnHold)
        {
            index = 0;
            stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::CooldownsInsertStatement);
            StatementInfo::SetIdentifier(stmt, index++, _owner);
            StatementInfo::WriteCooldown(stmt, index, cooldown);
            trans->Append(stmt);
        }
    }
 
    stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::ChargesDeleteStatement);
    StatementInfo::SetIdentifier(stmt, 0, _owner);
    trans->Append(stmt);
 
    for (auto const& [categoryId, consumedCharges] : _categoryCharges)
    {
        for (ChargeEntry const& charge : consumedCharges)
        {
            index = 0;
            stmt = CharacterDatabase.GetPreparedStatement(StatementInfo::ChargesInsertStatement);
            StatementInfo::SetIdentifier(stmt, index++, _owner);
            StatementInfo::WriteCharge(stmt, index, categoryId, charge);
            trans->Append(stmt);
        }
    }
}
 
void SpellHistory::Update()
{
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    for (auto itr = _categoryCooldowns.begin(); itr != _categoryCooldowns.end();)
    {
        if (itr->second->CategoryEnd < now && !itr->second->OnHold)
            itr = _categoryCooldowns.erase(itr);
        else
            ++itr;
    }
 
    for (auto itr = _spellCooldowns.begin(); itr != _spellCooldowns.end();)
    {
        if (itr->second.CooldownEnd < now && !itr->second.OnHold)
            itr = EraseCooldown(itr);
        else
            ++itr;
    }
 
    for (auto& [chargeCategoryId, chargeRefreshTimes] : _categoryCharges)
        while (!chargeRefreshTimes.empty() && chargeRefreshTimes.front().RechargeEnd <= now)
            chargeRefreshTimes.pop_front();
}
 
void SpellHistory::HandleCooldowns(SpellInfo const* spellInfo, uint32 itemId, Spell* spell /*= nullptr*/)
{
    if (spell && spell->IsIgnoringCooldowns())
        return;
 
    ConsumeCharge(spellInfo->ChargeCategoryId);
 
    if (_owner->HasAuraTypeWithAffectMask(SPELL_AURA_IGNORE_SPELL_COOLDOWN, spellInfo))
        return;
 
    if (spellInfo->IsPassive())
        return;
 
    StartCooldown(spellInfo, itemId, spell, spellInfo->IsCooldownStartedOnEvent());
 
    if (spellInfo->IsCooldownStartedOnEventAfterCombat() && !_owner->IsInCombat())
        SendCooldownEvent(spellInfo, itemId, spell, true);
}
 
bool SpellHistory::IsReady(SpellInfo const* spellInfo, uint32 itemId /*= 0*/) const
{
    if (!spellInfo->HasAttribute(SPELL_ATTR9_IGNORE_SCHOOL_LOCKOUT) && 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;
}
 
void SpellHistory::WritePacket(WorldPackets::Spells::SendSpellHistory* sendSpellHistory) const
{
    sendSpellHistory->Entries.reserve(_spellCooldowns.size());
 
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    for (auto const& [spellId, cooldown] : _spellCooldowns)
    {
        WorldPackets::Spells::SpellHistoryEntry historyEntry;
        historyEntry.SpellID = spellId;
        historyEntry.ItemID = cooldown.ItemId;
 
        if (cooldown.OnHold)
            historyEntry.OnHold = true;
        else
        {
            Milliseconds cooldownDuration = duration_cast<Milliseconds>(cooldown.CooldownEnd - now);
            if (cooldownDuration.count() <= 0)
                continue;
 
            Milliseconds categoryDuration = duration_cast<Milliseconds>(cooldown.CategoryEnd - now);
            if (categoryDuration.count() > 0)
            {
                historyEntry.Category = cooldown.CategoryId;
                historyEntry.CategoryRecoveryTime = uint32(categoryDuration.count());
            }
 
            if (cooldownDuration.count() > categoryDuration.count())
                historyEntry.RecoveryTime = uint32(cooldownDuration.count());
        }
 
        sendSpellHistory->Entries.push_back(historyEntry);
    }
}
 
void SpellHistory::WritePacket(WorldPackets::Spells::SendSpellCharges* sendSpellCharges) const
{
    sendSpellCharges->Entries.reserve(_categoryCharges.size());
 
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    for (auto const& [categoryId, consumedCharges] : _categoryCharges)
    {
        if (!consumedCharges.empty())
        {
            Milliseconds cooldownDuration = duration_cast<Milliseconds>(consumedCharges.front().RechargeEnd - now);
            if (cooldownDuration.count() <= 0)
                continue;
 
            WorldPackets::Spells::SpellChargeEntry chargeEntry;
            chargeEntry.Category = categoryId;
            chargeEntry.NextRecoveryTime = uint32(cooldownDuration.count());
            chargeEntry.ConsumedCharges = uint8(consumedCharges.size());
            sendSpellCharges->Entries.push_back(chargeEntry);
        }
    }
}
 
void SpellHistory::WritePacket(WorldPackets::Pet::PetSpells* petSpells) const
{
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
 
    petSpells->Cooldowns.reserve(_spellCooldowns.size());
    for (auto const& [spellId, cooldown] : _spellCooldowns)
    {
        WorldPackets::Pet::PetSpellCooldown petSpellCooldown;
        petSpellCooldown.SpellID = spellId;
        petSpellCooldown.Category = cooldown.CategoryId;
 
        if (!cooldown.OnHold)
        {
            Milliseconds cooldownDuration = duration_cast<Milliseconds>(cooldown.CooldownEnd - now);
            if (cooldownDuration.count() <= 0)
                continue;
 
            petSpellCooldown.Duration = uint32(cooldownDuration.count());
            Milliseconds categoryDuration = duration_cast<Milliseconds>(cooldown.CategoryEnd - now);
            if (categoryDuration.count() > 0)
                petSpellCooldown.CategoryDuration = uint32(categoryDuration.count());
        }
        else
            petSpellCooldown.CategoryDuration = std::numeric_limits<int32>::min();
 
        petSpells->Cooldowns.push_back(petSpellCooldown);
    }
 
    petSpells->SpellHistory.reserve(_categoryCharges.size());
    for (auto const& [categoryId, consumedCharges] : _categoryCharges)
    {
        if (!consumedCharges.empty())
        {
            Milliseconds cooldownDuration = duration_cast<Milliseconds>(consumedCharges.front().RechargeEnd - now);
            if (cooldownDuration.count() <= 0)
                continue;
 
            WorldPackets::Pet::PetSpellHistory petChargeEntry;
            petChargeEntry.CategoryID = categoryId;
            petChargeEntry.RecoveryTime = uint32(cooldownDuration.count());
            petChargeEntry.ConsumedCharges = int8(consumedCharges.size());
 
            petSpells->SpellHistory.push_back(petChargeEntry);
        }
    }
}
 
void SpellHistory::StartCooldown(SpellInfo const* spellInfo, uint32 itemId, Spell* spell /*= nullptr*/, bool onHold /*= false*/, Optional<Duration> forcedCooldown /*= {}*/)
{
    // init cooldown values
    uint32 categoryId = 0;
    Duration cooldown = Duration::zero();
    Duration categoryCooldown = Duration::zero();
 
    bool needsCooldownPacket = false;
 
    if (!forcedCooldown)
        GetCooldownDurations(spellInfo, itemId, &cooldown, &categoryId, &categoryCooldown);
    else
        cooldown = *forcedCooldown;
 
    // overwrite time for selected category
    if (!onHold)
    {
        if (!forcedCooldown)
        {
            Duration baseCooldown = cooldown;
 
            // 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));
            }
 
            {
                auto calcRecoveryRate = [&](AuraEffect const* modRecoveryRate)
                {
                    double rate = 100.0 / (std::max(modRecoveryRate->GetAmount(), -99.0) + 100.0);
                    if (baseCooldown <= 1h
                        && !spellInfo->HasAttribute(SPELL_ATTR6_IGNORE_FOR_MOD_TIME_RATE)
                        && !modRecoveryRate->GetSpellEffectInfo().EffectAttributes.HasFlag(SpellEffectAttributes::IgnoreDuringCooldownTimeRateCalculation))
                        rate *= *_owner->m_unitData->ModTimeRate;
 
                    return rate;
                };
 
                double recoveryRate = 1.0;
                for (AuraEffect const* modRecoveryRate : _owner->GetAuraEffectsByType(SPELL_AURA_MOD_RECOVERY_RATE))
                    if (modRecoveryRate->IsAffectingSpell(spellInfo))
                        recoveryRate *= calcRecoveryRate(modRecoveryRate);
 
                for (AuraEffect const* modRecoveryRate : _owner->GetAuraEffectsByType(SPELL_AURA_MOD_RECOVERY_RATE_BY_SPELL_LABEL))
                    if (spellInfo->HasLabel(modRecoveryRate->GetMiscValue()) || (modRecoveryRate->GetMiscValueB() && spellInfo->HasLabel(modRecoveryRate->GetMiscValueB())))
                        recoveryRate *= calcRecoveryRate(modRecoveryRate);
 
                if (recoveryRate > 0.0)
                {
                    cooldown = Duration(int64(cooldown.count() * recoveryRate));
                    categoryCooldown = Duration(int64(categoryCooldown.count() * recoveryRate));
                }
            }
 
            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->GetFlags().HasFlag(SpellCategoryFlags::CooldownInDays))
                    categoryCooldown = duration_cast<Milliseconds>(Clock::from_time_t(sWorld->GetNextDailyQuestsResetTime()) - GameTime::GetTime<Clock>());
            }
        }
        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;
    }
 
    TimePoint curTime = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    TimePoint catrecTime = categoryCooldown != Duration::zero() ? curTime + categoryCooldown : curTime;
    TimePoint recTime = cooldown != Duration::zero() ? curTime + 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());
            }
        }
    }
}
 
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, _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);
}
 
void SpellHistory::AddCooldown(uint32 spellId, uint32 itemId, TimePoint cooldownEnd, uint32 categoryId, TimePoint categoryEnd, bool onHold /*= false*/)
{
    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;
    }
}
 
void SpellHistory::ModifySpellCooldown(uint32 spellId, Duration cooldownMod, bool withoutCategoryCooldown)
{
    auto itr = _spellCooldowns.find(spellId);
    if (itr == _spellCooldowns.end() || itr->second.OnHold)
        return;
 
    ModifySpellCooldown(itr, cooldownMod, withoutCategoryCooldown);
}
 
void SpellHistory::ModifySpellCooldown(CooldownStorageType::iterator& itr, Duration cooldownMod, bool withoutCategoryCooldown)
{
    TimePoint now = time_point_cast<Duration>(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 = duration_cast<Milliseconds>(cooldownMod).count();
        modifyCooldown.SkipCategory = withoutCategoryCooldown;
        playerOwner->SendDirectMessage(modifyCooldown.Write());
    }
 
    if (itr->second.CooldownEnd <= now)
        itr = EraseCooldown(itr);
}
 
void SpellHistory::UpdateCooldownRecoveryRate(CooldownStorageType::iterator& itr, float modChange, bool apply)
{
    if (modChange <= 0.0f)
        return;
 
    if (!apply)
        modChange = 1.0f / modChange;
 
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
 
    itr->second.CooldownEnd = now + duration_cast<Duration>((itr->second.CooldownEnd - now) * modChange);
 
    if (itr->second.CategoryId)
        itr->second.CategoryEnd = now + duration_cast<Duration>((itr->second.CategoryEnd - now) * modChange);
 
    if (Player* playerOwner = GetPlayerOwner())
    {
        WorldPackets::Spells::UpdateCooldown updateCooldown;
        updateCooldown.SpellID = itr->second.SpellId;
        updateCooldown.ModChange = modChange;
        playerOwner->SendDirectMessage(updateCooldown.Write());
    }
}
 
void SpellHistory::ModifyCooldown(uint32 spellId, Duration cooldownMod, bool withoutCategoryCooldown)
{
    if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId, _owner->GetMap()->GetDifficultyID()))
        ModifyCooldown(spellInfo, cooldownMod, withoutCategoryCooldown);
}
 
void SpellHistory::ModifyCooldown(SpellInfo const* spellInfo, Duration cooldownMod, bool withoutCategoryCooldown)
{
    if (!cooldownMod.count())
        return;
 
    ModifyChargeRecoveryTime(spellInfo->ChargeCategoryId, cooldownMod);
    ModifySpellCooldown(spellInfo->Id, cooldownMod, withoutCategoryCooldown);
}
 
void SpellHistory::ResetCooldown(uint32 spellId, bool update /*= false*/)
{
    auto itr = _spellCooldowns.find(spellId);
    if (itr == _spellCooldowns.end() || itr->second.OnHold)
        return;
 
    ResetCooldown(itr, update);
}
 
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);
}
 
void SpellHistory::ResetAllCooldowns()
{
    ResetCooldowns([](CooldownEntry const&) { return true; }, true);
}
 
bool SpellHistory::HasCooldown(SpellInfo const* spellInfo, uint32 itemId /*= 0*/) const
{
    if (_owner->HasAuraTypeWithAffectMask(SPELL_AURA_IGNORE_SPELL_COOLDOWN, spellInfo))
        return false;
 
    if (_spellCooldowns.contains(spellInfo->Id))
        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.contains(category);
}
 
bool SpellHistory::HasCooldown(uint32 spellId, uint32 itemId /*= 0*/) const
{
    return HasCooldown(sSpellMgr->AssertSpellInfo(spellId, _owner->GetMap()->GetDifficultyID()), itemId);
}
 
bool SpellHistory::HasCooldownOnHold(uint32 spellId) const
{
    // TODO: Delete this function and make SpellHistory::IsReady return enum with reason instead of bool
    auto itr = _spellCooldowns.find(spellId);
    return itr != _spellCooldowns.end() && itr->second.OnHold;
}
 
SpellHistory::Duration SpellHistory::GetRemainingCooldown(SpellInfo const* spellInfo) const
{
    TimePoint end;
    auto itr = _spellCooldowns.find(spellInfo->Id);
    if (itr != _spellCooldowns.end())
    {
        if (itr->second.OnHold)
            return Duration::max();
 
        end = itr->second.CooldownEnd;
    }
    else
    {
        auto catItr = _categoryCooldowns.find(spellInfo->GetCategory());
        if (catItr == _categoryCooldowns.end())
            return Duration::zero();
 
        if (catItr->second->OnHold)
            return Duration::max();
 
        end = catItr->second->CategoryEnd;
    }
 
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    if (end < now)
        return Duration::zero();
 
    Clock::duration remaining = end - now;
    return duration_cast<Milliseconds>(remaining);
}
 
SpellHistory::Duration SpellHistory::GetRemainingCategoryCooldown(uint32 categoryId) const
{
    auto catItr = _categoryCooldowns.find(categoryId);
    if (catItr == _categoryCooldowns.end())
        return Duration::zero();
 
    if (catItr->second->OnHold)
        return Duration::max();
 
    TimePoint end = catItr->second->CategoryEnd;
 
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    if (end < now)
        return Duration::zero();
 
    Clock::duration remaining = end - now;
    return duration_cast<Milliseconds>(remaining);
}
 
SpellHistory::Duration SpellHistory::GetRemainingCategoryCooldown(SpellInfo const* spellInfo) const
{
    return GetRemainingCategoryCooldown(spellInfo->GetCategory());
}
 
void SpellHistory::LockSpellSchool(SpellSchoolMask schoolMask, Duration lockoutTime)
{
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    TimePoint 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& [spellId, playerSpell] : plrOwner->GetSpellMap())
            if (playerSpell.state != PLAYERSPELL_REMOVED)
                knownSpells.insert(spellId);
    }
    else if (Pet* petOwner = _owner->ToPet())
    {
        for (auto const& [spellId, petSpell] : petOwner->m_spells)
            if (petSpell.state != PETSPELL_REMOVED)
                knownSpells.insert(spellId);
    }
    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 (spellInfo->HasAttribute(SPELL_ATTR9_IGNORE_SCHOOL_LOCKOUT))
            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());
}
 
bool SpellHistory::IsSchoolLocked(SpellSchoolMask schoolMask) const
{
    TimePoint now = time_point_cast<Duration>(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;
}
 
void SpellHistory::ConsumeCharge(uint32 chargeCategoryId)
{
    if (!sSpellCategoryStore.LookupEntry(chargeCategoryId))
        return;
 
    int32 chargeRecovery = GetChargeRecoveryTime(chargeCategoryId);
    if (chargeRecovery <= 0 || GetMaxCharges(chargeCategoryId) <= 0)
        return;
 
    if (_owner->HasAuraTypeWithMiscvalue(SPELL_AURA_IGNORE_SPELL_CHARGE_COOLDOWN, chargeCategoryId))
        return;
 
    TimePoint recoveryStart;
    std::deque<ChargeEntry>& charges = _categoryCharges[chargeCategoryId];
    if (charges.empty())
        recoveryStart = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    else
        recoveryStart = charges.back().RechargeEnd;
 
    charges.emplace_back(recoveryStart, Milliseconds(chargeRecovery));
}
 
void SpellHistory::ModifyChargeRecoveryTime(uint32 chargeCategoryId, Duration cooldownMod)
{
    SpellCategoryEntry const* chargeCategoryEntry = sSpellCategoryStore.LookupEntry(chargeCategoryId);
    if (!chargeCategoryEntry)
        return;
 
    auto itr = _categoryCharges.find(chargeCategoryId);
    if (itr == _categoryCharges.end() || itr->second.empty())
        return;
 
    TimePoint now = time_point_cast<Duration>(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);
}
 
void SpellHistory::UpdateChargeRecoveryRate(uint32 chargeCategoryId, float modChange, bool apply)
{
    auto itr = _categoryCharges.find(chargeCategoryId);
    if (itr == _categoryCharges.end() || itr->second.empty())
        return;
 
    if (modChange <= 0.0f)
        return;
 
    if (!apply)
        modChange = 1.0f / modChange;
 
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
 
    auto chargeItr = itr->second.begin();
 
    chargeItr->RechargeEnd = now + duration_cast<Duration>((chargeItr->RechargeEnd - now) * modChange);
 
    TimePoint prevEnd = chargeItr->RechargeEnd;
 
    while (++chargeItr != itr->second.end())
    {
        Duration rechargeTime = duration_cast<Duration>((chargeItr->RechargeEnd - chargeItr->RechargeStart) * modChange);
        chargeItr->RechargeStart = prevEnd;
        chargeItr->RechargeEnd = prevEnd + rechargeTime;
        prevEnd = chargeItr->RechargeEnd;
    }
 
    if (Player* playerOwner = GetPlayerOwner())
    {
        WorldPackets::Spells::UpdateChargeCategoryCooldown updateChargeCategoryCooldown;
        updateChargeCategoryCooldown.Category = chargeCategoryId;
        updateChargeCategoryCooldown.ModChange = modChange;
        playerOwner->SendDirectMessage(updateChargeCategoryCooldown.Write());
    }
}
 
void SpellHistory::RestoreCharge(uint32 chargeCategoryId)
{
    auto itr = _categoryCharges.find(chargeCategoryId);
    if (itr != _categoryCharges.end() && !itr->second.empty())
    {
        itr->second.pop_back();
 
        SendSetSpellCharges(chargeCategoryId, itr->second);
    }
}
 
void SpellHistory::ResetCharges(uint32 chargeCategoryId)
{
    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());
        }
    }
}
 
void SpellHistory::ResetAllCharges()
{
    _categoryCharges.clear();
 
    if (Player* player = GetPlayerOwner())
    {
        WorldPackets::Spells::ClearAllSpellCharges clearAllSpellCharges;
        clearAllSpellCharges.IsPet = _owner != player;
        player->SendDirectMessage(clearAllSpellCharges.Write());
    }
}
 
bool SpellHistory::HasCharge(uint32 chargeCategoryId) const
{
    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;
}
 
int32 SpellHistory::GetMaxCharges(uint32 chargeCategoryId) const
{
    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;
}
 
int32 SpellHistory::GetChargeRecoveryTime(uint32 chargeCategoryId) const
{
    SpellCategoryEntry const* chargeCategoryEntry = sSpellCategoryStore.LookupEntry(chargeCategoryId);
    if (!chargeCategoryEntry)
        return 0;
 
    SpellEffectValue recoveryTime = chargeCategoryEntry->ChargeRecoveryTime;
    recoveryTime += _owner->GetTotalAuraModifierByMiscValue(SPELL_AURA_CHARGE_RECOVERY_MOD, chargeCategoryId);
 
    for (AuraEffect const* modRecoveryRate : _owner->GetAuraEffectsByType(SPELL_AURA_MOD_CHARGE_RECOVERY_BY_TYPE_MASK))
        if (modRecoveryRate->GetMiscValue() & chargeCategoryEntry->TypeMask)
            recoveryTime += modRecoveryRate->GetAmount();
 
    recoveryTime *= _owner->GetTotalAuraMultiplierByMiscValue(SPELL_AURA_CHARGE_RECOVERY_MULTIPLIER, chargeCategoryId);
 
    if (_owner->HasAuraType(SPELL_AURA_CHARGE_RECOVERY_AFFECTED_BY_HASTE))
        recoveryTime *= _owner->m_unitData->ModSpellHaste;
 
    if (_owner->HasAuraTypeWithMiscvalue(SPELL_AURA_CHARGE_RECOVERY_AFFECTED_BY_HASTE_REGEN, chargeCategoryId))
        recoveryTime *= _owner->m_unitData->ModHasteRegen;
 
    for (AuraEffect const* modRecoveryRate : _owner->GetAuraEffectsByType(SPELL_AURA_MOD_CHARGE_RECOVERY_RATE))
        if (modRecoveryRate->GetMiscValue() == int32(chargeCategoryId))
            recoveryTime *= 100.0 / (std::max(modRecoveryRate->GetAmount(), -99.0) + 100.0);
 
    for (AuraEffect const* modRecoveryRate : _owner->GetAuraEffectsByType(SPELL_AURA_MOD_CHARGE_RECOVERY_RATE_BY_TYPE_MASK))
        if (modRecoveryRate->GetMiscValue() & chargeCategoryEntry->TypeMask)
            recoveryTime *= 100.0 / (std::max(modRecoveryRate->GetAmount(), -99.0) + 100.0);
 
    if (Milliseconds(chargeCategoryEntry->ChargeRecoveryTime) <= 1h
        && !(chargeCategoryEntry->GetFlags().HasFlag(SpellCategoryFlags::IgnoreForModTimeRate))
        && !(chargeCategoryEntry->GetFlags().HasFlag(SpellCategoryFlags::CooldownInDays)))
        recoveryTime *= *_owner->m_unitData->ModTimeRate;
 
    return int32(std::floor(recoveryTime));
}
 
bool SpellHistory::HasGlobalCooldown(SpellInfo const* spellInfo) const
{
    auto itr = _globalCooldowns.find(spellInfo->StartRecoveryCategory);
    return itr != _globalCooldowns.end() && itr->second > Clock::now();
}
 
void SpellHistory::AddGlobalCooldown(SpellInfo const* spellInfo, Duration duration)
{
    _globalCooldowns[spellInfo->StartRecoveryCategory] = time_point_cast<Duration>(Clock::now() + duration);
}
 
void SpellHistory::CancelGlobalCooldown(SpellInfo const* spellInfo)
{
    _globalCooldowns[spellInfo->StartRecoveryCategory] = TimePoint(Duration(0));
}
 
SpellHistory::Duration SpellHistory::GetRemainingGlobalCooldown(SpellInfo const* spellInfo) const
{
    auto cdItr = _globalCooldowns.find(spellInfo->StartRecoveryCategory);
    if (cdItr == _globalCooldowns.end())
        return Duration::zero();
 
    TimePoint end = cdItr->second;
    TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
    if (end < now)
        return Duration::zero();
 
    Clock::duration remaining = end - now;
    return duration_cast<Milliseconds>(remaining);
}
 
void SpellHistory::PauseCooldowns()
{
    _pauseTime = time_point_cast<Duration>(GameTime::GetTime<Clock>());
}
 
void SpellHistory::ResumeCooldowns()
{
    if (!_pauseTime)
        return;
 
    Duration pausedDuration = time_point_cast<Duration>(GameTime::GetTime<Clock>()) - *_pauseTime;
 
    for (auto itr = _spellCooldowns.begin(); itr != _spellCooldowns.end();)
        if (!itr->second.OnHold)
            itr->second.CooldownEnd += pausedDuration;
 
    for (auto& [chargeCategoryId, chargeRefreshTimes] : _categoryCharges)
        for (ChargeEntry& chargeEntry : chargeRefreshTimes)
            chargeEntry.RechargeEnd += pausedDuration;
 
    _pauseTime.reset();
 
    Update();
}
 
Player* SpellHistory::GetPlayerOwner() const
{
    return _owner->GetCharmerOrOwnerPlayerOrPlayerItself();
}
 
void SpellHistory::SendClearCooldowns(std::vector<int32>&& cooldowns) const
{
    if (Player const* playerOwner = GetPlayerOwner())
    {
        WorldPackets::Spells::ClearCooldowns clearCooldowns;
        clearCooldowns.IsPet = _owner != playerOwner;
        clearCooldowns.SpellID = std::move(cooldowns);
        playerOwner->SendDirectMessage(clearCooldowns.Write());
    }
}
 
SpellHistory::CooldownStorageType::iterator SpellHistory::EraseCooldown(CooldownStorageType::iterator itr)
{
    _categoryCooldowns.erase(itr->second.CategoryId);
    return _spellCooldowns.erase(itr);
}
 
void SpellHistory::SendSetSpellCharges(uint32 chargeCategoryId, ChargeEntryCollection const& chargeCollection) const
{
    if (Player* player = GetPlayerOwner())
    {
        WorldPackets::Spells::SetSpellCharges setSpellCharges;
        setSpellCharges.Category = chargeCategoryId;
        if (!chargeCollection.empty())
            setSpellCharges.NextRecoveryTime = uint32(duration_cast<Milliseconds>(chargeCollection.front().RechargeEnd - GameTime::GetTime<Clock>()).count());
        setSpellCharges.ConsumedCharges = uint8(chargeCollection.size());
        setSpellCharges.IsPet = player != _owner;
        player->SendDirectMessage(setSpellCharges.Write());
    }
}
 
void SpellHistory::GetCooldownDurations(SpellInfo const* spellInfo, uint32 itemId, Duration* cooldown, uint32* categoryId, Duration* categoryCooldown)
{
    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;
}
 
void SpellHistory::AtExitCombat()
{
    boost::container::small_vector<std::pair<uint32, uint32>, 2> cooldownsToStart;
 
    for (auto [categoryId, cooldown] : _categoryCooldowns)
        if (sSpellCategoryStore.AssertEntry(categoryId)->GetFlags().HasFlag(SpellCategoryFlags::CooldownEventOnLeaveCombat))
            cooldownsToStart.emplace_back(cooldown->SpellId, cooldown->ItemId);
 
    for (auto [spellId, itemId] : cooldownsToStart)
        SendCooldownEvent(sSpellMgr->GetSpellInfo(spellId, DIFFICULTY_NONE), itemId);
}
 
void SpellHistory::SaveCooldownStateBeforeDuel()
{
    _spellCooldownsBeforeDuel = _spellCooldowns;
}
 
void SpellHistory::RestoreCooldownStateAfterDuel()
{
    if (Player* player = _owner->ToPlayer())
    {
        // add all profession CDs created while in duel (if any)
        for (auto const& [spellId, cooldown] : _spellCooldowns)
        {
            SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(spellId, DIFFICULTY_NONE);
 
            if (spellInfo->RecoveryTime > 10 * MINUTE * IN_MILLISECONDS ||
                spellInfo->CategoryRecoveryTime > 10 * MINUTE * IN_MILLISECONDS)
                _spellCooldownsBeforeDuel[spellId] = cooldown;
        }
 
        // check for spell with onHold active before and during the duel
        for (auto const& [spellId, cooldown] : _spellCooldownsBeforeDuel)
        {
            if (cooldown.OnHold)
                continue;
 
            auto [itr, inserted] = _spellCooldowns.try_emplace(spellId, cooldown);
            if (!inserted && !itr->second.OnHold /*don't override if pre-existing cooldown is on hold*/)
                itr->second = cooldown;
        }
 
        // 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& [spellId, cooldown] : _spellCooldowns)
        {
            TimePoint now = time_point_cast<Duration>(GameTime::GetTime<Clock>());
            uint32 cooldownDuration = uint32(cooldown.CooldownEnd > now ? duration_cast<Milliseconds>(cooldown.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 || cooldown.OnHold)
                continue;
 
            spellCooldown.SpellCooldowns.emplace_back(spellId, cooldownDuration);
        }
 
        player->SendDirectMessage(spellCooldown.Write());
    }
}
 
template void SpellHistory::LoadFromDB<Player>(PreparedQueryResult cooldownsResult, PreparedQueryResult chargesResult);
template void SpellHistory::LoadFromDB<Pet>(PreparedQueryResult cooldownsResult, PreparedQueryResult chargesResult);
template void SpellHistory::SaveToDB<Player>(CharacterDatabaseTransaction trans);
template void SpellHistory::SaveToDB<Pet>(CharacterDatabaseTransaction trans);