Scripts/Spells: Fixed remaining spells with SPELL_ATTR3_CAN_PROC_FROM_PROCS attribute

14 files changed, 1284 insertions, 18 deletions

diff --git a/src/server/scripts/Shadowlands/Torghast/spell_torghast.cpp b/src/server/scripts/Shadowlands/Torghast/spell_torghast.cpp
index c9c7e681a77..eef3eb0b075 100644
--- a/src/server/scripts/Shadowlands/Torghast/spell_torghast.cpp
+++ b/src/server/scripts/Shadowlands/Torghast/spell_torghast.cpp
@@ -16,12 +16,42 @@
  */
 
 #include "ScriptMgr.h"
+#include "Spell.h"
 #include "SpellAuraEffects.h"
 #include "SpellHistory.h"
 #include "SpellMgr.h"
 #include "SpellScript.h"
 #include "Unit.h"
 
+// 297721 - Subjugator's Manacles
+class spell_torghast_subjugators_manacles : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_subjugators_manacles);
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        if (_triggeredTargets.contains(procInfo.GetProcTarget()->GetGUID()))
+            return false;
+
+        _triggeredTargets.insert(procInfo.GetProcTarget()->GetGUID());
+        return true;
+    }
+
+    void ResetMarkedTargets(bool isNowInCombat)
+    {
+        if (!isNowInCombat)
+            _triggeredTargets.clear();
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_torghast_subjugators_manacles::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+        OnEnterLeaveCombat += AuraEnterLeaveCombatFn(spell_torghast_subjugators_manacles::ResetMarkedTargets);
+    }
+
+    std::unordered_set<ObjectGuid> _triggeredTargets;
+};
+
 // 300771 - Blade of the Lifetaker
 class spell_torghast_blade_of_the_lifetaker : public AuraScript
 {
@@ -137,10 +167,222 @@ class spell_torghast_dimensional_blade : public SpellScript
     }
 };
 
+// 341324 - Uncontrolled Darkness
+class spell_torghast_uncontrolled_darkness : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_uncontrolled_darkness);
+
+    void Register() override
+    {
+        // just a value holder, no hooks
+    }
+
+public:
+    int32 KillCounter = 0;
+};
+
+// 343174 - Uncontrolled Darkness
+class spell_torghast_uncontrolled_darkness_proc : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_uncontrolled_darkness_proc);
+
+    static constexpr uint32 SPELL_UNCONTROLLED_DARKNESS = 341324;
+    static constexpr uint32 SPELL_UNCONTROLLED_DARKNESS_BUFF = 341375;
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellEffect({ { SPELL_UNCONTROLLED_DARKNESS, EFFECT_1 } })
+            && ValidateSpellInfo({ SPELL_UNCONTROLLED_DARKNESS_BUFF });
+    }
+
+    void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& /*procInfo*/)
+    {
+        Unit* caster = GetCaster();
+        if (!caster)
+            return;
+
+        Aura* uncontrolledDarkness = caster->GetAura(SPELL_UNCONTROLLED_DARKNESS, caster->GetGUID());
+        if (!uncontrolledDarkness)
+            return;
+
+        spell_torghast_uncontrolled_darkness* script = uncontrolledDarkness->GetScript<spell_torghast_uncontrolled_darkness>();
+        if (!script)
+            return;
+
+        if (caster->HasAura(SPELL_UNCONTROLLED_DARKNESS_BUFF))
+        {
+            if (++script->KillCounter >= uncontrolledDarkness->GetSpellInfo()->GetEffect(EFFECT_1).CalcValue())
+            {
+                caster->RemoveAura(SPELL_UNCONTROLLED_DARKNESS_BUFF);
+                script->KillCounter = 0;
+            }
+        }
+        else
+        {
+            if (++script->KillCounter >= uncontrolledDarkness->GetSpellInfo()->GetEffect(EFFECT_0).CalcValue())
+            {
+                caster->CastSpell(caster, SPELL_UNCONTROLLED_DARKNESS_BUFF, true);
+                script->KillCounter = 0;
+            }
+        }
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_torghast_uncontrolled_darkness_proc::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
+    }
+};
+
+// 342632 - Malevolent Stitching
+class spell_torghast_fleshcraft_shield_proc : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_fleshcraft_shield_proc);
+
+    static constexpr uint32 SPELL_LABEL_FLESHCRAFT_BUFF = 1103;
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_FLESHCRAFT_BUFF);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_torghast_fleshcraft_shield_proc::CheckProc);
+    }
+};
+
+// 342779 - Crystallized Dreams
+class spell_torghast_soulshape_proc : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_soulshape_proc);
+
+    static constexpr uint32 SPELL_LABEL_SOULSHAPE = 1100;
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_SOULSHAPE);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_torghast_soulshape_proc::CheckProc);
+    }
+};
+
+// 342793 - Murmuring Shawl
+// 342799 - Gnarled Key
+class spell_torghast_door_of_shadows_proc : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_door_of_shadows_proc);
+
+    static constexpr uint32 SPELL_LABEL_DOOR_OF_SHADOWS = 726;
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_DOOR_OF_SHADOWS);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_torghast_door_of_shadows_proc::CheckProc);
+    }
+};
+
+// 348908 - Ethereal Wildseed
+class spell_torghast_flicker_proc : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_flicker_proc);
+
+    static constexpr uint32 SPELL_LABEL_FLICKER = 1105;
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_FLICKER);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_torghast_flicker_proc::CheckProc);
+    }
+};
+
+// 354569 - Potent Potion
+class spell_torghast_potent_potion_proc : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_potent_potion_proc);
+
+    static constexpr uint32 SPELL_LABEL_REJUVENATING_SIPHONED_ESSENCE = 1290;
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_REJUVENATING_SIPHONED_ESSENCE);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_torghast_potent_potion_proc::CheckProc);
+    }
+};
+
+// 354706 - Spiritual Rejuvenation Potion
+class spell_torghast_potent_potion_calc : public SpellScript
+{
+    PrepareSpellScript(spell_torghast_potent_potion_calc);
+
+    static constexpr uint32 SPELL_LABEL_SPIRITUAL_REJUVENATION_POTION = 354568;
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellEffect({ { SPELL_LABEL_SPIRITUAL_REJUVENATION_POTION, EFFECT_1 } });
+    }
+
+    void SetValue(SpellEffIndex effIndex)
+    {
+        SetEffectValue(sSpellMgr->AssertSpellInfo(SPELL_LABEL_SPIRITUAL_REJUVENATION_POTION, GetCastDifficulty())->GetEffect(effIndex)
+            .CalcValue(GetCaster(), nullptr, GetHitUnit()));;
+    }
+
+    void Register() override
+    {
+        OnEffectLaunchTarget += SpellEffectFn(spell_torghast_potent_potion_calc::SetValue, EFFECT_0, SPELL_EFFECT_HEAL);
+        OnEffectHitTarget += SpellEffectFn(spell_torghast_potent_potion_calc::SetValue, EFFECT_1, SPELL_EFFECT_ENERGIZE);
+    }
+};
+
+// 373761 - Poisonous Spores
+class spell_torghast_poisonous_spores : public AuraScript
+{
+    PrepareAuraScript(spell_torghast_poisonous_spores);
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& procInfo)
+    {
+        PreventDefaultAction();
+
+        Spell const* procSpell = procInfo.GetProcSpell();
+        procInfo.GetActor()->CastSpell(*procSpell->m_targets.GetDst(), aurEff->GetSpellEffectInfo().TriggerSpell,
+            CastSpellExtraArgs(aurEff).SetTriggeringSpell(procSpell));
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_torghast_poisonous_spores::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 void AddSC_torghast_spell_scripts()
 {
+    RegisterSpellScript(spell_torghast_subjugators_manacles);
     RegisterSpellScript(spell_torghast_blade_of_the_lifetaker);
     RegisterSpellScript(spell_torghast_touch_of_the_unseen);
     RegisterSpellScript(spell_torghast_yelshirs_powerglove);
     RegisterSpellScript(spell_torghast_dimensional_blade);
+    RegisterSpellScript(spell_torghast_uncontrolled_darkness);
+    RegisterSpellScript(spell_torghast_uncontrolled_darkness_proc);
+    RegisterSpellScript(spell_torghast_fleshcraft_shield_proc);
+    RegisterSpellScript(spell_torghast_soulshape_proc);
+    RegisterSpellScript(spell_torghast_door_of_shadows_proc);
+    RegisterSpellScript(spell_torghast_flicker_proc);
+    RegisterSpellScript(spell_torghast_potent_potion_proc);
+    RegisterSpellScript(spell_torghast_potent_potion_calc);
+    RegisterSpellScript(spell_torghast_poisonous_spores);
 }
diff --git a/src/server/scripts/Spells/spell_azerite.cpp b/src/server/scripts/Spells/spell_azerite.cpp
index 26d0076756e..3fa21120fa0 100644
--- a/src/server/scripts/Spells/spell_azerite.cpp
+++ b/src/server/scripts/Spells/spell_azerite.cpp
@@ -38,11 +38,11 @@ class spell_azerite_gen_aura_calc_from_2nd_effect_triggered_spell : public AuraS
     {
         if (Unit* caster = GetCaster())
         {
-            if (AuraEffect const* trait = caster->GetAuraEffect(GetEffectInfo(EFFECT_1).TriggerSpell, EFFECT_0))
-            {
-                amount = trait->GetAmount();
-                canBeRecalculated = false;
-            }
+            amount = 0;
+            canBeRecalculated = false;
+            for (auto const& [_, aurApp] : Trinity::Containers::MapEqualRange(caster->GetAppliedAuras(), GetEffectInfo(EFFECT_1).TriggerSpell))
+                if (aurApp->HasEffect(EFFECT_0))
+                    amount += aurApp->GetBase()->GetEffect(EFFECT_0)->GetAmount();
         }
     }
 
@@ -273,6 +273,42 @@ class spell_item_trample_the_weak : public AuraScript
     }
 };
 
