spell_dk.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/>.
 */
 
/*
 * Scripts for spells with SPELLFAMILY_DEATHKNIGHT and SPELLFAMILY_GENERIC spells used by deathknight players.
 * Ordered alphabetically using scriptname.
 * Scriptnames of files in this file should be prefixed with "spell_dk_".
 */
 
#include "AreaTrigger.h"
#include "AreaTriggerAI.h"
#include "ScriptMgr.h"
#include "Containers.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "Spell.h"
#include "SpellAuraEffects.h"
#include "SpellHistory.h"
#include "SpellMgr.h"
#include "SpellScript.h"
#include <numeric>
 
enum DeathKnightSpells
{
 SPELL_DK_ARMY_FLESH_BEAST_TRANSFORM = 127533,
 SPELL_DK_ARMY_GEIST_TRANSFORM = 127534,
 SPELL_DK_ARMY_NORTHREND_SKELETON_TRANSFORM = 127528,
 SPELL_DK_ARMY_SKELETON_TRANSFORM = 127527,
 SPELL_DK_ARMY_SPIKED_GHOUL_TRANSFORM = 127525,
 SPELL_DK_ARMY_SUPER_ZOMBIE_TRANSFORM = 127526,
 SPELL_DK_BLINDING_SLEET_SLOW = 317898,
 SPELL_DK_BLOOD = 137008,
 SPELL_DK_BLOOD_PLAGUE = 55078,
 SPELL_DK_BLOOD_SHIELD_ABSORB = 77535,
 SPELL_DK_BLOOD_SHIELD_MASTERY = 77513,
 SPELL_DK_BREATH_OF_SINDRAGOSA = 152279,
 SPELL_DK_CORPSE_EXPLOSION_TRIGGERED = 43999,
 SPELL_DK_DEATH_AND_DECAY_DAMAGE = 52212,
 SPELL_DK_DEATH_COIL_DAMAGE = 47632,
 SPELL_DK_DEATH_GRIP_DUMMY = 243912,
 SPELL_DK_DEATH_GRIP_JUMP = 49575,
 SPELL_DK_DEATH_GRIP_TAUNT = 51399,
 SPELL_DK_DEATH_STRIKE_HEAL = 45470,
 SPELL_DK_DEATH_STRIKE_OFFHAND = 66188,
 SPELL_DK_FESTERING_WOUND = 194310,
 SPELL_DK_FROST = 137006,
 SPELL_DK_FROST_FEVER = 55095,
 SPELL_DK_FROST_SCYTHE = 207230,
 SPELL_DK_FROST_SHIELD = 207203,
 SPELL_DK_GLYPH_OF_FOUL_MENAGERIE = 58642,
 SPELL_DK_GLYPH_OF_THE_GEIST = 58640,
 SPELL_DK_GLYPH_OF_THE_SKELETON = 146652,
 SPELL_DK_KILLING_MACHINE_PROC = 51124,
 SPELL_DK_MARK_OF_BLOOD_HEAL = 206945,
 SPELL_DK_NECROSIS_EFFECT = 216974,
 SPELL_DK_OBLITERATION = 281238,
 SPELL_DK_OBLITERATION_RUNE_ENERGIZE = 281327,
 SPELL_DK_PILLAR_OF_FROST = 51271,
 SPELL_DK_RAISE_DEAD_SUMMON = 52150,
 SPELL_DK_RECENTLY_USED_DEATH_STRIKE = 180612,
 SPELL_DK_RUNIC_POWER_ENERGIZE = 49088,
 SPELL_DK_RUNIC_RETURN = 61258,
 SPELL_DK_SLUDGE_BELCHER = 207313,
 SPELL_DK_SLUDGE_BELCHER_SUMMON = 212027,
 SPELL_DK_DEATH_STRIKE_ENABLER = 89832, // Server Side
 SPELL_DK_TIGHTENING_GRASP = 206970,
 //SPELL_DK_TIGHTENING_GRASP_SLOW = 143375, // dropped in BfA
 SPELL_DK_UNHOLY = 137007,
 SPELL_DK_UNHOLY_GROUND_HASTE = 374271,
 SPELL_DK_UNHOLY_GROUND_TALENT = 374265,
 SPELL_DK_UNHOLY_VIGOR = 196263,
 SPELL_DK_VOLATILE_SHIELDING = 207188,
 SPELL_DK_VOLATILE_SHIELDING_DAMAGE = 207194
};
 
