spell_hunter.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
/*
 * Scripts for spells with SPELLFAMILY_HUNTER, SPELLFAMILY_PET and SPELLFAMILY_GENERIC spells used by hunter players.
 * Ordered alphabetically using scriptname.
 * Scriptnames of files in this file should be prefixed with "spell_hun_".
 */
 
#include "ScriptMgr.h"
#include "CellImpl.h"
#include "GridNotifiersImpl.h"
#include "Pet.h"
#include "SpellAuraEffects.h"
#include "SpellHistory.h"
#include "SpellMgr.h"
#include "SpellScript.h"
 
enum HunterSpells
{
 SPELL_HUNTER_A_MURDER_OF_CROWS_DAMAGE = 131900,
 SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_1 = 131637,
 SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_2 = 131951,
 SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_3 = 131952,
 SPELL_HUNTER_ASPECT_CHEETAH_SLOW = 186258,
 SPELL_HUNTER_ASPECT_OF_THE_TURTLE_PACIFY_AURA = 205769,
 SPELL_HUNTER_EXHILARATION = 109304,
 SPELL_HUNTER_EXHILARATION_PET = 128594,
 SPELL_HUNTER_EXHILARATION_R2 = 231546,
 SPELL_HUNTER_EXPLOSIVE_SHOT_DAMAGE = 212680,
 SPELL_HUNTER_LATENT_POISON_STACK = 378015,
 SPELL_HUNTER_LATENT_POISON_DAMAGE = 378016,
 SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK = 336903,
 SPELL_HUNTER_LATENT_POISON_INJECTORS_DAMAGE = 336904,
 SPELL_HUNTER_LONE_WOLF = 155228,
 SPELL_HUNTER_MASTERS_CALL_TRIGGERED = 62305,
 SPELL_HUNTER_MISDIRECTION = 34477,
 SPELL_HUNTER_MISDIRECTION_PROC = 35079,
 SPELL_HUNTER_MULTI_SHOT_FOCUS = 213363,
 SPELL_HUNTER_PET_LAST_STAND_TRIGGERED = 53479,
 SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED = 54114,
 SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF = 55711,
 SPELL_HUNTER_POSTHASTE_INCREASE_SPEED = 118922,
 SPELL_HUNTER_POSTHASTE_TALENT = 109215,
 SPELL_HUNTER_RAPID_FIRE_DAMAGE = 257045,
 SPELL_HUNTER_RAPID_FIRE_ENERGIZE = 263585,
 SPELL_HUNTER_STEADY_SHOT_FOCUS = 77443,
 SPELL_HUNTER_T9_4P_GREATNESS = 68130,
 SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE = 394371,
 SPELL_ROAR_OF_SACRIFICE_TRIGGERED = 67481
};
 
enum MiscSpells
{
 SPELL_DRAENEI_GIFT_OF_THE_NAARU = 59543,
};
 
