Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-21 17:54:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

Scripts/Spells: wiped all class spell scripts

Browse Source
This commit is contained in:
Ovahlord
2024-06-06 21:16:06 +02:00
parent 59501586ce
commit 04a0d57f2b
10 changed files with 0 additions and 15052 deletions
Download Patch File Download Diff File Expand all files Collapse all files

950
src/server/scripts/Spells/spell_dk.cpp
View File

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

2109
src/server/scripts/Spells/spell_druid.cpp
View File

File diff suppressed because it is too large Load Diff

808
src/server/scripts/Spells/spell_hunter.cpp
View File

@@ -22,815 +22,7 @@
*/
#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);
}

1534
src/server/scripts/Spells/spell_mage.cpp
View File

File diff suppressed because it is too large Load Diff

1578
src/server/scripts/Spells/spell_paladin.cpp
View File

File diff suppressed because it is too large Load Diff

3231
src/server/scripts/Spells/spell_priest.cpp
View File

File diff suppressed because it is too large Load Diff

1041
src/server/scripts/Spells/spell_rogue.cpp
View File

File diff suppressed because it is too large Load Diff

1943
src/server/scripts/Spells/spell_shaman.cpp
View File

File diff suppressed because it is too large Load Diff

1036
src/server/scripts/Spells/spell_warlock.cpp
View File

File diff suppressed because it is too large Load Diff

822
src/server/scripts/Spells/spell_warrior.cpp
View File