enum Misc
{
 NPC_DK_DANCING_RUNE_WEAPON = 27893
};
 
// 70656 - Advantage (T10 4P Melee Bonus)
class spell_dk_advantage_t10_4p : public AuraScript
{
 bool CheckProc(ProcEventInfo& eventInfo)
 {
 if (Unit* caster = eventInfo.GetActor())
 {
 Player* player = caster->ToPlayer();
 if (!player || caster->GetClass() != CLASS_DEATH_KNIGHT)
 return false;
 
 for (uint8 i = 0; i < player->GetMaxPower(POWER_RUNES); ++i)
 if (player->GetRuneCooldown(i) == 0)
 return false;
 
 return true;
 }
 
 return false;
 }
 
 void Register() override
 {
 DoCheckProc += AuraCheckProcFn(spell_dk_advantage_t10_4p::CheckProc);
 }
};
 
// 48707 - Anti-Magic Shell
class spell_dk_anti_magic_shell : public AuraScript
{
public:
 spell_dk_anti_magic_shell()
 {
 absorbPct = 0;
 maxHealth = 0;
 absorbedAmount = 0;
 }
 
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellInfo({ SPELL_DK_RUNIC_POWER_ENERGIZE, SPELL_DK_VOLATILE_SHIELDING })
 && ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } });
 }
 
 bool Load() override
 {
 absorbPct = GetEffectInfo(EFFECT_1).CalcValue(GetCaster());
 maxHealth = GetCaster()->GetMaxHealth();
 absorbedAmount = 0;
 return true;
 }
 
 void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
 {
 amount = CalculatePct(maxHealth, absorbPct);
 
 if (Player const* player = GetUnitOwner()->ToPlayer())
 AddPct(amount, player->GetRatingBonusValue(CR_VERSATILITY_DAMAGE_DONE) + player->GetTotalAuraModifier(SPELL_AURA_MOD_VERSATILITY));
 }
 
 void Trigger(AuraEffect* aurEff, DamageInfo& /*dmgInfo*/, uint32& absorbAmount)
 {
 absorbedAmount += absorbAmount;
 
 if (!GetTarget()->HasAura(SPELL_DK_VOLATILE_SHIELDING))
 {
 CastSpellExtraArgs args(aurEff);
 args.AddSpellMod(SPELLVALUE_BASE_POINT0, CalculatePct(absorbAmount, 2 * absorbAmount * 100 / maxHealth));
 GetTarget()->CastSpell(GetTarget(), SPELL_DK_RUNIC_POWER_ENERGIZE, args);
 }
 }
 
 void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (AuraEffect const* volatileShielding = GetTarget()->GetAuraEffect(SPELL_DK_VOLATILE_SHIELDING, EFFECT_1))
 {
 CastSpellExtraArgs args(volatileShielding);
 args.AddSpellMod(SPELLVALUE_BASE_POINT0, CalculatePct(absorbedAmount, volatileShielding->GetAmount()));
 GetTarget()->CastSpell(nullptr, SPELL_DK_VOLATILE_SHIELDING_DAMAGE, args);
 }
 }
 
 void Register() override
 {
 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_anti_magic_shell::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
 AfterEffectAbsorb += AuraEffectAbsorbFn(spell_dk_anti_magic_shell::Trigger, EFFECT_0);
 AfterEffectRemove += AuraEffectRemoveFn(spell_dk_anti_magic_shell::HandleEffectRemove, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB, AURA_EFFECT_HANDLE_REAL);
 }
 
private:
 int32 absorbPct;
 int32 maxHealth;
 uint32 absorbedAmount;
};
 
static uint32 const ArmyTransforms[]
{
 SPELL_DK_ARMY_FLESH_BEAST_TRANSFORM,
 SPELL_DK_ARMY_GEIST_TRANSFORM,
 SPELL_DK_ARMY_NORTHREND_SKELETON_TRANSFORM,
 SPELL_DK_ARMY_SKELETON_TRANSFORM,
 SPELL_DK_ARMY_SPIKED_GHOUL_TRANSFORM,
 SPELL_DK_ARMY_SUPER_ZOMBIE_TRANSFORM
};
 