// 131894 - A Murder of Crows
class spell_hun_a_murder_of_crows : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo
 ({
 SPELL_HUNTER_A_MURDER_OF_CROWS_DAMAGE,
 SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_1,
 SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_2,
 SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_3
 });
 }
 
 void HandleDummyTick(AuraEffect const* /*aurEff*/)
 {
 Unit* target = GetTarget();
 
 if (Unit* caster = GetCaster())
 caster->CastSpell(target, SPELL_HUNTER_A_MURDER_OF_CROWS_DAMAGE, true);
 
 target->CastSpell(target, SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_1, true);
 target->CastSpell(target, SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_2, true);
 target->CastSpell(target, SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_3, true);
 target->CastSpell(target, SPELL_HUNTER_A_MURDER_OF_CROWS_VISUAL_3, true); // not a mistake, it is intended to cast twice
 }
 
 void RemoveEffect(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_DEATH)
 if (Unit* caster = GetCaster())
 caster->GetSpellHistory()->ResetCooldown(GetId(), true);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_hun_a_murder_of_crows::HandleDummyTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 OnEffectRemove += AuraEffectRemoveFn(spell_hun_a_murder_of_crows::RemoveEffect, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 186257 - Aspect of the Cheetah
class spell_hun_aspect_cheetah : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo
 ({
 SPELL_HUNTER_ASPECT_CHEETAH_SLOW
 });
 }
 
 void HandleOnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_EXPIRE)
 GetTarget()->CastSpell(GetTarget(), SPELL_HUNTER_ASPECT_CHEETAH_SLOW, true);
 }
 
 void Register() override
 {
 AfterEffectRemove += AuraEffectRemoveFn(spell_hun_aspect_cheetah::HandleOnRemove, EFFECT_0, SPELL_AURA_MOD_INCREASE_SPEED, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 186265 - Aspect of the Turtle
class spell_hun_aspect_of_the_turtle : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_ASPECT_OF_THE_TURTLE_PACIFY_AURA });
 }
 
 void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 GetTarget()->CastSpell(GetTarget(), SPELL_HUNTER_ASPECT_OF_THE_TURTLE_PACIFY_AURA, true);
 }
 
 void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 GetTarget()->RemoveAurasDueToSpell(SPELL_HUNTER_ASPECT_OF_THE_TURTLE_PACIFY_AURA);
 }
 
 void Register() override
 {
 AfterEffectApply += AuraEffectApplyFn(spell_hun_aspect_of_the_turtle::OnApply, EFFECT_0, SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE, AURA_EFFECT_HANDLE_REAL);
 AfterEffectRemove += AuraEffectRemoveFn(spell_hun_aspect_of_the_turtle::OnRemove, EFFECT_0, SPELL_AURA_MOD_ATTACKER_MELEE_HIT_CHANCE, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 378750 - Cobra Sting
class spell_hun_cobra_sting : public AuraScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } });
 }
 
 bool RollProc(AuraEffect const* /*aurEff*/, ProcEventInfo& /*procInfo*/)
 {
 return roll_chance_i(GetEffect(EFFECT_1)->GetAmount());
 }
 
 void Register() override
 {
 DoCheckEffectProc += AuraCheckEffectProcFn(spell_hun_cobra_sting::RollProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
 }
};
 
// 109304 - Exhilaration
class spell_hun_exhilaration : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_EXHILARATION_R2, SPELL_HUNTER_LONE_WOLF });
 }
 
 void HandleOnHit()
 {
 if (GetCaster()->HasAura(SPELL_HUNTER_EXHILARATION_R2) && !GetCaster()->HasAura(SPELL_HUNTER_LONE_WOLF))
 GetCaster()->CastSpell(nullptr, SPELL_HUNTER_EXHILARATION_PET, true);
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_hun_exhilaration::HandleOnHit);
 }
};
 
// 212431 - Explosive Shot
class spell_hun_explosive_shot : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_EXPLOSIVE_SHOT_DAMAGE });
 }
 
 void HandlePeriodic(AuraEffect const* /*aurEff*/)
 {
 if (Unit* caster = GetCaster())
 caster->CastSpell(GetTarget(), SPELL_HUNTER_EXPLOSIVE_SHOT_DAMAGE, true);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_hun_explosive_shot::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
// 212658 - Hunting Party
class spell_hun_hunting_party : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo(
 {
 SPELL_HUNTER_EXHILARATION,
 SPELL_HUNTER_EXHILARATION_PET
 });
 }
 
 void HandleProc(AuraEffect* aurEff, ProcEventInfo& /*eventInfo*/)
 {
 PreventDefaultAction();
 GetTarget()->GetSpellHistory()->ModifyCooldown(SPELL_HUNTER_EXHILARATION, -Seconds(aurEff->GetAmount()));
 GetTarget()->GetSpellHistory()->ModifyCooldown(SPELL_HUNTER_EXHILARATION_PET, -Seconds(aurEff->GetAmount()));
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_hun_hunting_party::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
// 53478 - Last Stand Pet
class spell_hun_last_stand_pet : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_PET_LAST_STAND_TRIGGERED });
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 Unit* caster = GetCaster();
 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
 args.AddSpellBP0(caster->CountPctFromMaxHealth(30));
 caster->CastSpell(caster, SPELL_HUNTER_PET_LAST_STAND_TRIGGERED, args);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_hun_last_stand_pet::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 378016 - Latent Poison
class spell_hun_latent_poison_damage : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_STACK });
 }
 
 void CalculateDamage()
 {
 if (Aura* stack = GetHitUnit()->GetAura(SPELL_HUNTER_LATENT_POISON_STACK, GetCaster()->GetGUID()))
 {
 SetHitDamage(GetHitDamage() * stack->GetStackAmount());
 stack->Remove();
 }
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_hun_latent_poison_damage::CalculateDamage);
 }
};
 
