mirror of
https://github.com/araxiaonline/TrinityCore.git
synced 2026-06-15 04:32:35 -04:00
e949ad3adb
* Call spell effect handlers in 4 modes: - SPELL_EFFECT_HANDLE_LAUNCH - called when spell is launched (cast just finished) - SPELL_EFFECT_HANDLE_LAUNCH_TARGET - called when spell is launched for each target in spell target map - SPELL_EFFECT_HANDLE_HIT - called when spell hits its destination - SPELL_EFFECT_HANDLE_HIT_TARGET - called when spell hits it's target from spell target map *Correctly implement SPELL_EFFECT_TRIGGER_SPELL, SPELL_EFFECT_TRIGGER_SPELL_WITH_VALUE, SPELL_EFFECT_TRIGGER_MISSILE_SPELL_WITH_VALUE, SPELL_EFFECT_TRIGGER_MISSILE_SPELL *Remove spell system hacks which became obsolete with this commit Core/SpellScripts: add OnEffectLaunch, OnEffectLaunchTarget, OnEffectHit, OnEffectHitTarget hooks for new effect handle modes and remove OnEffect hook. A generic rule of thumb how to update your scripts (will work for nearly all cases) for spell system noobs: if your spell script used GetHitXXXX function, you need to use OnEffectHitTarget, otherwise use OnEffectHit
339 lines
12 KiB
C++
339 lines
12 KiB
C++
/*
|
|
* Copyright (C) 2008-2011 TrinityCore <http://www.trinitycore.org/>
|
|
*
|
|
* 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_PALADIN and SPELLFAMILY_GENERIC spells used by paladin players.
|
|
* Ordered alphabetically using scriptname.
|
|
* Scriptnames of files in this file should be prefixed with "spell_pal_".
|
|
*/
|
|
|
|
#include "ScriptPCH.h"
|
|
#include "SpellAuraEffects.h"
|
|
|
|
enum PaladinSpells
|
|
{
|
|
PALADIN_SPELL_DIVINE_PLEA = 54428,
|
|
PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF = 67480,
|
|
|
|
PALADIN_SPELL_HOLY_SHOCK_R1 = 20473,
|
|
PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE = 25912,
|
|
PALADIN_SPELL_HOLY_SHOCK_R1_HEALING = 25914,
|
|
|
|
SPELL_BLESSING_OF_LOWER_CITY_DRUID = 37878,
|
|
SPELL_BLESSING_OF_LOWER_CITY_PALADIN = 37879,
|
|
SPELL_BLESSING_OF_LOWER_CITY_PRIEST = 37880,
|
|
SPELL_BLESSING_OF_LOWER_CITY_SHAMAN = 37881,
|
|
};
|
|
|
|
// 31850 - Ardent Defender
|
|
class spell_pal_ardent_defender : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_pal_ardent_defender() : SpellScriptLoader("spell_pal_ardent_defender") { }
|
|
|
|
class spell_pal_ardent_defender_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_pal_ardent_defender_AuraScript);
|
|
|
|
uint32 absorbPct, healPct;
|
|
|
|
enum Spell
|
|
{
|
|
PAL_SPELL_ARDENT_DEFENDER_HEAL = 66235,
|
|
};
|
|
|
|
bool Load()
|
|
{
|
|
healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue();
|
|
absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue();
|
|
return GetUnitOwner()->ToPlayer();
|
|
}
|
|
|
|
void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/)
|
|
{
|
|
// Set absorbtion amount to unlimited
|
|
amount = -1;
|
|
}
|
|
|
|
void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount)
|
|
{
|
|
Unit* victim = GetTarget();
|
|
int32 remainingHealth = victim->GetHealth() - dmgInfo.GetDamage();
|
|
uint32 allowedHealth = victim->CountPctFromMaxHealth(35);
|
|
// If damage kills us
|
|
if (remainingHealth <= 0 && !victim->ToPlayer()->HasSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL))
|
|
{
|
|
// Cast healing spell, completely avoid damage
|
|
absorbAmount = dmgInfo.GetDamage();
|
|
|
|
uint32 defenseSkillValue = victim->GetDefenseSkillValue();
|
|
// Max heal when defense skill denies critical hits from raid bosses
|
|
// Formula: max defense at level + 140 (raiting from gear)
|
|
uint32 reqDefForMaxHeal = victim->getLevel() * 5 + 140;
|
|
float pctFromDefense = (defenseSkillValue >= reqDefForMaxHeal)
|
|
? 1.0f
|
|
: float(defenseSkillValue) / float(reqDefForMaxHeal);
|
|
|
|
int32 healAmount = int32(victim->CountPctFromMaxHealth(uint32(healPct * pctFromDefense)));
|
|
victim->CastCustomSpell(victim, PAL_SPELL_ARDENT_DEFENDER_HEAL, &healAmount, NULL, NULL, true, NULL, aurEff);
|
|
victim->ToPlayer()->AddSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL, 0, time(NULL) + 120);
|
|
}
|
|
else if (remainingHealth < int32(allowedHealth))
|
|
{
|
|
// Reduce damage that brings us under 35% (or full damage if we are already under 35%) by x%
|
|
uint32 damageToReduce = (victim->GetHealth() < allowedHealth)
|
|
? dmgInfo.GetDamage()
|
|
: allowedHealth - remainingHealth;
|
|
absorbAmount = CalculatePctN(damageToReduce, absorbPct);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pal_ardent_defender_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB);
|
|
OnEffectAbsorb += AuraEffectAbsorbFn(spell_pal_ardent_defender_AuraScript::Absorb, EFFECT_0);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_pal_ardent_defender_AuraScript();
|
|
}
|
|
};
|
|
|
|
class spell_pal_blessing_of_faith : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_pal_blessing_of_faith() : SpellScriptLoader("spell_pal_blessing_of_faith") { }
|
|
|
|
class spell_pal_blessing_of_faith_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_pal_blessing_of_faith_SpellScript)
|
|
bool Validate(SpellInfo const* /*spellEntry*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_DRUID))
|
|
return false;
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_PALADIN))
|
|
return false;
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_PRIEST))
|
|
return false;
|
|
if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_SHAMAN))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Unit* unitTarget = GetHitUnit())
|
|
{
|
|
uint32 spell_id = 0;
|
|
switch(unitTarget->getClass())
|
|
{
|
|
case CLASS_DRUID: spell_id = SPELL_BLESSING_OF_LOWER_CITY_DRUID; break;
|
|
case CLASS_PALADIN: spell_id = SPELL_BLESSING_OF_LOWER_CITY_PALADIN; break;
|
|
case CLASS_PRIEST: spell_id = SPELL_BLESSING_OF_LOWER_CITY_PRIEST; break;
|
|
case CLASS_SHAMAN: spell_id = SPELL_BLESSING_OF_LOWER_CITY_SHAMAN; break;
|
|
default: return; // ignore for non-healing classes
|
|
}
|
|
|
|
GetCaster()->CastSpell(GetCaster(), spell_id, true);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
// add dummy effect spell handler to Blessing of Faith
|
|
OnEffectHitTarget += SpellEffectFn(spell_pal_blessing_of_faith_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_pal_blessing_of_faith_SpellScript();
|
|
}
|
|
};
|
|
|
|
// 20911 Blessing of Sanctuary
|
|
// 25899 Greater Blessing of Sanctuary
|
|
class spell_pal_blessing_of_sanctuary : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_pal_blessing_of_sanctuary() : SpellScriptLoader("spell_pal_blessing_of_sanctuary") { }
|
|
|
|
class spell_pal_blessing_of_sanctuary_AuraScript : public AuraScript
|
|
{
|
|
PrepareAuraScript(spell_pal_blessing_of_sanctuary_AuraScript)
|
|
bool Validate(SpellInfo const* /*entry*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
Unit* target = GetTarget();
|
|
if (Unit* pCaster = GetCaster())
|
|
pCaster->CastSpell(target, PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF, true);
|
|
}
|
|
|
|
void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
|
|
{
|
|
Unit* target = GetTarget();
|
|
target->RemoveAura(PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF, GetCasterGUID());
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
AfterEffectApply += AuraEffectApplyFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
|
|
AfterEffectRemove += AuraEffectRemoveFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK);
|
|
}
|
|
};
|
|
|
|
AuraScript* GetAuraScript() const
|
|
{
|
|
return new spell_pal_blessing_of_sanctuary_AuraScript();
|
|
}
|
|
};
|
|
|
|
// 63521 Guarded by The Light
|
|
class spell_pal_guarded_by_the_light : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_pal_guarded_by_the_light() : SpellScriptLoader("spell_pal_guarded_by_the_light") { }
|
|
|
|
class spell_pal_guarded_by_the_light_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_pal_guarded_by_the_light_SpellScript)
|
|
bool Validate(SpellInfo const* /*spellEntry*/)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_DIVINE_PLEA))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void HandleScriptEffect(SpellEffIndex /*effIndex*/)
|
|
{
|
|
// Divine Plea
|
|
if (Aura* aura = GetCaster()->GetAura(PALADIN_SPELL_DIVINE_PLEA))
|
|
aura->RefreshDuration();
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
OnEffectHitTarget += SpellEffectFn(spell_pal_guarded_by_the_light_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_pal_guarded_by_the_light_SpellScript();
|
|
}
|
|
};
|
|
|
|
class spell_pal_holy_shock : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_pal_holy_shock() : SpellScriptLoader("spell_pal_holy_shock") { }
|
|
|
|
class spell_pal_holy_shock_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_pal_holy_shock_SpellScript)
|
|
bool Validate(SpellInfo const* spellEntry)
|
|
{
|
|
if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_HOLY_SHOCK_R1))
|
|
return false;
|
|
|
|
// can't use other spell than holy shock due to spell_ranks dependency
|
|
if (sSpellMgr->GetFirstSpellInChain(PALADIN_SPELL_HOLY_SHOCK_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id))
|
|
return false;
|
|
|
|
uint8 rank = sSpellMgr->GetSpellRank(spellEntry->Id);
|
|
if (!sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE, rank, true))
|
|
return false;
|
|
if (!sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_HEALING, rank, true))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Unit* unitTarget = GetHitUnit())
|
|
{
|
|
Unit* caster = GetCaster();
|
|
|
|
uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id);
|
|
|
|
if (caster->IsFriendlyTo(unitTarget))
|
|
caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_HEALING, rank), true, 0);
|
|
else
|
|
caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE, rank), true, 0);
|
|
}
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
// add dummy effect spell handler to Holy Shock
|
|
OnEffectHitTarget += SpellEffectFn(spell_pal_holy_shock_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_pal_holy_shock_SpellScript();
|
|
}
|
|
};
|
|
|
|
class spell_pal_judgement_of_command : public SpellScriptLoader
|
|
{
|
|
public:
|
|
spell_pal_judgement_of_command() : SpellScriptLoader("spell_pal_judgement_of_command") { }
|
|
|
|
class spell_pal_judgement_of_command_SpellScript : public SpellScript
|
|
{
|
|
PrepareSpellScript(spell_pal_judgement_of_command_SpellScript)
|
|
void HandleDummy(SpellEffIndex /*effIndex*/)
|
|
{
|
|
if (Unit* unitTarget = GetHitUnit())
|
|
if (SpellInfo const* spell_proto = sSpellMgr->GetSpellInfo(GetEffectValue()))
|
|
GetCaster()->CastSpell(unitTarget, spell_proto, true, NULL);
|
|
}
|
|
|
|
void Register()
|
|
{
|
|
// add dummy effect spell handler to Judgement of Command
|
|
OnEffectHitTarget += SpellEffectFn(spell_pal_judgement_of_command_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY);
|
|
}
|
|
};
|
|
|
|
SpellScript* GetSpellScript() const
|
|
{
|
|
return new spell_pal_judgement_of_command_SpellScript();
|
|
}
|
|
};
|
|
|
|
void AddSC_paladin_spell_scripts()
|
|
{
|
|
new spell_pal_ardent_defender();
|
|
new spell_pal_blessing_of_faith();
|
|
new spell_pal_blessing_of_sanctuary();
|
|
new spell_pal_guarded_by_the_light();
|
|
new spell_pal_holy_shock();
|
|
new spell_pal_judgement_of_command();
|
|
}
|