// 127517 - Army Transform
class spell_dk_army_transform : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_GLYPH_OF_FOUL_MENAGERIE });
 }
 
 bool Load() override
 {
 return GetCaster()->IsGuardian();
 }
 
 SpellCastResult CheckCast()
 {
 if (Unit* owner = GetCaster()->GetOwner())
 if (owner->HasAura(SPELL_DK_GLYPH_OF_FOUL_MENAGERIE))
 return SPELL_CAST_OK;
 
 return SPELL_FAILED_SPELL_UNAVAILABLE;
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 GetCaster()->CastSpell(GetCaster(), Trinity::Containers::SelectRandomContainerElement(ArmyTransforms), true);
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_dk_army_transform::CheckCast);
 OnEffectHitTarget += SpellEffectFn(spell_dk_army_transform::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 207167 - Blinding Sleet
class spell_dk_blinding_sleet : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_BLINDING_SLEET_SLOW });
 }
 
 void HandleOnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
 GetTarget()->CastSpell(GetTarget(), SPELL_DK_BLINDING_SLEET_SLOW, true);
 }
 
 void Register() override
 {
 AfterEffectRemove += AuraEffectRemoveFn(spell_dk_blinding_sleet::HandleOnRemove, EFFECT_0, SPELL_AURA_MOD_CONFUSE, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 50842 - Blood Boil
class spell_dk_blood_boil : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_BLOOD_PLAGUE });
 }
 
 void HandleEffect()
 {
 GetCaster()->CastSpell(GetHitUnit(), SPELL_DK_BLOOD_PLAGUE, true);
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_dk_blood_boil::HandleEffect);
 }
};
 
// 49028 - Dancing Rune Weapon
class spell_dk_dancing_rune_weapon : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 if (!sObjectMgr->GetCreatureTemplate(NPC_DK_DANCING_RUNE_WEAPON))
 return false;
 return true;
 }
 
 // This is a port of the old switch hack in Unit.cpp, it's not correct
 void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 Unit* caster = GetCaster();
 if (!caster)
 return;
 
 Unit* drw = nullptr;
 for (Unit* controlled : caster->m_Controlled)
 {
 if (controlled->GetEntry() == NPC_DK_DANCING_RUNE_WEAPON)
 {
 drw = controlled;
 break;
 }
 }
 
 if (!drw || !drw->GetVictim())
 return;
 
 SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
 if (!spellInfo)
 return;
 
 DamageInfo* damageInfo = eventInfo.GetDamageInfo();
 if (!damageInfo || !damageInfo->GetDamage())
 return;
 
 int32 amount = static_cast<int32>(damageInfo->GetDamage()) / 2;
 SpellNonMeleeDamage log(drw, drw->GetVictim(), spellInfo, { spellInfo->GetSpellXSpellVisualId(drw), 0 }, spellInfo->GetSchoolMask());
 log.damage = amount;
 Unit::DealDamage(drw, drw->GetVictim(), amount, nullptr, SPELL_DIRECT_DAMAGE, spellInfo->GetSchoolMask(), spellInfo, true);
 drw->SendSpellNonMeleeDamageLog(&log);
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_dk_dancing_rune_weapon::HandleProc, EFFECT_1, SPELL_AURA_DUMMY);
 }
};
 