// 19434 - Aimed Shot
// 186270 - Raptor Strike
// 217200 - Barbed Shot
// 259387 - Mongoose Bite
class spell_hun_latent_poison_trigger : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_STACK, SPELL_HUNTER_LATENT_POISON_DAMAGE });
 }
 
 void TriggerDamage()
 {
 if (GetHitUnit()->HasAura(SPELL_HUNTER_LATENT_POISON_STACK, GetCaster()->GetGUID()))
 GetCaster()->CastSpell(GetHitUnit(), SPELL_HUNTER_LATENT_POISON_DAMAGE, GetSpell());
 }
 
 void Register() override
 {
 AfterHit += SpellHitFn(spell_hun_latent_poison_trigger::TriggerDamage);
 }
};
 
// 336904 - Latent Poison Injectors
class spell_hun_latent_poison_injectors_damage : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK });
 }
 
 void CalculateDamage()
 {
 if (Aura* stack = GetHitUnit()->GetAura(SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK, GetCaster()->GetGUID()))
 {
 SetHitDamage(GetHitDamage() * stack->GetStackAmount());
 stack->Remove();
 }
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_hun_latent_poison_injectors_damage::CalculateDamage);
 }
};
 
// 186270 - Raptor Strike
// 259387 - Mongoose Bite
class spell_hun_latent_poison_injectors_trigger : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK, SPELL_HUNTER_LATENT_POISON_INJECTORS_DAMAGE });
 }
 
 void TriggerDamage()
 {
 if (GetHitUnit()->HasAura(SPELL_HUNTER_LATENT_POISON_INJECTORS_STACK, GetCaster()->GetGUID()))
 GetCaster()->CastSpell(GetHitUnit(), SPELL_HUNTER_LATENT_POISON_INJECTORS_DAMAGE, GetSpell());
 }
 
 void Register() override
 {
 AfterHit += SpellHitFn(spell_hun_latent_poison_injectors_trigger::TriggerDamage);
 }
};
 
// 53271 - Masters Call
class spell_hun_masters_call : public SpellScript
{
 bool Validate(SpellInfo const* spellInfo) override
 {
 return ValidateSpellEffect({ { spellInfo->Id, EFFECT_0 } })
 && ValidateSpellInfo({ SPELL_HUNTER_MASTERS_CALL_TRIGGERED, uint32(spellInfo->GetEffect(EFFECT_0).CalcValue()) });
 }
 
 bool Load() override
 {
 return GetCaster()->GetTypeId() == TYPEID_PLAYER;
 }
 
 SpellCastResult DoCheckCast()
 {
 Guardian* pet = GetCaster()->ToPlayer()->GetGuardianPet();
 ASSERT(pet); // checked in Spell::CheckCast
 
 if (!pet->IsPet() || !pet->IsAlive())
 return SPELL_FAILED_NO_PET;
 
 // Do a mini Spell::CheckCasterAuras on the pet, no other way of doing this
 SpellCastResult result = SPELL_CAST_OK;
 uint32 const unitflag = pet->m_unitData->Flags;
 if (!pet->GetCharmerGUID().IsEmpty())
 result = SPELL_FAILED_CHARMED;
 else if (unitflag & UNIT_FLAG_STUNNED)
 result = SPELL_FAILED_STUNNED;
 else if (unitflag & UNIT_FLAG_FLEEING)
 result = SPELL_FAILED_FLEEING;
 else if (unitflag & UNIT_FLAG_CONFUSED)
 result = SPELL_FAILED_CONFUSED;
 
 if (result != SPELL_CAST_OK)
 return result;
 
 Unit* target = GetExplTargetUnit();
 if (!target)
 return SPELL_FAILED_BAD_TARGETS;
 
 if (!pet->IsWithinLOSInMap(target))
 return SPELL_FAILED_LINE_OF_SIGHT;
 
 return SPELL_CAST_OK;
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 GetCaster()->ToPlayer()->GetPet()->CastSpell(GetHitUnit(), GetEffectValue(), true);
 }
 
 void HandleScriptEffect(SpellEffIndex /*effIndex*/)
 {
 GetHitUnit()->CastSpell(nullptr, SPELL_HUNTER_MASTERS_CALL_TRIGGERED, true);
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_hun_masters_call::DoCheckCast);
 
