From 369ec57af6900c12e3d95c77db1a1135b9302b23 Mon Sep 17 00:00:00 2001 From: Ovahlord Date: Mon, 16 Dec 2019 00:00:36 +0100 Subject: [PATCH] Core/Spells: updated remaining warrior spell scripts to new scripting model --- src/server/scripts/Spells/spell_warrior.cpp | 1055 ++++++++----------- 1 file changed, 422 insertions(+), 633 deletions(-) diff --git a/src/server/scripts/Spells/spell_warrior.cpp b/src/server/scripts/Spells/spell_warrior.cpp index 27e243f578a..8a51bdfe6e9 100644 --- a/src/server/scripts/Spells/spell_warrior.cpp +++ b/src/server/scripts/Spells/spell_warrior.cpp @@ -41,9 +41,6 @@ enum WarriorSpells SPELL_WARRIOR_CHARGE_ENERGIZE = 34846, SPELL_WARRIOR_CHARGE_STUN = 7922, SPELL_WARRIOR_COLOSSUS_SMASH = 86346, - SPELL_WARRIOR_DEEP_WOUNDS_RANK_1 = 12834, - SPELL_WARRIOR_DEEP_WOUNDS_RANK_2 = 12849, - SPELL_WARRIOR_DEEP_WOUNDS_RANK_3 = 12867, SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC = 12721, SPELL_WARRIOR_EXECUTE = 20647, SPELL_WARRIOR_GLYPH_OF_EXECUTION = 58367, @@ -204,422 +201,294 @@ class spell_warr_concussion_blow : public SpellScript // Updated 4.3.4 // -12834 - Deep Wounds -class spell_warr_deep_wounds : public SpellScriptLoader +class spell_warr_deep_wounds : public AuraScript { - public: - spell_warr_deep_wounds() : SpellScriptLoader("spell_warr_deep_wounds") { } + PrepareAuraScript(spell_warr_deep_wounds); - class spell_warr_deep_wounds_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC }); + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + if (Player* player = GetTarget()->ToPlayer()) { - PrepareAuraScript(spell_warr_deep_wounds_AuraScript); + int32 damage = player->CalculateDamage(eventInfo.GetDamageInfo()->GetAttackType(), false, false); + damage = CalculatePct(damage, 16 * GetSpellInfo()->GetRank()); - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo( - { - SPELL_WARRIOR_DEEP_WOUNDS_RANK_1, - SPELL_WARRIOR_DEEP_WOUNDS_RANK_2, - SPELL_WARRIOR_DEEP_WOUNDS_RANK_3, - SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC - }); - } + if (damage) + if (SpellInfo const* periodicSpell = sSpellMgr->GetSpellInfo(SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC)) + if (uint32 ticks = periodicSpell->GetMaxTicks()) + damage = damage / ticks; - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - if (Player* player = GetTarget()->ToPlayer()) - { - int32 damage = player->CalculateDamage(eventInfo.GetDamageInfo()->GetAttackType(), false, false); - damage = CalculatePct(damage, 16 * GetSpellInfo()->GetRank()); - - if (damage) - if (SpellInfo const* periodicSpell = sSpellMgr->GetSpellInfo(SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC)) - if (uint32 ticks = periodicSpell->GetMaxTicks()) - damage = damage / ticks; - - if (Unit* target = eventInfo.GetProcTarget()) - player->CastCustomSpell(target, SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC, &damage, 0, 0, true, nullptr, aurEff); - } - } - - void Register() override - { - OnEffectProc += AuraEffectProcFn(spell_warr_deep_wounds_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); - } - - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_deep_wounds_AuraScript(); + if (Unit* target = eventInfo.GetProcTarget()) + player->CastCustomSpell(target, SPELL_WARRIOR_DEEP_WOUNDS_PERIODIC, &damage, 0, 0, true, nullptr, aurEff); } + } + + void Register() override + { + OnEffectProc += AuraEffectProcFn(spell_warr_deep_wounds::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); + } }; /// Updated 4.3.4 -class spell_warr_execute : public SpellScriptLoader +class spell_warr_execute : public SpellScript { - public: - spell_warr_execute() : SpellScriptLoader("spell_warr_execute") { } + PrepareSpellScript(spell_warr_execute); - class spell_warr_execute_SpellScript : public SpellScript + void HandleEffect(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (GetHitUnit()) { - PrepareSpellScript(spell_warr_execute_SpellScript); + SpellInfo const* spellInfo = GetSpellInfo(); + int32 rageUsed = std::min(200 - spellInfo->CalcPowerCost(caster, SpellSchoolMask(spellInfo->SchoolMask)), caster->GetPower(POWER_RAGE)); + int32 newRage = std::max(0, caster->GetPower(POWER_RAGE) - rageUsed); - void HandleEffect(SpellEffIndex /*effIndex*/) + // Sudden Death rage save + if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_GENERIC, WARRIOR_ICON_ID_SUDDEN_DEATH, EFFECT_0)) { - Unit* caster = GetCaster(); - if (GetHitUnit()) - { - SpellInfo const* spellInfo = GetSpellInfo(); - int32 rageUsed = std::min(200 - spellInfo->CalcPowerCost(caster, SpellSchoolMask(spellInfo->SchoolMask)), caster->GetPower(POWER_RAGE)); - int32 newRage = std::max(0, caster->GetPower(POWER_RAGE) - rageUsed); - - // Sudden Death rage save - if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_GENERIC, WARRIOR_ICON_ID_SUDDEN_DEATH, EFFECT_0)) - { - int32 ragesave = aurEff->GetSpellInfo()->Effects[EFFECT_0].CalcValue() * 10; - newRage = std::max(newRage, ragesave); - } - - caster->SetPower(POWER_RAGE, uint32(newRage)); - - /// Formula taken from the DBC: "${10+$AP*0.437*$m1/100}" - int32 baseDamage = int32(10 + caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.437f * GetEffectValue() / 100.0f); - /// Formula taken from the DBC: "${$ap*0.874*$m1/100-1} = 20 rage" - int32 moreDamage = int32(rageUsed * (caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.874f * GetEffectValue() / 100.0f - 1) / 200); - SetEffectValue(baseDamage + moreDamage); - } + int32 ragesave = aurEff->GetSpellInfo()->Effects[EFFECT_0].CalcValue() * 10; + newRage = std::max(newRage, ragesave); } - void Register() override - { - OnEffectLaunchTarget += SpellEffectFn(spell_warr_execute_SpellScript::HandleEffect, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE); - } - }; + caster->SetPower(POWER_RAGE, uint32(newRage)); - SpellScript* GetSpellScript() const override - { - return new spell_warr_execute_SpellScript(); + /// Formula taken from the DBC: "${10+$AP*0.437*$m1/100}" + int32 baseDamage = int32(10 + caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.437f * GetEffectValue() / 100.0f); + /// Formula taken from the DBC: "${$ap*0.874*$m1/100-1} = 20 rage" + int32 moreDamage = int32(rageUsed * (caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.874f * GetEffectValue() / 100.0f - 1) / 200); + SetEffectValue(baseDamage + moreDamage); } + } + + void Register() override + { + OnEffectLaunchTarget += SpellEffectFn(spell_warr_execute::HandleEffect, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE); + } }; // 58387 - Glyph of Sunder Armor -class spell_warr_glyph_of_sunder_armor : public SpellScriptLoader +class spell_warr_glyph_of_sunder_armor : public AuraScript { - public: - spell_warr_glyph_of_sunder_armor() : SpellScriptLoader("spell_warr_glyph_of_sunder_armor") { } + PrepareAuraScript(spell_warr_glyph_of_sunder_armor); - class spell_warr_glyph_of_sunder_armor_AuraScript : public AuraScript + void HandleEffectCalcSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod) + { + if (!spellMod) { - PrepareAuraScript(spell_warr_glyph_of_sunder_armor_AuraScript); - - void HandleEffectCalcSpellMod(AuraEffect const* aurEff, SpellModifier*& spellMod) - { - if (!spellMod) - { - spellMod = new SpellModifier(aurEff->GetBase()); - spellMod->op = SpellModOp(aurEff->GetMiscValue()); - spellMod->type = SPELLMOD_FLAT; - spellMod->spellId = GetId(); - spellMod->mask = GetSpellInfo()->Effects[aurEff->GetEffIndex()].SpellClassMask; - } - - spellMod->value = aurEff->GetAmount(); - } - - void Register() override - { - DoEffectCalcSpellMod += AuraEffectCalcSpellModFn(spell_warr_glyph_of_sunder_armor_AuraScript::HandleEffectCalcSpellMod, EFFECT_0, SPELL_AURA_DUMMY); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_glyph_of_sunder_armor_AuraScript(); + spellMod = new SpellModifier(aurEff->GetBase()); + spellMod->op = SpellModOp(aurEff->GetMiscValue()); + spellMod->type = SPELLMOD_FLAT; + spellMod->spellId = GetId(); + spellMod->mask = GetSpellInfo()->Effects[aurEff->GetEffIndex()].SpellClassMask; } + + spellMod->value = aurEff->GetAmount(); + } + + void Register() override + { + DoEffectCalcSpellMod += AuraEffectCalcSpellModFn(spell_warr_glyph_of_sunder_armor::HandleEffectCalcSpellMod, EFFECT_0, SPELL_AURA_DUMMY); + } }; // 5246 - Intimidating Shout -class spell_warr_intimidating_shout : public SpellScriptLoader +class spell_warr_intimidating_shout : public SpellScript { - public: - spell_warr_intimidating_shout() : SpellScriptLoader("spell_warr_intimidating_shout") { } + PrepareSpellScript(spell_warr_intimidating_shout); - class spell_warr_intimidating_shout_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_intimidating_shout_SpellScript); + void FilterTargets(std::list& unitList) + { + unitList.remove(GetExplTargetWorldObject()); + } - void FilterTargets(std::list& unitList) - { - unitList.remove(GetExplTargetWorldObject()); - } - - void Register() override - { - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout_SpellScript::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ENEMY); - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout_SpellScript::FilterTargets, EFFECT_2, TARGET_UNIT_SRC_AREA_ENEMY); - } - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_intimidating_shout_SpellScript(); - } + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ENEMY); + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_intimidating_shout::FilterTargets, EFFECT_2, TARGET_UNIT_SRC_AREA_ENEMY); + } }; // -84583 Lambs to the Slaughter -class spell_warr_lambs_to_the_slaughter : public SpellScriptLoader +class spell_warr_lambs_to_the_slaughter : public AuraScript { - public: - spell_warr_lambs_to_the_slaughter() : SpellScriptLoader("spell_warr_lambs_to_the_slaughter") { } + PrepareAuraScript(spell_warr_lambs_to_the_slaughter); - class spell_warr_lambs_to_the_slaughter_AuraScript : public AuraScript - { - PrepareAuraScript(spell_warr_lambs_to_the_slaughter_AuraScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_MORTAL_STRIKE, SPELL_WARRIOR_REND }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_MORTAL_STRIKE, SPELL_WARRIOR_REND }); - } + void OnProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo) + { + if (Aura* aur = eventInfo.GetProcTarget()->GetAura(SPELL_WARRIOR_REND, GetTarget()->GetGUID())) + aur->SetDuration(aur->GetSpellInfo()->GetMaxDuration(), true); - void OnProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo) - { - if (Aura* aur = eventInfo.GetProcTarget()->GetAura(SPELL_WARRIOR_REND, GetTarget()->GetGUID())) - aur->SetDuration(aur->GetSpellInfo()->GetMaxDuration(), true); + } - } - - void Register() override - { - OnEffectProc += AuraEffectProcFn(spell_warr_lambs_to_the_slaughter_AuraScript::OnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_lambs_to_the_slaughter_AuraScript(); - } + void Register() override + { + OnEffectProc += AuraEffectProcFn(spell_warr_lambs_to_the_slaughter::OnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); + } }; /// Updated 4.3.4 // 12975 - Last Stand -class spell_warr_last_stand : public SpellScriptLoader +class spell_warr_last_stand : public SpellScript { - public: - spell_warr_last_stand() : SpellScriptLoader("spell_warr_last_stand") { } + PrepareSpellScript(spell_warr_last_stand); - class spell_warr_last_stand_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_last_stand_SpellScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_LAST_STAND_TRIGGERED }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_LAST_STAND_TRIGGERED }); - } + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + int32 healthModSpellBasePoints0 = int32(caster->CountPctFromMaxHealth(GetEffectValue())); + caster->CastCustomSpell(caster, SPELL_WARRIOR_LAST_STAND_TRIGGERED, &healthModSpellBasePoints0, nullptr, nullptr, true, nullptr); + } - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Unit* caster = GetCaster(); - int32 healthModSpellBasePoints0 = int32(caster->CountPctFromMaxHealth(GetEffectValue())); - caster->CastCustomSpell(caster, SPELL_WARRIOR_LAST_STAND_TRIGGERED, &healthModSpellBasePoints0, nullptr, nullptr, true, nullptr); - } - - void Register() override - { - // add dummy effect spell handler to Last Stand - OnEffectHit += SpellEffectFn(spell_warr_last_stand_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_last_stand_SpellScript(); - } + void Register() override + { + // add dummy effect spell handler to Last Stand + OnEffectHit += SpellEffectFn(spell_warr_last_stand::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } }; // 7384 - Overpower -class spell_warr_overpower : public SpellScriptLoader +class spell_warr_overpower : public SpellScript { - public: - spell_warr_overpower() : SpellScriptLoader("spell_warr_overpower") { } + PrepareSpellScript(spell_warr_overpower); - class spell_warr_overpower_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_overpower_SpellScript); + void HandleEffect(SpellEffIndex /*effIndex*/) + { + uint32 spellId = 0; + if (GetCaster()->HasAura(SPELL_WARRIOR_UNRELENTING_ASSAULT_RANK_1)) + spellId = SPELL_WARRIOR_UNRELENTING_ASSAULT_TRIGGER_1; + else if (GetCaster()->HasAura(SPELL_WARRIOR_UNRELENTING_ASSAULT_RANK_2)) + spellId = SPELL_WARRIOR_UNRELENTING_ASSAULT_TRIGGER_2; - void HandleEffect(SpellEffIndex /*effIndex*/) - { - uint32 spellId = 0; - if (GetCaster()->HasAura(SPELL_WARRIOR_UNRELENTING_ASSAULT_RANK_1)) - spellId = SPELL_WARRIOR_UNRELENTING_ASSAULT_TRIGGER_1; - else if (GetCaster()->HasAura(SPELL_WARRIOR_UNRELENTING_ASSAULT_RANK_2)) - spellId = SPELL_WARRIOR_UNRELENTING_ASSAULT_TRIGGER_2; + if (!spellId) + return; - if (!spellId) - return; + if (Player* target = GetHitPlayer()) + if (target->IsNonMeleeSpellCast(false, false, true)) // UNIT_STATE_CASTING should not be used here, it's present during a tick for instant casts + target->CastSpell(target, spellId, true); + } - if (Player* target = GetHitPlayer()) - if (target->IsNonMeleeSpellCast(false, false, true)) // UNIT_STATE_CASTING should not be used here, it's present during a tick for instant casts - target->CastSpell(target, spellId, true); - } - - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_warr_overpower_SpellScript::HandleEffect, EFFECT_0, SPELL_EFFECT_ANY); - } - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_overpower_SpellScript(); - } + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_warr_overpower::HandleEffect, EFFECT_0, SPELL_EFFECT_ANY); + } }; // 97462 - Rallying Cry -class spell_warr_rallying_cry : public SpellScriptLoader +class spell_warr_rallying_cry : public SpellScript { - public: - spell_warr_rallying_cry() : SpellScriptLoader("spell_warr_rallying_cry") { } + PrepareSpellScript(spell_warr_rallying_cry); - class spell_warr_rallying_cry_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_rallying_cry_SpellScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_RALLYING_CRY }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_RALLYING_CRY }); - } + bool Load() override + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } - bool Load() override - { - return GetCaster()->GetTypeId() == TYPEID_PLAYER; - } + void HandleScript(SpellEffIndex /*effIndex*/) + { + int32 basePoints0 = int32(GetHitUnit()->CountPctFromMaxHealth(GetEffectValue())); - void HandleScript(SpellEffIndex /*effIndex*/) - { - int32 basePoints0 = int32(GetHitUnit()->CountPctFromMaxHealth(GetEffectValue())); + GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_WARRIOR_RALLYING_CRY, &basePoints0, nullptr, nullptr, true); + } - GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_WARRIOR_RALLYING_CRY, &basePoints0, nullptr, nullptr, true); - } - - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_warr_rallying_cry_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_rallying_cry_SpellScript(); - } + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_warr_rallying_cry::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY); + } }; // 94009 - Rend -class spell_warr_rend : public SpellScriptLoader +class spell_warr_rend : public AuraScript { - public: - spell_warr_rend() : SpellScriptLoader("spell_warr_rend") { } + PrepareAuraScript(spell_warr_rend); - class spell_warr_rend_AuraScript : public AuraScript + void CalculateAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated) + { + if (Unit* caster = GetCaster()) { - PrepareAuraScript(spell_warr_rend_AuraScript); + canBeRecalculated = false; - void CalculateAmount(AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated) - { - if (Unit* caster = GetCaster()) - { - canBeRecalculated = false; - - // $0.25 * (($MWB + $mwb) / 2 + $AP / 14 * $MWS) bonus per tick - float ap = caster->GetTotalAttackPowerValue(BASE_ATTACK); - int32 mws = caster->GetAttackTime(BASE_ATTACK); - float mwbMin = caster->GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE); - float mwbMax = caster->GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE); - float mwb = ((mwbMin + mwbMax) / 2 + ap * mws / 14000) * 0.25f; - amount += int32(caster->ApplyEffectModifiers(GetSpellInfo(), aurEff->GetEffIndex(), mwb)); - } - } - - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_warr_rend_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_rend_AuraScript(); + // $0.25 * (($MWB + $mwb) / 2 + $AP / 14 * $MWS) bonus per tick + float ap = caster->GetTotalAttackPowerValue(BASE_ATTACK); + int32 mws = caster->GetAttackTime(BASE_ATTACK); + float mwbMin = caster->GetWeaponDamageRange(BASE_ATTACK, MINDAMAGE); + float mwbMax = caster->GetWeaponDamageRange(BASE_ATTACK, MAXDAMAGE); + float mwb = ((mwbMin + mwbMax) / 2 + ap * mws / 14000) * 0.25f; + amount += int32(caster->ApplyEffectModifiers(GetSpellInfo(), aurEff->GetEffIndex(), mwb)); } + } + + void Register() override + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_warr_rend::CalculateAmount, EFFECT_0, SPELL_AURA_PERIODIC_DAMAGE); + } }; // 20230 - Retaliation -class spell_warr_retaliation : public SpellScriptLoader +class spell_warr_retaliation : public AuraScript { - public: - spell_warr_retaliation() : SpellScriptLoader("spell_warr_retaliation") { } + PrepareAuraScript(spell_warr_retaliation); - class spell_warr_retaliation_AuraScript : public AuraScript - { - PrepareAuraScript(spell_warr_retaliation_AuraScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_RETALIATION_DAMAGE }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_RETALIATION_DAMAGE }); - } + bool CheckProc(ProcEventInfo& eventInfo) + { + // check attack comes not from behind and warrior is not stunned + return GetTarget()->isInFront(eventInfo.GetActor(), float(M_PI)) && !GetTarget()->HasUnitState(UNIT_STATE_STUNNED); + } - bool CheckProc(ProcEventInfo& eventInfo) - { - // check attack comes not from behind and warrior is not stunned - return GetTarget()->isInFront(eventInfo.GetActor(), float(M_PI)) && !GetTarget()->HasUnitState(UNIT_STATE_STUNNED); - } + void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + PreventDefaultAction(); + GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_WARRIOR_RETALIATION_DAMAGE, true, nullptr, aurEff); + } - void HandleEffectProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - GetTarget()->CastSpell(eventInfo.GetProcTarget(), SPELL_WARRIOR_RETALIATION_DAMAGE, true, nullptr, aurEff); - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_warr_retaliation_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_warr_retaliation_AuraScript::HandleEffectProc, EFFECT_0, SPELL_AURA_DUMMY); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_retaliation_AuraScript(); - } + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_warr_retaliation::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_warr_retaliation::HandleEffectProc, EFFECT_0, SPELL_AURA_DUMMY); + } }; // 64380, 65941 - Shattering Throw -class spell_warr_shattering_throw : public SpellScriptLoader +class spell_warr_shattering_throw : public SpellScript { - public: - spell_warr_shattering_throw() : SpellScriptLoader("spell_warr_shattering_throw") { } + PrepareSpellScript(spell_warr_shattering_throw); - class spell_warr_shattering_throw_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_shattering_throw_SpellScript); + void HandleScript(SpellEffIndex effIndex) + { + PreventHitDefaultEffect(effIndex); - void HandleScript(SpellEffIndex effIndex) - { - PreventHitDefaultEffect(effIndex); + // remove shields, will still display immune to damage part + if (Unit* target = GetHitUnit()) + target->RemoveAurasWithMechanic(1 << MECHANIC_IMMUNE_SHIELD, AURA_REMOVE_BY_ENEMY_SPELL); + } - // remove shields, will still display immune to damage part - if (Unit* target = GetHitUnit()) - target->RemoveAurasWithMechanic(1 << MECHANIC_IMMUNE_SHIELD, AURA_REMOVE_BY_ENEMY_SPELL); - } - - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_warr_shattering_throw_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_shattering_throw_SpellScript(); - } + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_warr_shattering_throw::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } }; /// Updated 4.3.4 @@ -655,213 +524,161 @@ class spell_warr_slam : public SpellScript } }; -class spell_warr_second_wind_proc : public SpellScriptLoader +class spell_warr_second_wind_proc : public AuraScript { - public: - spell_warr_second_wind_proc() : SpellScriptLoader("spell_warr_second_wind_proc") { } + PrepareAuraScript(spell_warr_second_wind_proc); - class spell_warr_second_wind_proc_AuraScript : public AuraScript - { - PrepareAuraScript(spell_warr_second_wind_proc_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo( { - return ValidateSpellInfo( - { - SPELL_WARRIOR_SECOND_WIND_PROC_RANK_1, - SPELL_WARRIOR_SECOND_WIND_PROC_RANK_2, - SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_1, - SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_2 - }); - } + SPELL_WARRIOR_SECOND_WIND_PROC_RANK_1, + SPELL_WARRIOR_SECOND_WIND_PROC_RANK_2, + SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_1, + SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_2 + }); + } - bool CheckProc(ProcEventInfo& eventInfo) - { - if (eventInfo.GetProcTarget() == GetTarget()) - return false; - if (!eventInfo.GetDamageInfo()->GetSpellInfo() || !(eventInfo.GetDamageInfo()->GetSpellInfo()->GetAllEffectsMechanicMask() & ((1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN)))) - return false; - return true; - } + bool CheckProc(ProcEventInfo& eventInfo) + { + if (eventInfo.GetProcTarget() == GetTarget()) + return false; + if (!eventInfo.GetDamageInfo()->GetSpellInfo() || !(eventInfo.GetDamageInfo()->GetSpellInfo()->GetAllEffectsMechanicMask() & ((1 << MECHANIC_ROOT) | (1 << MECHANIC_STUN)))) + return false; + return true; + } - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/) - { - PreventDefaultAction(); - uint32 spellId = 0; + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& /*eventInfo*/) + { + PreventDefaultAction(); + uint32 spellId = 0; - if (GetSpellInfo()->Id == SPELL_WARRIOR_SECOND_WIND_PROC_RANK_1) - spellId = SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_1; - else if (GetSpellInfo()->Id == SPELL_WARRIOR_SECOND_WIND_PROC_RANK_2) - spellId = SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_2; - if (!spellId) - return; + if (GetSpellInfo()->Id == SPELL_WARRIOR_SECOND_WIND_PROC_RANK_1) + spellId = SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_1; + else if (GetSpellInfo()->Id == SPELL_WARRIOR_SECOND_WIND_PROC_RANK_2) + spellId = SPELL_WARRIOR_SECOND_WIND_TRIGGER_RANK_2; + if (!spellId) + return; - GetTarget()->CastSpell(GetTarget(), spellId, true, nullptr, aurEff); + GetTarget()->CastSpell(GetTarget(), spellId, true, nullptr, aurEff); - } + } - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_warr_second_wind_proc_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_warr_second_wind_proc_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); - } - - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_second_wind_proc_AuraScript(); - } + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_warr_second_wind_proc::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_warr_second_wind_proc::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); + } }; -class spell_warr_second_wind_trigger : public SpellScriptLoader +class spell_warr_second_wind_trigger : public AuraScript { - public: - spell_warr_second_wind_trigger() : SpellScriptLoader("spell_warr_second_wind_trigger") { } + PrepareAuraScript(spell_warr_second_wind_trigger); - class spell_warr_second_wind_trigger_AuraScript : public AuraScript - { - PrepareAuraScript(spell_warr_second_wind_trigger_AuraScript); + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) + { + amount = int32(GetUnitOwner()->CountPctFromMaxHealth(amount)); + } - void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) - { - amount = int32(GetUnitOwner()->CountPctFromMaxHealth(amount)); - } - - void Register() override - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_warr_second_wind_trigger_AuraScript::CalculateAmount, EFFECT_1, SPELL_AURA_PERIODIC_HEAL); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_second_wind_trigger_AuraScript(); - } + void Register() override + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_warr_second_wind_trigger::CalculateAmount, EFFECT_1, SPELL_AURA_PERIODIC_HEAL); + } }; // 52437 - Sudden Death -class spell_warr_sudden_death : public SpellScriptLoader +class spell_warr_sudden_death : public AuraScript { - public: - spell_warr_sudden_death() : SpellScriptLoader("spell_warr_sudden_death") { } + PrepareAuraScript(spell_warr_sudden_death); - class spell_warr_sudden_death_AuraScript : public AuraScript - { - PrepareAuraScript(spell_warr_sudden_death_AuraScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH }); - } + void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + // Remove cooldown on Colossus Smash + if (Player* player = GetTarget()->ToPlayer()) + player->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_COLOSSUS_SMASH, true); + } - void HandleApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - // Remove cooldown on Colossus Smash - if (Player* player = GetTarget()->ToPlayer()) - player->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_COLOSSUS_SMASH, true); - } - - void Register() override - { - AfterEffectApply += AuraEffectRemoveFn(spell_warr_sudden_death_AuraScript::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); // correct? - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_sudden_death_AuraScript(); - } + void Register() override + { + AfterEffectApply += AuraEffectRemoveFn(spell_warr_sudden_death::HandleApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); // correct? + } }; // 12328, 18765, 35429 - Sweeping Strikes -class spell_warr_sweeping_strikes : public SpellScriptLoader +class spell_warr_sweeping_strikes : public AuraScript { - public: - spell_warr_sweeping_strikes() : SpellScriptLoader("spell_warr_sweeping_strikes") { } + PrepareAuraScript(spell_warr_sweeping_strikes); - class spell_warr_sweeping_strikes_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo( + { + SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, + SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2 + }); + } + + bool CheckProc(ProcEventInfo& eventInfo) + { + _procTarget = eventInfo.GetActor()->SelectNearbyTarget(eventInfo.GetProcTarget()); + return _procTarget != nullptr; + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + PreventDefaultAction(); + if (eventInfo.GetDamageInfo()) { - PrepareAuraScript(spell_warr_sweeping_strikes_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override + SpellInfo const* spellInfo = eventInfo.GetDamageInfo()->GetSpellInfo(); + if (spellInfo && (spellInfo->Id == SPELL_WARRIOR_BLADESTORM_PERIODIC_WHIRLWIND || (spellInfo->Id == SPELL_WARRIOR_EXECUTE && !_procTarget->HasAuraState(AURA_STATE_HEALTHLESS_20_PERCENT)))) { - return ValidateSpellInfo({ SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2 }); + // If triggered by Execute (while target is not under 20% hp) or Bladestorm deals normalized weapon damage + GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2, true, nullptr, aurEff); } - - bool CheckProc(ProcEventInfo& eventInfo) + else { - _procTarget = eventInfo.GetActor()->SelectNearbyTarget(eventInfo.GetProcTarget()); - return _procTarget != nullptr; + int32 damage = eventInfo.GetDamageInfo()->GetDamage(); + GetTarget()->CastCustomSpell(SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, SPELLVALUE_BASE_POINT0, damage, _procTarget, true, nullptr, aurEff); } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - if (eventInfo.GetDamageInfo()) - { - SpellInfo const* spellInfo = eventInfo.GetDamageInfo()->GetSpellInfo(); - if (spellInfo && (spellInfo->Id == SPELL_WARRIOR_BLADESTORM_PERIODIC_WHIRLWIND || (spellInfo->Id == SPELL_WARRIOR_EXECUTE && !_procTarget->HasAuraState(AURA_STATE_HEALTHLESS_20_PERCENT)))) - { - // If triggered by Execute (while target is not under 20% hp) or Bladestorm deals normalized weapon damage - GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2, true, nullptr, aurEff); - } - else - { - int32 damage = eventInfo.GetDamageInfo()->GetDamage(); - GetTarget()->CastCustomSpell(SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, SPELLVALUE_BASE_POINT0, damage, _procTarget, true, nullptr, aurEff); - } - } - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_warr_sweeping_strikes_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_warr_sweeping_strikes_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); - } - - Unit* _procTarget = nullptr; - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_sweeping_strikes_AuraScript(); } + } + + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_warr_sweeping_strikes::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_warr_sweeping_strikes::HandleProc, EFFECT_0, SPELL_AURA_DUMMY); + } +private: + Unit* _procTarget = nullptr; }; // -46951 - Sword and Board -class spell_warr_sword_and_board : public SpellScriptLoader +class spell_warr_sword_and_board : public AuraScript { - public: - spell_warr_sword_and_board() : SpellScriptLoader("spell_warr_sword_and_board") { } + PrepareAuraScript(spell_warr_sword_and_board); - class spell_warr_sword_and_board_AuraScript : public AuraScript - { - PrepareAuraScript(spell_warr_sword_and_board_AuraScript); +private: + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_SHIELD_SLAM }); + } - private: - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_SHIELD_SLAM }); - } + void OnProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*eventInfo*/) + { + // Remove cooldown on Shield Slam + if (Player* player = GetTarget()->ToPlayer()) + player->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_SHIELD_SLAM, true); + } - void OnProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*eventInfo*/) - { - // Remove cooldown on Shield Slam - if (Player* player = GetTarget()->ToPlayer()) - player->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_SHIELD_SLAM, true); - } - - void Register() override - { - OnEffectProc += AuraEffectProcFn(spell_warr_sword_and_board_AuraScript::OnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); - } - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_sword_and_board_AuraScript(); - } + void Register() override + { + OnEffectProc += AuraEffectProcFn(spell_warr_sword_and_board::OnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); + } }; // 34428 - Victory Rush @@ -913,89 +730,72 @@ class spell_warr_victory_rush : public SpellScript }; // 50720 - Vigilance -class spell_warr_vigilance : public SpellScriptLoader +class spell_warr_vigilance : public AuraScript { - public: - spell_warr_vigilance() : SpellScriptLoader("spell_warr_vigilance") { } + PrepareAuraScript(spell_warr_vigilance); - class spell_warr_vigilance_AuraScript : public AuraScript + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_VENGEANCE }); + } + + bool CheckProc(ProcEventInfo& eventInfo) + { + _procTarget = GetCaster(); + return _procTarget && eventInfo.GetDamageInfo(); + } + + void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) + { + PreventDefaultAction(); + int32 damage = std::min(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue()), CalculatePct(_procTarget->GetMaxHealth(), 10)); + + GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_VIGILANCE_PROC, true, nullptr, aurEff); + _procTarget->CastCustomSpell(_procTarget, SPELL_WARRIOR_VENGEANCE, &damage, &damage, &damage, true, nullptr, aurEff); + } + + void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + if (Unit* caster = GetCaster()) { - PrepareAuraScript(spell_warr_vigilance_AuraScript); - - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_VENGEANCE }); - } - - bool CheckProc(ProcEventInfo& eventInfo) - { - _procTarget = GetCaster(); - return _procTarget && eventInfo.GetDamageInfo(); - } - - void HandleProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo) - { - PreventDefaultAction(); - int32 damage = std::min(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue()), CalculatePct(_procTarget->GetMaxHealth(), 10)); - - GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_VIGILANCE_PROC, true, nullptr, aurEff); - _procTarget->CastCustomSpell(_procTarget, SPELL_WARRIOR_VENGEANCE, &damage, &damage, &damage, true, nullptr, aurEff); - } - - void HandleRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - if (Unit* caster = GetCaster()) - { - if (caster->HasAura(SPELL_WARRIOR_VENGEANCE)) - caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VENGEANCE); - } - } - - void Register() override - { - DoCheckProc += AuraCheckProcFn(spell_warr_vigilance_AuraScript::CheckProc); - OnEffectProc += AuraEffectProcFn(spell_warr_vigilance_AuraScript::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); - OnEffectRemove += AuraEffectRemoveFn(spell_warr_vigilance_AuraScript::HandleRemove, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL); - } - - Unit* _procTarget = nullptr; - }; - - AuraScript* GetAuraScript() const override - { - return new spell_warr_vigilance_AuraScript(); + if (caster->HasAura(SPELL_WARRIOR_VENGEANCE)) + caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VENGEANCE); } + } + + void Register() override + { + DoCheckProc += AuraCheckProcFn(spell_warr_vigilance::CheckProc); + OnEffectProc += AuraEffectProcFn(spell_warr_vigilance::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL); + OnEffectRemove += AuraEffectRemoveFn(spell_warr_vigilance::HandleRemove, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL); + } +private: + Unit* _procTarget = nullptr; }; // 50725 Vigilance -class spell_warr_vigilance_trigger : public SpellScriptLoader +class spell_warr_vigilance_trigger : public SpellScript { - public: - spell_warr_vigilance_trigger() : SpellScriptLoader("spell_warr_vigilance_trigger") { } + PrepareSpellScript(spell_warr_vigilance_trigger); - class spell_warr_vigilance_trigger_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_vigilance_trigger_SpellScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_TAUNT }); + } - void HandleScript(SpellEffIndex effIndex) - { - PreventHitDefaultEffect(effIndex); + void HandleScript(SpellEffIndex effIndex) + { + PreventHitDefaultEffect(effIndex); - // Remove Taunt cooldown - if (Player* target = GetHitPlayer()) - target->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_TAUNT, true); - } + // Remove Taunt cooldown + if (Player* target = GetHitPlayer()) + target->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_TAUNT, true); + } - void Register() override - { - OnEffectHitTarget += SpellEffectFn(spell_warr_vigilance_trigger_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_vigilance_trigger_SpellScript(); - } + void Register() override + { + OnEffectHitTarget += SpellEffectFn(spell_warr_vigilance_trigger::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } }; // 76838 - Strikes of Opportunity @@ -1028,57 +828,46 @@ class spell_warr_strikes_of_opportunity : public AuraScript } }; -class spell_warr_thunder_clap : public SpellScriptLoader +class spell_warr_thunder_clap : public SpellScript { - public: - spell_warr_thunder_clap() : SpellScriptLoader("spell_warr_thunder_clap") { } + PrepareSpellScript(spell_warr_thunder_clap); - class spell_warr_thunder_clap_SpellScript : public SpellScript - { - PrepareSpellScript(spell_warr_thunder_clap_SpellScript); + bool Validate(SpellInfo const* /*spellInfo*/) override + { + return ValidateSpellInfo({ SPELL_WARRIOR_REND }); + } - bool Validate(SpellInfo const* /*spellInfo*/) override - { - return ValidateSpellInfo({ SPELL_WARRIOR_REND }); - } + bool Load() override + { + _allowRendSpread = false; + if (AuraEffect* aurEff = GetCaster()->GetDummyAuraEffect(SPELLFAMILY_WARRIOR, WARRIOR_ICON_ID_BLOOD_AND_THUNDER, EFFECT_0)) + return roll_chance_i(aurEff->GetAmount()); - bool Load() override - { - allowRendSpread = false; - if (AuraEffect* aurEff = GetCaster()->GetDummyAuraEffect(SPELLFAMILY_WARRIOR, WARRIOR_ICON_ID_BLOOD_AND_THUNDER, EFFECT_0)) - return roll_chance_i(aurEff->GetAmount()); + return false; + } - return false; - } + void FilterTargets(std::list& unitList) + { + for (std::list::const_iterator itr = unitList.begin(); itr != unitList.end(); ++itr) + if (Unit* target = (*itr)->ToUnit()) + if (target->HasAura(SPELL_WARRIOR_REND)) + _allowRendSpread = true; + } - void FilterTargets(std::list& unitList) - { - for (std::list::const_iterator itr = unitList.begin(); itr != unitList.end(); ++itr) - if (Unit* target = (*itr)->ToUnit()) - if (target->HasAura(SPELL_WARRIOR_REND)) - allowRendSpread = true; - } + void HandleHit(SpellEffIndex /*effIndex*/) + { + if (_allowRendSpread) + GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_REND, true); + } - void HandleHit(SpellEffIndex /*effIndex*/) - { - if (allowRendSpread) - GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_REND, true); - } + void Register() override + { + OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_thunder_clap::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY); + OnEffectHitTarget += SpellEffectFn(spell_warr_thunder_clap::HandleHit, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE); + } - void Register() override - { - OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_warr_thunder_clap_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY); - OnEffectHitTarget += SpellEffectFn(spell_warr_thunder_clap_SpellScript::HandleHit, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE); - } - - private: - bool allowRendSpread; - }; - - SpellScript* GetSpellScript() const override - { - return new spell_warr_thunder_clap_SpellScript(); - } +private: + bool _allowRendSpread; }; class spell_warr_shield_specialization : public AuraScript @@ -1220,31 +1009,31 @@ void AddSC_warrior_spell_scripts() RegisterSpellScript(spell_warr_bloodthirst_heal); RegisterSpellScript(spell_warr_charge); RegisterSpellScript(spell_warr_concussion_blow); - new spell_warr_deep_wounds(); + RegisterAuraScript(spell_warr_deep_wounds); RegisterSpellScript(spell_warr_devastate); - new spell_warr_execute(); - new spell_warr_glyph_of_sunder_armor(); + RegisterSpellScript(spell_warr_execute); + RegisterAuraScript(spell_warr_glyph_of_sunder_armor); RegisterSpellScript(spell_warr_heroic_leap); - new spell_warr_intimidating_shout(); - new spell_warr_lambs_to_the_slaughter(); - new spell_warr_last_stand(); - new spell_warr_overpower(); - new spell_warr_rallying_cry(); - new spell_warr_rend(); - new spell_warr_retaliation(); - new spell_warr_second_wind_proc(); - new spell_warr_second_wind_trigger(); - new spell_warr_shattering_throw(); + RegisterSpellScript(spell_warr_intimidating_shout); + RegisterAuraScript(spell_warr_lambs_to_the_slaughter); + RegisterSpellScript(spell_warr_last_stand); + RegisterSpellScript(spell_warr_overpower); + RegisterSpellScript(spell_warr_rallying_cry); + RegisterAuraScript(spell_warr_rend); + RegisterAuraScript(spell_warr_retaliation); + RegisterAuraScript(spell_warr_second_wind_proc); + RegisterAuraScript(spell_warr_second_wind_trigger); + RegisterSpellScript(spell_warr_shattering_throw); RegisterAuraScript(spell_warr_shield_specialization); RegisterSpellScript(spell_warr_shockwave); RegisterSpellScript(spell_warr_slam); RegisterAuraScript(spell_warr_strikes_of_opportunity); - new spell_warr_sudden_death(); - new spell_warr_sweeping_strikes(); - new spell_warr_sword_and_board(); - new spell_warr_thunder_clap(); + RegisterAuraScript(spell_warr_sudden_death); + RegisterAuraScript(spell_warr_sweeping_strikes); + RegisterAuraScript(spell_warr_sword_and_board); + RegisterSpellScript(spell_warr_thunder_clap); RegisterSpellScript(spell_warr_victory_rush); - new spell_warr_vigilance(); - new spell_warr_vigilance_trigger(); + RegisterAuraScript(spell_warr_vigilance); + RegisterSpellScript(spell_warr_vigilance_trigger); RegisterSpellScript(spell_warr_whirlwind); }