+// 272892 - Wracking Brilliance
+class spell_item_wracking_brilliance : public AuraScript
+{
+    PrepareAuraScript(spell_item_wracking_brilliance);
+
+    enum
+    {
+        SPELL_AGONY_SOUL_SHARD_GAIN = 210067
+    };
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_AGONY_SOUL_SHARD_GAIN });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
+    {
+        SpellInfo const* spellInfo = eventInfo.GetSpellInfo();
+        if (!spellInfo)
+            return false;
+
+        if (spellInfo->Id != SPELL_AGONY_SOUL_SHARD_GAIN)
+            return false;
+
+        _canTrigger = !_canTrigger; // every other soul shard gain
+        return _canTrigger;
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_item_wracking_brilliance::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+
+    bool _canTrigger = true;
+};
+
 enum OrbitalPrecision
 {
     SPELL_MAGE_FROZEN_ORB   = 84714
@@ -635,6 +671,7 @@ void AddSC_azerite_item_spell_scripts()
     RegisterSpellScript(spell_item_bracing_chill_proc);
     RegisterSpellScript(spell_item_bracing_chill_search_jump_target);
     RegisterSpellScript(spell_item_trample_the_weak);
+    RegisterSpellScript(spell_item_wracking_brilliance);
     RegisterSpellScript(spell_item_orbital_precision);
     RegisterSpellScript(spell_item_blur_of_talons);
     RegisterSpellScript(spell_item_divine_right);
diff --git a/src/server/scripts/Spells/spell_dh.cpp b/src/server/scripts/Spells/spell_dh.cpp
index 15f33bf9be8..207861c3539 100644
--- a/src/server/scripts/Spells/spell_dh.cpp
+++ b/src/server/scripts/Spells/spell_dh.cpp
@@ -161,6 +161,7 @@ enum DemonHunterSpells
     SPELL_DH_SOUL_CLEAVE                           = 228477,
     SPELL_DH_SOUL_CLEAVE_DMG                       = 228478,
     SPELL_DH_SOUL_FRAGMENT_COUNTER                 = 203981,
+    SPELL_DH_SOUL_FURNACE_DAMAGE_BUFF              = 391172,
     SPELL_DH_SOUL_RENDING                          = 204909,
     SPELL_DH_SPIRIT_BOMB_DAMAGE                    = 218677,
     SPELL_DH_SPIRIT_BOMB_HEAL                      = 227255,
@@ -443,6 +444,58 @@ class spell_dh_glide_timer : public AuraScript
     }
 };
 
+// 391166 - Soul Furnace
+class spell_dh_soul_furnace : public AuraScript
+{
+    PrepareAuraScript(spell_dh_soul_furnace);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_DH_SOUL_FURNACE_DAMAGE_BUFF });
+    }
+
+    void CalculateSpellMod(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
+    {
+        if (GetStackAmount() == GetAura()->CalcMaxStackAmount())
+        {
+            GetTarget()->CastSpell(GetTarget(), SPELL_DH_SOUL_FURNACE_DAMAGE_BUFF, true);
+            Remove();
+        }
+    }
+
+    void Register() override
+    {
+        AfterEffectApply += AuraEffectApplyFn(spell_dh_soul_furnace::CalculateSpellMod, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+    }
+};
+
+// 339424 - Soul Furnace
+class spell_dh_soul_furnace_conduit : public AuraScript
+{
+    PrepareAuraScript(spell_dh_soul_furnace_conduit);
+
+    void CalculateSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod)
+    {
+        if (aurEff->GetAmount() == 10)
+        {
+            if (!spellMod)
+            {
+                spellMod = new SpellModifierByClassMask(GetAura());
+                spellMod->op = SpellModOp::HealingAndDamage;
+                spellMod->type = SPELLMOD_PCT;
+                spellMod->spellId = GetId();
+                static_cast<SpellModifierByClassMask*>(spellMod)->mask = flag128(0x80000000);
+                static_cast<SpellModifierByClassMask*>(spellMod)->value = GetEffect(EFFECT_1)->GetAmount() + 1;
+            }
+        }
+    }
+
+    void Register() override
+    {
+        DoEffectCalcSpellMod += AuraEffectCalcSpellModFn(spell_dh_soul_furnace_conduit::CalculateSpellMod, EFFECT_0, SPELL_AURA_DUMMY);
+    }
+};
+
 void AddSC_demon_hunter_spell_scripts()
 {
     RegisterSpellScript(spell_dh_chaos_strike);
@@ -468,9 +521,14 @@ void AddSC_demon_hunter_spell_scripts()
     RegisterSpellScript(spell_dh_blade_dance);
     RegisterSpellScript(spell_dh_blade_dance_damage);
 
+    // Vengeance
+    RegisterSpellScript(spell_dh_soul_furnace);
+
     // Vengeance & Havoc
 
     RegisterSpellAndAuraScriptPair(spell_dh_glide, spell_dh_glide_AuraScript);
     RegisterSpellScript(spell_dh_glide_timer);
 
+    // Soulbind conduits
+    RegisterSpellScript(spell_dh_soul_furnace_conduit);
 }
diff --git a/src/server/scripts/Spells/spell_dk.cpp b/src/server/scripts/Spells/spell_dk.cpp
index b19fa275cc3..7f54053b765 100644
--- a/src/server/scripts/Spells/spell_dk.cpp
+++ b/src/server/scripts/Spells/spell_dk.cpp
@@ -44,6 +44,7 @@ enum DeathKnightSpells
     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,
@@ -64,6 +65,7 @@ enum DeathKnightSpells
     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,
@@ -881,6 +883,52 @@ class spell_dk_rime : public AuraScript
     }
 };
 
+// 242057 - Rune Empowered
+class spell_dk_t20_2p_rune_empowered : public AuraScript
+{
+    PrepareAuraScript(spell_dk_t20_2p_rune_empowered);
+
+    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
 {
@@ -923,5 +971,6 @@ void AddSC_deathknight_spell_scripts()
     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);
 }
diff --git a/src/server/scripts/Spells/spell_druid.cpp b/src/server/scripts/Spells/spell_druid.cpp
index 9b80914359b..a663c76b40c 100644
--- a/src/server/scripts/Spells/spell_druid.cpp
+++ b/src/server/scripts/Spells/spell_druid.cpp
@@ -1036,6 +1036,31 @@ class spell_dru_starfall_dummy : public SpellScript
     }
 };
 
+// 340694 - Sudden Ambush
+// 384667 - Sudden Ambush
+class spell_dru_sudden_ambush : public AuraScript
+{
+    PrepareAuraScript(spell_dru_sudden_ambush);
+
+    bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& procInfo)
+    {
+        Spell const* procSpell = procInfo.GetProcSpell();
+        if (!procSpell)
+            return false;
+
+        Optional<int32> comboPoints = procSpell->GetPowerTypeCostAmount(POWER_COMBO_POINTS);
+        if (!comboPoints)
+            return false;
+
+        return roll_chance_i(*comboPoints * aurEff->GetAmount());
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_dru_sudden_ambush::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 //  93402 - Sunfire
 class spell_dru_sunfire : public SpellScript
 {
@@ -1640,6 +1665,7 @@ void AddSC_druid_spell_scripts()
     RegisterSpellScript(spell_dru_skull_bash);
     RegisterSpellScript(spell_dru_stampeding_roar);
     RegisterSpellScript(spell_dru_starfall_dummy);
+    RegisterSpellScript(spell_dru_sudden_ambush);
     RegisterSpellScript(spell_dru_sunfire);
     RegisterSpellScript(spell_dru_survival_instincts);
     RegisterSpellScript(spell_dru_swift_flight_passive);
diff --git a/src/server/scripts/Spells/spell_evoker.cpp b/src/server/scripts/Spells/spell_evoker.cpp
index 61958b7e4a7..9bf320f04c6 100644
--- a/src/server/scripts/Spells/spell_evoker.cpp
+++ b/src/server/scripts/Spells/spell_evoker.cpp
@@ -38,10 +38,16 @@ enum EvokerSpells
     SPELL_EVOKER_LIVING_FLAME              = 361469,
     SPELL_EVOKER_LIVING_FLAME_DAMAGE       = 361500,
     SPELL_EVOKER_LIVING_FLAME_HEAL         = 361509,
+    SPELL_EVOKER_PERMEATING_CHILL_TALENT   = 370897,
     SPELL_EVOKER_PYRE_DAMAGE               = 357212,
     SPELL_EVOKER_SOAR_RACIAL               = 369536
 };
 
+enum EvokerSpellLabels
+{
+    SPELL_LABEL_EVOKER_BLUE                 = 1465,
+};
+
 // 362969 - Azure Strike (blue)
 class spell_evo_azure_strike : public SpellScript
 {
@@ -60,6 +66,22 @@ class spell_evo_azure_strike : public SpellScript
     }
 };
 