 OnEffectHitTarget += SpellEffectFn(spell_hun_masters_call::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 OnEffectHitTarget += SpellEffectFn(spell_hun_masters_call::HandleScriptEffect, EFFECT_1, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 34477 - Misdirection
class spell_hun_misdirection : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_MISDIRECTION_PROC });
 }
 
 void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 if (GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_DEFAULT || GetTargetApplication()->GetRemoveMode() == AURA_REMOVE_BY_INTERRUPT)
 return;
 
 if (!GetTarget()->HasAura(SPELL_HUNTER_MISDIRECTION_PROC))
 GetTarget()->GetThreatManager().UnregisterRedirectThreat(SPELL_HUNTER_MISDIRECTION);
 }
 
 void HandleProc(AuraEffect* aurEff, ProcEventInfo& /*eventInfo*/)
 {
 PreventDefaultAction();
 GetTarget()->CastSpell(GetTarget(), SPELL_HUNTER_MISDIRECTION_PROC, aurEff);
 }
 
 void Register() override
 {
 AfterEffectRemove += AuraEffectRemoveFn(spell_hun_misdirection::OnRemove, EFFECT_1, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
 OnEffectProc += AuraEffectProcFn(spell_hun_misdirection::HandleProc, EFFECT_1, SPELL_AURA_DUMMY);
 }
};
 
// 35079 - Misdirection (Proc)
class spell_hun_misdirection_proc : public AuraScript
{
 void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
 {
 GetTarget()->GetThreatManager().UnregisterRedirectThreat(SPELL_HUNTER_MISDIRECTION);
 }
 
 void Register() override
 {
 AfterEffectRemove += AuraEffectRemoveFn(spell_hun_misdirection_proc::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL);
 }
};
 
// 2643 - Multi-Shot
class spell_hun_multi_shot : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_MULTI_SHOT_FOCUS });
 }
 
 bool Load() override
 {
 return GetCaster()->GetTypeId() == TYPEID_PLAYER;
 }
 
 void HandleOnHit()
 {
 // We need to check hunter's spec because it doesn't generate focus on other specs than MM
 if (GetCaster()->ToPlayer()->GetPrimarySpecialization() == ChrSpecialization::HunterMarksmanship)
 GetCaster()->CastSpell(GetCaster(), SPELL_HUNTER_MULTI_SHOT_FOCUS, true);
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_hun_multi_shot::HandleOnHit);
 }
};
 
// 55709 - Pet Heart of the Phoenix
class spell_hun_pet_heart_of_the_phoenix : public SpellScript
{
 bool Load() override
 {
 if (!GetCaster()->IsPet())
 return false;
 return true;
 }
 
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED, SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 Unit* caster = GetCaster();
 if (Unit* owner = caster->GetOwner())
 {
 if (!caster->HasAura(SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF))
 {
 CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
 args.AddSpellBP0(100);
 owner->CastSpell(caster, SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED, args);
 caster->CastSpell(caster, SPELL_HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF, true);
 }
 }
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_hun_pet_heart_of_the_phoenix::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 781 - Disengage
class spell_hun_posthaste : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_POSTHASTE_TALENT, SPELL_HUNTER_POSTHASTE_INCREASE_SPEED });
 }
 
 void HandleAfterCast()
 {
 if (GetCaster()->HasAura(SPELL_HUNTER_POSTHASTE_TALENT))
 {
 GetCaster()->RemoveMovementImpairingAuras(true);
 GetCaster()->CastSpell(GetCaster(), SPELL_HUNTER_POSTHASTE_INCREASE_SPEED, GetSpell());
 }
 }
 
 void Register() override
 {
 AfterCast += SpellCastFn(spell_hun_posthaste::HandleAfterCast);
 }
};
 
// 257044 - Rapid Fire
class spell_hun_rapid_fire : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_RAPID_FIRE_DAMAGE });
 }
 
 void HandlePeriodic(AuraEffect const* /*aurEff*/)
 {
 if (Unit* caster = GetCaster())
 caster->CastSpell(GetTarget(), SPELL_HUNTER_RAPID_FIRE_DAMAGE, true);
 }
 
 void Register() override
 {
 OnEffectPeriodic += AuraEffectPeriodicFn(spell_hun_rapid_fire::HandlePeriodic, EFFECT_1, SPELL_AURA_PERIODIC_DUMMY);
 }
};
 
// 257045 - Rapid Fire Damage
class spell_hun_rapid_fire_damage : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_RAPID_FIRE_ENERGIZE });
 }
 
 void HandleHit(SpellEffIndex /*effIndex*/)
 {
 GetCaster()->CastSpell(nullptr, SPELL_HUNTER_RAPID_FIRE_ENERGIZE, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_hun_rapid_fire_damage::HandleHit, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
 }
};
 