// 43265 - Death and Decay (Aura)
class spell_dk_death_and_decay : public AuraScript
{
 void HandleDummyTick(AuraEffect const* aurEff)
 {
 if (Unit* caster = GetCaster())
 caster->CastSpell(GetTarget(), SPELL_DK_DEATH_AND_DECAY_DAMAGE, aurEff);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_dk_death_and_decay::HandleDummyTick, EFFECT_2, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
// 47541 - Death Coil
class spell_dk_death_coil : public SpellScript
{
 bool Validate(SpellInfo const* /*spell*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_DEATH_COIL_DAMAGE, SPELL_DK_UNHOLY, SPELL_DK_UNHOLY_VIGOR });
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 Unit* caster = GetCaster();
 caster->CastSpell(GetHitUnit(), SPELL_DK_DEATH_COIL_DAMAGE, true);
 if (AuraEffect const* unholyAura = caster->GetAuraEffect(SPELL_DK_UNHOLY, EFFECT_6)) // can be any effect, just here to send SPELL_FAILED_DONT_REPORT on failure
 caster->CastSpell(caster, SPELL_DK_UNHOLY_VIGOR, unholyAura);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_dk_death_coil::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 52751 - Death Gate
class spell_dk_death_gate : public SpellScript
{
 SpellCastResult CheckClass()
 {
 if (GetCaster()->GetClass() != CLASS_DEATH_KNIGHT)
 {
 SetCustomCastResultMessage(SPELL_CUSTOM_ERROR_MUST_BE_DEATH_KNIGHT);
 return SPELL_FAILED_CUSTOM_ERROR;
 }
 
 return SPELL_CAST_OK;
 }
 
 void HandleScript(SpellEffIndex effIndex)
 {
 PreventHitDefaultEffect(effIndex);
 if (Unit* target = GetHitUnit())
 target->CastSpell(target, GetEffectValue(), false);
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_dk_death_gate::CheckClass);
 OnEffectHitTarget += SpellEffectFn(spell_dk_death_gate::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 49576 - Death Grip Initial
class spell_dk_death_grip_initial : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_DK_DEATH_GRIP_DUMMY,
 SPELL_DK_DEATH_GRIP_JUMP,
 SPELL_DK_BLOOD,
 SPELL_DK_DEATH_GRIP_TAUNT
 });
 }
 
 SpellCastResult CheckCast()
 {
 Unit* caster = GetCaster();
 // Death Grip should not be castable while jumping/falling
 if (caster->HasUnitState(UNIT_STATE_JUMPING) || caster->HasUnitMovementFlag(MOVEMENTFLAG_FALLING))
 return SPELL_FAILED_MOVING;
 
 return SPELL_CAST_OK;
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 GetCaster()->CastSpell(GetHitUnit(), SPELL_DK_DEATH_GRIP_DUMMY, true);
 GetHitUnit()->CastSpell(GetCaster(), SPELL_DK_DEATH_GRIP_JUMP, true);
 if (GetCaster()->HasAura(SPELL_DK_BLOOD))
 GetCaster()->CastSpell(GetHitUnit(), SPELL_DK_DEATH_GRIP_TAUNT, true);
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_dk_death_grip_initial::CheckCast);
 OnEffectHitTarget += SpellEffectFn(spell_dk_death_grip_initial::HandleDummy, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 48743 - Death Pact
class spell_dk_death_pact : public AuraScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_2 } });
 }
 
 void HandleCalcAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
 {
 if (Unit* caster = GetCaster())
 amount = int32(caster->CountPctFromMaxHealth(GetEffectInfo(EFFECT_2).CalcValue(caster)));
 }
 
 void Register() override
 {
 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_death_pact::HandleCalcAmount, EFFECT_1, SPELL_AURA_SCHOOL_HEAL_ABSORB);
 }
};
 
// 49998 - Death Strike
class spell_dk_death_strike : public SpellScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellInfo(
 {
 SPELL_DK_DEATH_STRIKE_ENABLER,
 SPELL_DK_DEATH_STRIKE_HEAL,
 SPELL_DK_BLOOD_SHIELD_MASTERY,
 SPELL_DK_BLOOD_SHIELD_ABSORB,
 SPELL_DK_FROST,
 SPELL_DK_DEATH_STRIKE_OFFHAND
 })
 && ValidateSpellEffect({ { spellInfo->Id, EFFECT_2 } });
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 Unit* caster = GetCaster();
 
 if (AuraEffect* enabler = caster->GetAuraEffect(SPELL_DK_DEATH_STRIKE_ENABLER, EFFECT_0, GetCaster()->GetGUID()))
 {
 // Heals you for 25% of all damage taken in the last 5 sec,
 int32 heal = CalculatePct(enabler->CalculateAmount(GetCaster()), GetEffectInfo(EFFECT_1).CalcValue(GetCaster()));
 // minimum 7.0% of maximum health.
 int32 pctOfMaxHealth = CalculatePct(GetEffectInfo(EFFECT_2).CalcValue(GetCaster()), caster->GetMaxHealth());
 heal = std::max(heal, pctOfMaxHealth);
 
 caster->CastSpell(caster, SPELL_DK_DEATH_STRIKE_HEAL, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_BASE_POINT0, heal));
 
 if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_DK_BLOOD_SHIELD_MASTERY, EFFECT_0))
 caster->CastSpell(caster, SPELL_DK_BLOOD_SHIELD_ABSORB, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_BASE_POINT0, CalculatePct(heal, aurEff->GetAmount())));
 
 if (caster->HasAura(SPELL_DK_FROST))
 caster->CastSpell(GetHitUnit(), SPELL_DK_DEATH_STRIKE_OFFHAND, true);
 }
 }
 
 void TriggerRecentlyUsedDeathStrike()
 {
 GetCaster()->CastSpell(GetCaster(), SPELL_DK_RECENTLY_USED_DEATH_STRIKE, true);
 }
 
 void Register() override
 {
 OnEffectLaunch += SpellEffectFn(spell_dk_death_strike::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY);
 AfterCast += SpellCastFn(spell_dk_death_strike::TriggerRecentlyUsedDeathStrike);
 }
};
 
// 89832 - Death Strike Enabler - SPELL_DK_DEATH_STRIKE_ENABLER
class spell_dk_death_strike_enabler : public AuraScript
{
 // Amount of seconds we calculate damage over
 constexpr static uint8 LAST_SECONDS = 5;
 
 bool CheckProc(ProcEventInfo& eventInfo)
 {
 return eventInfo.GetDamageInfo() != nullptr;
 }
 
 void Update(AuraEffect* /*aurEff*/)
 {
 // Move backwards all datas by one from [23][0][0][0][0] -> [0][23][0][0][0]
 std::move_backward(_damagePerSecond.begin(), std::next(_damagePerSecond.begin(), LAST_SECONDS - 1), _damagePerSecond.end());
 _damagePerSecond[0] = 0;
 }
 
 void HandleCalcAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& canBeRecalculated)
 {
 canBeRecalculated = true;
 amount = int32(std::accumulate(_damagePerSecond.begin(), _damagePerSecond.end(), 0u));
 }
 
 void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
 {
 _damagePerSecond[0] += eventInfo.GetDamageInfo()->GetDamage();
 }
 
 void Register() override
 {
 DoCheckProc += AuraCheckProcFn(spell_dk_death_strike_enabler::CheckProc);
 OnEffectProc += AuraEffectProcFn(spell_dk_death_strike_enabler::HandleProc, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_death_strike_enabler::HandleCalcAmount, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 OnEffectUpdatePeriodic += AuraEffectUpdatePeriodicFn(spell_dk_death_strike_enabler::Update, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 }
 
private:
 std::array<uint32, LAST_SECONDS> _damagePerSecond = { };
};
 
// 85948 - Festering Strike
class spell_dk_festering_strike : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_FESTERING_WOUND });
 }
 
 void HandleScriptEffect(SpellEffIndex /*effIndex*/)
 {
 GetCaster()->CastSpell(GetHitUnit(), SPELL_DK_FESTERING_WOUND, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_AURA_STACK, GetEffectValue()));
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_dk_festering_strike::HandleScriptEffect, EFFECT_1, SPELL_EFFECT_DUMMY);
 }
};
 