+// 370455 - Charged Blast
+class spell_evo_charged_blast : public AuraScript
+{
+    PrepareAuraScript(spell_evo_charged_blast);
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        return procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_EVOKER_BLUE);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_evo_charged_blast::CheckProc);
+    }
+};
+
 // 358733 - Glide (Racial)
 class spell_evo_glide : public SpellScript
 {
@@ -140,6 +162,38 @@ class spell_evo_living_flame : public SpellScript
     }
 };
 
+// 381773 - Permeating Chill
+class spell_evo_permeating_chill : public AuraScript
+{
+    PrepareAuraScript(spell_evo_permeating_chill);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_EVOKER_PERMEATING_CHILL_TALENT });
+    }
+
+    bool CheckProc(ProcEventInfo& procInfo)
+    {
+        SpellInfo const* spellInfo = procInfo.GetSpellInfo();
+        if (!spellInfo)
+            return false;
+
+        if (!spellInfo->HasLabel(SPELL_LABEL_EVOKER_BLUE))
+            return false;
+
+        if (!procInfo.GetActor()->HasAura(SPELL_EVOKER_PERMEATING_CHILL_TALENT))
+            if (!spellInfo->IsAffected(SPELLFAMILY_EVOKER, { 0x40, 0, 0, 0 })) // disintegrate
+                return false;
+
+        return true;
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_evo_permeating_chill::CheckProc);
+    }
+};
+
 // 393568 - Pyre
 class spell_evo_pyre : public SpellScript
 {
@@ -164,7 +218,9 @@ class spell_evo_pyre : public SpellScript
 void AddSC_evoker_spell_scripts()
 {
     RegisterSpellScript(spell_evo_azure_strike);
+    RegisterSpellScript(spell_evo_charged_blast);
     RegisterSpellScript(spell_evo_glide);
     RegisterSpellScript(spell_evo_living_flame);
+    RegisterSpellScript(spell_evo_permeating_chill);
     RegisterSpellScript(spell_evo_pyre);
 }
diff --git a/src/server/scripts/Spells/spell_generic.cpp b/src/server/scripts/Spells/spell_generic.cpp
index 4e5eae59346..cd8fcfb0663 100644
--- a/src/server/scripts/Spells/spell_generic.cpp
+++ b/src/server/scripts/Spells/spell_generic.cpp
@@ -4894,6 +4894,31 @@ class spell_gen_impatient_mind : public AuraScript
     }
 };
 
+// 209352 - Boost 2.0 [Paladin+Priest] - Watch for Shield
+class spell_gen_boost_2_0_paladin_priest_watch_for_shield : public AuraScript
+{
+    PrepareAuraScript(spell_gen_boost_2_0_paladin_priest_watch_for_shield);
+
+    static constexpr uint32 SPELL_POWER_WORD_SHIELD = 17;
+    static constexpr uint32 SPELL_DIVINE_SHIELD = 642;
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_POWER_WORD_SHIELD, SPELL_DIVINE_SHIELD });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        SpellInfo const* spellInfo = procInfo.GetSpellInfo();
+        return spellInfo && (spellInfo->Id == SPELL_POWER_WORD_SHIELD || spellInfo->Id == SPELL_DIVINE_SHIELD);
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_gen_boost_2_0_paladin_priest_watch_for_shield::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 // 269083 - Enlisted
 // 282559 - Enlisted
 class spell_gen_war_mode_enlisted : public AuraScript
@@ -5680,6 +5705,7 @@ void AddSC_generic_spell_scripts()
     RegisterSpellScript(spell_gen_azgalor_rain_of_fire_hellfire_citadel);
     RegisterSpellScript(spell_gen_face_rage);
     RegisterSpellScript(spell_gen_impatient_mind);
+    RegisterSpellScript(spell_gen_boost_2_0_paladin_priest_watch_for_shield);
     RegisterSpellScript(spell_gen_war_mode_enlisted);
     RegisterSpellScript(spell_defender_of_azeroth_death_gate_selector);
     RegisterSpellScript(spell_defender_of_azeroth_speak_with_mograine);
diff --git a/src/server/scripts/Spells/spell_hunter.cpp b/src/server/scripts/Spells/spell_hunter.cpp
index 0566369c928..258faa9f23c 100644
--- a/src/server/scripts/Spells/spell_hunter.cpp
+++ b/src/server/scripts/Spells/spell_hunter.cpp
@@ -27,6 +27,7 @@
 #include "Pet.h"
 #include "SpellAuraEffects.h"
 #include "SpellHistory.h"
+#include "SpellMgr.h"
 #include "SpellScript.h"
 
 enum HunterSpells
@@ -40,6 +41,10 @@ enum HunterSpells
     SPELL_HUNTER_EXHILARATION_PET                   = 128594,
     SPELL_HUNTER_EXHILARATION_R2                    = 231546,
     SPELL_HUNTER_EXPLOSIVE_SHOT_DAMAGE              = 212680,
+    SPELL_HUNTER_LATENT_POISON_STACK                = 378015,
+    SPELL_HUNTER_LATENT_POISON_DAMAGE               = 378016,
+    SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK      = 336903,
+    SPELL_HUNTER_LATENT_POISON_INJECTORS_DAMAGE     = 336904,
     SPELL_HUNTER_LONE_WOLF                          = 155228,
     SPELL_HUNTER_MASTERS_CALL_TRIGGERED             = 62305,
     SPELL_HUNTER_MISDIRECTION                       = 34477,
@@ -54,6 +59,7 @@ enum HunterSpells
     SPELL_HUNTER_RAPID_FIRE_ENERGIZE                = 263585,
     SPELL_HUNTER_STEADY_SHOT_FOCUS                  = 77443,
     SPELL_HUNTER_T9_4P_GREATNESS                    = 68130,
+    SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE         = 394371,
     SPELL_ROAR_OF_SACRIFICE_TRIGGERED               = 67481
 };
 
@@ -130,6 +136,27 @@ class spell_hun_aspect_cheetah : public AuraScript
     }
 };
 
+// 378750 - Cobra Sting
+class spell_hun_cobra_sting : public AuraScript
+{
+    PrepareAuraScript(spell_hun_cobra_sting);
+
+    bool Validate(SpellInfo const* spellInfo) override
+    {
+        return ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } });
+    }
+
+    bool RollProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*procInfo*/)
+    {
+        return roll_chance_i(GetEffect(EFFECT_1)->GetAmount());
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_hun_cobra_sting::RollProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 // 109304 - Exhilaration
 class spell_hun_exhilaration : public SpellScript
 {
@@ -225,6 +252,104 @@ class spell_hun_last_stand_pet : public SpellScript
     }
 };
 
+// 378016 - Latent Poison
+class spell_hun_latent_poison_damage : public SpellScript
+{
+    PrepareSpellScript(spell_hun_latent_poison_damage);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_STACK });
+    }
+
+    void CalculateDamage()
+    {
+        if (Aura* stack = GetHitUnit()->GetAura(SPELL_HUNTER_LATENT_POISON_STACK, GetCaster()->GetGUID()))
+        {
+            SetHitDamage(GetHitDamage() * stack->GetStackAmount());
+            stack->Remove();
+        }
+    }
+
+    void Register() override
+    {
+        OnHit += SpellHitFn(spell_hun_latent_poison_damage::CalculateDamage);
+    }
+};
+
+// 19434 - Aimed Shot
+// 186270 - Raptor Strike
+// 217200 - Barbed Shot
+// 259387 - Mongoose Bite
+class spell_hun_latent_poison_trigger : public SpellScript
+{
+    PrepareSpellScript(spell_hun_latent_poison_trigger);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_STACK, SPELL_HUNTER_LATENT_POISON_DAMAGE });
+    }
+
+    void TriggerDamage()
+    {
+        if (GetHitUnit()->HasAura(SPELL_HUNTER_LATENT_POISON_STACK, GetCaster()->GetGUID()))
+            GetCaster()->CastSpell(GetHitUnit(), SPELL_HUNTER_LATENT_POISON_DAMAGE, GetSpell());
+    }
+
+    void Register() override
+    {
+        AfterHit += SpellHitFn(spell_hun_latent_poison_trigger::TriggerDamage);
+    }
+};
+
+// 336904 - Latent Poison Injectors
+class spell_hun_latent_poison_injectors_damage : public SpellScript
+{
+    PrepareSpellScript(spell_hun_latent_poison_injectors_damage);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK });
+    }
+
+    void CalculateDamage()
+    {
+        if (Aura* stack = GetHitUnit()->GetAura(SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK, GetCaster()->GetGUID()))
+        {
+            SetHitDamage(GetHitDamage() * stack->GetStackAmount());
+            stack->Remove();
+        }
+    }
+
+    void Register() override
+    {
+        OnHit += SpellHitFn(spell_hun_latent_poison_injectors_damage::CalculateDamage);
+    }
+};
+
+// 186270 - Raptor Strike
+// 259387 - Mongoose Bite
+class spell_hun_latent_poison_injectors_trigger : public SpellScript
+{
+    PrepareSpellScript(spell_hun_latent_poison_injectors_trigger);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK, SPELL_HUNTER_LATENT_POISON_INJECTORS_DAMAGE });
+    }
+
+    void TriggerDamage()
+    {
+        if (GetHitUnit()->HasAura(SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK, GetCaster()->GetGUID()))
+            GetCaster()->CastSpell(GetHitUnit(), SPELL_HUNTER_LATENT_POISON_INJECTORS_DAMAGE, GetSpell());
+    }
+
+    void Register() override
+    {
+        AfterHit += SpellHitFn(spell_hun_latent_poison_injectors_trigger::TriggerDamage);
+    }
+};
+
 // 53271 - Masters Call
 class spell_hun_masters_call : public SpellScript
 {
@@ -674,14 +799,49 @@ class spell_hun_t9_4p_bonus : public AuraScript
     }
 };
 
