hondacrx
1259 lines
45 KiB
C#
1259 lines
45 KiB
C#
/*
|
|
* Copyright (C) 2012-2017 CypherCore <http://github.com/CypherCore>
|
|
*
|
|
* 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 3 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/>.
|
|
*/
|
|
|
|
using Framework.Constants;
|
|
using Game.Entities;
|
|
using Game.Scripting;
|
|
using Game.Spells;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Scripts.Spells.DeathKnight
|
|
{
|
|
struct SpellIds
|
|
{
|
|
public const uint ArmyFleshBeastTransform = 127533;
|
|
public const uint ArmyGeistTransform = 127534;
|
|
public const uint ArmyNorthrendSkeletonTransform = 127528;
|
|
public const uint ArmySkeletonTransform = 127527;
|
|
public const uint ArmySpikedGhoulTransform = 127525;
|
|
public const uint ArmySuperZombieTransform = 127526;
|
|
public const uint BloodPlague = 55078;
|
|
public const uint BloodPresence = 48263;
|
|
public const uint BloodShieldMastery = 77513;
|
|
public const uint BloodShieldAbsorb = 77535;
|
|
public const uint ChainsOfIce = 45524;
|
|
public const uint CorpseExplosionTriggered = 43999;
|
|
public const uint DeathAndDecayDamage = 52212;
|
|
public const uint DeathAndDecaySlow = 143375;
|
|
public const uint DeathCoilBarrier = 115635;
|
|
public const uint DeathCoilDamage = 47632;
|
|
public const uint DeathCoilHeal = 47633;
|
|
public const uint DeathGrip = 49560;
|
|
public const uint DeathStrikeHeal = 45470;
|
|
public const uint EnhancedDeathCoil = 157343;
|
|
public const uint FrostFever = 55095;
|
|
public const uint GhoulExplode = 47496;
|
|
public const uint GlyphOfAbsorbMagic = 159415;
|
|
public const uint GlyphOfAntiMagicShell = 58623;
|
|
public const uint GlyphOfArmyOfTheDead = 58669;
|
|
public const uint GlyphOfDeathCoil = 63333;
|
|
public const uint GlyphOfDeathAndDecay = 58629;
|
|
public const uint GlyphOfFoulMenagerie = 58642;
|
|
public const uint GlyphOfRegenerativeMagic = 146648;
|
|
public const uint GlyphOfRunicPowerTriggered = 159430;
|
|
public const uint GlyphOfSwiftDeath = 146645;
|
|
public const uint GlyphOfTheGeist = 58640;
|
|
public const uint GlyphOfTheSkeleton = 146652;
|
|
public const uint ImprovedBloodPresence = 50371;
|
|
public const uint ImprovedSoulReaper = 157342;
|
|
public const uint MarkOfBloodHeal = 206945;
|
|
public const uint NecrosisEffect = 216974;
|
|
public const uint RunicPowerEnergize = 49088;
|
|
public const uint RunicReturn = 61258;
|
|
public const uint ScourgeStrikeTriggered = 70890;
|
|
public const uint ShadowOfDeath = 164047;
|
|
public const uint SoulReaperDamage = 114867;
|
|
public const uint SoulReaperHaste = 114868;
|
|
public const uint T15Dps4pBonus = 138347;
|
|
public const uint UnholyPresence = 48265;
|
|
public const uint WillOfTheNecropolis = 157335;
|
|
|
|
public static uint[] ArmyTransforms =
|
|
{
|
|
ArmyFleshBeastTransform,
|
|
ArmyGeistTransform,
|
|
ArmyNorthrendSkeletonTransform,
|
|
ArmySkeletonTransform,
|
|
ArmySpikedGhoulTransform,
|
|
ArmySuperZombieTransform
|
|
};
|
|
}
|
|
|
|
struct CreatureIds
|
|
{
|
|
public const uint DancingRuneWeapon = 27893;
|
|
}
|
|
|
|
[Script] // 70656 - Advantage (T10 4P Melee Bonus)
|
|
class spell_dk_advantage_t10_4p : SpellScriptLoader
|
|
{
|
|
public spell_dk_advantage_t10_4p() : base("spell_dk_advantage_t10_4p") { }
|
|
|
|
class spell_dk_advantage_t10_4p_AuraScript : AuraScript
|
|
{
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
Unit caster = eventInfo.GetActor();
|
|
if (caster)
|
|
{
|
|
if (!caster.IsTypeId(TypeId.Player) || caster.GetClass() != Class.Deathknight)
|
|
return false;
|
|
|
|
for (byte i = 0; i < PlayerConst.MaxRunes; ++i)
|
|
if (caster.ToPlayer().GetRuneCooldown(i) == 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new CheckProcHandler(CheckProc));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_advantage_t10_4p_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 48707 - Anti-Magic Shell
|
|
class spell_dk_anti_magic_shell : SpellScriptLoader
|
|
{
|
|
public spell_dk_anti_magic_shell() : base("spell_dk_anti_magic_shell") { }
|
|
|
|
class spell_dk_anti_magic_shell_AuraScript : AuraScript
|
|
{
|
|
public spell_dk_anti_magic_shell_AuraScript()
|
|
{
|
|
absorbPct = 0;
|
|
maxHealth = 0;
|
|
absorbedAmount = 0;
|
|
}
|
|
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.RunicPowerEnergize, SpellIds.GlyphOfAbsorbMagic, SpellIds.GlyphOfRegenerativeMagic);
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
absorbPct = GetSpellInfo().GetEffect(0).CalcValue(GetCaster());
|
|
maxHealth = (int)GetCaster().GetMaxHealth();
|
|
absorbedAmount = 0;
|
|
return true;
|
|
}
|
|
|
|
void CalculateAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
amount = maxHealth;
|
|
|
|
/// todo, check if AMS has basepoints for 2. in that case, this function should be rewritten.
|
|
if (!GetUnitOwner().HasAura(SpellIds.GlyphOfAbsorbMagic))
|
|
amount /= 2;
|
|
}
|
|
|
|
void Absorb(AuraEffect aurEff, DamageInfo dmgInfo, ref uint absorbAmount)
|
|
{
|
|
// we may only absorb a certain percentage of incoming damage.
|
|
absorbAmount = (uint)(dmgInfo.GetDamage() * absorbPct / 100);
|
|
}
|
|
|
|
void Trigger(AuraEffect aurEff, DamageInfo dmgInfo, ref uint absorbAmount)
|
|
{
|
|
absorbedAmount += absorbAmount;
|
|
|
|
if (!GetTarget().HasAura(SpellIds.GlyphOfAbsorbMagic))
|
|
{
|
|
// Patch 6.0.2 (October 14, 2014): Anti-Magic Shell now restores 2 Runic Power per 1% of max health absorbed.
|
|
int bp = (int)(2 * absorbAmount * 100 / maxHealth);
|
|
GetTarget().CastCustomSpell(SpellIds.RunicPowerEnergize, SpellValueMod.BasePoint0, bp, GetTarget(), true, null, aurEff);
|
|
}
|
|
}
|
|
|
|
void HandleEffectRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
Player player = GetTarget().ToPlayer();
|
|
if (player)
|
|
{
|
|
AuraEffect glyph = player.GetAuraEffect(SpellIds.GlyphOfRegenerativeMagic, 0);
|
|
if (glyph != null) // reduce cooldown of AMS if player has glyph
|
|
{
|
|
// Cannot reduce cooldown by more than 50%
|
|
int val = Math.Min(glyph.GetAmount(), (int)absorbedAmount * 100 / maxHealth);
|
|
player.GetSpellHistory().ModifyCooldown(GetId(), -(int)(player.GetSpellHistory().GetRemainingCooldown(GetSpellInfo()) * val / 100));
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new EffectCalcAmountHandler(CalculateAmount, 0, AuraType.SchoolAbsorb));
|
|
OnEffectAbsorb.Add(new EffectAbsorbHandler(Absorb, 0));
|
|
AfterEffectAbsorb.Add(new EffectAbsorbHandler(Trigger, 0));
|
|
AfterEffectRemove.Add(new EffectApplyHandler(HandleEffectRemove, 0, AuraType.SchoolAbsorb, AuraEffectHandleModes.Real));
|
|
}
|
|
|
|
int absorbPct;
|
|
int maxHealth;
|
|
uint absorbedAmount;
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_anti_magic_shell_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 43264 - Periodic Taunt // 6.x, does this belong here or in spell_generic? apply this in creature_template_addon? sniffs say this is always cast army of the dead ghouls.
|
|
class spell_dk_army_periodic_taunt : SpellScriptLoader
|
|
{
|
|
public spell_dk_army_periodic_taunt() : base("spell_dk_army_periodic_taunt") { }
|
|
|
|
class spell_dk_army_periodic_taunt_SpellScript : SpellScript
|
|
{
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsGuardian();
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit owner = GetCaster().GetOwner();
|
|
if (owner)
|
|
if (!owner.HasAura(SpellIds.GlyphOfArmyOfTheDead))
|
|
return SpellCastResult.SpellCastOk;
|
|
|
|
return SpellCastResult.SpellUnavailable;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckCast));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_army_periodic_taunt_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 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 : SpellScriptLoader
|
|
{
|
|
public spell_dk_army_transform() : base("spell_dk_army_transform") { }
|
|
|
|
class spell_dk_army_transform_SpellScript : SpellScript
|
|
{
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsGuardian();
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit owner = GetCaster().GetOwner();
|
|
if (owner)
|
|
if (owner.HasAura(SpellIds.GlyphOfFoulMenagerie))
|
|
return SpellCastResult.SpellCastOk;
|
|
|
|
return SpellCastResult.SpellUnavailable;
|
|
}
|
|
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.ArmyTransforms[RandomHelper.URand(0, 5)], true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckCast));
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_army_transform_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 50842 - Blood Boil
|
|
class spell_dk_blood_boil : SpellScriptLoader
|
|
{
|
|
public spell_dk_blood_boil() : base("spell_dk_blood_boil") { }
|
|
|
|
class spell_dk_blood_boil_SpellScript : SpellScript
|
|
{
|
|
public spell_dk_blood_boil_SpellScript()
|
|
{
|
|
bpDuration = 0;
|
|
ffDuration = 0;
|
|
}
|
|
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BloodPlague, SpellIds.FrostFever);
|
|
}
|
|
|
|
void FilterTargets(List<WorldObject> targets)
|
|
{
|
|
if (targets.Empty())
|
|
return;
|
|
|
|
Unit caster = GetCaster();
|
|
|
|
foreach (WorldObject target in targets)
|
|
{
|
|
if (bpDuration != 0 && ffDuration != 0)
|
|
break;
|
|
|
|
Unit unit = target.ToUnit();
|
|
if (unit)
|
|
{
|
|
Aura bp = unit.GetAura(SpellIds.BloodPlague, caster.GetGUID());
|
|
if (bp != null)
|
|
bpDuration = bp.GetDuration();
|
|
Aura ff = unit.GetAura(SpellIds.FrostFever, caster.GetGUID());
|
|
if (ff != null)
|
|
ffDuration = ff.GetDuration();
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandleEffect(uint effIndex)
|
|
{
|
|
Unit caster = GetCaster();
|
|
Unit target = GetHitUnit();
|
|
|
|
if (ffDuration != 0)
|
|
caster.CastSpell(target, SpellIds.FrostFever, true);
|
|
if (bpDuration != 0)
|
|
caster.CastSpell(target, SpellIds.BloodPlague, true);
|
|
|
|
Aura bp = target.GetAura(SpellIds.BloodPlague, caster.GetGUID());
|
|
if (bp != null)
|
|
{
|
|
bp.SetDuration(bpDuration);
|
|
bp.SetMaxDuration(bpDuration);
|
|
}
|
|
|
|
Aura ff = target.GetAura(SpellIds.FrostFever, caster.GetGUID());
|
|
if (ff != null)
|
|
{
|
|
ff.SetDuration(ffDuration);
|
|
ff.SetMaxDuration(ffDuration);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new ObjectAreaTargetSelectHandler(FilterTargets, 0, Targets.UnitDestAreaEnemy));
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleEffect, 0, SpellEffectName.SchoolDamage));
|
|
}
|
|
|
|
int bpDuration;
|
|
int ffDuration;
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_blood_boil_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 49028 - Dancing Rune Weapon 7.1.5
|
|
class spell_dk_dancing_rune_weapon : SpellScriptLoader
|
|
{
|
|
public spell_dk_dancing_rune_weapon() : base("spell_dk_dancing_rune_weapon") { }
|
|
|
|
class spell_dk_dancing_rune_weapon_AuraScript : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
if (Global.ObjectMgr.GetCreatureTemplate(CreatureIds.DancingRuneWeapon) == null)
|
|
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 = null;
|
|
foreach (Unit controlled in caster.m_Controlled)
|
|
{
|
|
if (controlled.GetEntry() == CreatureIds.DancingRuneWeapon)
|
|
{
|
|
drw = controlled;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!drw || !drw.GetVictim())
|
|
return;
|
|
|
|
SpellInfo spellInfo = eventInfo.GetSpellInfo();
|
|
if (spellInfo == null)
|
|
return;
|
|
|
|
DamageInfo damageInfo = eventInfo.GetDamageInfo();
|
|
if (damageInfo == null || damageInfo.GetDamage() == 0)
|
|
return;
|
|
|
|
int amount = (int)(damageInfo.GetDamage() / 2);
|
|
SpellNonMeleeDamage log = new SpellNonMeleeDamage(drw, drw.GetVictim(), spellInfo.Id, spellInfo.GetSpellXSpellVisualId(drw), spellInfo.GetSchoolMask());
|
|
log.damage = (uint)amount;
|
|
drw.DealDamage(drw.GetVictim(), (uint)amount, null, DamageEffectType.Direct, spellInfo.GetSchoolMask(), spellInfo, true);
|
|
drw.SendSpellNonMeleeDamageLog(log);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new EffectProcHandler(HandleProc, 1, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_dancing_rune_weapon_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 43265 - Death and Decay
|
|
class spell_dk_death_and_decay : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_and_decay() : base("spell_dk_death_and_decay") { }
|
|
|
|
class spell_dk_death_and_decay_SpellScript : SpellScript
|
|
{
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
if (GetCaster().HasAura(SpellIds.GlyphOfDeathAndDecay))
|
|
{
|
|
Position pos = GetExplTargetDest();
|
|
if (pos != null)
|
|
GetCaster().CastSpell(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), SpellIds.DeathAndDecaySlow, true);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_death_and_decay_SpellScript();
|
|
}
|
|
|
|
class spell_dk_death_and_decay_AuraScript : AuraScript
|
|
{
|
|
void HandleDummyTick(AuraEffect aurEff)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster)
|
|
caster.CastCustomSpell(SpellIds.DeathAndDecayDamage, SpellValueMod.BasePoint0, aurEff.GetAmount(), GetTarget(), true, null, aurEff);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new EffectPeriodicHandler(HandleDummyTick, 2, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_death_and_decay_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 47541 - Death Coil
|
|
class spell_dk_death_coil : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_coil() : base("spell_dk_death_coil") { }
|
|
|
|
class spell_dk_death_coil_SpellScript : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spell)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.DeathCoilDamage, SpellIds.DeathCoilHeal, SpellIds.GlyphOfDeathCoil);
|
|
}
|
|
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
Unit caster = GetCaster();
|
|
Unit target = GetHitUnit();
|
|
if (target)
|
|
{
|
|
if (caster.IsFriendlyTo(target))
|
|
{
|
|
if (target.GetCreatureType() == CreatureType.Undead) // Any undead ally, including caster if he has lichborne.
|
|
{
|
|
caster.CastSpell(target, SpellIds.DeathCoilHeal, true);
|
|
}
|
|
else if (target != caster) // Any non undead ally except caster and only if caster has glyph of death coil.
|
|
{
|
|
SpellInfo DCD = Global.SpellMgr.GetSpellInfo(SpellIds.DeathCoilDamage);
|
|
SpellEffectInfo eff = DCD.GetEffect(0);
|
|
int bp = (int)caster.SpellDamageBonusDone(target, DCD, (uint)eff.CalcValue(caster), DamageEffectType.SpellDirect, eff);
|
|
|
|
caster.CastCustomSpell(target, SpellIds.DeathCoilBarrier, bp, 0, 0, true);
|
|
}
|
|
}
|
|
else // Any enemy target.
|
|
{
|
|
caster.CastSpell(target, SpellIds.DeathCoilDamage, true);
|
|
}
|
|
}
|
|
|
|
if (caster.HasAura(SpellIds.EnhancedDeathCoil))
|
|
caster.CastSpell(caster, SpellIds.ShadowOfDeath, true);
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit caster = GetCaster();
|
|
Unit target = GetExplTargetUnit();
|
|
if (target)
|
|
{
|
|
if (!caster.IsFriendlyTo(target) && !caster.isInFront(target))
|
|
return SpellCastResult.UnitNotInfront;
|
|
|
|
if (target.IsFriendlyTo(caster) && target.GetCreatureType() != CreatureType.Undead && !caster.HasAura(SpellIds.GlyphOfDeathCoil))
|
|
return SpellCastResult.BadTargets;
|
|
}
|
|
else
|
|
return SpellCastResult.BadTargets;
|
|
|
|
return SpellCastResult.SpellCastOk;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckCast));
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_death_coil_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 52751 - Death Gate
|
|
class spell_dk_death_gate : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_gate() : base("spell_dk_death_gate") { }
|
|
|
|
class spell_dk_death_gate_SpellScript : SpellScript
|
|
{
|
|
SpellCastResult CheckClass()
|
|
{
|
|
if (GetCaster().GetClass() != Class.Deathknight)
|
|
{
|
|
SetCustomCastResultMessage(SpellCustomErrors.MustBeDeathKnight);
|
|
return SpellCastResult.CustomError;
|
|
}
|
|
|
|
return SpellCastResult.SpellCastOk;
|
|
}
|
|
|
|
void HandleScript(uint effIndex)
|
|
{
|
|
PreventHitDefaultEffect(effIndex);
|
|
Unit target = GetHitUnit();
|
|
if (target)
|
|
target.CastSpell(target, (uint)GetEffectValue(), false);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckClass));
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleScript, 0, SpellEffectName.ScriptEffect));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_death_gate_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 49560 - Death Grip
|
|
class spell_dk_death_grip : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_grip() : base("spell_dk_death_grip") { }
|
|
|
|
class spell_dk_death_grip_SpellScript : SpellScript
|
|
{
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
int damage = GetEffectValue();
|
|
Position pos = GetExplTargetDest();
|
|
Unit target = GetHitUnit();
|
|
if (target)
|
|
{
|
|
if (!target.HasAuraType(AuraType.DeflectSpells)) // Deterrence
|
|
target.CastSpell(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), (uint)damage, true);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_death_grip_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 48743 - Death Pact
|
|
class spell_dk_death_pact : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_pact() : base("spell_dk_death_pact") { }
|
|
|
|
class spell_dk_death_pact_AuraScript : AuraScript
|
|
{
|
|
void HandleCalcAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster)
|
|
amount = (int)caster.CountPctFromMaxHealth(amount);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new EffectCalcAmountHandler(HandleCalcAmount, 1, AuraType.SchoolHealAbsorb));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_death_pact_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 49998 - Death Strike
|
|
class spell_dk_death_strike : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_strike() : base("spell_dk_death_strike") { }
|
|
|
|
class spell_dk_death_strike_SpellScript : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.DeathStrikeHeal, SpellIds.BloodShieldMastery, SpellIds.BloodShieldAbsorb);
|
|
}
|
|
|
|
void HandleHeal(uint effIndex)
|
|
{
|
|
Unit caster = GetCaster();
|
|
int heal = (int)caster.GetTotalAttackPowerValue(WeaponAttackType.BaseAttack) * 4; /// todo, add versatality bonus as it will probably not apply to the heal due to its damageclass SPELL_DAMAGE_CLASS_NONE.
|
|
caster.CastCustomSpell(SpellIds.DeathStrikeHeal, SpellValueMod.BasePoint0, heal, caster, true);
|
|
|
|
if (!caster.HasAura(SpellIds.BloodPresence) || !caster.HasAura(SpellIds.ImprovedBloodPresence))
|
|
return;
|
|
|
|
/// todo, if SPELL_AURA_MOD_ABSORB_PERCENTAGE will not apply to SPELL_DAMAGE_CLASS_NONE, resolve must be applied here.
|
|
AuraEffect aurEff = caster.GetAuraEffect(SpellIds.BloodShieldMastery, 0);
|
|
if (aurEff != null)
|
|
caster.CastCustomSpell(SpellIds.BloodShieldAbsorb, SpellValueMod.BasePoint0, MathFunctions.CalculatePct(heal, aurEff.GetAmount()), caster);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleHeal, 1, SpellEffectName.WeaponPercentDamage));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_death_strike_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 85948 - Festering Strike
|
|
class spell_dk_festering_strike : SpellScriptLoader
|
|
{
|
|
public spell_dk_festering_strike() : base("spell_dk_festering_strike") { }
|
|
|
|
class spell_dk_festering_strike_SpellScript : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.FrostFever, SpellIds.BloodPlague, SpellIds.ChainsOfIce);
|
|
}
|
|
|
|
void HandleScriptEffect(uint effIndex)
|
|
{
|
|
int extraDuration = GetEffectValue();
|
|
Unit target = GetHitUnit();
|
|
ObjectGuid casterGUID = GetCaster().GetGUID();
|
|
|
|
Aura ff = target.GetAura(SpellIds.FrostFever, casterGUID);
|
|
if (ff != null)
|
|
{
|
|
int newDuration = Math.Min(ff.GetDuration() + extraDuration, 2 * Time.Minute * Time.InMilliseconds); // caps at 2min.
|
|
ff.SetDuration(newDuration);
|
|
ff.SetMaxDuration(newDuration);
|
|
}
|
|
|
|
Aura bp = target.GetAura(SpellIds.BloodPlague, casterGUID);
|
|
if (bp != null)
|
|
{
|
|
int newDuration = Math.Min(bp.GetDuration() + extraDuration, 2 * Time.Minute * Time.InMilliseconds); // caps at 2min.
|
|
bp.SetDuration(newDuration);
|
|
bp.SetMaxDuration(newDuration);
|
|
}
|
|
|
|
Aura coi = target.GetAura(SpellIds.ChainsOfIce, casterGUID);
|
|
if (coi != null)
|
|
{
|
|
int newDuration = Math.Min(coi.GetDuration() + extraDuration, 20 * Time.InMilliseconds); // is 20sec cap? couldnt manage to get runes up to pass 20.
|
|
coi.SetDuration(newDuration);
|
|
coi.SetMaxDuration(newDuration);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleScriptEffect, 2, SpellEffectName.ScriptEffect));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_festering_strike_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 47496 - Explode, Ghoul spell for Corpse Explosion
|
|
class spell_dk_ghoul_explode : SpellScriptLoader
|
|
{
|
|
public spell_dk_ghoul_explode() : base("spell_dk_ghoul_explode") { }
|
|
|
|
class spell_dk_ghoul_explode_SpellScript : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.CorpseExplosionTriggered);
|
|
}
|
|
|
|
void HandleDamage(uint effIndex)
|
|
{
|
|
SetHitDamage((int)GetCaster().CountPctFromMaxHealth(GetEffectInfo(2).CalcValue(GetCaster())));
|
|
}
|
|
|
|
void Suicide(uint effIndex)
|
|
{
|
|
Unit unitTarget = GetHitUnit();
|
|
if (unitTarget)
|
|
{
|
|
// Corpse Explosion (Suicide)
|
|
unitTarget.CastSpell(unitTarget, SpellIds.CorpseExplosionTriggered, true);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDamage, 0, SpellEffectName.SchoolDamage));
|
|
OnEffectHitTarget.Add(new EffectHandler(Suicide, 1, SpellEffectName.SchoolDamage));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_ghoul_explode_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 58677 - Glyph of Death's Embrace
|
|
class spell_dk_glyph_of_deaths_embrace : SpellScriptLoader
|
|
{
|
|
public spell_dk_glyph_of_deaths_embrace() : base("spell_dk_glyph_of_deaths_embrace") { }
|
|
|
|
class spell_dk_glyph_of_deaths_embrace_AuraScript : AuraScript
|
|
{
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
Unit actionTarget = eventInfo.GetActionTarget();
|
|
return actionTarget && actionTarget.GetCreatureType() == CreatureType.Undead && actionTarget.GetOwner();
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new CheckProcHandler(CheckProc));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_glyph_of_deaths_embrace_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 159429 - Glyph of Runic Power
|
|
class spell_dk_glyph_of_runic_power : SpellScriptLoader
|
|
{
|
|
public spell_dk_glyph_of_runic_power() : base("spell_dk_glyph_of_runic_power") { }
|
|
|
|
class spell_dk_glyph_of_runic_power_AuraScript : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.GlyphOfRunicPowerTriggered);
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetUnitOwner().GetClass() == Class.Deathknight;
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
return eventInfo.GetSpellInfo() != null
|
|
&& Convert.ToBoolean(eventInfo.GetSpellInfo().GetAllEffectsMechanicMask() & (1 << (int)Mechanics.Snare | 1 << (int)Mechanics.Root | 1 << (int)Mechanics.Freeze));
|
|
}
|
|
|
|
void HandleProc(ProcEventInfo eventInfo)
|
|
{
|
|
Unit target = eventInfo.GetProcTarget();
|
|
if (target)
|
|
target.CastSpell(target, SpellIds.GlyphOfRunicPowerTriggered, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new CheckProcHandler(CheckProc));
|
|
OnProc.Add(new AuraProcHandler(HandleProc));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_glyph_of_runic_power_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 48792 - Icebound Fortitude
|
|
class spell_dk_icebound_fortitude : SpellScriptLoader
|
|
{
|
|
public spell_dk_icebound_fortitude() : base("spell_dk_icebound_fortitude") { }
|
|
|
|
class spell_dk_icebound_fortitude_AuraScript : AuraScript
|
|
{
|
|
void CalculateAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
if (GetUnitOwner().HasAura(SpellIds.ImprovedBloodPresence))
|
|
amount += 30; /// todo, figure out how tooltip is updated
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new EffectCalcAmountHandler(CalculateAmount, 2, AuraType.ModDamagePercentTaken));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_icebound_fortitude_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 206940 - Mark of Blood 7.1.5
|
|
class spell_dk_mark_of_blood : SpellScriptLoader
|
|
{
|
|
public spell_dk_mark_of_blood() : base("spell_dk_mark_of_blood") { }
|
|
|
|
class spell_dk_mark_of_blood_AuraScript : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.MarkOfBloodHeal);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
Unit caster = GetCaster();
|
|
if (caster)
|
|
caster.CastSpell(eventInfo.GetProcTarget(), SpellIds.MarkOfBloodHeal, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new EffectProcHandler(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_mark_of_blood_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 207346 - Necrosis 7.1.5
|
|
class spell_dk_necrosis : SpellScriptLoader
|
|
{
|
|
public spell_dk_necrosis() : base("spell_dk_necrosis") { }
|
|
|
|
class spell_dk_necrosis_AuraScript : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.NecrosisEffect);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
GetTarget().CastSpell(eventInfo.GetProcTarget(), SpellIds.NecrosisEffect, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new EffectProcHandler(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_necrosis_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 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 : SpellScriptLoader
|
|
{
|
|
public spell_dk_pet_geist_transform() : base("spell_dk_pet_geist_transform") { }
|
|
|
|
class spell_dk_pet_geist_transform_SpellScript : SpellScript
|
|
{
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsPet();
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit owner = GetCaster().GetOwner();
|
|
if (owner)
|
|
if (owner.HasAura(SpellIds.GlyphOfTheGeist))
|
|
return SpellCastResult.SpellCastOk;
|
|
|
|
return SpellCastResult.SpellUnavailable;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckCast));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_pet_geist_transform_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 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 : SpellScriptLoader
|
|
{
|
|
public spell_dk_pet_skeleton_transform() : base("spell_dk_pet_skeleton_transform") { }
|
|
|
|
class spell_dk_pet_skeleton_transform_SpellScript : SpellScript
|
|
{
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit owner = GetCaster().GetOwner();
|
|
if (owner)
|
|
if (owner.HasAura(SpellIds.GlyphOfTheSkeleton))
|
|
return SpellCastResult.SpellCastOk;
|
|
|
|
return SpellCastResult.SpellUnavailable;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckCast));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_pet_skeleton_transform_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 61257 - Runic Power Back on Snare/Root 7.1.5
|
|
class spell_dk_pvp_4p_bonus : SpellScriptLoader
|
|
{
|
|
public spell_dk_pvp_4p_bonus() : base("spell_dk_pvp_4p_bonus") { }
|
|
|
|
class spell_dk_pvp_4p_bonus_AuraScript : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.RunicReturn);
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
SpellInfo spellInfo = eventInfo.GetSpellInfo();
|
|
if (spellInfo == null)
|
|
return false;
|
|
|
|
return (spellInfo.GetAllEffectsMechanicMask() & ((1 << (int)Mechanics.Root) | (1 << (int)Mechanics.Snare))) != 0;
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
eventInfo.GetActionTarget().CastSpell((Unit)null, SpellIds.RunicReturn, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new CheckProcHandler(CheckProc));
|
|
OnEffectProc.Add(new EffectProcHandler(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_pvp_4p_bonus_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 46584 - Raise Dead
|
|
class spell_dk_raise_dead : SpellScriptLoader
|
|
{
|
|
public spell_dk_raise_dead() : base("spell_dk_raise_dead") { }
|
|
|
|
class spell_dk_raise_dead_SpellScript : SpellScript
|
|
{
|
|
public spell_dk_raise_dead_SpellScript() { }
|
|
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return spellInfo.GetEffect(0) != null && ValidateSpellInfo((uint)spellInfo.GetEffect(0).CalcValue());
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsTypeId(TypeId.Player);
|
|
}
|
|
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell((Unit)null, (uint)GetEffectValue(), true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_raise_dead_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 114866 - Soul Reaper, 130735 - Soul Reaper, 130736 - Soul Reaper
|
|
class spell_dk_soul_reaper : SpellScriptLoader
|
|
{
|
|
public spell_dk_soul_reaper() : base("spell_dk_soul_reaper") { }
|
|
|
|
class spell_dk_soul_reaper_AuraScript : AuraScript
|
|
{
|
|
void HandlePeriodicDummy(AuraEffect aurEff)
|
|
{
|
|
Unit caster = GetCaster();
|
|
Unit target = GetUnitOwner();
|
|
|
|
if (!caster || !target)
|
|
return;
|
|
|
|
float pct = target.GetHealthPct();
|
|
|
|
if (pct < 35.0f || (pct < 45.0f && (caster.HasAura(SpellIds.ImprovedSoulReaper) || caster.HasAura(SpellIds.T15Dps4pBonus))))
|
|
caster.CastSpell(target, SpellIds.SoulReaperDamage, true, null, aurEff);
|
|
}
|
|
|
|
void HandleRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
if (GetTargetApplication().GetRemoveMode() != AuraRemoveMode.ByDeath)
|
|
return;
|
|
|
|
Unit caster = GetCaster();
|
|
if (caster)
|
|
caster.CastSpell(caster, SpellIds.SoulReaperHaste, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new EffectPeriodicHandler(HandlePeriodicDummy, 1, AuraType.PeriodicDummy));
|
|
AfterEffectRemove.Add(new EffectApplyHandler(HandleRemove, 1, AuraType.PeriodicDummy, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_soul_reaper_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 115994 - Unholy Blight
|
|
class spell_dk_unholy_blight : SpellScriptLoader
|
|
{
|
|
public spell_dk_unholy_blight() : base("spell_dk_unholy_blight") { }
|
|
|
|
class spell_dk_unholy_blight_SpellScript : SpellScript
|
|
{
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.FrostFever, true);
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.BloodPlague, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_unholy_blight_SpellScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 55233 - Vampiric Blood
|
|
class spell_dk_vampiric_blood : SpellScriptLoader
|
|
{
|
|
public spell_dk_vampiric_blood() : base("spell_dk_vampiric_blood") { }
|
|
|
|
class spell_dk_vampiric_blood_AuraScript : AuraScript
|
|
{
|
|
void CalculateAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
amount = (int)GetUnitOwner().CountPctFromMaxHealth(amount);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new EffectCalcAmountHandler(CalculateAmount, 1, AuraType.ModIncreaseHealth));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_vampiric_blood_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 81164 - Will of the Necropolis
|
|
class spell_dk_will_of_the_necropolis : SpellScriptLoader
|
|
{
|
|
public spell_dk_will_of_the_necropolis() : base("spell_dk_will_of_the_necropolis") { }
|
|
|
|
class spell_dk_will_of_the_necropolis_AuraScript : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return spellInfo.GetEffect(0) != null && ValidateSpellInfo(SpellIds.WillOfTheNecropolis);
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
Unit target = GetTarget();
|
|
|
|
if (target.HasAura(SpellIds.WillOfTheNecropolis))
|
|
return false;
|
|
|
|
return target.HealthBelowPctDamaged(30, eventInfo.GetDamageInfo().GetDamage());
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.WillOfTheNecropolis, true, null, aurEff);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new CheckProcHandler(CheckProc));
|
|
OnEffectProc.Add(new EffectProcHandler(HandleProc, 0, AuraType.ProcTriggerSpell));
|
|
}
|
|
}
|
|
|
|
public override AuraScript GetAuraScript()
|
|
{
|
|
return new spell_dk_will_of_the_necropolis_AuraScript();
|
|
}
|
|
}
|
|
|
|
[Script] // 49576 - Death Grip Initial
|
|
class spell_dk_death_grip_initial : SpellScriptLoader
|
|
{
|
|
public spell_dk_death_grip_initial() : base("spell_dk_death_grip_initial") { }
|
|
|
|
class spell_dk_death_grip_initial_SpellScript : SpellScript
|
|
{
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit caster = GetCaster();
|
|
// Death Grip should not be castable while jumping/falling
|
|
if (caster.HasUnitState(UnitState.Jumping) || caster.HasUnitMovementFlag(MovementFlag.Falling))
|
|
return SpellCastResult.Moving;
|
|
|
|
// Patch 3.3.3 (2010-03-23): Minimum range has been changed to 8 yards in PvP.
|
|
Unit target = GetExplTargetUnit();
|
|
if (target && target.IsTypeId(TypeId.Player))
|
|
if (caster.GetDistance(target) < 8.0f)
|
|
return SpellCastResult.TooClose;
|
|
|
|
return SpellCastResult.SpellCastOk;
|
|
}
|
|
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.DeathGrip, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new CheckCastHandler(CheckCast));
|
|
OnEffectHitTarget.Add(new EffectHandler(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
public override SpellScript GetSpellScript()
|
|
{
|
|
return new spell_dk_death_grip_initial_SpellScript();
|
|
}
|
|
}
|
|
}
|