// 47496 - Explode, Ghoul spell for Corpse Explosion
class spell_dk_ghoul_explode : public SpellScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellInfo({ SPELL_DK_CORPSE_EXPLOSION_TRIGGERED }) && ValidateSpellEffect({ { spellInfo->Id, EFFECT_2 } });
 }
 
 void HandleDamage(SpellEffIndex /*effIndex*/)
 {
 SetHitDamage(GetCaster()->CountPctFromMaxHealth(GetEffectInfo(EFFECT_2).CalcValue(GetCaster())));
 }
 
 void Suicide(SpellEffIndex /*effIndex*/)
 {
 if (Unit* unitTarget = GetHitUnit())
 {
 // Corpse Explosion (Suicide)
 unitTarget->CastSpell(unitTarget, SPELL_DK_CORPSE_EXPLOSION_TRIGGERED, true);
 }
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_dk_ghoul_explode::HandleDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
 OnEffectHitTarget += SpellEffectFn(spell_dk_ghoul_explode::Suicide, EFFECT_1, SPELL_EFFECT_SCHOOL_DAMAGE);
 }
};
 
// 69961 - Glyph of Scourge Strike
class spell_dk_glyph_of_scourge_strike_script : public SpellScript
{
 void HandleScriptEffect(SpellEffIndex /*effIndex*/)
 {
 Unit* caster = GetCaster();
 Unit* target = GetHitUnit();
 
 Unit::AuraEffectList const& mPeriodic = target->GetAuraEffectsByType(SPELL_AURA_PERIODIC_DAMAGE);
 for (Unit::AuraEffectList::const_iterator i = mPeriodic.begin(); i != mPeriodic.end(); ++i)
 {
 AuraEffect const* aurEff = *i;
 SpellInfo const* spellInfo = aurEff->GetSpellInfo();
 // search our Blood Plague and Frost Fever on target
 if (spellInfo->SpellFamilyName == SPELLFAMILY_DEATHKNIGHT && spellInfo->SpellFamilyFlags[2] & 0x2 &&
 aurEff->GetCasterGUID() == caster->GetGUID())
 {
 uint32 countMin = aurEff->GetBase()->GetMaxDuration();
 uint32 countMax = spellInfo->GetMaxDuration();
 
 // this Glyph
 countMax += 9000;
 
 if (countMin < countMax)
 {
 aurEff->GetBase()->SetDuration(aurEff->GetBase()->GetDuration() + 3000);
 aurEff->GetBase()->SetMaxDuration(countMin + 3000);
 }
 }
 }
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_dk_glyph_of_scourge_strike_script::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 49184 - Howling Blast
class spell_dk_howling_blast : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_FROST_FEVER });
 }
 
 void HandleFrostFever(SpellEffIndex /*effIndex*/)
 {
 GetCaster()->CastSpell(GetHitUnit(), SPELL_DK_FROST_FEVER);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_dk_howling_blast::HandleFrostFever, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
 }
};
 