+// 394366 - Find The Mark
+class spell_hun_t29_2p_marksmanship_bonus : public AuraScript
+{
+    PrepareAuraScript(spell_hun_t29_2p_marksmanship_bonus);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellEffect({ { SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, EFFECT_0 } })
+            && sSpellMgr->AssertSpellInfo(SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, DIFFICULTY_NONE)->GetMaxTicks();
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
+    {
+        PreventDefaultAction();
+
+        Unit* caster = eventInfo.GetActor();
+        uint32 ticks = sSpellMgr->AssertSpellInfo(SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, DIFFICULTY_NONE)->GetMaxTicks();
+        uint32 damage = CalculatePct(eventInfo.GetDamageInfo()->GetOriginalDamage(), aurEff->GetAmount()) / ticks;
+
+        caster->CastSpell(eventInfo.GetActionTarget(), SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, CastSpellExtraArgs(aurEff)
+            .SetTriggeringSpell(eventInfo.GetProcSpell())
+            .AddSpellMod(SPELLVALUE_BASE_POINT0, damage));
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_hun_t29_2p_marksmanship_bonus::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
+    }
+};
+
 void AddSC_hunter_spell_scripts()
 {
     RegisterSpellScript(spell_hun_a_murder_of_crows);
     RegisterSpellScript(spell_hun_aspect_cheetah);
+    RegisterSpellScript(spell_hun_cobra_sting);
     RegisterSpellScript(spell_hun_exhilaration);
     RegisterSpellScript(spell_hun_explosive_shot);
     RegisterSpellScript(spell_hun_hunting_party);
     RegisterSpellScript(spell_hun_last_stand_pet);
+    RegisterSpellScript(spell_hun_latent_poison_damage);
+    RegisterSpellScript(spell_hun_latent_poison_trigger);
+    RegisterSpellScript(spell_hun_latent_poison_injectors_damage);
+    RegisterSpellScript(spell_hun_latent_poison_injectors_trigger);
     RegisterSpellScript(spell_hun_masters_call);
     RegisterSpellScript(spell_hun_misdirection);
     RegisterSpellScript(spell_hun_misdirection_proc);
@@ -695,4 +855,5 @@ void AddSC_hunter_spell_scripts()
     RegisterSpellScript(spell_hun_steady_shot);
     RegisterSpellScript(spell_hun_tame_beast);
     RegisterSpellScript(spell_hun_t9_4p_bonus);
+    RegisterSpellScript(spell_hun_t29_2p_marksmanship_bonus);
 }
diff --git a/src/server/scripts/Spells/spell_item.cpp b/src/server/scripts/Spells/spell_item.cpp
index debda5555b8..22a2e8e9676 100644
--- a/src/server/scripts/Spells/spell_item.cpp
+++ b/src/server/scripts/Spells/spell_item.cpp
@@ -4477,6 +4477,65 @@ class spell_item_eggnog : public SpellScript
     }
 };
 
+enum SephuzsSecret
+{
+    SPELL_SEPHUZS_SECRET_COOLDOWN = 226262
+};
+
+// 208051 - Sephuz's Secret
+// 234867 - Sephuz's Secret
+// 236763 - Sephuz's Secret
+class spell_item_sephuzs_secret : public AuraScript
+{
+    PrepareAuraScript(spell_item_sephuzs_secret);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_SEPHUZS_SECRET_COOLDOWN });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
+    {
+        if (GetUnitOwner()->HasAura(SPELL_SEPHUZS_SECRET_COOLDOWN))
+            return false;
+
+        if (eventInfo.GetHitMask() & (PROC_HIT_INTERRUPT | PROC_HIT_DISPEL))
+            return true;
+
+        Spell const* procSpell = eventInfo.GetProcSpell();
+        if (!procSpell)
+            return false;
+
+        bool isCrowdControl = procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_CONFUSE)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_FEAR)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_STUN)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_PACIFY)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_ROOT)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_SILENCE)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_PACIFY_SILENCE)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_ROOT_2);
+
+        if (!isCrowdControl)
+            return false;
+
+        return true;
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& procInfo)
+    {
+        PreventDefaultAction();
+
+        GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SEPHUZS_SECRET_COOLDOWN, TRIGGERED_FULL_MASK);
+        GetUnitOwner()->CastSpell(procInfo.GetProcTarget(), aurEff->GetSpellEffectInfo().TriggerSpell, CastSpellExtraArgs(aurEff).SetTriggeringSpell(procInfo.GetProcSpell()));
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_item_sephuzs_secret::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+        OnEffectProc += AuraEffectProcFn(spell_item_sephuzs_secret::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 enum AmalgamsSeventhSpine
 {
     SPELL_FRAGILE_ECHOES_MONK               = 225281,
@@ -4841,6 +4900,58 @@ class spell_item_phial_of_the_arcane_tempest_periodic : public AuraScript
     }
 };
 
+// 410530 - Mettle
+// 410964 - Mettle
+class spell_item_infurious_crafted_gear_mettle : public AuraScript
+{
+    PrepareAuraScript(spell_item_infurious_crafted_gear_mettle);
+
+    static constexpr uint32 SPELL_METTLE_COOLDOWN = 410532;
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_METTLE_COOLDOWN });
+    }
+
+    bool CheckProc(ProcEventInfo& eventInfo)
+    {
+        if (GetTarget()->HasAura(SPELL_METTLE_COOLDOWN))
+            return false;
+
+        if (eventInfo.GetHitMask() & (PROC_HIT_INTERRUPT | PROC_HIT_DISPEL))
+            return true;
+
+        Spell const* procSpell = eventInfo.GetProcSpell();
+        if (!procSpell)
+            return false;
+
+        bool isCrowdControl = procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_CONFUSE)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_FEAR)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_STUN)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_PACIFY)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_ROOT)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_SILENCE)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_PACIFY_SILENCE)
+            || procSpell->GetSpellInfo()->HasAura(SPELL_AURA_MOD_ROOT_2);
+
+        if (!isCrowdControl)
+            return false;
+
+        return eventInfo.GetActionTarget()->HasAura([&](Aura const* aura) { return aura->GetCastId() == procSpell->m_castId; });
+    }
+
+    void TriggerCooldown(ProcEventInfo& /*eventInfo*/)
+    {
+        GetTarget()->CastSpell(GetTarget(), SPELL_METTLE_COOLDOWN, true);
+    }
+
+    void Register() override
+    {
+        DoCheckProc += AuraCheckProcFn(spell_item_infurious_crafted_gear_mettle::CheckProc);
+        AfterProc += AuraProcFn(spell_item_infurious_crafted_gear_mettle::TriggerCooldown);
+    }
+};
+
 void AddSC_item_spell_scripts()
 {
     // 23074 Arcanite Dragonling
@@ -4981,6 +5092,7 @@ void AddSC_item_spell_scripts()
     RegisterSpellScript(spell_item_crazy_alchemists_potion);
     RegisterSpellScript(spell_item_eggnog);
 
+    RegisterSpellScript(spell_item_sephuzs_secret);
     RegisterSpellScript(spell_item_amalgams_seventh_spine);
     RegisterSpellScript(spell_item_amalgams_seventh_spine_mana_restore);
     RegisterSpellScript(spell_item_set_march_of_the_legion);
@@ -4995,4 +5107,6 @@ void AddSC_item_spell_scripts()
     RegisterSpellScriptWithArgs(spell_item_shiver_venom_weapon_proc, "spell_item_shiver_venom_lance", SPELL_VENOMOUS_LANCE);
     RegisterSpellScript(spell_item_phial_of_the_arcane_tempest_damage);
     RegisterSpellScript(spell_item_phial_of_the_arcane_tempest_periodic);
+
+    RegisterSpellScript(spell_item_infurious_crafted_gear_mettle);
 }
diff --git a/src/server/scripts/Spells/spell_mage.cpp b/src/server/scripts/Spells/spell_mage.cpp
index b11b37ad07e..f2926c79acd 100644
--- a/src/server/scripts/Spells/spell_mage.cpp
+++ b/src/server/scripts/Spells/spell_mage.cpp
@@ -57,7 +57,9 @@ enum MageSpells
     SPELL_MAGE_CONJURE_REFRESHMENT               = 116136,
     SPELL_MAGE_CONJURE_REFRESHMENT_TABLE         = 167145,
     SPELL_MAGE_DRAGONHAWK_FORM                   = 32818,
+    SPELL_MAGE_ETHEREAL_BLINK                    = 410939,
     SPELL_MAGE_EVERWARM_SOCKS                    = 320913,
+    SPELL_MAGE_FEEL_THE_BURN                     = 383391,
     SPELL_MAGE_FINGERS_OF_FROST                  = 44544,
     SPELL_MAGE_FIRE_BLAST                        = 108853,
     SPELL_MAGE_FIRESTARTER                       = 205026,
@@ -71,6 +73,7 @@ enum MageSpells
     SPELL_MAGE_LIVING_BOMB_PERIODIC              = 217694,
     SPELL_MAGE_MANA_SURGE                        = 37445,
     SPELL_MAGE_MASTER_OF_TIME                    = 342249,