@@ -22,829 +22,7 @@
*/
#include "ScriptMgr.h"
#include "Map.h"
#include "MoveSpline.h"
#include "PathGenerator.h"
#include "Player.h"
#include "Spell.h"
#include "SpellMgr.h"
#include "SpellAuraEffects.h"
#include "SpellHistory.h"
#include "SpellScript.h"
enum WarriorSpells
{
SPELL_WARRIOR_BLADESTORM_PERIODIC_WHIRLWIND = 50622,
SPELL_WARRIOR_BLOODTHIRST_HEAL = 117313,
SPELL_WARRIOR_CHARGE = 34846,
SPELL_WARRIOR_CHARGE_EFFECT = 218104,
SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL = 198337,
SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY = 109128,
SPELL_WARRIOR_CHARGE_ROOT_EFFECT = 105771,
SPELL_WARRIOR_CHARGE_SLOW_EFFECT = 236027,
SPELL_WARRIOR_COLOSSUS_SMASH = 167105,
SPELL_WARRIOR_COLOSSUS_SMASH_AURA = 208086,
SPELL_WARRIOR_CRITICAL_THINKING_ENERGIZE = 392776,
SPELL_WARRIOR_EXECUTE = 20647,
SPELL_WARRIOR_FUELED_BY_VIOLENCE_HEAL = 383104,
SPELL_WARRIOR_GLYPH_OF_THE_BLAZING_TRAIL = 123779,
SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP = 159708,
SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF = 133278,
SPELL_WARRIOR_HEROIC_LEAP_JUMP = 178368,
SPELL_WARRIOR_IGNORE_PAIN = 190456,
SPELL_WARRIOR_IN_FOR_THE_KILL = 248621,
SPELL_WARRIOR_IN_FOR_THE_KILL_HASTE = 248622,
SPELL_WARRIOR_IMPENDING_VICTORY = 202168,
SPELL_WARRIOR_IMPENDING_VICTORY_HEAL = 202166,
SPELL_WARRIOR_IMPROVED_HEROIC_LEAP = 157449,
SPELL_WARRIOR_MORTAL_STRIKE = 12294,
SPELL_WARRIOR_MORTAL_WOUNDS = 213667,
SPELL_WARRIOR_RALLYING_CRY = 97463,
SPELL_WARRIOR_SHIELD_BLOCK_AURA = 132404,
SPELL_WARRIOR_SHIELD_CHARGE_EFFECT = 385953,
SPELL_WARRIOR_SHIELD_SLAM = 23922,
SPELL_WARRIOR_SHIELD_SLAM_MARKER = 224324,
SPELL_WARRIOR_SHOCKWAVE = 46968,
SPELL_WARRIOR_SHOCKWAVE_STUN = 132168,
SPELL_WARRIOR_STOICISM = 70845,
SPELL_WARRIOR_STORM_BOLT_STUN = 132169,
SPELL_WARRIOR_STRATEGIST = 384041,
SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1 = 12723,
SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_2 = 26654,
SPELL_WARRIOR_TAUNT = 355,
SPELL_WARRIOR_TRAUMA_EFFECT = 215537,
SPELL_WARRIOR_VICTORIOUS = 32216,
SPELL_WARRIOR_VICTORY_RUSH_HEAL = 118779,
};
enum WarriorMisc
{
SPELL_VISUAL_BLAZING_CHARGE = 26423
};
// 23881 - Bloodthirst
class spell_warr_bloodthirst : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_BLOODTHIRST_HEAL });
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetCaster(), SPELL_WARRIOR_BLOODTHIRST_HEAL, true);
}
void Register() override
{
OnEffectHit += SpellEffectFn(spell_warr_bloodthirst::HandleDummy, EFFECT_3, SPELL_EFFECT_DUMMY);
}
};
// 384036 - Brutal Vitality
class spell_warr_brutal_vitality : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_IGNORE_PAIN });
}
void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
{
_damageAmount += CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount());
}
void HandleDummyTick(AuraEffect const* /*aurEff*/)
{
if (_damageAmount == 0)
return;
if (AuraEffect* ignorePainAura = GetTarget()->GetAuraEffect(SPELL_WARRIOR_IGNORE_PAIN, EFFECT_0))
ignorePainAura->ChangeAmount(ignorePainAura->GetAmount() + _damageAmount);
_damageAmount = 0;
}
void Register() override
{
AfterEffectProc += AuraEffectProcFn(spell_warr_brutal_vitality::HandleProc, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_warr_brutal_vitality::HandleDummyTick, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
private:
uint32 _damageAmount = 0;
};
// 100 - Charge
class spell_warr_charge : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo
({
SPELL_WARRIOR_CHARGE_EFFECT,
SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL
});
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
uint32 spellId = SPELL_WARRIOR_CHARGE_EFFECT;
if (GetCaster()->HasAura(SPELL_WARRIOR_GLYPH_OF_THE_BLAZING_TRAIL))
spellId = SPELL_WARRIOR_CHARGE_EFFECT_BLAZING_TRAIL;
GetCaster()->CastSpell(GetHitUnit(), spellId, true);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_charge::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// 126661 - Warrior Charge Drop Fire Periodic
class spell_warr_charge_drop_fire_periodic : public AuraScript
{
void DropFireVisual(AuraEffect const* aurEff)
{
PreventDefaultAction();
if (GetTarget()->IsSplineEnabled())
{
for (uint32 i = 0; i < 5; ++i)
{
int32 timeOffset = 6 * i * aurEff->GetPeriod() / 25;
Movement::Location loc = GetTarget()->movespline->ComputePosition(timeOffset);
GetTarget()->SendPlaySpellVisual(Position(loc.x, loc.y, loc.z), SPELL_VISUAL_BLAZING_CHARGE, 0, 0, 1.f, true);
}
}
}
void Register() override
{
OnEffectPeriodic += AuraEffectPeriodicFn(spell_warr_charge_drop_fire_periodic::DropFireVisual, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL);
}
};
// 198337 - Charge Effect (dropping Blazing Trail)
// 218104 - Charge Effect
class spell_warr_charge_effect : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo
({
SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY,
SPELL_WARRIOR_CHARGE_ROOT_EFFECT,
SPELL_WARRIOR_CHARGE_SLOW_EFFECT
});
}
void HandleCharge(SpellEffIndex /*effIndex*/)
{
Unit* caster = GetCaster();
Unit* target = GetHitUnit();
caster->CastSpell(caster, SPELL_WARRIOR_CHARGE_PAUSE_RAGE_DECAY, CastSpellExtraArgs(TRIGGERED_FULL_MASK).AddSpellMod(SPELLVALUE_BASE_POINT0, 0));
caster->CastSpell(target, SPELL_WARRIOR_CHARGE_ROOT_EFFECT, true);
caster->CastSpell(target, SPELL_WARRIOR_CHARGE_SLOW_EFFECT, true);
}
void Register() override
{
OnEffectLaunchTarget += SpellEffectFn(spell_warr_charge_effect::HandleCharge, EFFECT_0, SPELL_EFFECT_CHARGE);
}
};
// 167105 - Colossus Smash
// 262161 - Warbreaker
class spell_warr_colossus_smash : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_COLOSSUS_SMASH_AURA, SPELL_WARRIOR_IN_FOR_THE_KILL, SPELL_WARRIOR_IN_FOR_THE_KILL_HASTE })
&& ValidateSpellEffect({ { SPELL_WARRIOR_IN_FOR_THE_KILL, EFFECT_2 } });
}
void HandleHit()
{
Unit* target = GetHitUnit();
Unit* caster = GetCaster();
GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_COLOSSUS_SMASH_AURA, true);
if (caster->HasAura(SPELL_WARRIOR_IN_FOR_THE_KILL))
{
if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_WARRIOR_IN_FOR_THE_KILL, DIFFICULTY_NONE))
{
if (target->HealthBelowPct(spellInfo->GetEffect(EFFECT_2).CalcValue(caster)))
_bonusHaste = true;
}
}
}
void HandleAfterCast()
{
Unit* caster = GetCaster();
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_WARRIOR_IN_FOR_THE_KILL, DIFFICULTY_NONE);
if (!spellInfo)
return;
CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
args.AddSpellBP0(spellInfo->GetEffect(EFFECT_0).CalcValue(caster));
if (_bonusHaste)
args.AddSpellBP0(spellInfo->GetEffect(EFFECT_1).CalcValue(caster));
caster->CastSpell(caster, SPELL_WARRIOR_IN_FOR_THE_KILL_HASTE, args);
}
void Register() override
{
OnHit += SpellHitFn(spell_warr_colossus_smash::HandleHit);
AfterCast += SpellCastFn(spell_warr_colossus_smash::HandleAfterCast);
}
private:
bool _bonusHaste = false;
};
// 389306 - Critical Thinking
class spell_warr_critical_thinking : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_CRITICAL_THINKING_ENERGIZE });
}
void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
{
if (Optional<int32> rageCost = eventInfo.GetProcSpell()->GetPowerTypeCostAmount(POWER_RAGE))
GetTarget()->CastSpell(nullptr, SPELL_WARRIOR_CRITICAL_THINKING_ENERGIZE, CastSpellExtraArgs(TRIGGERED_FULL_MASK)
.AddSpellBP0(CalculatePct(*rageCost, aurEff->GetAmount())));
}
void Register() override
{
AfterEffectProc += AuraEffectProcFn(spell_warr_critical_thinking::HandleProc, EFFECT_1, SPELL_AURA_DUMMY);
}
};
// 236279 - Devastator
class spell_warr_devastator : public AuraScript
{
bool Validate(SpellInfo const* spellInfo) override
{
return ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } }) && ValidateSpellInfo({ SPELL_WARRIOR_SHIELD_SLAM, SPELL_WARRIOR_SHIELD_SLAM_MARKER });
}
void OnProc(AuraEffect const* /*aurEff*/, ProcEventInfo const& /*eventInfo*/) const
{
if (GetTarget()->GetSpellHistory()->HasCooldown(SPELL_WARRIOR_SHIELD_SLAM))
{
if (roll_chance_i(GetEffectInfo(EFFECT_1).CalcValue()))
{
GetTarget()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_SHIELD_SLAM, true);
GetTarget()->CastSpell(GetTarget(), SPELL_WARRIOR_SHIELD_SLAM_MARKER, TRIGGERED_IGNORE_CAST_IN_PROGRESS);
}
}
}
void Register() override
{
OnEffectProc += AuraEffectProcFn(spell_warr_devastator::OnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
}
};
// 383103 - Fueled by Violence
class spell_warr_fueled_by_violence : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_FUELED_BY_VIOLENCE_HEAL });
}
void HandleProc(ProcEventInfo& eventInfo)
{
PreventDefaultAction();
_nextHealAmount += CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), GetEffectInfo(EFFECT_0).CalcValue(GetTarget()));
}
void HandlePeriodic(AuraEffect const* /*aurEff*/)
{
if (_nextHealAmount == 0)
return;
Unit* target = GetTarget();
CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
args.AddSpellBP0(_nextHealAmount);
target->CastSpell(target, SPELL_WARRIOR_FUELED_BY_VIOLENCE_HEAL, args);
_nextHealAmount = 0;
}
void Register() override
{
OnProc += AuraProcFn(spell_warr_fueled_by_violence::HandleProc);
OnEffectPeriodic += AuraEffectPeriodicFn(spell_warr_fueled_by_violence::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY);
}
private:
uint32 _nextHealAmount = 0;
};
// 6544 - Heroic leap
class spell_warr_heroic_leap : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_HEROIC_LEAP_JUMP });
}
SpellCastResult CheckElevation()
{
if (WorldLocation const* dest = GetExplTargetDest())
{
if (GetCaster()->HasUnitMovementFlag(MOVEMENTFLAG_ROOT))
return SPELL_FAILED_ROOTED;
if (GetCaster()->GetMap()->Instanceable())
{
float range = GetSpellInfo()->GetMaxRange(true, GetCaster()) * 1.5f;
PathGenerator generatedPath(GetCaster());
generatedPath.SetPathLengthLimit(range);
bool result = generatedPath.CalculatePath(dest->GetPositionX(), dest->GetPositionY(), dest->GetPositionZ(), false);
if (generatedPath.GetPathType() & PATHFIND_SHORT)
return SPELL_FAILED_OUT_OF_RANGE;
else if (!result || generatedPath.GetPathType() & PATHFIND_NOPATH)
return SPELL_FAILED_NOPATH;
}
else if (dest->GetPositionZ() > GetCaster()->GetPositionZ() + 4.0f)
return SPELL_FAILED_NOPATH;
return SPELL_CAST_OK;
}
return SPELL_FAILED_NO_VALID_TARGETS;
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
if (WorldLocation* dest = GetHitDest())
GetCaster()->CastSpell(*dest, SPELL_WARRIOR_HEROIC_LEAP_JUMP, true);
}
void Register() override
{
OnCheckCast += SpellCheckCastFn(spell_warr_heroic_leap::CheckElevation);
OnEffectHit += SpellEffectFn(spell_warr_heroic_leap::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// Heroic Leap (triggered by Heroic Leap (6544)) - 178368
class spell_warr_heroic_leap_jump : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo(
{
SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP,
SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF,
SPELL_WARRIOR_IMPROVED_HEROIC_LEAP,
SPELL_WARRIOR_TAUNT
});
}
void AfterJump(SpellEffIndex /*effIndex*/)
{
if (GetCaster()->HasAura(SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP))
GetCaster()->CastSpell(GetCaster(), SPELL_WARRIOR_GLYPH_OF_HEROIC_LEAP_BUFF, true);
if (GetCaster()->HasAura(SPELL_WARRIOR_IMPROVED_HEROIC_LEAP))
GetCaster()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_TAUNT, true);
}
void Register() override
{
OnEffectHit += SpellEffectFn(spell_warr_heroic_leap_jump::AfterJump, EFFECT_1, SPELL_EFFECT_JUMP_DEST);
}
};
// 202168 - Impending Victory
class spell_warr_impending_victory : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_IMPENDING_VICTORY_HEAL });
}
void HandleAfterCast()
{
Unit* caster = GetCaster();
caster->CastSpell(caster, SPELL_WARRIOR_IMPENDING_VICTORY_HEAL, true);
caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VICTORIOUS);
}
void Register() override
{
AfterCast += SpellCastFn(spell_warr_impending_victory::HandleAfterCast);
}
};
// 5246 - Intimidating Shout
class spell_warr_intimidating_shout : public SpellScript
{
void FilterTargets(std::list<WorldObject*>& unitList)
{
unitList.remove(GetExplTargetWorldObject());
}
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);
}
};
// 70844 - Item - Warrior T10 Protection 4P Bonus
class spell_warr_item_t10_prot_4p_bonus : public AuraScript
{
bool Validate(SpellInfo const* spellInfo) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_STOICISM })
&& ValidateSpellEffect({ { spellInfo->Id, EFFECT_1 } });
}
void HandleProc(ProcEventInfo& eventInfo)
{
PreventDefaultAction();
Unit* target = eventInfo.GetActionTarget();
int32 bp0 = CalculatePct(target->GetMaxHealth(), GetEffectInfo(EFFECT_1).CalcValue());
CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
args.AddSpellBP0(bp0);
target->CastSpell(nullptr, SPELL_WARRIOR_STOICISM, args);
}
void Register() override
{
OnProc += AuraProcFn(spell_warr_item_t10_prot_4p_bonus::HandleProc);
}
};
// 12294 - Mortal Strike 7.1.5
class spell_warr_mortal_strike : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_MORTAL_WOUNDS });
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
if (Unit* target = GetHitUnit())
GetCaster()->CastSpell(target, SPELL_WARRIOR_MORTAL_WOUNDS, true);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_mortal_strike::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// 97462 - Rallying Cry
class spell_warr_rallying_cry : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_RALLYING_CRY });
}
bool Load() override
{
return GetCaster()->GetTypeId() == TYPEID_PLAYER;
}
void HandleScript(SpellEffIndex /*effIndex*/)
{
CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
args.AddSpellMod(SPELLVALUE_BASE_POINT0, int32(GetHitUnit()->CountPctFromMaxHealth(GetEffectValue())));
GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_RALLYING_CRY, args);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_rallying_cry::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// 2565 - Shield Block
class spell_warr_shield_block : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_SHIELD_BLOCK_AURA });
}
void HandleHitTarget(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(nullptr, SPELL_WARRIOR_SHIELD_BLOCK_AURA, true);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_shield_block::HandleHitTarget, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// 385952 - Shield Charge
class spell_warr_shield_charge : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_SHIELD_CHARGE_EFFECT });
}
void HandleDummy(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_SHIELD_CHARGE_EFFECT, true);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_shield_charge::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
}
};
// 46968 - Shockwave
class spell_warr_shockwave : public SpellScript
{
bool Validate(SpellInfo const* spellInfo) override
{
return !ValidateSpellInfo({ SPELL_WARRIOR_SHOCKWAVE, SPELL_WARRIOR_SHOCKWAVE_STUN })
&& ValidateSpellEffect({ { spellInfo->Id, EFFECT_3 } });
}
bool Load() override
{
return GetCaster()->GetTypeId() == TYPEID_PLAYER;
}
void HandleStun(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_SHOCKWAVE_STUN, true);
++_targetCount;
}
// Cooldown reduced by 20 sec if it strikes at least 3 targets.
void HandleAfterCast()
{
if (_targetCount >= uint32(GetEffectInfo(EFFECT_0).CalcValue()))
GetCaster()->ToPlayer()->GetSpellHistory()->ModifyCooldown(GetSpellInfo()->Id, Seconds(-GetEffectInfo(EFFECT_3).CalcValue()));
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_shockwave::HandleStun, EFFECT_0, SPELL_EFFECT_DUMMY);
AfterCast += SpellCastFn(spell_warr_shockwave::HandleAfterCast);
}
uint32 _targetCount = 0;
};
// 107570 - Storm Bolt
class spell_warr_storm_bolt : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo
({
SPELL_WARRIOR_STORM_BOLT_STUN
});
}
void HandleOnHit(SpellEffIndex /*effIndex*/)
{
GetCaster()->CastSpell(GetHitUnit(), SPELL_WARRIOR_STORM_BOLT_STUN, true);
}
void Register() override
{
OnEffectHitTarget += SpellEffectFn(spell_warr_storm_bolt::HandleOnHit, EFFECT_1, SPELL_EFFECT_DUMMY);
}
};
// 384041 - Strategist
class spell_warr_strategist : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_SHIELD_SLAM, SPELL_WARRIOR_SHIELD_SLAM_MARKER })
&& ValidateSpellEffect({ { SPELL_WARRIOR_STRATEGIST, EFFECT_0 } });
}
static bool CheckProc(AuraEffect const* aurEff, ProcEventInfo const& /*procEvent*/)
{
return roll_chance_i(aurEff->GetAmount());
}
void HandleCooldown(AuraEffect const* /*aurEff*/, ProcEventInfo const& /*procEvent*/) const
{
Unit* caster = GetTarget();
caster->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_SHIELD_SLAM, true);
caster->CastSpell(caster, SPELL_WARRIOR_SHIELD_SLAM_MARKER, TRIGGERED_IGNORE_CAST_IN_PROGRESS);
}
void Register() override
{
DoCheckEffectProc += AuraCheckEffectProcFn(spell_warr_strategist::CheckProc, EFFECT_0, SPELL_AURA_DUMMY);
OnEffectProc += AuraEffectProcFn(spell_warr_strategist::HandleCooldown, EFFECT_0, SPELL_AURA_DUMMY);
}
};
// 52437 - Sudden Death
class spell_warr_sudden_death : public AuraScript
{
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 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 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* aurEff, ProcEventInfo& eventInfo)
{
PreventDefaultAction();
if (DamageInfo* damageInfo = eventInfo.GetDamageInfo())
{
SpellInfo const* spellInfo = damageInfo->GetSpellInfo();
if (spellInfo && (spellInfo->Id == SPELL_WARRIOR_BLADESTORM_PERIODIC_WHIRLWIND || (spellInfo->Id == SPELL_WARRIOR_EXECUTE && !_procTarget->HasAuraState(AURA_STATE_WOUNDED_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, aurEff);
}
else
{
CastSpellExtraArgs args(aurEff);
args.AddSpellMod(SPELLVALUE_BASE_POINT0, damageInfo->GetDamage());
GetTarget()->CastSpell(_procTarget, SPELL_WARRIOR_SWEEPING_STRIKES_EXTRA_ATTACK_1, args);
}
}
}
void Register() override
{
DoCheckProc += AuraCheckProcFn(spell_warr_sweeping_strikes::CheckProc);
OnEffectProc += AuraEffectProcFn(spell_warr_sweeping_strikes::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
}
Unit* _procTarget = nullptr;
};
// 215538 - Trauma
class spell_warr_trauma : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_TRAUMA_EFFECT });
}
void HandleProc(AuraEffect* aurEff, ProcEventInfo& eventInfo)
{
Unit* target = eventInfo.GetActionTarget();
//Get 25% of damage from the spell casted (Slam & Whirlwind) plus Remaining Damage from Aura
int32 damage = int32(CalculatePct(eventInfo.GetDamageInfo()->GetDamage(), aurEff->GetAmount()) / sSpellMgr->AssertSpellInfo(SPELL_WARRIOR_TRAUMA_EFFECT, GetCastDifficulty())->GetMaxTicks());
CastSpellExtraArgs args(TRIGGERED_FULL_MASK);
args.AddSpellMod(SPELLVALUE_BASE_POINT0, damage);
GetCaster()->CastSpell(target, SPELL_WARRIOR_TRAUMA_EFFECT, args);
}
void Register() override
{
OnEffectProc += AuraEffectProcFn(spell_warr_trauma::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
}
};
// 28845 - Cheat Death
class spell_warr_t3_prot_8p_bonus : public AuraScript
{
bool CheckProc(ProcEventInfo& eventInfo)
{
if (eventInfo.GetActionTarget()->HealthBelowPct(20))
return true;
DamageInfo* damageInfo = eventInfo.GetDamageInfo();
if (damageInfo && damageInfo->GetDamage())
if (GetTarget()->HealthBelowPctDamaged(20, damageInfo->GetDamage()))
return true;
return false;
}
void Register() override
{
DoCheckProc += AuraCheckProcFn(spell_warr_t3_prot_8p_bonus::CheckProc);
}
};
// 32215 - Victorious State
class spell_warr_victorious_state : public AuraScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo({ SPELL_WARRIOR_IMPENDING_VICTORY });
}
void HandleOnProc(AuraEffect* /*aurEff*/, ProcEventInfo& procInfo)
{
if (procInfo.GetActor()->GetTypeId() == TYPEID_PLAYER && procInfo.GetActor()->ToPlayer()->GetPrimarySpecialization() == ChrSpecialization::WarriorFury)
PreventDefaultAction();
procInfo.GetActor()->GetSpellHistory()->ResetCooldown(SPELL_WARRIOR_IMPENDING_VICTORY, true);
}
void Register() override
{
OnEffectProc += AuraEffectProcFn(spell_warr_victorious_state::HandleOnProc, EFFECT_0, SPELL_AURA_PROC_TRIGGER_SPELL);
}
};
// 34428 - Victory Rush
class spell_warr_victory_rush : public SpellScript
{
bool Validate(SpellInfo const* /*spellInfo*/) override
{
return ValidateSpellInfo
({
SPELL_WARRIOR_VICTORIOUS,
SPELL_WARRIOR_VICTORY_RUSH_HEAL
});
}
void HandleHeal()
{
Unit* caster = GetCaster();
caster->CastSpell(caster, SPELL_WARRIOR_VICTORY_RUSH_HEAL, true);
caster->RemoveAurasDueToSpell(SPELL_WARRIOR_VICTORIOUS);
}
void Register() override
{
AfterCast += SpellCastFn(spell_warr_victory_rush::HandleHeal);
}
};
void AddSC_warrior_spell_scripts()
{
RegisterSpellScript(spell_warr_bloodthirst);
RegisterSpellScript(spell_warr_brutal_vitality);
RegisterSpellScript(spell_warr_charge);
RegisterSpellScript(spell_warr_charge_drop_fire_periodic);
RegisterSpellScript(spell_warr_charge_effect);
RegisterSpellScript(spell_warr_colossus_smash);
RegisterSpellScript(spell_warr_critical_thinking);
RegisterSpellScript(spell_warr_devastator);
RegisterSpellScript(spell_warr_fueled_by_violence);
RegisterSpellScript(spell_warr_heroic_leap);
RegisterSpellScript(spell_warr_heroic_leap_jump);
RegisterSpellScript(spell_warr_impending_victory);
RegisterSpellScript(spell_warr_intimidating_shout);
RegisterSpellScript(spell_warr_item_t10_prot_4p_bonus);
RegisterSpellScript(spell_warr_mortal_strike);
RegisterSpellScript(spell_warr_rallying_cry);
RegisterSpellScript(spell_warr_shield_block);
RegisterSpellScript(spell_warr_shield_charge);
RegisterSpellScript(spell_warr_shockwave);
RegisterSpellScript(spell_warr_storm_bolt);
RegisterSpellScript(spell_warr_strategist);
RegisterSpellScript(spell_warr_sudden_death);
RegisterSpellScript(spell_warr_sweeping_strikes);
RegisterSpellScript(spell_warr_trauma);
RegisterSpellScript(spell_warr_t3_prot_8p_bonus);
RegisterSpellScript(spell_warr_victorious_state);
RegisterSpellScript(spell_warr_victory_rush);
}