// 206940 - Mark of Blood
class spell_dk_mark_of_blood : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_MARK_OF_BLOOD_HEAL });
 }
 
 void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 if (Unit* caster = GetCaster())
 caster->CastSpell(eventInfo.GetProcTarget(), SPELL_DK_MARK_OF_BLOOD_HEAL, true);
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_dk_mark_of_blood::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
// 207346 - Necrosis
class spell_dk_necrosis : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_NECROSIS_EFFECT });
 }
 
 void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_DK_NECROSIS_EFFECT, true);
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_dk_necrosis::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
// 207256 - Obliteration
class spell_dk_obliteration : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_OBLITERATION, SPELL_DK_OBLITERATION_RUNE_ENERGIZE, SPELL_DK_KILLING_MACHINE_PROC })
 && ValidateSpellEffect({ { SPELL_DK_OBLITERATION, EFFECT_1 } });
 }
 
 void HandleProc(AuraEffect* aurEff, ProcEventInfo& /*eventInfo*/)
 {
 Unit* target = GetTarget();
 target->CastSpell(target, SPELL_DK_KILLING_MACHINE_PROC, aurEff);
 
 if (AuraEffect const* oblitaration = target->GetAuraEffect(SPELL_DK_OBLITERATION, EFFECT_1))
 if (roll_chance_i(oblitaration->GetAmount()))
 target->CastSpell(target, SPELL_DK_OBLITERATION_RUNE_ENERGIZE, aurEff);
 }
 
 void Register() override
 {
 AfterEffectProc += AuraEffectProcFn(spell_dk_obliteration::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
// 207200 - Permafrost
class spell_dk_permafrost : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_FROST_SHIELD });
 }
 
 void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)
 {
 CastSpellExtraArgs args(aurEff);
 args.AddSpellMod(SPELLVALUE_BASE_POINT0, CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount()));
 GetTarget()->CastSpell(GetTarget(), SPELL_DK_FROST_SHIELD, args);
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_dk_permafrost::HandleEffectProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
// 121916 - Glyph of the Geist (Unholy)
class spell_dk_pet_geist_transform : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_GLYPH_OF_THE_GEIST });
 }
 
 bool Load() override
 {
 return GetCaster()->IsPet();
 }
 
 SpellCastResult CheckCast()
 {
 if (Unit* owner = GetCaster()->GetOwner())
 if (owner->HasAura(SPELL_DK_GLYPH_OF_THE_GEIST))
 return SPELL_CAST_OK;
 
 return SPELL_FAILED_SPELL_UNAVAILABLE;
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_dk_pet_geist_transform::CheckCast);
 }
};
 