+    SPELL_MAGE_RADIANT_SPARK_PROC_BLOCKER        = 376105,
     SPELL_MAGE_RAY_OF_FROST_BONUS                = 208141,
     SPELL_MAGE_RAY_OF_FROST_FINGERS_OF_FROST     = 269748,
     SPELL_MAGE_REVERBERATE                       = 281482,
@@ -79,7 +82,10 @@ enum MageSpells
     SPELL_MAGE_RING_OF_FROST_SUMMON              = 113724,
     SPELL_MAGE_SERPENT_FORM                      = 32817,
     SPELL_MAGE_SHEEP_FORM                        = 32820,
+    SPELL_MAGE_SHIMMER                           = 212653,
+    SPELL_MAGE_SLOW                              = 31589,
     SPELL_MAGE_SQUIRREL_FORM                     = 32813,
+    SPELL_MAGE_SUPERNOVA                         = 157980,
     SPELL_MAGE_WORGEN_FORM                       = 32819,
     SPELL_PET_NETHERWINDS_FATIGUED               = 160455,
     SPELL_MAGE_ICE_LANCE_TRIGGER                 = 228598,
@@ -589,6 +595,121 @@ class spell_mage_conjure_refreshment : public SpellScript
     }
 };
 
+// 410939 - Ethereal Blink
+class spell_mage_ethereal_blink : public AuraScript
+{
+    PrepareAuraScript(spell_mage_ethereal_blink);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MAGE_BLINK, SPELL_MAGE_SHIMMER });
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& procInfo)
+    {
+        PreventDefaultAction();
+
+        // this proc only works for players because teleport relocation happens after an ACK
+        GetTarget()->CastSpell(*procInfo.GetProcSpell()->m_targets.GetDst(), aurEff->GetSpellEffectInfo().TriggerSpell, CastSpellExtraArgs(aurEff)
+            .SetTriggeringSpell(procInfo.GetProcSpell())
+            .SetCustomArg(GetTarget()->GetPosition()));
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_mage_ethereal_blink::HandleProc, EFFECT_1, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
+// 410941 - Ethereal Blink
+class spell_mage_ethereal_blink_triggered : public SpellScript
+{
+    PrepareSpellScript(spell_mage_ethereal_blink_triggered);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MAGE_BLINK, SPELL_MAGE_SHIMMER, SPELL_MAGE_SLOW })
+            && ValidateSpellEffect({ { SPELL_MAGE_ETHEREAL_BLINK, EFFECT_3 } });
+    }
+
+    void FilterTargets(std::list<WorldObject*>& targets)
+    {
+        Position const* src = std::any_cast<Position>(&GetSpell()->m_customArg);
+        WorldLocation const* dst = GetExplTargetDest();
+        if (!src || !dst)
+        {
+            targets.clear();
+            return;
+        }
+
+        targets.remove_if([&](WorldObject* target)
+        {
+            return !target->IsInBetween(*src, *dst, (target->GetCombatReach() + GetCaster()->GetCombatReach()) / 2.0f);
+        });
+
+
+        AuraEffect const* reductionEffect = GetCaster()->GetAuraEffect(SPELL_MAGE_ETHEREAL_BLINK, EFFECT_2);
+        if (!reductionEffect)
+            return;
+
+        Seconds reduction = Seconds(reductionEffect->GetAmount()) * targets.size();
+
+        if (AuraEffect const* cap = GetCaster()->GetAuraEffect(SPELL_MAGE_ETHEREAL_BLINK, EFFECT_3))
+            if (reduction > Seconds(cap->GetAmount()))
+                reduction = Seconds(cap->GetAmount());
+
+        if (reduction > 0s)
+        {
+            GetCaster()->GetSpellHistory()->ModifyCooldown(SPELL_MAGE_BLINK, -reduction);
+            GetCaster()->GetSpellHistory()->ModifyCooldown(SPELL_MAGE_SHIMMER, -reduction);
+        }
+    }
+
+    void TriggerSlow(SpellEffIndex /*effIndex*/)
+    {
+        int32 effectivenessPct = 100;
+        if (AuraEffect const* effectivenessEffect = GetCaster()->GetAuraEffect(SPELL_MAGE_ETHEREAL_BLINK, EFFECT_1))
+            effectivenessPct = effectivenessEffect->GetAmount();
+
+        int32 slowPct = sSpellMgr->AssertSpellInfo(SPELL_MAGE_SLOW, DIFFICULTY_NONE)->GetEffect(EFFECT_0).CalcBaseValue(GetCaster(), GetHitUnit(), 0, -1);
+        ApplyPct(slowPct, effectivenessPct);
+
+        GetCaster()->CastSpell(GetHitUnit(), SPELL_MAGE_SLOW, CastSpellExtraArgs(GetSpell())
+            .AddSpellMod(SPELLVALUE_BASE_POINT0, slowPct));
+    }
+
+    void Register() override
+    {
+        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_mage_ethereal_blink_triggered::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY);
+        OnEffectHitTarget += SpellEffectFn(spell_mage_ethereal_blink_triggered::TriggerSlow, EFFECT_0, SPELL_EFFECT_DUMMY);
+    }
+};
+
+// 383395 - Feel the Burn
+class spell_mage_feel_the_burn : public AuraScript
+{
+    PrepareAuraScript(spell_mage_feel_the_burn);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MAGE_FEEL_THE_BURN });
+    }
+
+    void CalcAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& canBeRecalculated)
+    {
+        if (Unit* caster = GetCaster())
+            if (AuraEffect const* valueHolder = caster->GetAuraEffect(SPELL_MAGE_FEEL_THE_BURN, EFFECT_0))
+                amount = valueHolder->GetAmount();
+
+        canBeRecalculated = false;
+    }
+
+    void Register() override
+    {
+        DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_mage_feel_the_burn::CalcAmount, EFFECT_0, SPELL_AURA_MASTERY);
+    }
+};
+
 // 112965 - Fingers of Frost
 class spell_mage_fingers_of_frost : public AuraScript
 {
@@ -718,6 +839,27 @@ class spell_mage_frostbolt : public SpellScript
     }
 };
 
+// 386737 - Hyper Impact
+class spell_mage_hyper_impact : public AuraScript
+{
+    PrepareAuraScript(spell_mage_hyper_impact);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MAGE_SUPERNOVA });
+    }
+
+    void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
+    {
+        eventInfo.GetActor()->CastSpell(eventInfo.GetActionTarget(), SPELL_MAGE_SUPERNOVA, true);
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_mage_hyper_impact::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
+    }
+};
+
 // 11426 - Ice Barrier
 class spell_mage_ice_barrier : public AuraScript
 {
@@ -1104,6 +1246,38 @@ class spell_mage_prismatic_barrier : public AuraScript
     }
 };
 