// 53480 - Roar of Sacrifice
class spell_hun_roar_of_sacrifice : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_ROAR_OF_SACRIFICE_TRIGGERED });
 }
 
 bool CheckProc(AuraEffect const* aurEff, ProcEventInfo& eventInfo)
 {
 DamageInfo* damageInfo = eventInfo.GetDamageInfo();
 if (!damageInfo || !(damageInfo->GetSchoolMask() & aurEff->GetMiscValue()))
 return false;
 
 if (!GetCaster())
 return false;
 
 return true;
 }
 
 void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 
 CastSpellExtraArgs args(aurEff);
 args.AddSpellBP0(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount()));
 eventInfo.GetActor()->CastSpell(GetCaster(), SPELL_ROAR_OF_SACRIFICE_TRIGGERED, args);
 }
 
 void Register() override
 {
 DoCheckEffectProc += AuraCheckEffectProcFn(spell_hun_roar_of_sacrifice::CheckProc, EFFECT_1, SPELL_AURA_DUMMY);
 OnEffectProc += AuraEffectProcFn(spell_hun_roar_of_sacrifice::HandleProc, EFFECT_1, SPELL_AURA_DUMMY);
 }
};
 
// 37506 - Scatter Shot
class spell_hun_scatter_shot : public SpellScript
{
 bool Load() override
 {
 return GetCaster()->GetTypeId() == TYPEID_PLAYER;
 }
 
 void HandleDummy(SpellEffIndex /*effIndex*/)
 {
 Player* caster = GetCaster()->ToPlayer();
 // break Auto Shot and autohit
 caster->InterruptSpell(CURRENT_AUTOREPEAT_SPELL);
 caster->AttackStop();
 caster->SendAttackSwingCancelAttack();
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_hun_scatter_shot::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
 }
};
 
// 56641 - Steady Shot
class spell_hun_steady_shot : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_STEADY_SHOT_FOCUS });
 }
 
 bool Load() override
 {
 return GetCaster()->GetTypeId() == TYPEID_PLAYER;
 }
 
 void HandleOnHit()
 {
 GetCaster()->CastSpell(GetCaster(), SPELL_HUNTER_STEADY_SHOT_FOCUS, true);
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_hun_steady_shot::HandleOnHit);
 }
};
 
// 1515 - Tame Beast
class spell_hun_tame_beast : public SpellScript
{
 static constexpr uint32 CallPetSpellIds[MAX_ACTIVE_PETS] =
 {
 883,
 83242,
 83243,
 83244,
 83245,
 };
 
 SpellCastResult CheckCast()
 {
 Player* caster = GetCaster()->ToPlayer();
 if (!caster)
 return SPELL_FAILED_DONT_REPORT;
 
 if (!GetExplTargetUnit())
 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
 if (Creature* target = GetExplTargetUnit()->ToCreature())
 {
 if (target->GetLevelForTarget(caster) > caster->GetLevel())
 return SPELL_FAILED_HIGHLEVEL;
 
 // use SMSG_PET_TAME_FAILURE?
 if (!target->GetCreatureTemplate()->IsTameable(caster->CanTameExoticPets(), target->GetCreatureDifficulty()))
 return SPELL_FAILED_BAD_TARGETS;
 
 if (PetStable const* petStable = caster->GetPetStable())
 {
 if (petStable->CurrentPetIndex)
 return SPELL_FAILED_ALREADY_HAVE_SUMMON;
 
 auto freeSlotItr = std::find_if(petStable->ActivePets.begin(), petStable->ActivePets.end(), [](Optional<PetStable::PetInfo> const& petInfo)
 {
 return !petInfo.has_value();
 });
 
 if (freeSlotItr == petStable->ActivePets.end())
 {
 caster->SendTameFailure(PetTameResult::TooMany);
 return SPELL_FAILED_DONT_REPORT;
 }
 
 // Check for known Call Pet X spells
 std::size_t freeSlotIndex = std::distance(petStable->ActivePets.begin(), freeSlotItr);
 if (!caster->HasSpell(CallPetSpellIds[freeSlotIndex]))
 {
 caster->SendTameFailure(PetTameResult::TooMany);
 return SPELL_FAILED_DONT_REPORT;
 }
 }
 
 if (!caster->GetCharmedGUID().IsEmpty())
 return SPELL_FAILED_ALREADY_HAVE_CHARM;
 
 if (!target->GetOwnerGUID().IsEmpty())
 {
 caster->SendTameFailure(PetTameResult::CreatureAlreadyOwned);
 return SPELL_FAILED_DONT_REPORT;
 }
 }
 else
 return SPELL_FAILED_BAD_IMPLICIT_TARGETS;
 
 return SPELL_CAST_OK;
 }
 
