From ebfa8878c18d482f52106f098530918a454323f5 Mon Sep 17 00:00:00 2001 From: Kitzunu <24550914+Kitzunu@users.noreply.github.com> Date: Tue, 9 Nov 2021 11:45:19 +0100 Subject: [PATCH] refactor(Scripts/Spells): convert spell_priest into new system (#9063) --- src/server/scripts/Spells/spell_priest.cpp | 1335 ++++++++------------ 1 file changed, 558 insertions(+), 777 deletions(-) diff --git a/src/server/scripts/Spells/spell_priest.cpp b/src/server/scripts/Spells/spell_priest.cpp index 3ee1e1cb7..7d6ba350b 100644 --- a/src/server/scripts/Spells/spell_priest.cpp +++ b/src/server/scripts/Spells/spell_priest.cpp @@ -60,987 +60,768 @@ enum PriestSpellIcons PRIEST_ICON_ID_PAIN_AND_SUFFERING = 2874, }; -// Ours -class spell_pri_shadowfiend_scaling : public SpellScriptLoader +class spell_pri_shadowfiend_scaling : public AuraScript { -public: - spell_pri_shadowfiend_scaling() : SpellScriptLoader("spell_pri_shadowfiend_scaling") { } + PrepareAuraScript(spell_pri_shadowfiend_scaling); - class spell_pri_shadowfiend_scaling_AuraScript : public AuraScript + void CalculateResistanceAmount(AuraEffect const* aurEff, int32& amount, bool& /*canBeRecalculated*/) { - PrepareAuraScript(spell_pri_shadowfiend_scaling_AuraScript); - - void CalculateResistanceAmount(AuraEffect const* aurEff, int32& amount, bool& /*canBeRecalculated*/) + // xinef: shadowfiend inherits 40% of resistance from owner and 35% of armor (guessed) + if (Unit* owner = GetUnitOwner()->GetOwner()) { - // xinef: shadowfiend inherits 40% of resistance from owner and 35% of armor (guessed) - if (Unit* owner = GetUnitOwner()->GetOwner()) - { - SpellSchoolMask schoolMask = SpellSchoolMask(aurEff->GetSpellInfo()->Effects[aurEff->GetEffIndex()].MiscValue); - int32 modifier = schoolMask == SPELL_SCHOOL_MASK_NORMAL ? 35 : 40; - amount = CalculatePct(std::max(0, owner->GetResistance(schoolMask)), modifier); - } + SpellSchoolMask schoolMask = SpellSchoolMask(aurEff->GetSpellInfo()->Effects[aurEff->GetEffIndex()].MiscValue); + int32 modifier = schoolMask == SPELL_SCHOOL_MASK_NORMAL ? 35 : 40; + amount = CalculatePct(std::max(0, owner->GetResistance(schoolMask)), modifier); } + } - void CalculateStatAmount(AuraEffect const* aurEff, int32& amount, bool& /*canBeRecalculated*/) - { - // xinef: shadowfiend inherits 30% of intellect / stamina (guessed) - if (Unit* owner = GetUnitOwner()->GetOwner()) - { - Stats stat = Stats(aurEff->GetSpellInfo()->Effects[aurEff->GetEffIndex()].MiscValue); - amount = CalculatePct(std::max(0, owner->GetStat(stat)), 30); - } - } - - void CalculateAPAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) - { - // xinef: shadowfiend inherits 333% of SP as AP - 35.7% of damage increase per hit - if (Unit* owner = GetUnitOwner()->GetOwner()) - { - int32 shadow = owner->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SHADOW); - amount = CalculatePct(std::max(0, shadow), 300); // xinef: deacrased to 300, including 15% from self buff - } - } - - void CalculateSPAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) - { - // xinef: shadowfiend inherits 30% of SP - if (Unit* owner = GetUnitOwner()->GetOwner()) - { - int32 shadow = owner->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SHADOW); - amount = CalculatePct(std::max(0, shadow), 30); - - // xinef: Update appropriate player field - if (owner->GetTypeId() == TYPEID_PLAYER) - owner->SetUInt32Value(PLAYER_PET_SPELL_POWER, (uint32)amount); - } - } - - void HandleEffectApply(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/) - { - GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_STATE, aurEff->GetAuraType(), true, SPELL_BLOCK_TYPE_POSITIVE); - if (aurEff->GetAuraType() == SPELL_AURA_MOD_ATTACK_POWER) - GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_ATTACK_POWER_PCT, true, SPELL_BLOCK_TYPE_POSITIVE); - else if (aurEff->GetAuraType() == SPELL_AURA_MOD_STAT) - GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, true, SPELL_BLOCK_TYPE_POSITIVE); - } - - void Register() override - { - if (m_scriptSpellId != 35661) - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling_AuraScript::CalculateResistanceAmount, EFFECT_ALL, SPELL_AURA_MOD_RESISTANCE); - - if (m_scriptSpellId == 35661 || m_scriptSpellId == 35662) - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling_AuraScript::CalculateStatAmount, EFFECT_ALL, SPELL_AURA_MOD_STAT); - - if (m_scriptSpellId == 35661) - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling_AuraScript::CalculateAPAmount, EFFECT_ALL, SPELL_AURA_MOD_ATTACK_POWER); - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling_AuraScript::CalculateSPAmount, EFFECT_ALL, SPELL_AURA_MOD_DAMAGE_DONE); - } - - OnEffectApply += AuraEffectApplyFn(spell_pri_shadowfiend_scaling_AuraScript::HandleEffectApply, EFFECT_ALL, SPELL_AURA_ANY, AURA_EFFECT_HANDLE_REAL); - } - }; - - AuraScript* GetAuraScript() const override + void CalculateStatAmount(AuraEffect const* aurEff, int32& amount, bool& /*canBeRecalculated*/) { - return new spell_pri_shadowfiend_scaling_AuraScript(); + // xinef: shadowfiend inherits 30% of intellect / stamina (guessed) + if (Unit* owner = GetUnitOwner()->GetOwner()) + { + Stats stat = Stats(aurEff->GetSpellInfo()->Effects[aurEff->GetEffIndex()].MiscValue); + amount = CalculatePct(std::max(0, owner->GetStat(stat)), 30); + } + } + + void CalculateAPAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) + { + // xinef: shadowfiend inherits 333% of SP as AP - 35.7% of damage increase per hit + if (Unit* owner = GetUnitOwner()->GetOwner()) + { + int32 shadow = owner->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SHADOW); + amount = CalculatePct(std::max(0, shadow), 300); // xinef: deacrased to 300, including 15% from self buff + } + } + + void CalculateSPAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) + { + // xinef: shadowfiend inherits 30% of SP + if (Unit* owner = GetUnitOwner()->GetOwner()) + { + int32 shadow = owner->SpellBaseDamageBonusDone(SPELL_SCHOOL_MASK_SHADOW); + amount = CalculatePct(std::max(0, shadow), 30); + + // xinef: Update appropriate player field + if (owner->GetTypeId() == TYPEID_PLAYER) + owner->SetUInt32Value(PLAYER_PET_SPELL_POWER, (uint32)amount); + } + } + + void HandleEffectApply(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/) + { + GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_STATE, aurEff->GetAuraType(), true, SPELL_BLOCK_TYPE_POSITIVE); + if (aurEff->GetAuraType() == SPELL_AURA_MOD_ATTACK_POWER) + GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_ATTACK_POWER_PCT, true, SPELL_BLOCK_TYPE_POSITIVE); + else if (aurEff->GetAuraType() == SPELL_AURA_MOD_STAT) + GetUnitOwner()->ApplySpellImmune(0, IMMUNITY_STATE, SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE, true, SPELL_BLOCK_TYPE_POSITIVE); + } + + void Register() override + { + if (m_scriptSpellId != 35661) + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling::CalculateResistanceAmount, EFFECT_ALL, SPELL_AURA_MOD_RESISTANCE); + + if (m_scriptSpellId == 35661 || m_scriptSpellId == 35662) + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling::CalculateStatAmount, EFFECT_ALL, SPELL_AURA_MOD_STAT); + + if (m_scriptSpellId == 35661) + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling::CalculateAPAmount, EFFECT_ALL, SPELL_AURA_MOD_ATTACK_POWER); + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_shadowfiend_scaling::CalculateSPAmount, EFFECT_ALL, SPELL_AURA_MOD_DAMAGE_DONE); + } + + OnEffectApply += AuraEffectApplyFn(spell_pri_shadowfiend_scaling::HandleEffectApply, EFFECT_ALL, SPELL_AURA_ANY, AURA_EFFECT_HANDLE_REAL); } }; -// Theirs // -34861 - Circle of Healing -class spell_pri_circle_of_healing : public SpellScriptLoader +class spell_pri_circle_of_healing : public SpellScript { -public: - spell_pri_circle_of_healing() : SpellScriptLoader("spell_pri_circle_of_healing") { } + PrepareSpellScript(spell_pri_circle_of_healing); - class spell_pri_circle_of_healing_SpellScript : public SpellScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareSpellScript(spell_pri_circle_of_healing_SpellScript); + return ValidateSpellInfo({ SPELL_PRIEST_GLYPH_OF_CIRCLE_OF_HEALING }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_GLYPH_OF_CIRCLE_OF_HEALING }); - } - - void FilterTargets(std::list& targets) - { - targets.remove_if(Acore::RaidCheck(GetCaster(), false)); - - uint32 const maxTargets = GetCaster()->HasAura(SPELL_PRIEST_GLYPH_OF_CIRCLE_OF_HEALING) ? 6 : 5; // Glyph of Circle of Healing - - if (targets.size() > maxTargets) - { - targets.sort(Acore::HealthPctOrderPred()); - targets.resize(maxTargets); - } - } - - void Register() override - { - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_circle_of_healing_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ALLY); - } - }; - - SpellScript* GetSpellScript() const override + void FilterTargets(std::list& targets) { - return new spell_pri_circle_of_healing_SpellScript(); + targets.remove_if(Acore::RaidCheck(GetCaster(), false)); + + uint32 const maxTargets = GetCaster()->HasAura(SPELL_PRIEST_GLYPH_OF_CIRCLE_OF_HEALING) ? 6 : 5; // Glyph of Circle of Healing + + if (targets.size() > maxTargets) + { + targets.sort(Acore::HealthPctOrderPred()); + targets.resize(maxTargets); + } + } + + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_circle_of_healing::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ALLY); } }; // -47509 - Divine Aegis -class spell_pri_divine_aegis : public SpellScriptLoader +class spell_pri_divine_aegis : public AuraScript { -public: - spell_pri_divine_aegis() : SpellScriptLoader("spell_pri_divine_aegis") { } + PrepareAuraScript(spell_pri_divine_aegis); - class spell_pri_divine_aegis_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_divine_aegis_AuraScript); + return ValidateSpellInfo({ SPELL_PRIEST_DIVINE_AEGIS }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_DIVINE_AEGIS }); - } - - bool CheckProc(ProcEventInfo& eventInfo) - { - return eventInfo.GetProcTarget(); - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - - int32 absorb = CalculatePct(int32(eventInfo.GetHealInfo()->GetHeal()), aurEff->GetAmount()); - - // Multiple effects stack, so let's try to find this aura. - if (AuraEffect const* aegis = eventInfo.GetProcTarget()->GetAuraEffect(SPELL_PRIEST_DIVINE_AEGIS, EFFECT_0)) - absorb += aegis->GetAmount(); - - absorb = std::min(absorb, eventInfo.GetProcTarget()->getLevel() * 125); - - GetTarget()->CastCustomSpell(SPELL_PRIEST_DIVINE_AEGIS, SPELLVALUE_BASE_POINT0, absorb, eventInfo.GetProcTarget(), true, nullptr, aurEff); - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_pri_divine_aegis_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_pri_divine_aegis_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); - } - }; - - AuraScript* GetAuraScript() const override + bool CheckProc(ProcEventInfo& eventInfo) { - return new spell_pri_divine_aegis_AuraScript(); + return eventInfo.GetProcTarget(); + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + PreventDefaultAction(); + + int32 absorb = CalculatePct(int32(eventInfo.GetHealInfo()->GetHeal()), aurEff->GetAmount()); + + // Multiple effects stack, so let's try to find this aura. + if (AuraEffect const* aegis = eventInfo.GetProcTarget()->GetAuraEffect(SPELL_PRIEST_DIVINE_AEGIS, EFFECT_0)) + absorb += aegis->GetAmount(); + + absorb = std::min(absorb, eventInfo.GetProcTarget()->getLevel() * 125); + + GetTarget()->CastCustomSpell(SPELL_PRIEST_DIVINE_AEGIS, SPELLVALUE_BASE_POINT0, absorb, eventInfo.GetProcTarget(), true, nullptr, aurEff); + } + + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_pri_divine_aegis::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_pri_divine_aegis::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); } }; // 64844 - Divine Hymn -class spell_pri_divine_hymn : public SpellScriptLoader +class spell_pri_divine_hymn : public SpellScript { -public: - spell_pri_divine_hymn() : SpellScriptLoader("spell_pri_divine_hymn") { } + PrepareSpellScript(spell_pri_divine_hymn); - class spell_pri_divine_hymn_SpellScript : public SpellScript + void FilterTargets(std::list& targets) { - PrepareSpellScript(spell_pri_divine_hymn_SpellScript); + targets.remove_if(Acore::RaidCheck(GetCaster(), false)); - void FilterTargets(std::list& targets) + uint32 const maxTargets = 3; + + if (targets.size() > maxTargets) { - targets.remove_if(Acore::RaidCheck(GetCaster(), false)); - - uint32 const maxTargets = 3; - - if (targets.size() > maxTargets) - { - targets.sort(Acore::HealthPctOrderPred()); - targets.resize(maxTargets); - } + targets.sort(Acore::HealthPctOrderPred()); + targets.resize(maxTargets); } + } - void Register() override - { - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_divine_hymn_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ALLY); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_divine_hymn_SpellScript(); + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_divine_hymn::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ALLY); } }; // 55680 - Glyph of Prayer of Healing -class spell_pri_glyph_of_prayer_of_healing : public SpellScriptLoader +class spell_pri_glyph_of_prayer_of_healing : public AuraScript { -public: - spell_pri_glyph_of_prayer_of_healing() : SpellScriptLoader("spell_pri_glyph_of_prayer_of_healing") { } + PrepareAuraScript(spell_pri_glyph_of_prayer_of_healing); - class spell_pri_glyph_of_prayer_of_healing_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_glyph_of_prayer_of_healing_AuraScript); + return ValidateSpellInfo({ SPELL_PRIEST_GLYPH_OF_PRAYER_OF_HEALING_HEAL }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_GLYPH_OF_PRAYER_OF_HEALING_HEAL }); - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - - HealInfo* healInfo = eventInfo.GetHealInfo(); - if (!healInfo || healInfo->GetHeal()) - { - return; - } - - SpellInfo const* triggeredSpellInfo = sSpellMgr->AssertSpellInfo(SPELL_PRIEST_GLYPH_OF_PRAYER_OF_HEALING_HEAL); - int32 heal = int32(CalculatePct(int32(healInfo->GetHeal()), aurEff->GetAmount()) / triggeredSpellInfo->GetMaxTicks()); - GetTarget()->CastCustomSpell(SPELL_PRIEST_GLYPH_OF_PRAYER_OF_HEALING_HEAL, SPELLVALUE_BASE_POINT0, heal, eventInfo.GetProcTarget(), true, nullptr, aurEff); - } - - void Register() override - { - OnEffectProc += AuraEffectProcFn(spell_pri_glyph_of_prayer_of_healing_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); - } - }; - - AuraScript* GetAuraScript() const override + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) { - return new spell_pri_glyph_of_prayer_of_healing_AuraScript(); + PreventDefaultAction(); + + HealInfo* healInfo = eventInfo.GetHealInfo(); + if (!healInfo || healInfo->GetHeal()) + { + return; + } + + SpellInfo const* triggeredSpellInfo = sSpellMgr->AssertSpellInfo(SPELL_PRIEST_GLYPH_OF_PRAYER_OF_HEALING_HEAL); + int32 heal = int32(CalculatePct(int32(healInfo->GetHeal()), aurEff->GetAmount()) / triggeredSpellInfo->GetMaxTicks()); + GetTarget()->CastCustomSpell(SPELL_PRIEST_GLYPH_OF_PRAYER_OF_HEALING_HEAL, SPELLVALUE_BASE_POINT0, heal, eventInfo.GetProcTarget(), true, nullptr, aurEff); + } + + void Register() override + { + OnEffectProc += AuraEffectProcFn(spell_pri_glyph_of_prayer_of_healing::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); } }; // 47788 - Guardian Spirit -class spell_pri_guardian_spirit : public SpellScriptLoader +class spell_pri_guardian_spirit : public AuraScript { -public: - spell_pri_guardian_spirit() : SpellScriptLoader("spell_pri_guardian_spirit") { } + PrepareAuraScript(spell_pri_guardian_spirit); - class spell_pri_guardian_spirit_AuraScript : public AuraScript + uint32 healPct; + + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_guardian_spirit_AuraScript); + return ValidateSpellInfo({ SPELL_PRIEST_GUARDIAN_SPIRIT_HEAL }); + } - uint32 healPct; - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_GUARDIAN_SPIRIT_HEAL }); - } - - bool Load() override - { - healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); - return true; - } - - void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) - { - // Set absorbtion amount to unlimited - amount = -1; - } - - void Absorb(AuraEffect* /*aurEff*/, DamageInfo& dmgInfo, uint32& absorbAmount) - { - Unit* target = GetTarget(); - if (dmgInfo.GetDamage() < target->GetHealth()) - return; - - int32 healAmount = int32(target->CountPctFromMaxHealth(healPct)); - // remove the aura now, we don't want 40% healing bonus - Remove(AURA_REMOVE_BY_ENEMY_SPELL); - target->CastCustomSpell(target, SPELL_PRIEST_GUARDIAN_SPIRIT_HEAL, &healAmount, nullptr, nullptr, true); - absorbAmount = dmgInfo.GetDamage(); - } - - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_guardian_spirit_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_SCHOOL_ABSORB); - OnEffectAbsorb += AuraEffectAbsorbFn(spell_pri_guardian_spirit_AuraScript::Absorb, EFFECT_1); - } - }; - - AuraScript* GetAuraScript() const override + bool Load() override { - return new spell_pri_guardian_spirit_AuraScript(); + healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); + return true; + } + + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) + { + // Set absorbtion amount to unlimited + amount = -1; + } + + void Absorb(AuraEffect* /*aurEff*/, DamageInfo& dmgInfo, uint32& absorbAmount) + { + Unit* target = GetTarget(); + if (dmgInfo.GetDamage() < target->GetHealth()) + return; + + int32 healAmount = int32(target->CountPctFromMaxHealth(healPct)); + // remove the aura now, we don't want 40% healing bonus + Remove(AURA_REMOVE_BY_ENEMY_SPELL); + target->CastCustomSpell(target, SPELL_PRIEST_GUARDIAN_SPIRIT_HEAL, &healAmount, nullptr, nullptr, true); + absorbAmount = dmgInfo.GetDamage(); + } + + void Register() override + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_guardian_spirit::CalculateAmount, EFFECT_1, SPELL_AURA_SCHOOL_ABSORB); + OnEffectAbsorb += AuraEffectAbsorbFn(spell_pri_guardian_spirit::Absorb, EFFECT_1); } }; // 64904 - Hymn of Hope -class spell_pri_hymn_of_hope : public SpellScriptLoader +class spell_pri_hymn_of_hope : public SpellScript { -public: - spell_pri_hymn_of_hope() : SpellScriptLoader("spell_pri_hymn_of_hope") { } + PrepareSpellScript(spell_pri_hymn_of_hope); - class spell_pri_hymn_of_hope_SpellScript : public SpellScript + void FilterTargets(std::list& targets) { - PrepareSpellScript(spell_pri_hymn_of_hope_SpellScript); + targets.remove_if(Acore::PowerCheck(POWER_MANA, false)); + targets.remove_if(Acore::RaidCheck(GetCaster(), false)); - void FilterTargets(std::list& targets) + uint32 const maxTargets = 3; + + if (targets.size() > maxTargets) { - targets.remove_if(Acore::PowerCheck(POWER_MANA, false)); - targets.remove_if(Acore::RaidCheck(GetCaster(), false)); - - uint32 const maxTargets = 3; - - if (targets.size() > maxTargets) - { - targets.sort(Acore::PowerPctOrderPred(POWER_MANA)); - targets.resize(maxTargets); - } + targets.sort(Acore::PowerPctOrderPred(POWER_MANA)); + targets.resize(maxTargets); } + } - void Register() override - { - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_hymn_of_hope_SpellScript::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ALLY); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_hymn_of_hope_SpellScript(); + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_hymn_of_hope::FilterTargets, EFFECT_ALL, TARGET_UNIT_SRC_AREA_ALLY); } }; // 37594 - Greater Heal Refund -class spell_pri_item_greater_heal_refund : public SpellScriptLoader +class spell_pri_item_greater_heal_refund : public AuraScript { -public: - spell_pri_item_greater_heal_refund() : SpellScriptLoader("spell_pri_item_greater_heal_refund") { } + PrepareAuraScript(spell_pri_item_greater_heal_refund); - class spell_pri_item_greater_heal_refund_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_item_greater_heal_refund_AuraScript); + return ValidateSpellInfo({ SPELL_PRIEST_ITEM_EFFICIENCY }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_ITEM_EFFICIENCY }); - } - - bool CheckProc(ProcEventInfo& eventInfo) - { - if (HealInfo* healInfo = eventInfo.GetHealInfo()) - if (Unit* healTarget = healInfo->GetTarget()) - if (eventInfo.GetHitMask() & PROC_EX_NO_OVERHEAL && healTarget->IsFullHealth()) - return true; - return false; - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/) - { - PreventDefaultAction(); - GetTarget()->CastSpell(GetTarget(), SPELL_PRIEST_ITEM_EFFICIENCY, true, nullptr, aurEff); - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_pri_item_greater_heal_refund_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_pri_item_greater_heal_refund_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); - } - }; - - AuraScript* GetAuraScript() const override + bool CheckProc(ProcEventInfo& eventInfo) { - return new spell_pri_item_greater_heal_refund_AuraScript(); + if (HealInfo* healInfo = eventInfo.GetHealInfo()) + if (Unit* healTarget = healInfo->GetTarget()) + if (eventInfo.GetHitMask() & PROC_EX_NO_OVERHEAL && healTarget->IsFullHealth()) + return true; + return false; + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/) + { + PreventDefaultAction(); + GetTarget()->CastSpell(GetTarget(), SPELL_PRIEST_ITEM_EFFICIENCY, true, nullptr, aurEff); + } + + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_pri_item_greater_heal_refund::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_pri_item_greater_heal_refund::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); } }; // -7001 - Lightwell Renew -class spell_pri_lightwell_renew : public SpellScriptLoader +class spell_pri_lightwell_renew : public AuraScript { -public: - spell_pri_lightwell_renew() : SpellScriptLoader("spell_pri_lightwell_renew") { } + PrepareAuraScript(spell_pri_lightwell_renew); - class spell_pri_lightwell_renew_AuraScript : public AuraScript + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) { - PrepareAuraScript(spell_pri_lightwell_renew_AuraScript); - - void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) + if (Unit* caster = GetCaster()) { - if (Unit* caster = GetCaster()) - { - // Bonus from Glyph of Lightwell - if (AuraEffect* modHealing = caster->GetAuraEffect(SPELL_PRIEST_GLYPH_OF_LIGHTWELL, EFFECT_0)) - AddPct(amount, modHealing->GetAmount()); - } + // Bonus from Glyph of Lightwell + if (AuraEffect* modHealing = caster->GetAuraEffect(SPELL_PRIEST_GLYPH_OF_LIGHTWELL, EFFECT_0)) + AddPct(amount, modHealing->GetAmount()); } + } - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_lightwell_renew_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_HEAL); - } - }; - - AuraScript* GetAuraScript() const override + void Register() override { - return new spell_pri_lightwell_renew_AuraScript(); + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_lightwell_renew::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_HEAL); } }; // 8129 - Mana Burn -class spell_pri_mana_burn : public SpellScriptLoader +class spell_pri_mana_burn : public SpellScript { -public: - spell_pri_mana_burn() : SpellScriptLoader("spell_pri_mana_burn") { } + PrepareSpellScript(spell_pri_mana_burn); - class spell_pri_mana_burn_SpellScript : public SpellScript + void HandleAfterHit() { - PrepareSpellScript(spell_pri_mana_burn_SpellScript); + if (Unit* unitTarget = GetHitUnit()) + unitTarget->RemoveAurasWithMechanic((1 << MECHANIC_FEAR) | (1 << MECHANIC_POLYMORPH)); + } - void HandleAfterHit() - { - if (Unit* unitTarget = GetHitUnit()) - unitTarget->RemoveAurasWithMechanic((1 << MECHANIC_FEAR) | (1 << MECHANIC_POLYMORPH)); - } - - void Register() override - { - AfterHit += SpellHitFn(spell_pri_mana_burn_SpellScript::HandleAfterHit); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_mana_burn_SpellScript; + AfterHit += SpellHitFn(spell_pri_mana_burn::HandleAfterHit); } }; // 28305 - Mana Leech (Passive) (Priest Pet Aura) -class spell_pri_mana_leech : public SpellScriptLoader +class spell_pri_mana_leech : public AuraScript { -public: - spell_pri_mana_leech() : SpellScriptLoader("spell_pri_mana_leech") { } + PrepareAuraScript(spell_pri_mana_leech); - class spell_pri_mana_leech_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_mana_leech_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_MANA_LEECH_PROC }); - } - - bool Load() override - { - _procTarget = nullptr; - return true; - } - - bool CheckProc(ProcEventInfo& /*eventInfo*/) - { - _procTarget = GetTarget()->GetOwner(); - return _procTarget; - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/) - { - PreventDefaultAction(); - GetTarget()->CastSpell(_procTarget, SPELL_PRIEST_MANA_LEECH_PROC, true, nullptr, aurEff); - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_pri_mana_leech_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_pri_mana_leech_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); - } - - private: - Unit* _procTarget; - }; - - AuraScript* GetAuraScript() const override - { - return new spell_pri_mana_leech_AuraScript(); + return ValidateSpellInfo({ SPELL_PRIEST_MANA_LEECH_PROC }); } + + bool Load() override + { + _procTarget = nullptr; + return true; + } + + bool CheckProc(ProcEventInfo& /*eventInfo*/) + { + _procTarget = GetTarget()->GetOwner(); + return _procTarget; + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/) + { + PreventDefaultAction(); + GetTarget()->CastSpell(_procTarget, SPELL_PRIEST_MANA_LEECH_PROC, true, nullptr, aurEff); + } + + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_pri_mana_leech::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_pri_mana_leech::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); + } + +private: + Unit* _procTarget; }; // -49821 - Mind Sear -class spell_pri_mind_sear : public SpellScriptLoader +class spell_pri_mind_sear : public SpellScript { -public: - spell_pri_mind_sear() : SpellScriptLoader("spell_pri_mind_sear") { } + PrepareSpellScript(spell_pri_mind_sear); - class spell_pri_mind_sear_SpellScript : public SpellScript + void FilterTargets(std::list& unitList) { - PrepareSpellScript(spell_pri_mind_sear_SpellScript); + unitList.remove_if(Acore::ObjectGUIDCheck(GetCaster()->GetGuidValue(UNIT_FIELD_CHANNEL_OBJECT), true)); + } - void FilterTargets(std::list& unitList) - { - unitList.remove_if(Acore::ObjectGUIDCheck(GetCaster()->GetGuidValue(UNIT_FIELD_CHANNEL_OBJECT), true)); - } - - void Register() override - { - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_mind_sear_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_mind_sear_SpellScript(); + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_pri_mind_sear::FilterTargets, EFFECT_0, TARGET_UNIT_DEST_AREA_ENEMY); } }; // 47948 - Pain and Suffering (Proc) -class spell_pri_pain_and_suffering_proc : public SpellScriptLoader +class spell_pri_pain_and_suffering_proc : public SpellScript { -public: - spell_pri_pain_and_suffering_proc() : SpellScriptLoader("spell_pri_pain_and_suffering_proc") { } + PrepareSpellScript(spell_pri_pain_and_suffering_proc); - class spell_pri_pain_and_suffering_proc_SpellScript : public SpellScript + void HandleEffectScriptEffect(SpellEffIndex /*effIndex*/) { - PrepareSpellScript(spell_pri_pain_and_suffering_proc_SpellScript); + // Refresh Shadow Word: Pain on target + if (Unit* unitTarget = GetHitUnit()) + if (AuraEffect* aur = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetCaster()->GetGUID())) + { + aur->GetBase()->RefreshTimers(); + aur->ChangeAmount(aur->CalculateAmount(aur->GetCaster()), false); + } + } - void HandleEffectScriptEffect(SpellEffIndex /*effIndex*/) - { - // Refresh Shadow Word: Pain on target - if (Unit* unitTarget = GetHitUnit()) - if (AuraEffect* aur = unitTarget->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_PRIEST, 0x8000, 0, 0, GetCaster()->GetGUID())) - { - aur->GetBase()->RefreshTimers(); - aur->ChangeAmount(aur->CalculateAmount(aur->GetCaster()), false); - } - } - - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_pri_pain_and_suffering_proc_SpellScript::HandleEffectScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_pain_and_suffering_proc_SpellScript; + OnEffectHitTarget += SpellEffectFn(spell_pri_pain_and_suffering_proc::HandleEffectScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); } }; // -47540 - Penance -class spell_pri_penance : public SpellScriptLoader +class spell_pri_penance : public SpellScript { -public: - spell_pri_penance() : SpellScriptLoader("spell_pri_penance") { } + PrepareSpellScript(spell_pri_penance); - class spell_pri_penance_SpellScript : public SpellScript + bool Load() override { - PrepareSpellScript(spell_pri_penance_SpellScript); + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } - bool Load() override + bool Validate(SpellInfo const* spellInfo) override + { + SpellInfo const* firstRankSpellInfo = sSpellMgr->GetSpellInfo(SPELL_PRIEST_PENANCE_R1); + if (!firstRankSpellInfo) + return false; + + // can't use other spell than this penance due to spell_ranks dependency + if (!spellInfo->IsRankOf(firstRankSpellInfo)) + return false; + + uint8 rank = spellInfo->GetRank(); + if (!sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_DAMAGE, rank, true)) + return false; + if (!sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_HEAL, rank, true)) + return false; + + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* unitTarget = GetHitUnit()) { - return GetCaster()->GetTypeId() == TYPEID_PLAYER; - } + if (!unitTarget->IsAlive()) + return; - bool Validate(SpellInfo const* spellInfo) override - { - SpellInfo const* firstRankSpellInfo = sSpellMgr->GetSpellInfo(SPELL_PRIEST_PENANCE_R1); - if (!firstRankSpellInfo) - return false; + uint8 rank = GetSpellInfo()->GetRank(); - // can't use other spell than this penance due to spell_ranks dependency - if (!spellInfo->IsRankOf(firstRankSpellInfo)) - return false; - - uint8 rank = spellInfo->GetRank(); - if (!sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_DAMAGE, rank, true)) - return false; - if (!sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_HEAL, rank, true)) - return false; - - return true; - } - - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Unit* caster = GetCaster(); - if (Unit* unitTarget = GetHitUnit()) - { - if (!unitTarget->IsAlive()) - return; - - uint8 rank = GetSpellInfo()->GetRank(); - - if (caster->IsFriendlyTo(unitTarget)) - caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_HEAL, rank), false); - else - caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_DAMAGE, rank), false); - } - } - - SpellCastResult CheckCast() - { - Unit* caster = GetCaster(); - if (Unit* target = GetExplTargetUnit()) - { - if (!caster->IsFriendlyTo(target)) - { - if (!caster->IsValidAttackTarget(target)) - return SPELL_FAILED_BAD_TARGETS; - - if (!caster->isInFront(target)) - return SPELL_FAILED_UNIT_NOT_INFRONT; - } - } + if (caster->IsFriendlyTo(unitTarget)) + caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_HEAL, rank), false); else - return SPELL_FAILED_BAD_TARGETS; - return SPELL_CAST_OK; + caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(SPELL_PRIEST_PENANCE_R1_DAMAGE, rank), false); } + } - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_pri_penance_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - OnCheckCast += SpellCheckCastFn(spell_pri_penance_SpellScript::CheckCast); - } - }; - - SpellScript* GetSpellScript() const override + SpellCastResult CheckCast() { - return new spell_pri_penance_SpellScript; + Unit* caster = GetCaster(); + if (Unit* target = GetExplTargetUnit()) + { + if (!caster->IsFriendlyTo(target)) + { + if (!caster->IsValidAttackTarget(target)) + return SPELL_FAILED_BAD_TARGETS; + + if (!caster->isInFront(target)) + return SPELL_FAILED_UNIT_NOT_INFRONT; + } + } + else + return SPELL_FAILED_BAD_TARGETS; + return SPELL_CAST_OK; + } + + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_pri_penance::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + OnCheckCast += SpellCheckCastFn(spell_pri_penance::CheckCast); } }; // -17 - Power Word: Shield -class spell_pri_power_word_shield : public SpellScriptLoader +static int32 CalculateSpellAmount(Unit* caster, int32 amount, const SpellInfo* spellInfo, const AuraEffect* aurEff) { -public: - spell_pri_power_word_shield() : SpellScriptLoader("spell_pri_power_word_shield") { } + // +80.68% from sp bonus + float bonus = 0.8068f; - static int32 CalculateSpellAmount(Unit* caster, int32 amount, const SpellInfo* spellInfo, const AuraEffect* aurEff) + // Borrowed Time + if (AuraEffect const* borrowedTime = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, PRIEST_ICON_ID_BORROWED_TIME, EFFECT_1)) + bonus += CalculatePct(1.0f, borrowedTime->GetAmount()); + + bonus *= caster->SpellBaseHealingBonusDone(spellInfo->GetSchoolMask()); + + // Improved PW: Shield: its weird having a SPELLMOD_ALL_EFFECTS here but its blizzards doing :) + // Improved PW: Shield is only applied at the spell healing bonus because it was already applied to the base value in CalculateSpellDamage + bonus = caster->ApplyEffectModifiers(spellInfo, aurEff->GetEffIndex(), bonus); + bonus *= caster->CalculateLevelPenalty(spellInfo); + + amount += int32(bonus); + + // Twin Disciplines + if (AuraEffect const* twinDisciplines = caster->GetAuraEffect(SPELL_AURA_ADD_PCT_MODIFIER, SPELLFAMILY_PRIEST, 0x400000, 0, 0, caster->GetGUID())) + AddPct(amount, twinDisciplines->GetAmount()); + + // Focused Power, xinef: apply positive modifier only + if (int32 healModifier = caster->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_DONE_PERCENT)) + AddPct(amount, healModifier); + + // Arena - Dampening + if (AuraEffect const* arenaDampening = caster->GetAuraEffect(SPELL_GENERIC_ARENA_DAMPENING, EFFECT_0)) { - // +80.68% from sp bonus - float bonus = 0.8068f; - - // Borrowed Time - if (AuraEffect const* borrowedTime = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, PRIEST_ICON_ID_BORROWED_TIME, EFFECT_1)) - bonus += CalculatePct(1.0f, borrowedTime->GetAmount()); - - bonus *= caster->SpellBaseHealingBonusDone(spellInfo->GetSchoolMask()); - - // Improved PW: Shield: its weird having a SPELLMOD_ALL_EFFECTS here but its blizzards doing :) - // Improved PW: Shield is only applied at the spell healing bonus because it was already applied to the base value in CalculateSpellDamage - bonus = caster->ApplyEffectModifiers(spellInfo, aurEff->GetEffIndex(), bonus); - bonus *= caster->CalculateLevelPenalty(spellInfo); - - amount += int32(bonus); - - // Twin Disciplines - if (AuraEffect const* twinDisciplines = caster->GetAuraEffect(SPELL_AURA_ADD_PCT_MODIFIER, SPELLFAMILY_PRIEST, 0x400000, 0, 0, caster->GetGUID())) - AddPct(amount, twinDisciplines->GetAmount()); - - // Focused Power, xinef: apply positive modifier only - if (int32 healModifier = caster->GetMaxPositiveAuraModifier(SPELL_AURA_MOD_HEALING_DONE_PERCENT)) - AddPct(amount, healModifier); - - // Arena - Dampening - if (AuraEffect const* arenaDampening = caster->GetAuraEffect(SPELL_GENERIC_ARENA_DAMPENING, EFFECT_0)) - { - AddPct(amount, arenaDampening->GetAmount()); - } - // Battleground - Dampening - else if (AuraEffect const* bgDampening = caster->GetAuraEffect(SPELL_GENERIC_BATTLEGROUND_DAMPENING, EFFECT_0)) - { - AddPct(amount, bgDampening->GetAmount()); - } - - return amount; + AddPct(amount, arenaDampening->GetAmount()); + } + // Battleground - Dampening + else if (AuraEffect const* bgDampening = caster->GetAuraEffect(SPELL_GENERIC_BATTLEGROUND_DAMPENING, EFFECT_0)) + { + AddPct(amount, bgDampening->GetAmount()); } - class spell_pri_power_word_shield_AuraScript : public AuraScript + return amount; +}; + +class spell_pri_power_word_shield_aura : public AuraScript +{ + PrepareAuraScript(spell_pri_power_word_shield_aura); + + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_power_word_shield_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_REFLECTIVE_SHIELD_TRIGGERED, SPELL_PRIEST_REFLECTIVE_SHIELD_R1 }); - } - - void CalculateAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated) - { - canBeRecalculated = false; - if (Unit* caster = GetCaster()) - amount = CalculateSpellAmount(caster, amount, GetSpellInfo(), aurEff); - } - - void ReflectDamage(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount) - { - Unit* target = GetTarget(); - if (dmgInfo.GetAttacker() == target) - return; - - if (Unit* owner = GetUnitOwner()) - if (AuraEffect* talentAurEff = owner->GetAuraEffectOfRankedSpell(SPELL_PRIEST_REFLECTIVE_SHIELD_R1, EFFECT_0)) - { - int32 bp = CalculatePct(absorbAmount, talentAurEff->GetAmount()); - // xinef: prevents infinite loop! - if (!dmgInfo.GetSpellInfo() || dmgInfo.GetSpellInfo()->Id != SPELL_PRIEST_REFLECTIVE_SHIELD_TRIGGERED) - target->CastCustomSpell(dmgInfo.GetAttacker(), SPELL_PRIEST_REFLECTIVE_SHIELD_TRIGGERED, &bp, nullptr, nullptr, true, nullptr, aurEff); - } - } - - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_power_word_shield_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); - AfterEffectAbsorb += AuraEffectAbsorbFn(spell_pri_power_word_shield_AuraScript::ReflectDamage, EFFECT_0); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_pri_power_word_shield_AuraScript(); + return ValidateSpellInfo({ SPELL_PRIEST_REFLECTIVE_SHIELD_TRIGGERED, SPELL_PRIEST_REFLECTIVE_SHIELD_R1 }); } - class spell_pri_power_word_shield_SpellScript : public SpellScript + void CalculateAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated) { - PrepareSpellScript(spell_pri_power_word_shield_SpellScript); + canBeRecalculated = false; + if (Unit* caster = GetCaster()) + amount = CalculateSpellAmount(caster, amount, GetSpellInfo(), aurEff); + } - SpellCastResult CheckCast() - { - Unit* caster = GetCaster(); - Unit* target = GetExplTargetUnit(); - if (!target) - return SPELL_FAILED_BAD_TARGETS; + void ReflectDamage(AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount) + { + Unit* target = GetTarget(); + if (dmgInfo.GetAttacker() == target) + return; - if (AuraEffect* aurEff = target->GetAuraEffect(SPELL_AURA_SCHOOL_ABSORB, (SpellFamilyNames)GetSpellInfo()->SpellFamilyName, GetSpellInfo()->SpellIconID, EFFECT_0)) + if (Unit* owner = GetUnitOwner()) + if (AuraEffect* talentAurEff = owner->GetAuraEffectOfRankedSpell(SPELL_PRIEST_REFLECTIVE_SHIELD_R1, EFFECT_0)) { - int32 newAmount = GetSpellInfo()->Effects[EFFECT_0].CalcValue(caster, nullptr, nullptr); - newAmount = CalculateSpellAmount(caster, newAmount, GetSpellInfo(), aurEff); - - if (aurEff->GetAmount() > newAmount) - return SPELL_FAILED_AURA_BOUNCED; + int32 bp = CalculatePct(absorbAmount, talentAurEff->GetAmount()); + // xinef: prevents infinite loop! + if (!dmgInfo.GetSpellInfo() || dmgInfo.GetSpellInfo()->Id != SPELL_PRIEST_REFLECTIVE_SHIELD_TRIGGERED) + target->CastCustomSpell(dmgInfo.GetAttacker(), SPELL_PRIEST_REFLECTIVE_SHIELD_TRIGGERED, &bp, nullptr, nullptr, true, nullptr, aurEff); } + } - return SPELL_CAST_OK; - } - - void Register() override - { - OnCheckCast += SpellCheckCastFn(spell_pri_power_word_shield_SpellScript::CheckCast); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_power_word_shield_SpellScript; + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pri_power_word_shield_aura::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); + AfterEffectAbsorb += AuraEffectAbsorbFn(spell_pri_power_word_shield_aura::ReflectDamage, EFFECT_0); + } +}; + +class spell_pri_power_word_shield : public SpellScript +{ + PrepareSpellScript(spell_pri_power_word_shield); + + SpellCastResult CheckCast() + { + Unit* caster = GetCaster(); + Unit* target = GetExplTargetUnit(); + if (!target) + return SPELL_FAILED_BAD_TARGETS; + + if (AuraEffect* aurEff = target->GetAuraEffect(SPELL_AURA_SCHOOL_ABSORB, (SpellFamilyNames)GetSpellInfo()->SpellFamilyName, GetSpellInfo()->SpellIconID, EFFECT_0)) + { + int32 newAmount = GetSpellInfo()->Effects[EFFECT_0].CalcValue(caster, nullptr, nullptr); + newAmount = CalculateSpellAmount(caster, newAmount, GetSpellInfo(), aurEff); + + if (aurEff->GetAmount() > newAmount) + return SPELL_FAILED_AURA_BOUNCED; + } + + return SPELL_CAST_OK; + } + + void Register() override + { + OnCheckCast += SpellCheckCastFn(spell_pri_power_word_shield::CheckCast); } }; // 33110 - Prayer of Mending Heal -class spell_pri_prayer_of_mending_heal : public SpellScriptLoader +class spell_pri_prayer_of_mending_heal : public SpellScript { -public: - spell_pri_prayer_of_mending_heal() : SpellScriptLoader("spell_pri_prayer_of_mending_heal") { } + PrepareSpellScript(spell_pri_prayer_of_mending_heal); - class spell_pri_prayer_of_mending_heal_SpellScript : public SpellScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareSpellScript(spell_pri_prayer_of_mending_heal_SpellScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo( - { - SPELL_PRIEST_T9_HEALING_2P, - SPELL_PRIEST_TWIN_DISCIPLINE_R1, - SPELL_PRIEST_SPIRITUAL_HEALING_R1, - SPELL_PRIEST_DIVINE_PROVIDENCE_R1 - }); - } - - void HandleHeal(SpellEffIndex /*effIndex*/) - { - if (Unit* caster = GetOriginalCaster()) + return ValidateSpellInfo( { - int32 heal = GetEffectValue(); - if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_PRIEST_T9_HEALING_2P, EFFECT_0)) - { - AddPct(heal, aurEff->GetAmount()); - } + SPELL_PRIEST_T9_HEALING_2P, + SPELL_PRIEST_TWIN_DISCIPLINE_R1, + SPELL_PRIEST_SPIRITUAL_HEALING_R1, + SPELL_PRIEST_DIVINE_PROVIDENCE_R1 + }); + } - if (AuraEffect* aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_PRIEST_TWIN_DISCIPLINE_R1, EFFECT_0)) - { - AddPct(heal, aurEff->GetAmount()); - } - if (AuraEffect* aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_PRIEST_SPIRITUAL_HEALING_R1, EFFECT_0)) - { - AddPct(heal, aurEff->GetAmount()); - } - if (AuraEffect* aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_PRIEST_DIVINE_PROVIDENCE_R1, EFFECT_0)) - { - AddPct(heal, aurEff->GetAmount()); - } - - SetEffectValue(heal); - } - } - - void Register() override - { - OnEffectLaunchTarget += SpellEffectFn(spell_pri_prayer_of_mending_heal_SpellScript::HandleHeal, EFFECT_0, SPELL_EFFECT_HEAL); - } - }; - - SpellScript* GetSpellScript() const override + void HandleHeal(SpellEffIndex /*effIndex*/) { - return new spell_pri_prayer_of_mending_heal_SpellScript(); + if (Unit* caster = GetOriginalCaster()) + { + int32 heal = GetEffectValue(); + if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_PRIEST_T9_HEALING_2P, EFFECT_0)) + { + AddPct(heal, aurEff->GetAmount()); + } + + if (AuraEffect* aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_PRIEST_TWIN_DISCIPLINE_R1, EFFECT_0)) + { + AddPct(heal, aurEff->GetAmount()); + } + if (AuraEffect* aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_PRIEST_SPIRITUAL_HEALING_R1, EFFECT_0)) + { + AddPct(heal, aurEff->GetAmount()); + } + if (AuraEffect* aurEff = caster->GetAuraEffectOfRankedSpell(SPELL_PRIEST_DIVINE_PROVIDENCE_R1, EFFECT_0)) + { + AddPct(heal, aurEff->GetAmount()); + } + + SetEffectValue(heal); + } + } + + void Register() override + { + OnEffectLaunchTarget += SpellEffectFn(spell_pri_prayer_of_mending_heal::HandleHeal, EFFECT_0, SPELL_EFFECT_HEAL); } }; // -139 - Renew -class spell_pri_renew : public SpellScriptLoader +class spell_pri_renew : public AuraScript { -public: - spell_pri_renew() : SpellScriptLoader("spell_pri_renew") { } + PrepareAuraScript(spell_pri_renew); - class spell_pri_renew_AuraScript : public AuraScript + bool Load() override { - PrepareAuraScript(spell_pri_renew_AuraScript); + return GetCaster() && GetCaster()->GetTypeId() == TYPEID_PLAYER; + } - bool Load() override - { - return GetCaster() && GetCaster()->GetTypeId() == TYPEID_PLAYER; - } + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({SPELL_PRIEST_EMPOWERED_RENEW}); + } - bool Validate(SpellInfo const* /*spellInfo*/) override + void HandleApplyEffect(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/) + { + if (Unit* caster = GetCaster()) { - return ValidateSpellInfo({SPELL_PRIEST_EMPOWERED_RENEW}); - } - - void HandleApplyEffect(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/) - { - if (Unit* caster = GetCaster()) + // Empowered Renew + if (AuraEffect const* empoweredRenewAurEff = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, PRIEST_ICON_ID_EMPOWERED_RENEW_TALENT, EFFECT_1)) { - // Empowered Renew - if (AuraEffect const* empoweredRenewAurEff = caster->GetDummyAuraEffect(SPELLFAMILY_PRIEST, PRIEST_ICON_ID_EMPOWERED_RENEW_TALENT, EFFECT_1)) - { - uint32 heal = GetEffect(EFFECT_0)->GetAmount(); - heal = GetTarget()->SpellHealingBonusTaken(caster, GetSpellInfo(), heal, DOT); + uint32 heal = GetEffect(EFFECT_0)->GetAmount(); + heal = GetTarget()->SpellHealingBonusTaken(caster, GetSpellInfo(), heal, DOT); - int32 basepoints0 = empoweredRenewAurEff->GetAmount() * GetEffect(EFFECT_0)->GetTotalTicks() * int32(heal) / 100; - caster->CastCustomSpell(GetTarget(), SPELL_PRIEST_EMPOWERED_RENEW, &basepoints0, nullptr, nullptr, true, nullptr, aurEff); - } + int32 basepoints0 = empoweredRenewAurEff->GetAmount() * GetEffect(EFFECT_0)->GetTotalTicks() * int32(heal) / 100; + caster->CastCustomSpell(GetTarget(), SPELL_PRIEST_EMPOWERED_RENEW, &basepoints0, nullptr, nullptr, true, nullptr, aurEff); } } + } - void Register() override - { - OnEffectApply += AuraEffectApplyFn(spell_pri_renew_AuraScript::HandleApplyEffect, EFFECT_0, SPELL_AURA_PERIODIC_HEAL, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); - } - }; - - AuraScript* GetAuraScript() const override + void Register() override { - return new spell_pri_renew_AuraScript(); + OnEffectApply += AuraEffectApplyFn(spell_pri_renew::HandleApplyEffect, EFFECT_0, SPELL_AURA_PERIODIC_HEAL, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); } }; // -32379 - Shadow Word Death -class spell_pri_shadow_word_death : public SpellScriptLoader +class spell_pri_shadow_word_death : public SpellScript { -public: - spell_pri_shadow_word_death() : SpellScriptLoader("spell_pri_shadow_word_death") { } + PrepareSpellScript(spell_pri_shadow_word_death); - class spell_pri_shadow_word_death_SpellScript : public SpellScript + void HandleDamage() { - PrepareSpellScript(spell_pri_shadow_word_death_SpellScript); + int32 damage = GetHitDamage(); - void HandleDamage() - { - int32 damage = GetHitDamage(); + // Pain and Suffering reduces damage + if (AuraEffect* aurEff = GetCaster()->GetDummyAuraEffect(SPELLFAMILY_PRIEST, PRIEST_ICON_ID_PAIN_AND_SUFFERING, EFFECT_1)) + AddPct(damage, aurEff->GetAmount()); - // Pain and Suffering reduces damage - if (AuraEffect* aurEff = GetCaster()->GetDummyAuraEffect(SPELLFAMILY_PRIEST, PRIEST_ICON_ID_PAIN_AND_SUFFERING, EFFECT_1)) - AddPct(damage, aurEff->GetAmount()); + GetCaster()->CastCustomSpell(GetCaster(), SPELL_PRIEST_SHADOW_WORD_DEATH, &damage, 0, 0, true); + } - GetCaster()->CastCustomSpell(GetCaster(), SPELL_PRIEST_SHADOW_WORD_DEATH, &damage, 0, 0, true); - } - - void Register() override - { - OnHit += SpellHitFn(spell_pri_shadow_word_death_SpellScript::HandleDamage); - } - }; - - SpellScript* GetSpellScript() const override + void Register() override { - return new spell_pri_shadow_word_death_SpellScript(); + OnHit += SpellHitFn(spell_pri_shadow_word_death::HandleDamage); } }; // -34914 - Vampiric Touch -class spell_pri_vampiric_touch : public SpellScriptLoader +class spell_pri_vampiric_touch : public AuraScript { -public: - spell_pri_vampiric_touch() : SpellScriptLoader("spell_pri_vampiric_touch") { } + PrepareAuraScript(spell_pri_vampiric_touch); - class spell_pri_vampiric_touch_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override { - PrepareAuraScript(spell_pri_vampiric_touch_AuraScript); + return ValidateSpellInfo({ SPELL_PRIEST_VAMPIRIC_TOUCH_DISPEL }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_PRIEST_VAMPIRIC_TOUCH_DISPEL }); - } - - void HandleDispel(DispelInfo* /*dispelInfo*/) - { - if (Unit* caster = GetCaster()) - if (Unit* target = GetUnitOwner()) - if (AuraEffect const* aurEff = GetEffect(EFFECT_1)) - { - int32 damage = aurEff->GetBaseAmount(); - damage = aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue(caster, &damage, nullptr) * 8; - // backfire damage - caster->CastCustomSpell(target, SPELL_PRIEST_VAMPIRIC_TOUCH_DISPEL, &damage, nullptr, nullptr, true, nullptr, aurEff); - } - } - - bool CheckProc(ProcEventInfo& eventInfo) - { - return eventInfo.GetActionTarget() && eventInfo.GetActionTarget()->IsAlive() && GetOwner()->GetGUID() == eventInfo.GetActionTarget()->GetGUID(); - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - eventInfo.GetActor()->CastSpell(eventInfo.GetActor(), 57669, true, nullptr, aurEff); - } - - void Register() override - { - AfterDispel += AuraDispelFn(spell_pri_vampiric_touch_AuraScript::HandleDispel); - DoCheckProc += AuraCheckProcFn(spell_pri_vampiric_touch_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_pri_vampiric_touch_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); - } - }; - - AuraScript* GetAuraScript() const override + void HandleDispel(DispelInfo* /*dispelInfo*/) { - return new spell_pri_vampiric_touch_AuraScript(); + if (Unit* caster = GetCaster()) + if (Unit* target = GetUnitOwner()) + if (AuraEffect const* aurEff = GetEffect(EFFECT_1)) + { + int32 damage = aurEff->GetBaseAmount(); + damage = aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue(caster, &damage, nullptr) * 8; + // backfire damage + caster->CastCustomSpell(target, SPELL_PRIEST_VAMPIRIC_TOUCH_DISPEL, &damage, nullptr, nullptr, true, nullptr, aurEff); + } + } + + bool CheckProc(ProcEventInfo& eventInfo) + { + return eventInfo.GetActionTarget() && eventInfo.GetActionTarget()->IsAlive() && GetOwner()->GetGUID() == eventInfo.GetActionTarget()->GetGUID(); + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + PreventDefaultAction(); + eventInfo.GetActor()->CastSpell(eventInfo.GetActor(), 57669, true, nullptr, aurEff); + } + + void Register() override + { + AfterDispel += AuraDispelFn(spell_pri_vampiric_touch::HandleDispel); + DoCheckProc += AuraCheckProcFn(spell_pri_vampiric_touch::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_pri_vampiric_touch::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); } }; void AddSC_priest_spell_scripts() { - // Ours - new spell_pri_shadowfiend_scaling(); - - // Theirs - new spell_pri_circle_of_healing(); - new spell_pri_divine_aegis(); - new spell_pri_divine_hymn(); - new spell_pri_glyph_of_prayer_of_healing(); - new spell_pri_guardian_spirit(); - new spell_pri_hymn_of_hope(); - new spell_pri_item_greater_heal_refund(); - new spell_pri_lightwell_renew(); - new spell_pri_mana_burn(); - new spell_pri_mana_leech(); - new spell_pri_mind_sear(); - new spell_pri_pain_and_suffering_proc(); - new spell_pri_penance(); - new spell_pri_power_word_shield(); - new spell_pri_prayer_of_mending_heal(); - new spell_pri_renew(); - new spell_pri_shadow_word_death(); - new spell_pri_vampiric_touch(); + RegisterSpellScript(spell_pri_shadowfiend_scaling); + RegisterSpellScript(spell_pri_circle_of_healing); + RegisterSpellScript(spell_pri_divine_aegis); + RegisterSpellScript(spell_pri_divine_hymn); + RegisterSpellScript(spell_pri_glyph_of_prayer_of_healing); + RegisterSpellScript(spell_pri_guardian_spirit); + RegisterSpellScript(spell_pri_hymn_of_hope); + RegisterSpellScript(spell_pri_item_greater_heal_refund); + RegisterSpellScript(spell_pri_lightwell_renew); + RegisterSpellScript(spell_pri_mana_burn); + RegisterSpellScript(spell_pri_mana_leech); + RegisterSpellScript(spell_pri_mind_sear); + RegisterSpellScript(spell_pri_pain_and_suffering_proc); + RegisterSpellScript(spell_pri_penance); + RegisterSpellAndAuraScriptPair(spell_pri_power_word_shield, spell_pri_power_word_shield_aura); + RegisterSpellScript(spell_pri_prayer_of_mending_heal); + RegisterSpellScript(spell_pri_renew); + RegisterSpellScript(spell_pri_shadow_word_death); + RegisterSpellScript(spell_pri_vampiric_touch); }