+// 376103 - Radiant Spark
+class spell_mage_radiant_spark : public AuraScript
+{
+    PrepareAuraScript(spell_mage_radiant_spark);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MAGE_RADIANT_SPARK_PROC_BLOCKER });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        return !procInfo.GetProcTarget()->HasAura(SPELL_MAGE_RADIANT_SPARK_PROC_BLOCKER, GetCasterGUID());
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& procInfo)
+    {
+        Aura* vulnerability = procInfo.GetProcTarget()->GetAura(aurEff->GetSpellEffectInfo().TriggerSpell, GetCasterGUID());
+        if (vulnerability && vulnerability->GetStackAmount() == vulnerability->CalcMaxStackAmount())
+        {
+            PreventDefaultAction();
+            vulnerability->Remove();
+            GetTarget()->CastSpell(GetTarget(), SPELL_MAGE_RADIANT_SPARK_PROC_BLOCKER, true);
+        }
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_mage_radiant_spark::HandleProc, EFFECT_2, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 // 205021 - Ray of Frost
 class spell_mage_ray_of_frost : public SpellScript
 {
@@ -1372,11 +1546,15 @@ void AddSC_mage_spell_scripts()
     RegisterSpellScript(spell_mage_comet_storm_damage);
     RegisterSpellScript(spell_mage_cone_of_cold);
     RegisterSpellScript(spell_mage_conjure_refreshment);
+    RegisterSpellScript(spell_mage_ethereal_blink);
+    RegisterSpellScript(spell_mage_ethereal_blink_triggered);
+    RegisterSpellScript(spell_mage_feel_the_burn);
     RegisterSpellScript(spell_mage_fingers_of_frost);
     RegisterSpellScript(spell_mage_firestarter);
     RegisterSpellScript(spell_mage_firestarter_dots);
     RegisterSpellScript(spell_mage_flame_on);
     RegisterSpellScript(spell_mage_frostbolt);
+    RegisterSpellScript(spell_mage_hyper_impact);
     RegisterSpellScript(spell_mage_ice_barrier);
     RegisterSpellScript(spell_mage_ice_block);
     RegisterSpellScript(spell_mage_ice_lance);
@@ -1389,6 +1567,7 @@ void AddSC_mage_spell_scripts()
     RegisterSpellScript(spell_mage_living_bomb_periodic);
     RegisterSpellScript(spell_mage_polymorph_visual);
     RegisterSpellScript(spell_mage_prismatic_barrier);
+    RegisterSpellScript(spell_mage_radiant_spark);
     RegisterSpellAndAuraScriptPair(spell_mage_ray_of_frost, spell_mage_ray_of_frost_aura);
     RegisterSpellScript(spell_mage_ring_of_frost);
     RegisterSpellAndAuraScriptPair(spell_mage_ring_of_frost_freeze, spell_mage_ring_of_frost_freeze_AuraScript);
diff --git a/src/server/scripts/Spells/spell_monk.cpp b/src/server/scripts/Spells/spell_monk.cpp
index d5846f9b16d..8c707b5c8a4 100644
--- a/src/server/scripts/Spells/spell_monk.cpp
+++ b/src/server/scripts/Spells/spell_monk.cpp
@@ -22,15 +22,16 @@
 
 #include "ScriptMgr.h"
 #include "DB2Stores.h"
+#include "Player.h"
 #include "Spell.h"
 #include "SpellAuraEffects.h"
 #include "SpellInfo.h"
 #include "SpellMgr.h"
 #include "SpellScript.h"
-#include "Unit.h"
 
 enum MonkSpells
 {
+    SPELL_MONK_CALMING_COALESCENCE                      = 388220,
     SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHANNEL         = 117952,
     SPELL_MONK_CRACKLING_JADE_LIGHTNING_CHI_PROC        = 123333,
     SPELL_MONK_CRACKLING_JADE_LIGHTNING_KNOCKBACK       = 117962,
@@ -40,6 +41,7 @@ enum MonkSpells
     SPELL_MONK_PROVOKE_SINGLE_TARGET                    = 116189,
     SPELL_MONK_PROVOKE_AOE                              = 118635,
     SPELL_MONK_NO_FEATHER_FALL                          = 79636,
+    SPELL_MONK_OPEN_PALM_STRIKES_TALENT                 = 392970,
     SPELL_MONK_ROLL_BACKWARD                            = 109131,
     SPELL_MONK_ROLL_FORWARD                             = 107427,
     SPELL_MONK_SOOTHING_MIST                            = 115175,
@@ -120,6 +122,59 @@ class spell_monk_crackling_jade_lightning_knockback_proc_aura : public AuraScrip
     }
 };
 
+// 116849 - Life Cocoon
+class spell_monk_life_cocoon : public SpellScript
+{
+    PrepareSpellScript(spell_monk_life_cocoon);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_MONK_CALMING_COALESCENCE });
+    }
+
+    void CalculateAbsorb(SpellEffIndex /*effIndex*/)
+    {
+        int32 absorb = GetCaster()->CountPctFromMaxHealth(GetEffectValue());
+        if (Player* player = GetCaster()->ToPlayer())
+            AddPct(absorb, player->GetRatingBonusValue(CR_VERSATILITY_HEALING_DONE));
+
+        if (AuraEffect* calmingCoalescence = GetCaster()->GetAuraEffect(SPELL_MONK_CALMING_COALESCENCE, EFFECT_0, GetCaster()->GetGUID()))
+        {
+            AddPct(absorb, calmingCoalescence->GetAmount());
+            calmingCoalescence->GetBase()->Remove();
+        }
+
+        GetSpell()->SetSpellValue(SPELLVALUE_BASE_POINT0, absorb);
+    }
+
+    void Register() override
+    {
+        OnEffectLaunch += SpellEffectFn(spell_monk_life_cocoon::CalculateAbsorb, EFFECT_2, SPELL_EFFECT_DUMMY);
+    }
+};
+
+// 392972 - Open Palm Strikes
+class spell_monk_open_palm_strikes : public AuraScript
+{
+    PrepareAuraScript(spell_monk_open_palm_strikes);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellEffect({ { SPELL_MONK_OPEN_PALM_STRIKES_TALENT, EFFECT_1} });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*procInfo*/)
+    {
+        AuraEffect const* talent = GetTarget()->GetAuraEffect(SPELL_MONK_OPEN_PALM_STRIKES_TALENT, EFFECT_1);
+        return talent && roll_chance_i(talent->GetAmount());
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_monk_open_palm_strikes::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 // 121817 - Power Strike
 class spell_monk_power_strike_periodic : public AuraScript
 {
@@ -509,6 +564,8 @@ void AddSC_monk_spell_scripts()
 {
     RegisterSpellScript(spell_monk_crackling_jade_lightning);
     RegisterSpellScript(spell_monk_crackling_jade_lightning_knockback_proc_aura);
+    RegisterSpellScript(spell_monk_life_cocoon);
+    RegisterSpellScript(spell_monk_open_palm_strikes);
     RegisterSpellScript(spell_monk_power_strike_periodic);
     RegisterSpellScript(spell_monk_power_strike_proc);
     RegisterSpellScript(spell_monk_provoke);
diff --git a/src/server/scripts/Spells/spell_paladin.cpp b/src/server/scripts/Spells/spell_paladin.cpp
index 1fbe326b4be..e0bedb8ca7b 100644
--- a/src/server/scripts/Spells/spell_paladin.cpp
+++ b/src/server/scripts/Spells/spell_paladin.cpp
@@ -51,6 +51,7 @@ enum PaladinSpells
     SPELL_PALADIN_CONSECRATION                   = 26573,
     SPELL_PALADIN_CONSECRATION_DAMAGE            = 81297,
     SPELL_PALADIN_CONSECRATION_PROTECTION_AURA   = 188370,
+    SPELL_PALADIN_CRUSADING_STRIKES_ENERGIZE     = 406834,
     SPELL_PALADIN_DIVINE_PURPOSE_TRIGGERED       = 223819,
     SPELL_PALADIN_DIVINE_STEED_HUMAN             = 221883,
     SPELL_PALADIN_DIVINE_STEED_DWARF             = 276111,
@@ -99,6 +100,8 @@ enum PaladinSpells
     SPELL_PALADIN_RIGHTEOUS_VERDICT_AURA         = 267611,
     SPELL_PALADIN_SEAL_OF_RIGHTEOUSNESS          = 25742,
     SPELL_PALADIN_TEMPLAR_VERDICT_DAMAGE         = 224266,
+    SPELL_PALADIN_T30_2P_HEARTFIRE_DAMAGE        = 408399,
+    SPELL_PALADIN_T30_2P_HEARTFIRE_HEAL          = 408400,
     SPELL_PALADIN_ZEAL_AURA                      = 269571
 };
 
@@ -123,6 +126,11 @@ enum PaladinSpellVisual
     PALADIN_VISUAL_SPELL_HOLY_SHOCK_HEAL_CRIT    = 83880,
 };
 
+enum PaladinSpellLabel
+{
+    SPELL_LABEL_PALADIN_T30_2P_HEARTFIRE         = 2598
+};
+
 // 267344 - Art of War
 class spell_pal_art_of_war : public AuraScript
 {
@@ -471,6 +479,33 @@ class spell_pal_crusader_might : public AuraScript
     }
 };
 
+// 406833 - Crusading Strikes
+class spell_pal_crusading_strikes : public AuraScript
+{
+    PrepareAuraScript(spell_pal_crusading_strikes);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_PALADIN_CRUSADING_STRIKES_ENERGIZE });
+    }
+
+    void HandleEffectProc(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
+    {
+        if (GetStackAmount() == 2)
+        {
+            GetTarget()->CastSpell(GetTarget(), SPELL_PALADIN_CRUSADING_STRIKES_ENERGIZE, aurEff);
+
+            // this spell has weird proc order dependency set up in db2 data so we do removal manually
+            Remove();
+        }
+    }
+
+    void Register() override
+    {
+        AfterEffectApply += AuraEffectApplyFn(spell_pal_crusading_strikes::HandleEffectProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
+    }
+};
+
 // 223817 - Divine Purpose
 class spell_pal_divine_purpose : public AuraScript
 {
@@ -1507,6 +1542,64 @@ class spell_pal_t8_2p_bonus : public AuraScript
     }
 };
 