 void Register() override
 {
 OnCheckCast += SpellCheckCastFn(spell_hun_tame_beast::CheckCast);
 }
};
 
// 67151 - Item - Hunter T9 4P Bonus (Steady Shot)
class spell_hun_t9_4p_bonus : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_HUNTER_T9_4P_GREATNESS });
 }
 
 bool CheckProc(ProcEventInfo& eventInfo)
 {
 if (eventInfo.GetActor()->GetTypeId() == TYPEID_PLAYER && eventInfo.GetActor()->ToPlayer()->GetPet())
 return true;
 return false;
 }
 
 void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 Unit* caster = eventInfo.GetActor();
 
 caster->CastSpell(caster->ToPlayer()->GetPet(), SPELL_HUNTER_T9_4P_GREATNESS, aurEff);
 }
 
 void Register() override
 {
 DoCheckProc += AuraCheckProcFn(spell_hun_t9_4p_bonus::CheckProc);
 OnEffectProc += AuraEffectProcFn(spell_hun_t9_4p_bonus::HandleProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
 }
};
 
// 394366 - Find The Mark
class spell_hun_t29_2p_marksmanship_bonus : public AuraScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellEffect({ { SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, EFFECT_0 } })
 && sSpellMgr->AssertSpellInfo(SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, DIFFICULTY_NONE)->GetMaxTicks();
 }
 
 void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
 {
 PreventDefaultAction();
 
 Unit* caster = eventInfo.GetActor();
 uint32 ticks = sSpellMgr->AssertSpellInfo(SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, DIFFICULTY_NONE)->GetMaxTicks();
 uint32 damage = CalculatePct(eventInfo.GetDamageInfo()->GetOriginalDamage(), aurEff->GetAmount()) / ticks;
 
 caster->CastSpell(eventInfo.GetActionTarget(), SPELL_HUNTER_T29_2P_MARKSMANSHIP_DAMAGE, CastSpellExtraArgs(aurEff)
 .SetTriggeringSpell(eventInfo.GetProcSpell())
 .AddSpellMod(SPELLVALUE_BASE_POINT0, damage));
 }
 
 void Register() override
 {
 OnEffectProc += AuraEffectProcFn(spell_hun_t29_2p_marksmanship_bonus::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
 }
};
 
void AddSC_hunter_spell_scripts()
{
 RegisterSpellScript(spell_hun_a_murder_of_crows);
 RegisterSpellScript(spell_hun_aspect_cheetah);
 RegisterSpellScript(spell_hun_aspect_of_the_turtle);
 RegisterSpellScript(spell_hun_cobra_sting);
 RegisterSpellScript(spell_hun_exhilaration);
 RegisterSpellScript(spell_hun_explosive_shot);
 RegisterSpellScript(spell_hun_hunting_party);
 RegisterSpellScript(spell_hun_last_stand_pet);
 RegisterSpellScript(spell_hun_latent_poison_damage);
 RegisterSpellScript(spell_hun_latent_poison_trigger);
 RegisterSpellScript(spell_hun_latent_poison_injectors_damage);
 RegisterSpellScript(spell_hun_latent_poison_injectors_trigger);
 RegisterSpellScript(spell_hun_masters_call);
 RegisterSpellScript(spell_hun_misdirection);
 RegisterSpellScript(spell_hun_misdirection_proc);
 RegisterSpellScript(spell_hun_multi_shot);
 RegisterSpellScript(spell_hun_pet_heart_of_the_phoenix);
 RegisterSpellScript(spell_hun_posthaste);
 RegisterSpellScript(spell_hun_rapid_fire);
 RegisterSpellScript(spell_hun_rapid_fire_damage);
 RegisterSpellScript(spell_hun_roar_of_sacrifice);
 RegisterSpellScript(spell_hun_scatter_shot);
 RegisterSpellScript(spell_hun_steady_shot);
 RegisterSpellScript(spell_hun_tame_beast);
 RegisterSpellScript(spell_hun_t9_4p_bonus);
 RegisterSpellScript(spell_hun_t29_2p_marksmanship_bonus);
}