// 147157 Glyph of the Skeleton (Unholy)
class spell_dk_pet_skeleton_transform : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_GLYPH_OF_THE_SKELETON });
 }
 
 SpellCastResult CheckCast()
 {
 if (Unit* owner = GetCaster()->GetOwner())
 if (owner->HasAura(SPELL_DK_GLYPH_OF_THE_SKELETON))
 return SPELL_CAST_OK;
 
 return SPELL_FAILED_SPELL_UNAVAILABLE;
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_dk_pet_skeleton_transform::CheckCast);
 }
};
 
// 61257 - Runic Power Back on Snare/Root
class spell_dk_pvp_4p_bonus : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_RUNIC_RETURN });
 }
 
 bool CheckProc(ProcEventInfo& eventInfo)
 {
 SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
 if (!spellInfo)
 return false;
 
 return (spellInfo->GetAllEffectsMechanicMask() & ((1 << MECHANIC_ROOT) | (1 << MECHANIC_SNARE))) != 0;
 }
 
 void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 eventInfo.GetActionTarget()->CastSpell(nullptr, SPELL_DK_RUNIC_RETURN, true);
 }
 
 void Register() override
 {
 DoCheckProc += AuraCheckProcFn(spell_dk_pvp_4p_bonus::CheckProc);
 OnEffectProc += AuraEffectProcFn(spell_dk_pvp_4p_bonus::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
// 46584 - Raise Dead
class spell_dk_raise_dead : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_RAISE_DEAD_SUMMON, SPELL_DK_SLUDGE_BELCHER, SPELL_DK_SLUDGE_BELCHER_SUMMON });
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 uint32 spellId = SPELL_DK_RAISE_DEAD_SUMMON;
 if (GetCaster()->HasAura(SPELL_DK_SLUDGE_BELCHER))
 spellId = SPELL_DK_SLUDGE_BELCHER_SUMMON;
 
 GetCaster()->CastSpell(nullptr, spellId, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_dk_raise_dead::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 59057 - Rime
class spell_dk_rime : public AuraScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } }) && ValidateSpellInfo({ SPELL_DK_FROST_SCYTHE });
 }
 
 bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
 {
 float chance = static_cast<float>(GetSpellInfo()->GetEffect(EFFECT_1).CalcValue(GetTarget()));
 if (eventInfo.GetSpellInfo()->Id == SPELL_DK_FROST_SCYTHE)
 chance /= 2.f;
 
 return roll_chance_f(chance);
 }
 
 void Register() override
 {
 DoCheckEffectProc += AuraCheckEffectProcFn(spell_dk_rime::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
 }
};
 