+// 405547 - Paladin Protection 10.1 Class Set 2pc
+class spell_pal_t30_2p_protection_bonus : public AuraScript
+{
+    PrepareAuraScript(spell_pal_t30_2p_protection_bonus);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_PALADIN_T30_2P_HEARTFIRE_DAMAGE });
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& procInfo)
+    {
+        PreventDefaultAction();
+
+        Unit* caster = procInfo.GetActor();
+        uint32 ticks = sSpellMgr->AssertSpellInfo(SPELL_PALADIN_T30_2P_HEARTFIRE_DAMAGE, DIFFICULTY_NONE)->GetMaxTicks();
+        uint32 damage = CalculatePct(procInfo.GetDamageInfo()->GetOriginalDamage(), aurEff->GetAmount()) / ticks;
+
+        caster->CastSpell(procInfo.GetActionTarget(), SPELL_PALADIN_T30_2P_HEARTFIRE_DAMAGE, CastSpellExtraArgs(aurEff)
+            .SetTriggeringSpell(procInfo.GetProcSpell())
+            .AddSpellMod(SPELLVALUE_BASE_POINT0, damage));
+    }
+
+    void Register() override
+    {
+        OnEffectProc += AuraEffectProcFn(spell_pal_t30_2p_protection_bonus::HandleProc, EFFECT_1, SPELL_AURA_DUMMY);
+    }
+};
+
+// 408461 - Heartfire
+class spell_pal_t30_2p_protection_bonus_heal : public AuraScript
+{
+    PrepareAuraScript(spell_pal_t30_2p_protection_bonus_heal);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_PALADIN_T30_2P_HEARTFIRE_HEAL });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        return procInfo.GetDamageInfo() && procInfo.GetSpellInfo() && procInfo.GetSpellInfo()->HasLabel(SPELL_LABEL_PALADIN_T30_2P_HEARTFIRE);
+    }
+
+    void HandleProc(AuraEffect* aurEff, ProcEventInfo& procInfo)
+    {
+        GetTarget()->CastSpell(GetTarget(), SPELL_PALADIN_T30_2P_HEARTFIRE_HEAL, CastSpellExtraArgs(aurEff)
+            .SetTriggeringSpell(procInfo.GetProcSpell())
+            .AddSpellMod(SPELLVALUE_BASE_POINT0, procInfo.GetDamageInfo()->GetOriginalDamage()));
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_pal_t30_2p_protection_bonus_heal::CheckProc, EFFECT_0, SPELL_AURA_DUMMY);
+        OnEffectProc += AuraEffectProcFn(spell_pal_t30_2p_protection_bonus_heal::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
+    }
+};
+
 // 269569 - Zeal
 class spell_pal_zeal : public AuraScript
 {
@@ -1540,6 +1633,7 @@ void AddSC_paladin_spell_scripts()
     RegisterSpellScript(spell_pal_blessing_of_protection);
     RegisterSpellScript(spell_pal_blinding_light);
     RegisterSpellScript(spell_pal_crusader_might);
+    RegisterSpellScript(spell_pal_crusading_strikes);
     RegisterSpellScript(spell_pal_consecration);
     RegisterAreaTriggerAI(areatrigger_pal_consecration);
     RegisterSpellScript(spell_pal_divine_purpose);
@@ -1572,5 +1666,7 @@ void AddSC_paladin_spell_scripts()
     RegisterSpellScript(spell_pal_templar_s_verdict);
     RegisterSpellScript(spell_pal_t3_6p_bonus);
     RegisterSpellScript(spell_pal_t8_2p_bonus);
+    RegisterSpellScript(spell_pal_t30_2p_protection_bonus);
+    RegisterSpellScript(spell_pal_t30_2p_protection_bonus_heal);
     RegisterSpellScript(spell_pal_zeal);
 }
diff --git a/src/server/scripts/Spells/spell_rogue.cpp b/src/server/scripts/Spells/spell_rogue.cpp
index ff126c3274e..21fbf2b31f9 100644
--- a/src/server/scripts/Spells/spell_rogue.cpp
+++ b/src/server/scripts/Spells/spell_rogue.cpp
@@ -452,6 +452,22 @@ class spell_rog_killing_spree : public SpellScript
     }
 };
 
+// 385627 - Kingsbane
+class spell_rog_kingsbane : public AuraScript
+{
+    PrepareAuraScript(spell_rog_kingsbane);
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        return procInfo.GetActionTarget()->HasAura(GetId(), GetCasterGUID());
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_rog_kingsbane::CheckProc, EFFECT_4, SPELL_AURA_PROC_TRIGGER_SPELL);;
+    }
+};
+
 // 76806 - Mastery: Main Gauche
 class spell_rog_mastery_main_gauche : public AuraScript
 {
@@ -1040,6 +1056,7 @@ void AddSC_rogue_spell_scripts()
     RegisterSpellScript(spell_rog_grand_melee);
     RegisterSpellScript(spell_rog_honor_among_thieves);
     RegisterSpellAndAuraScriptPair(spell_rog_killing_spree, spell_rog_killing_spree_aura);
+    RegisterSpellScript(spell_rog_kingsbane);
     RegisterSpellScript(spell_rog_mastery_main_gauche);
     RegisterSpellScript(spell_rog_pickpocket);
     RegisterSpellScript(spell_rog_restless_blades);
diff --git a/src/server/scripts/Spells/spell_shaman.cpp b/src/server/scripts/Spells/spell_shaman.cpp
index 80711dd25ad..324b3cb808d 100644
--- a/src/server/scripts/Spells/spell_shaman.cpp
+++ b/src/server/scripts/Spells/spell_shaman.cpp
@@ -47,6 +47,7 @@ enum ShamanSpells
     SPELL_SHAMAN_CHAIN_LIGHTNING_OVERLOAD_ENERGIZE = 218558,
     SPELL_SHAMAN_CHAINED_HEAL                   = 70809,
     SPELL_SHAMAN_CRASH_LIGHTNING_CLEAVE         = 187878,
+    SPELL_SHAMAN_DOOM_WINDS_LEGENDARY_COOLDOWN  = 335904,
     SPELL_SHAMAN_EARTHQUAKE                     = 61882,
     SPELL_SHAMAN_EARTHQUAKE_KNOCKING_DOWN       = 77505,
     SPELL_SHAMAN_EARTHQUAKE_TICK                = 77478,
@@ -54,6 +55,8 @@ enum ShamanSpells
     SPELL_SHAMAN_EARTHEN_RAGE_PASSIVE           = 170374,
     SPELL_SHAMAN_EARTHEN_RAGE_PERIODIC          = 170377,
     SPELL_SHAMAN_EARTHEN_RAGE_DAMAGE            = 170379,
+    SPELL_SHAMAN_ECHOES_OF_GREAT_SUNDERING_LEGENDARY = 336217,
+    SPELL_SHAMAN_ECHOES_OF_GREAT_SUNDERING_TALENT = 384088,
     SPELL_SHAMAN_ELECTRIFIED                    = 64930,
     SPELL_SHAMAN_ELEMENTAL_BLAST                = 117014,
     SPELL_SHAMAN_ELEMENTAL_BLAST_CRIT           = 118522,
@@ -100,18 +103,25 @@ enum ShamanSpells
     SPELL_SHAMAN_SPIRIT_WOLF_PERIODIC           = 260882,
     SPELL_SHAMAN_SPIRIT_WOLF_AURA               = 260881,
     SPELL_SHAMAN_STORMKEEPER                    = 191634,
+    SPELL_SHAMAN_T29_2P_ELEMENTAL_DAMAGE_BUFF   = 394651,
     SPELL_SHAMAN_TIDAL_WAVES                    = 53390,
+    SPELL_SHAMAN_TOTEMIC_POWER_ARMOR            = 28827,
+    SPELL_SHAMAN_TOTEMIC_POWER_ATTACK_POWER     = 28826,
     SPELL_SHAMAN_TOTEMIC_POWER_MP5              = 28824,
     SPELL_SHAMAN_TOTEMIC_POWER_SPELL_POWER      = 28825,
-    SPELL_SHAMAN_TOTEMIC_POWER_ATTACK_POWER     = 28826,
-    SPELL_SHAMAN_TOTEMIC_POWER_ARMOR            = 28827,
     SPELL_SHAMAN_UNDULATION_PROC                = 216251,
     SPELL_SHAMAN_UNLIMITED_POWER_BUFF           = 272737,
+    SPELL_SHAMAN_VOLCANIC_SURGE                 = 408572,
     SPELL_SHAMAN_WINDFURY_ATTACK                = 25504,
     SPELL_SHAMAN_WINDFURY_ENCHANTMENT           = 334302,
     SPELL_SHAMAN_WIND_RUSH                      = 192082
 };
 
+enum ShamanSpellLabels
+{
+    SPELL_LABEL_SHAMAN_WINDFURY_TOTEM           = 1038,
+};
+
 enum MiscNpcs
 {
     NPC_HEALING_RAIN_INVISIBLE_STALKER          = 73400,
@@ -298,6 +308,34 @@ class spell_sha_crash_lightning : public SpellScript
     size_t _targetsHit = 0;
 };
 
+// 335902 - Doom Winds
+class spell_sha_doom_winds_legendary : public AuraScript
+{
+    PrepareAuraScript(spell_sha_doom_winds_legendary);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_SHAMAN_DOOM_WINDS_LEGENDARY_COOLDOWN });
+    }
+
+    bool CheckProc(AuraEffect const* /*aurEff*/, ProcEventInfo& procInfo)
+    {
+        if (GetTarget()->HasAura(SPELL_SHAMAN_DOOM_WINDS_LEGENDARY_COOLDOWN))
+            return false;
+
+        SpellInfo const* spellInfo = procInfo.GetSpellInfo();
+        if (!spellInfo)
+            return false;
+
+        return spellInfo->HasLabel(SPELL_LABEL_SHAMAN_WINDFURY_TOTEM);
+    }
+
+    void Register() override
+    {
+        DoCheckEffectProc += AuraCheckEffectProcFn(spell_sha_doom_winds_legendary::CheckProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
+    }
+};
+
 // 207778 - Downpour
 class spell_sha_downpour : public SpellScript
 {
@@ -368,6 +406,31 @@ class spell_sha_earth_shield : public AuraScript
     }
 };
 