// 242057 - Rune Empowered
class spell_dk_t20_2p_rune_empowered : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_DK_PILLAR_OF_FROST, SPELL_DK_BREATH_OF_SINDRAGOSA });
 }
 
 void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& procInfo)
 {
 Spell const* procSpell = procInfo.GetProcSpell();
 if (!procSpell)
 return;
 
 Aura* pillarOfFrost = GetTarget()->GetAura(SPELL_DK_PILLAR_OF_FROST);
 if (!pillarOfFrost)
 return;
 
 _runicPowerSpent += procSpell->GetPowerTypeCostAmount(POWER_RUNIC_POWER).value_or(0);
 // Breath of Sindragosa special case
 SpellInfo const* breathOfSindragosa = sSpellMgr->AssertSpellInfo(SPELL_DK_BREATH_OF_SINDRAGOSA, DIFFICULTY_NONE);
 if (procSpell->IsTriggeredByAura(breathOfSindragosa))
 {
 auto powerItr = std::find_if(breathOfSindragosa->PowerCosts.begin(), breathOfSindragosa->PowerCosts.end(),
 [](SpellPowerEntry const* power) { return power->PowerType == POWER_RUNIC_POWER && power->PowerPctPerSecond > 0.0f; });
 if (powerItr != breathOfSindragosa->PowerCosts.end())
 _runicPowerSpent += CalculatePct(GetTarget()->GetMaxPower(POWER_RUNIC_POWER), (*powerItr)->PowerPctPerSecond);
 }
 
 if (_runicPowerSpent >= 600)
 {
 pillarOfFrost->SetDuration(pillarOfFrost->GetDuration() + 1000);
 _runicPowerSpent -= 600;
 }
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_dk_t20_2p_rune_empowered::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
 
 int32 _runicPowerSpent = 0;
};
 
// 55233 - Vampiric Blood
class spell_dk_vampiric_blood : public AuraScript
{
 void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/)
 {
 amount = GetUnitOwner()->CountPctFromMaxHealth(amount);
 }
 
 void Register() override
 {
 DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_dk_vampiric_blood::CalculateAmount, EFFECT_1, SPELL_AURA_MOD_INCREASE_HEALTH_2);
 }
};
 
// 43265 - Death and Decay
struct at_dk_death_and_decay : AreaTriggerAI
{
 at_dk_death_and_decay(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger) { }
 
 void OnUnitEnter(Unit* unit) override
 {
 if (Unit* caster = at->GetCaster())
 {
 if (caster == unit)
 {
 if (caster->HasAura(SPELL_DK_UNHOLY_GROUND_TALENT))
 caster->CastSpell(caster, SPELL_DK_UNHOLY_GROUND_HASTE);
 }
 }
 }
 
 void OnUnitExit(Unit* unit) override
 {
 unit->RemoveAurasDueToSpell(SPELL_DK_UNHOLY_GROUND_HASTE);
 }
};
 
void AddSC_deathknight_spell_scripts()
{
 RegisterSpellScript(spell_dk_advantage_t10_4p);
 RegisterSpellScript(spell_dk_anti_magic_shell);
 RegisterSpellScript(spell_dk_army_transform);
 RegisterSpellScript(spell_dk_blinding_sleet);
 RegisterSpellScript(spell_dk_blood_boil);
 RegisterSpellScript(spell_dk_dancing_rune_weapon);
 RegisterSpellScript(spell_dk_death_and_decay);
 RegisterSpellScript(spell_dk_death_coil);
 RegisterSpellScript(spell_dk_death_gate);
 RegisterSpellScript(spell_dk_death_grip_initial);
 RegisterSpellScript(spell_dk_death_pact);
 RegisterSpellScript(spell_dk_death_strike);
 RegisterSpellScript(spell_dk_death_strike_enabler);
 RegisterSpellScript(spell_dk_festering_strike);
 RegisterSpellScript(spell_dk_ghoul_explode);
 RegisterSpellScript(spell_dk_glyph_of_scourge_strike_script);
 RegisterSpellScript(spell_dk_howling_blast);
 RegisterSpellScript(spell_dk_mark_of_blood);
 RegisterSpellScript(spell_dk_necrosis);
 RegisterSpellScript(spell_dk_obliteration);
 RegisterSpellScript(spell_dk_permafrost);
 RegisterSpellScript(spell_dk_pet_geist_transform);
 RegisterSpellScript(spell_dk_pet_skeleton_transform);
 RegisterSpellScript(spell_dk_pvp_4p_bonus);
 RegisterSpellScript(spell_dk_raise_dead);
 RegisterSpellScript(spell_dk_rime);
 RegisterSpellScript(spell_dk_t20_2p_rune_empowered);
 RegisterSpellScript(spell_dk_vampiric_blood);
 
 RegisterAreaTriggerAI(at_dk_death_and_decay);
}