+// 8042 - Earth Shock
+class spell_sha_earth_shock : public SpellScript
+{
+    PrepareSpellScript(spell_sha_earth_shock);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellEffect({ { SPELL_SHAMAN_T29_2P_ELEMENTAL_DAMAGE_BUFF, EFFECT_0 } });
+    }
+
+    void AddScriptedDamageMods()
+    {
+        if (AuraEffect* t29 = GetCaster()->GetAuraEffect(SPELL_SHAMAN_T29_2P_ELEMENTAL_DAMAGE_BUFF, EFFECT_0))
+        {
+            SetHitDamage(CalculatePct(GetHitDamage(), 100 + t29->GetAmount()));
+            t29->GetBase()->Remove();
+        }
+    }
+
+    void Register() override
+    {
+        OnHit += SpellHitFn(spell_sha_earth_shock::AddScriptedDamageMods);
+    }
+};
+
 // 170374 - Earthen Rage (Passive)
 class spell_sha_earthen_rage_passive : public AuraScript
 {
@@ -434,13 +497,17 @@ class spell_sha_earthen_rage_proc_aura : public AuraScript
 //  8382 - AreaTriggerId
 struct areatrigger_sha_earthquake : AreaTriggerAI
 {
-    areatrigger_sha_earthquake(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger), _refreshTimer(0s), _period(1s) { }
+    areatrigger_sha_earthquake(AreaTrigger* areatrigger) : AreaTriggerAI(areatrigger), _refreshTimer(0s), _period(1s), _damageMultiplier(1.0f) { }
 
-    void OnCreate(Spell const* /*creatingSpell*/) override
+    void OnCreate(Spell const* creatingSpell) override
     {
         if (Unit* caster = at->GetCaster())
             if (AuraEffect const* earthquake = caster->GetAuraEffect(SPELL_SHAMAN_EARTHQUAKE, EFFECT_1))
                 _period = Milliseconds(earthquake->GetPeriod());
+
+        if (creatingSpell)
+            if (float const* damageMultiplier = std::any_cast<float>(&creatingSpell->m_customArg))
+                _damageMultiplier = *damageMultiplier;
     }
 
     void OnUpdate(uint32 diff) override
@@ -450,7 +517,8 @@ struct areatrigger_sha_earthquake : AreaTriggerAI
         {
             if (Unit* caster = at->GetCaster())
                 caster->CastSpell(at->GetPosition(), SPELL_SHAMAN_EARTHQUAKE_TICK, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
-                    .SetOriginalCaster(at->GetGUID()));
+                    .SetOriginalCaster(at->GetGUID())
+                    .AddSpellMod(SPELLVALUE_BASE_POINT0, caster->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_NATURE) * 0.213f * _damageMultiplier));
 
             _refreshTimer += _period;
         }
@@ -466,6 +534,46 @@ private:
     Milliseconds _refreshTimer;
     Milliseconds _period;
     GuidUnorderedSet _stunnedUnits;
+    float _damageMultiplier;
+};
+
+// 61882 - Earthquake
+class spell_sha_earthquake : public SpellScript
+{
+    PrepareSpellScript(spell_sha_earthquake);
+
+    static constexpr std::array<std::pair<uint32, SpellEffIndex>, 3> DamageBuffs =
+    { {
+        { SPELL_SHAMAN_ECHOES_OF_GREAT_SUNDERING_LEGENDARY, EFFECT_1 },
+        { SPELL_SHAMAN_ECHOES_OF_GREAT_SUNDERING_TALENT, EFFECT_0 },
+        { SPELL_SHAMAN_T29_2P_ELEMENTAL_DAMAGE_BUFF, EFFECT_0 }
+    } };
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellEffect(DamageBuffs);
+    }
+
+    void SnapshotDamageMultiplier(SpellEffIndex /*effIndex*/)
+    {
+        float damageMultiplier = 1.0f;
+        for (auto const& [spellId, effect] : DamageBuffs)
+        {
+            if (AuraEffect* buff = GetCaster()->GetAuraEffect(spellId, effect))
+            {
+                AddPct(damageMultiplier, buff->GetAmount());
+                buff->GetBase()->Remove();
+            }
+        }
+
+        if (damageMultiplier != 1.0f)
+            GetSpell()->m_customArg = damageMultiplier;
+    }
+
+    void Register() override
+    {
+        OnEffectLaunch += SpellEffectFn(spell_sha_earthquake::SnapshotDamageMultiplier, EFFECT_2, SPELL_EFFECT_CREATE_AREATRIGGER);
+    }
 };
 
 // 77478 - Earthquake tick
@@ -479,11 +587,6 @@ class spell_sha_earthquake_tick : public SpellScript
             && ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } });
     }
 
-    void HandleDamageCalc(SpellEffIndex /*effIndex*/)
-    {
-        SetEffectValue(GetCaster()->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_NATURE) * 0.391f);
-    }
-
     void HandleOnHit()
     {
         if (Unit* target = GetHitUnit())
@@ -505,7 +608,6 @@ class spell_sha_earthquake_tick : public SpellScript
 
     void Register() override
     {
-        OnEffectLaunchTarget += SpellEffectFn(spell_sha_earthquake_tick::HandleDamageCalc, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
         OnHit += SpellHitFn(spell_sha_earthquake_tick::HandleOnHit);
     }
 };
@@ -527,7 +629,10 @@ class spell_sha_elemental_blast : public SpellScript
             SPELL_SHAMAN_ELEMENTAL_BLAST_MASTERY,
             SPELL_SHAMAN_ELEMENTAL_BLAST_ENERGIZE,
             SPELL_SHAMAN_MAELSTROM_CONTROLLER
-        }) && ValidateSpellEffect({ { SPELL_SHAMAN_MAELSTROM_CONTROLLER, EFFECT_10 } });
+        }) && ValidateSpellEffect({
+            { SPELL_SHAMAN_MAELSTROM_CONTROLLER, EFFECT_10 },
+            { SPELL_SHAMAN_T29_2P_ELEMENTAL_DAMAGE_BUFF, EFFECT_0 }
+        });
     }
 
     void HandleEnergize(SpellEffIndex /*effIndex*/)
@@ -548,10 +653,20 @@ class spell_sha_elemental_blast : public SpellScript
         GetCaster()->CastSpell(GetCaster(), spellId, TRIGGERED_FULL_MASK);
     }
 
+    void AddScriptedDamageMods()
+    {
+        if (AuraEffect* t29 = GetCaster()->GetAuraEffect(SPELL_SHAMAN_T29_2P_ELEMENTAL_DAMAGE_BUFF, EFFECT_0))
+        {
+            SetHitDamage(CalculatePct(GetHitDamage(), 100 + t29->GetAmount()));
+            t29->GetBase()->Remove();
+        }
+    }
+
     void Register() override
     {
         OnEffectLaunch += SpellEffectFn(spell_sha_elemental_blast::HandleEnergize, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
         AfterCast += SpellCastFn(spell_sha_elemental_blast::TriggerBuff);
+        OnHit += SpellHitFn(spell_sha_elemental_blast::AddScriptedDamageMods);
     }
 };
 
@@ -1685,6 +1800,35 @@ class spell_sha_windfury_weapon_proc : public AuraScript
     }
 };
 
+// 378269 - Windspeaker's Lava Resurgence
+class spell_sha_windspeakers_lava_resurgence : public SpellScript
+{
+    PrepareSpellScript(spell_sha_windspeakers_lava_resurgence);
+
+    bool Validate(SpellInfo const* /*spellInfo*/) override
+    {
+        return ValidateSpellInfo({ SPELL_SHAMAN_VOLCANIC_SURGE });
+    }
+
+    void PreventLavaSurge(SpellEffIndex effIndex)
+    {
+        if (GetCaster()->HasAura(SPELL_SHAMAN_VOLCANIC_SURGE))
+            PreventHitDefaultEffect(effIndex);
+    }
+
+    void PreventVolcanicSurge(SpellEffIndex effIndex)
+    {
+        if (!GetCaster()->HasAura(SPELL_SHAMAN_VOLCANIC_SURGE))
+            PreventHitDefaultEffect(effIndex);
+    }
+
+    void Register() override
+    {
+        OnEffectLaunch += SpellEffectFn(spell_sha_windspeakers_lava_resurgence::PreventLavaSurge, EFFECT_1, SPELL_EFFECT_TRIGGER_SPELL);
+        OnEffectLaunch += SpellEffectFn(spell_sha_windspeakers_lava_resurgence::PreventVolcanicSurge, EFFECT_2, SPELL_EFFECT_TRIGGER_SPELL);
+    }
+};
+
 // 192078 - Wind Rush Totem (Spell)
 //  12676 - AreaTriggerId
 struct areatrigger_sha_wind_rush_totem : AreaTriggerAI
@@ -1737,11 +1881,14 @@ void AddSC_shaman_spell_scripts()
     RegisterSpellScript(spell_sha_chain_lightning);
     RegisterSpellScript(spell_sha_chain_lightning_overload);
     RegisterSpellScript(spell_sha_crash_lightning);
+    RegisterSpellScript(spell_sha_doom_winds_legendary);
     RegisterSpellScript(spell_sha_downpour);
     RegisterSpellScript(spell_sha_earth_shield);
+    RegisterSpellScript(spell_sha_earth_shock);
     RegisterSpellScript(spell_sha_earthen_rage_passive);
     RegisterSpellScript(spell_sha_earthen_rage_proc_aura);
     RegisterAreaTriggerAI(areatrigger_sha_earthquake);
+    RegisterSpellScript(spell_sha_earthquake);
     RegisterSpellScript(spell_sha_earthquake_tick);
     RegisterSpellScript(spell_sha_elemental_blast);
     RegisterSpellScript(spell_sha_flametongue_weapon);
@@ -1779,5 +1926,6 @@ void AddSC_shaman_spell_scripts()
     RegisterSpellScript(spell_sha_undulation_passive);
     RegisterSpellScript(spell_sha_windfury_weapon);
     RegisterSpellScript(spell_sha_windfury_weapon_proc);
+    RegisterSpellScript(spell_sha_windspeakers_lava_resurgence);
     RegisterAreaTriggerAI(areatrigger_sha_wind_rush_totem);
 }