Hondacrx
2560 lines
80 KiB
C#
2560 lines
80 KiB
C#
// Copyright (c) CypherCore <http://github.com/CypherCore> All rights reserved.
|
|
// Licensed under the Gnu General Public License. See License file in the project root for full license information.
|
|
|
|
using Framework.Constants;
|
|
using Framework.Dynamic;
|
|
using Game.AI;
|
|
using Game.DataStorage;
|
|
using Game.Entities;
|
|
using Game.Maps;
|
|
using Game.Scripting;
|
|
using Game.Spells;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Scripts.Spells.Druid;
|
|
|
|
struct SpellIds
|
|
{
|
|
public const uint Abundance = 207383;
|
|
public const uint AbundanceEffect = 207640;
|
|
public const uint AstralCommunionEnergize = 450599;
|
|
public const uint AstralCommunionTalent = 450598;
|
|
public const uint AstralSmolderDamage = 394061;
|
|
public const uint BalanceT10_Bonus = 70718;
|
|
public const uint BalanceT10_BonusProc = 70721;
|
|
public const uint BearForm = 5487;
|
|
public const uint BlessingOfCenarius = 40452;
|
|
public const uint BlessingOfElune = 40446;
|
|
public const uint BlessingOfRemulos = 40445;
|
|
public const uint BlessingOfTheClaw = 28750;
|
|
public const uint BloodFrenzyAura = 203962;
|
|
public const uint BloodFrenzyRageGain = 203961;
|
|
public const uint BramblesDamageAura = 213709;
|
|
public const uint BramblesPassive = 203953;
|
|
public const uint BramblesReflect = 203958;
|
|
public const uint BristlingFurGainRage = 204031;
|
|
public const uint CatForm = 768;
|
|
public const uint Cultivation = 200390;
|
|
public const uint CultivationHeal = 200389;
|
|
public const uint CuriousBramblepatch = 330670;
|
|
public const uint Dreamstate = 450346;
|
|
public const uint DreamOfCenarius = 372152;
|
|
public const uint DreamOfCenariusCooldown = 372523;
|
|
public const uint EarthwardenAura = 203975;
|
|
public const uint EclipseDummy = 79577;
|
|
public const uint EclipseLunarAura = 48518;
|
|
public const uint EclipseLunarSpellCnt = 326055;
|
|
public const uint EclipseOoc = 329910;
|
|
public const uint EclipseSolarAura = 48517;
|
|
public const uint EclipseSolarSpellCnt = 326053;
|
|
public const uint EclipseVisualLunar = 93431;
|
|
public const uint EclipseVisualSolar = 93430;
|
|
public const uint EfflorescenceAura = 81262;
|
|
public const uint EfflorescenceHeal = 81269;
|
|
public const uint EmbraceOfTheDreamEffect = 392146;
|
|
public const uint EmbraceOfTheDreamHeal = 392147;
|
|
public const uint EntanglingRoots = 339;
|
|
public const uint Exhilarate = 28742;
|
|
public const uint FormAquaticPassive = 276012;
|
|
public const uint FormAquatic = 1066;
|
|
public const uint FormFlight = 33943;
|
|
public const uint FormStag = 165961;
|
|
public const uint FormSwiftFlight = 40120;
|
|
public const uint FormsTrinketBear = 37340;
|
|
public const uint FormsTrinketCat = 37341;
|
|
public const uint FormsTrinketMoonkin = 37343;
|
|
public const uint FormsTrinketNone = 37344;
|
|
public const uint FormsTrinketTree = 37342;
|
|
public const uint FullMoon = 274283;
|
|
public const uint GalacticGuardianAura = 213708;
|
|
public const uint Germination = 155675;
|
|
public const uint GlyphOfStars = 114301;
|
|
public const uint GlyphOfStarsVisual = 114302;
|
|
public const uint GoreProc = 93622;
|
|
public const uint Growl = 6795;
|
|
public const uint HalfMoon = 274282;
|
|
public const uint HalfMoonOverride = 274297;
|
|
public const uint IdolOfFeralShadows = 34241;
|
|
public const uint IdolOfWorship = 60774;
|
|
public const uint Incarnation = 117679;
|
|
public const uint IncarnationKingOfTheJungle = 102543;
|
|
public const uint IncarnationTreeOfLife = 33891;
|
|
public const uint InnerPeace = 197073;
|
|
public const uint Innervate = 29166;
|
|
public const uint InnervateRank2 = 326228;
|
|
public const uint Infusion = 37238;
|
|
public const uint Languish = 71023;
|
|
public const uint LifebloomFinalHeal = 33778;
|
|
public const uint LunarBeamHeal = 204069;
|
|
public const uint LunarBeamDamage = 414613;
|
|
public const uint LunarInspirationOverride = 155627;
|
|
public const uint Mangle = 33917;
|
|
public const uint MangleTalent = 231064;
|
|
public const uint MassEntanglement = 102359;
|
|
public const uint MoonfireDamage = 164812;
|
|
public const uint NaturesGraceTalent = 450347;
|
|
public const uint NewMoon = 274281;
|
|
public const uint NewMoonOverride = 274295;
|
|
public const uint PowerOfTheArchdruid = 392302;
|
|
public const uint Prowl = 5215;
|
|
public const uint Regrowth = 8936;
|
|
public const uint Rejuvenation = 774;
|
|
public const uint RejuvenationGermination = 155777;
|
|
public const uint RejuvenationT10_Proc = 70691;
|
|
public const uint RestorationT10_2PBonus = 70658;
|
|
public const uint SavageRoar = 62071;
|
|
public const uint ShootingStars = 202342;
|
|
public const uint ShootingStarsDamage = 202497;
|
|
public const uint SkullBashCharge = 221514;
|
|
public const uint SkullBashInterrupt = 93985;
|
|
public const uint SpringBlossoms = 207385;
|
|
public const uint SpringBlossomsHeal = 207386;
|
|
public const uint StarBurst = 356474;
|
|
public const uint SunfireDamage = 164815;
|
|
public const uint SurvivalInstincts = 50322;
|
|
public const uint TravelForm = 783;
|
|
public const uint TreeOfLife = 33891;
|
|
public const uint ThrashBear = 77758;
|
|
public const uint ThrashBearAura = 192090;
|
|
public const uint ThrashCat = 106830;
|
|
public const uint UmbralEmbrace = 393763;
|
|
public const uint UmbralInspirationTalent = 450418;
|
|
public const uint UmbralInspirationAura = 450419;
|
|
public const uint UrsocsFuryShield = 372505;
|
|
public const uint YserasGiftHealParty = 145110;
|
|
public const uint YserasGiftHealSelf = 145109;
|
|
}
|
|
|
|
// 774 - Rejuvenation
|
|
[Script] // 155777 - Rejuvenation (Germination)
|
|
class spell_dru_abundance : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Abundance, SpellIds.AbundanceEffect);
|
|
}
|
|
|
|
void HandleOnApplyOrReapply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster == null || !caster.HasAura(SpellIds.Abundance))
|
|
return;
|
|
|
|
// Note: caster only casts Abundance when first applied on the target, otherwise that given stack is refreshed.
|
|
if ((mode & AuraEffectHandleModes.Real) != 0)
|
|
caster.CastSpell(caster, SpellIds.AbundanceEffect, new CastSpellExtraArgs().SetTriggeringAura(aurEff));
|
|
else
|
|
{
|
|
Aura abundanceAura = caster.GetAura(SpellIds.AbundanceEffect);
|
|
if (abundanceAura != null)
|
|
abundanceAura.RefreshDuration();
|
|
}
|
|
}
|
|
|
|
void HandleOnRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster == null)
|
|
return;
|
|
|
|
Aura abundanceEffect = caster.GetAura(SpellIds.AbundanceEffect);
|
|
if (abundanceEffect != null)
|
|
abundanceEffect.ModStackAmount(-1);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectApply.Add(new(HandleOnApplyOrReapply, 0, AuraType.PeriodicHeal, AuraEffectHandleModes.RealOrReapplyMask));
|
|
AfterEffectRemove.Add(new(HandleOnRemove, 0, AuraType.PeriodicHeal, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
// 102560 - Incarnation: Chosen of Elune
|
|
// 194223 - Celestial Alignment
|
|
// 383410 - Celestial Alignment
|
|
[Script] // 390414 - Incarnation: Chosen of Elune
|
|
class spell_dru_astral_communion_celestial_alignment : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.AstralCommunionTalent, SpellIds.AstralCommunionEnergize);
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().HasAura(SpellIds.AstralCommunionTalent);
|
|
}
|
|
|
|
void Energize()
|
|
{
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.AstralCommunionEnergize, new CastSpellExtraArgs()
|
|
.SetTriggeringSpell(GetSpell())
|
|
.SetTriggerFlags(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterCast.Add(new(Energize));
|
|
}
|
|
}
|
|
|
|
[Script] // 394058 - Astral Smolder
|
|
class spell_dru_astral_smolder : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellEffect((SpellIds.AstralSmolderDamage, 0))
|
|
&& Global.SpellMgr.GetSpellInfo(SpellIds.AstralSmolderDamage, Difficulty.None).GetMaxTicks() != 0;
|
|
}
|
|
|
|
bool CheckProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
return eventInfo.GetProcTarget() != null;
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
|
|
SpellInfo astralSmolderDmg = Global.SpellMgr.GetSpellInfo(SpellIds.AstralSmolderDamage, GetCastDifficulty());
|
|
int pct = aurEff.GetAmount();
|
|
|
|
int amount = (int)(MathFunctions.CalculatePct(eventInfo.GetDamageInfo().GetDamage(), pct) / astralSmolderDmg.GetMaxTicks());
|
|
|
|
CastSpellExtraArgs args = new(aurEff);
|
|
args.AddSpellMod(SpellValueMod.BasePoint0, amount);
|
|
GetTarget().CastSpell(eventInfo.GetProcTarget(), SpellIds.AstralSmolderDamage, args);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckProc, 0, AuraType.Dummy));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 22812 - Barkskin
|
|
class spell_dru_barkskin : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BramblesPassive);
|
|
}
|
|
|
|
void HandlePeriodic(AuraEffect aurEff)
|
|
{
|
|
Unit target = GetTarget();
|
|
if (target.HasAura(SpellIds.BramblesPassive))
|
|
target.CastSpell(target, SpellIds.BramblesDamageAura, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(HandlePeriodic, 2, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 50334 - Berserk
|
|
class spell_dru_berserk : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BearForm, SpellIds.Mangle, SpellIds.ThrashBear, SpellIds.Growl);
|
|
}
|
|
|
|
void HandleOnCast()
|
|
{
|
|
// Change into correct form
|
|
if (GetCaster().GetShapeshiftForm() != ShapeShiftForm.BearForm)
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.BearForm, true);
|
|
}
|
|
|
|
void ResetCooldowns()
|
|
{
|
|
GetCaster().GetSpellHistory().ResetCooldown(SpellIds.Mangle);
|
|
GetCaster().GetSpellHistory().ResetCooldown(SpellIds.ThrashBear);
|
|
GetCaster().GetSpellHistory().ResetCooldown(SpellIds.Growl);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
BeforeCast.Add(new(HandleOnCast));
|
|
AfterCast.Add(new(ResetCooldowns));
|
|
}
|
|
}
|
|
|
|
[Script] // 203953 - Brambles - SpellBramblesPassive
|
|
class spell_dru_brambles : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BramblesReflect, SpellIds.BramblesDamageAura);
|
|
}
|
|
|
|
void HandleAbsorb(AuraEffect aurEff, DamageInfo dmgInfo, ref uint absorbAmount)
|
|
{
|
|
// Prevent Removal
|
|
PreventDefaultAction();
|
|
}
|
|
|
|
void HandleAfterAbsorb(AuraEffect aurEff, DamageInfo dmgInfo, ref uint absorbAmount)
|
|
{
|
|
// reflect back damage to the attacker
|
|
Unit target = GetTarget();
|
|
Unit attacker = dmgInfo.GetAttacker();
|
|
if (attacker != null)
|
|
target.CastSpell(attacker, SpellIds.BramblesReflect, new CastSpellExtraArgs(TriggerCastFlags.FullMask).AddSpellMod(SpellValueMod.BasePoint0, (int)absorbAmount));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectAbsorb.Add(new(HandleAbsorb, 0));
|
|
AfterEffectAbsorb.Add(new(HandleAfterAbsorb, 0));
|
|
}
|
|
}
|
|
|
|
[Script] // 155835 - Bristling Fur
|
|
class spell_dru_bristling_fur : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BristlingFurGainRage);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
// BristlingFurRage = 100 * Damage / MaxHealth.
|
|
DamageInfo damageInfo = eventInfo.GetDamageInfo();
|
|
if (damageInfo != null)
|
|
{
|
|
Unit target = GetTarget();
|
|
int rage = (int)(target.GetMaxPower(PowerType.Rage) * (float)damageInfo.GetDamage() / (float)target.GetMaxHealth());
|
|
if (rage > 0)
|
|
target.CastSpell(target, SpellIds.BristlingFurGainRage, new CastSpellExtraArgs(TriggerCastFlags.FullMask).AddSpellMod(SpellValueMod.BasePoint0, rage));
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 768 - CatForm - SpellCatForm
|
|
class spell_dru_cat_form : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Prowl);
|
|
}
|
|
|
|
void HandleAfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveOwnedAura(SpellIds.Prowl);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectRemove.Add(new(HandleAfterRemove, 0, AuraType.ModShapeshift, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
// 102560 - Incarnation: Chosen of Elune
|
|
// 194223 - Celestial Alignment
|
|
// 383410 - Celestial Alignment
|
|
[Script] // 390414 - Incarnation: Chosen of Elune
|
|
class spell_dru_celestial_alignment : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EclipseSolarAura, SpellIds.EclipseLunarAura, SpellIds.EclipseVisualSolar, SpellIds.EclipseVisualLunar);
|
|
}
|
|
|
|
void TriggerEclipses()
|
|
{
|
|
Unit caster = GetCaster();
|
|
CastSpellExtraArgs args = new();
|
|
args.SetTriggeringSpell(GetSpell());
|
|
args.SetTriggerFlags(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError);
|
|
|
|
caster.CastSpell(caster, SpellIds.EclipseSolarAura, args);
|
|
caster.CastSpell(caster, SpellIds.EclipseLunarAura, args);
|
|
caster.CastSpell(caster, SpellIds.EclipseVisualSolar, args);
|
|
caster.CastSpell(caster, SpellIds.EclipseVisualLunar, args);
|
|
}
|
|
|
|
|
|
public override void Register()
|
|
{
|
|
AfterCast.Add(new(TriggerEclipses));
|
|
}
|
|
}
|
|
|
|
// 774 - Rejuvenation
|
|
[Script] // 155777 - Rejuventation (Germination)
|
|
class spell_dru_cultivation : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.CultivationHeal)
|
|
&& ValidateSpellEffect((SpellIds.Cultivation, 0));
|
|
}
|
|
|
|
void HandleOnTick(AuraEffect aurEff)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster == null)
|
|
return;
|
|
|
|
Unit target = GetTarget();
|
|
AuraEffect cultivationEffect = caster.GetAuraEffect(SpellIds.Cultivation, 0);
|
|
if (cultivationEffect != null)
|
|
if (target.HealthBelowPct(cultivationEffect.GetAmount()))
|
|
caster.CastSpell(target, SpellIds.CultivationHeal, new CastSpellExtraArgs().SetTriggeringAura(aurEff));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(HandleOnTick, 0, AuraType.PeriodicHeal));
|
|
}
|
|
}
|
|
|
|
[Script] // 1850 - Dash
|
|
class spell_dru_dash : AuraScript
|
|
{
|
|
void CalculateAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
// do not set speed if not in cat form
|
|
if (GetUnitOwner().GetShapeshiftForm() != ShapeShiftForm.CatForm)
|
|
amount = 0;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new(CalculateAmount, 0, AuraType.ModIncreaseSpeed));
|
|
}
|
|
}
|
|
|
|
[Script] // 372119 - Dream of Cenarius (Guardian)
|
|
class spell_dru_dream_of_cenarius_guardian : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.DreamOfCenarius, SpellIds.DreamOfCenariusCooldown);
|
|
}
|
|
|
|
bool CheckEffectProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
if (GetUnitOwner().HasAura(SpellIds.DreamOfCenariusCooldown))
|
|
return false;
|
|
|
|
return RandomHelper.randChance(GetUnitOwner().GetUnitCriticalChanceDone(WeaponAttackType.BaseAttack));
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo procInfo)
|
|
{
|
|
Unit target = GetTarget();
|
|
CastSpellExtraArgs args = new();
|
|
args.SetTriggeringAura(aurEff);
|
|
args.SetTriggerFlags(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError);
|
|
|
|
target.CastSpell(target, SpellIds.DreamOfCenarius, args);
|
|
target.CastSpell(target, SpellIds.DreamOfCenariusCooldown, args);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckEffectProc, 0, AuraType.Dummy));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 203974 - Earthwarden
|
|
class spell_dru_earthwarden : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.ThrashCat, SpellIds.ThrashBear, SpellIds.EarthwardenAura);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
Unit target = GetTarget();
|
|
target.CastSpell(target, SpellIds.EarthwardenAura, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
class spell_dru_eclipse_common
|
|
{
|
|
public static void SetSpellCount(Unit unitOwner, uint spellId, uint amount)
|
|
{
|
|
Aura aura = unitOwner.GetAura(spellId);
|
|
if (aura == null)
|
|
unitOwner.CastSpell(unitOwner, spellId, new CastSpellExtraArgs(TriggerCastFlags.FullMask).AddSpellMod(SpellValueMod.AuraStack, (int)amount));
|
|
else
|
|
aura.SetStackAmount((byte)amount);
|
|
}
|
|
}
|
|
|
|
[Script] // 48517 Eclipse (Solar) + 48518 Eclipse (Lunar)
|
|
class spell_dru_eclipse_aura : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EclipseLunarSpellCnt, SpellIds.EclipseSolarSpellCnt, SpellIds.EclipseDummy);
|
|
}
|
|
|
|
void HandleRemoved(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
AuraEffect auraEffDummy = GetTarget().GetAuraEffect(SpellIds.EclipseDummy, 0);
|
|
if (auraEffDummy == null)
|
|
return;
|
|
|
|
uint spellId = GetSpellInfo().Id == SpellIds.EclipseSolarAura ? SpellIds.EclipseLunarSpellCnt : SpellIds.EclipseSolarSpellCnt;
|
|
spell_dru_eclipse_common.SetSpellCount(GetTarget(), spellId, (uint)auraEffDummy.GetAmount());
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectRemove.Add(new(HandleRemoved, 0, AuraType.AddPctModifier, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 79577 - Eclipse - SpellIds.EclipseDummy
|
|
class spell_dru_eclipse_dummy : AuraScript
|
|
{
|
|
class InitializeEclipseCountersEvent(Unit owner, uint count) : BasicEvent()
|
|
{
|
|
public override bool Execute(ulong e_time, uint p_time)
|
|
{
|
|
spell_dru_eclipse_common.SetSpellCount(owner, SpellIds.EclipseSolarSpellCnt, count);
|
|
spell_dru_eclipse_common.SetSpellCount(owner, SpellIds.EclipseLunarSpellCnt, count);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EclipseSolarSpellCnt, SpellIds.EclipseLunarSpellCnt, SpellIds.EclipseSolarAura, SpellIds.EclipseLunarAura, SpellIds.AstralCommunionTalent, SpellIds.AstralCommunionEnergize);
|
|
}
|
|
|
|
void HandleProc(ProcEventInfo eventInfo)
|
|
{
|
|
SpellInfo spellInfo = eventInfo.GetSpellInfo();
|
|
if (spellInfo != null)
|
|
{
|
|
if (spellInfo.SpellFamilyFlags & new FlagArray128(0x4, 0x0, 0x0, 0x0)) // Starfire
|
|
OnSpellCast(SpellIds.EclipseSolarSpellCnt, SpellIds.EclipseLunarSpellCnt, SpellIds.EclipseSolarAura);
|
|
else if (spellInfo.SpellFamilyFlags & new FlagArray128(0x1, 0x0, 0x0, 0x0)) // Wrath
|
|
OnSpellCast(SpellIds.EclipseLunarSpellCnt, SpellIds.EclipseSolarSpellCnt, SpellIds.EclipseLunarAura);
|
|
}
|
|
}
|
|
|
|
void HandleApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
// counters are applied with a delay
|
|
GetTarget().m_Events.AddEventAtOffset(new InitializeEclipseCountersEvent(GetTarget(), (uint)aurEff.GetAmount()), TimeSpan.FromSeconds(1));
|
|
}
|
|
|
|
void HandleRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveAura(SpellIds.EclipseSolarSpellCnt);
|
|
GetTarget().RemoveAura(SpellIds.EclipseLunarSpellCnt);
|
|
}
|
|
|
|
void OnOwnerOutOfCombat(bool isNowInCombat)
|
|
{
|
|
if (!isNowInCombat)
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.EclipseOoc, TriggerCastFlags.FullMask);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectApply.Add(new(HandleApply, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
AfterEffectRemove.Add(new(HandleRemove, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
OnProc.Add(new(HandleProc));
|
|
OnEnterLeaveCombat.Add(new(OnOwnerOutOfCombat));
|
|
}
|
|
|
|
|
|
void OnSpellCast(uint cntSpellId, uint otherCntSpellId, uint eclipseAuraSpellId)
|
|
{
|
|
Unit target = GetTarget();
|
|
Aura aura = target.GetAura(cntSpellId);
|
|
if (aura != null)
|
|
{
|
|
uint remaining = aura.GetStackAmount();
|
|
if (remaining == 0)
|
|
return;
|
|
|
|
if (remaining > 1)
|
|
aura.SetStackAmount((byte)(remaining - 1));
|
|
else
|
|
{
|
|
// cast eclipse
|
|
target.CastSpell(target, eclipseAuraSpellId, TriggerCastFlags.FullMask);
|
|
|
|
if (target.HasAura(SpellIds.AstralCommunionTalent))
|
|
target.CastSpell(target, SpellIds.AstralCommunionEnergize, true);
|
|
|
|
// Remove stacks from other one as well
|
|
// reset remaining power on other spellId
|
|
target.RemoveAura(cntSpellId);
|
|
target.RemoveAura(otherCntSpellId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Script] // 329910 - Eclipse out of combat - SpellEclipseOoc
|
|
class spell_dru_eclipse_ooc : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EclipseDummy, SpellIds.EclipseSolarSpellCnt, SpellIds.EclipseLunarSpellCnt);
|
|
}
|
|
|
|
void Tick(AuraEffect aurEff)
|
|
{
|
|
Unit owner = GetTarget();
|
|
AuraEffect auraEffDummy = owner.GetAuraEffect(SpellIds.EclipseDummy, 0);
|
|
if (auraEffDummy == null)
|
|
return;
|
|
|
|
if (!owner.IsInCombat() && (!owner.HasAura(SpellIds.EclipseSolarSpellCnt) || !owner.HasAura(SpellIds.EclipseLunarSpellCnt)))
|
|
{
|
|
// Restore 2 stacks to each spell when out of combat
|
|
spell_dru_eclipse_common.SetSpellCount(owner, SpellIds.EclipseSolarSpellCnt, (uint)auraEffDummy.GetAmount());
|
|
spell_dru_eclipse_common.SetSpellCount(owner, SpellIds.EclipseLunarSpellCnt, (uint)auraEffDummy.GetAmount());
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(Tick, 0, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 145205 - Efflorescence
|
|
class spell_dru_efflorescence : SpellScript
|
|
{
|
|
void RemoveOldAreaTrigger(uint effIndex)
|
|
{
|
|
// if caster has any Efflorescence areatrigger, we remove it.
|
|
GetCaster().RemoveAreaTrigger(GetSpellInfo().Id);
|
|
}
|
|
|
|
void InitSummon()
|
|
{
|
|
foreach (var summonedObject in GetSpell().GetExecuteLogEffect(SpellEffectName.Summon).GenericVictimTargets)
|
|
{
|
|
Unit summon = ObjectAccessor.GetCreature(GetCaster(), summonedObject.Victim);
|
|
if (summon != null)
|
|
summon.CastSpell(summon, SpellIds.EfflorescenceAura,
|
|
new CastSpellExtraArgs().SetTriggeringSpell(GetSpell()));
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectLaunch.Add(new(RemoveOldAreaTrigger, 2, SpellEffectName.CreateAreaTrigger));
|
|
AfterCast.Add(new(InitSummon));
|
|
}
|
|
}
|
|
|
|
[Script] // 81262 - Efflorescence (Dummy)
|
|
class spell_dru_efflorescence_dummy : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EfflorescenceHeal);
|
|
}
|
|
|
|
void HandlePeriodicDummy(AuraEffect aurEff)
|
|
{
|
|
Unit target = GetTarget();
|
|
Unit summoner = target.GetOwner();
|
|
if (summoner == null)
|
|
return;
|
|
|
|
summoner.CastSpell(target, SpellIds.EfflorescenceHeal, TriggerCastFlags.DontReportCastError);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(HandlePeriodicDummy, 0, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 81269 - Efflorescence (Heal)
|
|
class spell_dru_efflorescence_heal : SpellScript
|
|
{
|
|
void FilterTargets(List<WorldObject> targets)
|
|
{
|
|
// Efflorescence became a smart heal which prioritizes players and their pets in their group before any unit outside their group.
|
|
SelectRandomInjuredTargets(targets, 3, true, GetCaster());
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new(FilterTargets, 0, Targets.UnitDestAreaAlly));
|
|
}
|
|
}
|
|
|
|
[Script] // 392124 - Embrace of the Dream
|
|
class spell_dru_embrace_of_the_dream : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EmbraceOfTheDreamEffect)
|
|
&& ValidateSpellEffect((spellInfo.Id, 2));
|
|
}
|
|
|
|
bool CheckProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
return RandomHelper.randChance(GetEffectInfo(2).CalcValue(GetCaster()));
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.EmbraceOfTheDreamEffect,
|
|
new CastSpellExtraArgs(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError)
|
|
.SetTriggeringAura(aurEff)
|
|
.SetTriggeringSpell(eventInfo.GetProcSpell()));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckProc, 0, AuraType.Dummy));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 392146 - Embrace of the Dream (Selector)
|
|
class spell_dru_embrace_of_the_dream_effect : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EmbraceOfTheDreamHeal, SpellIds.Regrowth, SpellIds.Rejuvenation, SpellIds.RejuvenationGermination);
|
|
}
|
|
|
|
void FilterTargets(List<WorldObject> targets)
|
|
{
|
|
targets.RemoveAll(target =>
|
|
{
|
|
Unit unitTarget = target.ToUnit();
|
|
return unitTarget == null || unitTarget.GetAuraEffect(AuraType.PeriodicHeal, SpellFamilyNames.Druid, new FlagArray128(0x50, 0, 0, 0), GetCaster().GetGUID()) == null;
|
|
});
|
|
}
|
|
|
|
void HandleEffect(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.EmbraceOfTheDreamHeal,
|
|
new CastSpellExtraArgs(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError)
|
|
.SetTriggeringSpell(GetSpell()));
|
|
}
|
|
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new(FilterTargets, 0, Targets.UnitDestAreaAlly));
|
|
OnEffectHitTarget.Add(new(HandleEffect, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
// 339 - Entangling Roots
|
|
[Script] // 102359 - Mass Entanglement
|
|
class spell_dru_entangling_roots : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.CuriousBramblepatch);
|
|
}
|
|
|
|
void HandleCuriousBramblepatch(ref WorldObject target)
|
|
{
|
|
if (!GetCaster().HasAura(SpellIds.CuriousBramblepatch))
|
|
target = null;
|
|
}
|
|
|
|
void HandleCuriousBramblepatchAoe(List<WorldObject> targets)
|
|
{
|
|
if (!GetCaster().HasAura(SpellIds.CuriousBramblepatch))
|
|
targets.Clear();
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectTargetSelect.Add(new(HandleCuriousBramblepatch, 1, Targets.UnitTargetEnemy));
|
|
if (m_scriptSpellId == SpellIds.MassEntanglement)
|
|
OnObjectAreaTargetSelect.Add(new(HandleCuriousBramblepatchAoe, 1, Targets.UnitDestAreaEnemy));
|
|
}
|
|
}
|
|
|
|
[Script]
|
|
class spell_dru_entangling_roots_aura : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EntanglingRoots, SpellIds.MassEntanglement);
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
SpellInfo spellInfo = eventInfo.GetSpellInfo();
|
|
if (spellInfo != null)
|
|
{
|
|
// dont subtract dmg caused by roots from dmg required to break root
|
|
if (spellInfo.Id == SpellIds.EntanglingRoots || spellInfo.Id == SpellIds.MassEntanglement)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new(CheckProc));
|
|
}
|
|
}
|
|
|
|
[Script] // 22568 - Ferocious Bite
|
|
class spell_dru_ferocious_bite : SpellScript
|
|
{
|
|
float _damageMultiplier;
|
|
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellEffect((SpellIds.IncarnationKingOfTheJungle, 1));
|
|
}
|
|
|
|
void HandleHitTargetBurn(uint effIndex)
|
|
{
|
|
int newValue = (int)((float)GetEffectValue() * _damageMultiplier);
|
|
SetEffectValue(newValue);
|
|
}
|
|
|
|
void HandleHitTargetDmg(uint effIndex)
|
|
{
|
|
int newValue = (int)((float)GetHitDamage() * (1.0f + _damageMultiplier));
|
|
SetHitDamage(newValue);
|
|
}
|
|
|
|
void HandleLaunchTarget(uint effIndex)
|
|
{
|
|
Unit caster = GetCaster();
|
|
|
|
int maxExtraConsumedPower = GetEffectValue();
|
|
|
|
AuraEffect auraEffect = caster.GetAuraEffect(SpellIds.IncarnationKingOfTheJungle, 1);
|
|
if (auraEffect != null)
|
|
{
|
|
float multiplier = 1.0f + (float)auraEffect.GetAmount() / 100.0f;
|
|
maxExtraConsumedPower = (int)((float)maxExtraConsumedPower * multiplier);
|
|
SetEffectValue(maxExtraConsumedPower);
|
|
}
|
|
|
|
_damageMultiplier = MathF.Min(caster.GetPower(PowerType.Energy), maxExtraConsumedPower) / maxExtraConsumedPower;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectLaunchTarget.Add(new(HandleLaunchTarget, 1, SpellEffectName.PowerBurn));
|
|
OnEffectHitTarget.Add(new(HandleHitTargetBurn, 1, SpellEffectName.PowerBurn));
|
|
OnEffectHitTarget.Add(new(HandleHitTargetDmg, 0, SpellEffectName.SchoolDamage));
|
|
}
|
|
}
|
|
|
|
[Script] // 37336 - Druid Forms Trinket
|
|
class spell_dru_forms_trinket : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.FormsTrinketBear, SpellIds.FormsTrinketCat, SpellIds.FormsTrinketMoonkin, SpellIds.FormsTrinketNone, SpellIds.FormsTrinketTree);
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
Unit target = eventInfo.GetActor();
|
|
|
|
switch (target.GetShapeshiftForm())
|
|
{
|
|
case ShapeShiftForm.BearForm:
|
|
case ShapeShiftForm.DireBearForm:
|
|
case ShapeShiftForm.CatForm:
|
|
case ShapeShiftForm.MoonkinForm:
|
|
case ShapeShiftForm.None:
|
|
case ShapeShiftForm.TreeOfLife:
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
Unit target = eventInfo.GetActor();
|
|
uint triggerspell = 0;
|
|
|
|
switch (target.GetShapeshiftForm())
|
|
{
|
|
case ShapeShiftForm.BearForm:
|
|
case ShapeShiftForm.DireBearForm:
|
|
triggerspell = SpellIds.FormsTrinketBear;
|
|
break;
|
|
case ShapeShiftForm.CatForm:
|
|
triggerspell = SpellIds.FormsTrinketCat;
|
|
break;
|
|
case ShapeShiftForm.MoonkinForm:
|
|
triggerspell = SpellIds.FormsTrinketMoonkin;
|
|
break;
|
|
case ShapeShiftForm.None:
|
|
triggerspell = SpellIds.FormsTrinketNone;
|
|
break;
|
|
case ShapeShiftForm.TreeOfLife:
|
|
triggerspell = SpellIds.FormsTrinketTree;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
target.CastSpell(target, triggerspell, aurEff);
|
|
}
|
|
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new(CheckProc));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.ProcTriggerSpell));
|
|
}
|
|
}
|
|
|
|
[Script] // 203964 - Galactic Guardian
|
|
class spell_dru_galactic_guardian : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.GalacticGuardianAura);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
DamageInfo damageInfo = eventInfo.GetDamageInfo();
|
|
if (damageInfo != null)
|
|
{
|
|
Unit target = GetTarget();
|
|
|
|
// free automatic moonfire on target
|
|
target.CastSpell(damageInfo.GetVictim(), SpellIds.MoonfireDamage, true);
|
|
|
|
// Cast aura
|
|
target.CastSpell(damageInfo.GetVictim(), SpellIds.GalacticGuardianAura, true);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 774 - Rejuvenation
|
|
class spell_dru_germination : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Rejuvenation, SpellIds.Germination, SpellIds.RejuvenationGermination);
|
|
}
|
|
|
|
void PickRejuvenationVariant(ref WorldObject target)
|
|
{
|
|
Unit caster = GetCaster();
|
|
|
|
// Germination talent.
|
|
if (caster.HasAura(SpellIds.Germination))
|
|
{
|
|
Unit unitTarget = target.ToUnit();
|
|
Aura rejuvenationAura = unitTarget.GetAura(SpellIds.Rejuvenation, caster.GetGUID());
|
|
Aura germinationAura = unitTarget.GetAura(SpellIds.RejuvenationGermination, caster.GetGUID());
|
|
|
|
// if target doesn't have Rejuventation, cast passes through.
|
|
if (rejuvenationAura == null)
|
|
return;
|
|
|
|
// if target has Rejuvenation, but not Germination, or Germination has lower remaining duration than Rejuvenation, then cast Germination
|
|
if (germinationAura != null && germinationAura.GetDuration() >= rejuvenationAura.GetDuration())
|
|
return;
|
|
|
|
caster.CastSpell(target, SpellIds.RejuvenationGermination,
|
|
new CastSpellExtraArgs(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError)
|
|
.SetTriggeringSpell(GetSpell()));
|
|
|
|
// prevent aura refresh (but cast must still happen to consume mana)
|
|
target = null;
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectTargetSelect.Add(new(PickRejuvenationVariant, 0, Targets.UnitTargetAlly));
|
|
}
|
|
}
|
|
|
|
[Script] // 24858 - Moonkin Form
|
|
class spell_dru_glyph_of_stars : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spell)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.GlyphOfStars, SpellIds.GlyphOfStarsVisual);
|
|
}
|
|
|
|
void OnApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
Unit target = GetTarget();
|
|
if (target.HasAura(SpellIds.GlyphOfStars))
|
|
target.CastSpell(target, SpellIds.GlyphOfStarsVisual, true);
|
|
}
|
|
|
|
void OnRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveAurasDueToSpell(SpellIds.GlyphOfStarsVisual);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectApply.Add(new(OnApply, 1, AuraType.ModShapeshift, AuraEffectHandleModes.Real));
|
|
OnEffectRemove.Add(new(OnRemove, 1, AuraType.ModShapeshift, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 210706 - Gore
|
|
class spell_dru_gore : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.GoreProc, SpellIds.Mangle);
|
|
}
|
|
|
|
bool CheckEffectProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
return RandomHelper.randChance(aurEff.GetAmount());
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo procInfo)
|
|
{
|
|
Unit owner = GetTarget();
|
|
owner.CastSpell(owner, SpellIds.GoreProc);
|
|
owner.GetSpellHistory().ResetCooldown(SpellIds.Mangle, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckEffectProc, 0, AuraType.Dummy));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 99 - Incapacitating Roar
|
|
class spell_dru_incapacitating_roar : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BearForm);
|
|
}
|
|
|
|
void HandleOnCast()
|
|
{
|
|
// Change into cat form
|
|
if (GetCaster().GetShapeshiftForm() != ShapeShiftForm.BearForm)
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.BearForm, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
BeforeCast.Add(new(HandleOnCast));
|
|
}
|
|
}
|
|
|
|
[Script] // 29166 - Innervate
|
|
class spell_dru_innervate : SpellScript
|
|
{
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Player target = GetExplTargetUnit()?.ToPlayer();
|
|
if (target == null)
|
|
return SpellCastResult.BadTargets;
|
|
|
|
ChrSpecializationRecord spec = target.GetPrimarySpecializationEntry();
|
|
if (spec == null || spec.GetRole() != ChrSpecializationRole.Healer)
|
|
return SpellCastResult.BadTargets;
|
|
|
|
return SpellCastResult.SpellCastOk;
|
|
}
|
|
|
|
void HandleRank2()
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster != GetHitUnit())
|
|
{
|
|
AuraEffect innervateR2 = caster.GetAuraEffect(SpellIds.InnervateRank2, 0);
|
|
if (innervateR2 != null)
|
|
caster.CastSpell(caster, SpellIds.Innervate,
|
|
new CastSpellExtraArgs(TriggerCastFlags.IgnoreSpellAndCategoryCD | TriggerCastFlags.IgnoreCastInProgress)
|
|
.SetTriggeringSpell(GetSpell())
|
|
.AddSpellMod(SpellValueMod.BasePoint0, -innervateR2.GetAmount()));
|
|
}
|
|
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new(CheckCast));
|
|
OnHit.Add(new(HandleRank2));
|
|
}
|
|
}
|
|
|
|
[Script] // 117679 - Incarnation (Passive)
|
|
class spell_dru_incarnation : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.IncarnationTreeOfLife);
|
|
}
|
|
|
|
void OnRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveAurasDueToSpell(SpellIds.IncarnationTreeOfLife);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectRemove.Add(new(OnRemove, 0, AuraType.IgnoreSpellCooldown, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 33891 - Incarnation: Tree of Life (Talent, Shapeshift)
|
|
class spell_dru_incarnation_tree_of_life : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Incarnation);
|
|
}
|
|
|
|
void AfterApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
if (!GetTarget().HasAura(SpellIds.Incarnation))
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.Incarnation, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectApply.Add(new(AfterApply, 2, AuraType.PeriodicDummy, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 740 - Tranquility
|
|
class spell_dru_inner_peace : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.InnerPeace)
|
|
&& ValidateSpellEffect((spellInfo.Id, 4))
|
|
|
|
&& spellInfo.GetEffect(3).IsAura(AuraType.MechanicImmunityMask)
|
|
&& spellInfo.GetEffect(4).IsAura(AuraType.ModDamagePercentTaken);
|
|
}
|
|
|
|
void PreventEffect(ref WorldObject target)
|
|
{
|
|
// Note: Inner Peace talent.
|
|
if (!GetCaster().HasAura(SpellIds.InnerPeace))
|
|
target = null;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectTargetSelect.Add(new(PreventEffect, 3, Targets.UnitCaster));
|
|
OnObjectTargetSelect.Add(new(PreventEffect, 4, Targets.UnitCaster));
|
|
}
|
|
}
|
|
|
|
[Script] // 40442 - Druid Tier 6 Trinket
|
|
class spell_dru_item_t6_trinket : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BlessingOfRemulos, SpellIds.BlessingOfElune, SpellIds.BlessingOfCenarius);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
SpellInfo spellInfo = eventInfo.GetSpellInfo();
|
|
if (spellInfo == null)
|
|
return;
|
|
|
|
uint spellId;
|
|
int chance;
|
|
|
|
// Starfire
|
|
if ((spellInfo.SpellFamilyFlags[0] & 0x00000004) != 0)
|
|
{
|
|
spellId = SpellIds.BlessingOfRemulos;
|
|
chance = 25;
|
|
}
|
|
// Rejuvenation
|
|
else if ((spellInfo.SpellFamilyFlags[0] & 0x00000010) != 0)
|
|
{
|
|
spellId = SpellIds.BlessingOfElune;
|
|
chance = 25;
|
|
}
|
|
// Mangle (Bear) and Mangle (Cat)
|
|
else if ((spellInfo.SpellFamilyFlags[1] & 0x00000440) != 0)
|
|
{
|
|
spellId = SpellIds.BlessingOfCenarius;
|
|
chance = 40;
|
|
}
|
|
else
|
|
return;
|
|
|
|
if (RandomHelper.randChance(chance))
|
|
eventInfo.GetActor().CastSpell(null, spellId, aurEff);
|
|
}
|
|
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 33763 - Lifebloom
|
|
class spell_dru_lifebloom : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spell)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.LifebloomFinalHeal);
|
|
}
|
|
|
|
void AfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
// Final heal only on duration end
|
|
if (GetTargetApplication().GetRemoveMode() == AuraRemoveMode.Expire || GetTargetApplication().GetRemoveMode() == AuraRemoveMode.EnemySpell)
|
|
GetCaster().CastSpell(GetUnitOwner(), SpellIds.LifebloomFinalHeal, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectRemove.Add(new(AfterRemove, 0, AuraType.PeriodicHeal, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 204066 - Lunar Beam
|
|
class at_dru_lunar_beam(AreaTrigger areaTrigger) : AreaTriggerAI(areaTrigger)
|
|
{
|
|
TaskScheduler _scheduler = new();
|
|
|
|
public override void OnCreate(Spell creatingSpell)
|
|
{
|
|
_scheduler.Schedule(TimeSpan.FromSeconds(500), task =>
|
|
{
|
|
Unit caster = at.GetCaster();
|
|
if (caster != null)
|
|
{
|
|
caster.CastSpell(caster, SpellIds.LunarBeamHeal, TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError);
|
|
caster.CastSpell(at.GetPosition(), SpellIds.LunarBeamDamage, TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError);
|
|
}
|
|
task.Repeat(TimeSpan.FromSeconds(1));
|
|
|
|
});
|
|
}
|
|
|
|
public override void OnUpdate(uint diff)
|
|
{
|
|
_scheduler.Update(diff);
|
|
}
|
|
}
|
|
|
|
[Script] // 155580 - Lunar Inspiration
|
|
class spell_dru_lunar_inspiration : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spell)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.LunarInspirationOverride);
|
|
}
|
|
|
|
void AfterApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.LunarInspirationOverride, true);
|
|
}
|
|
|
|
void AfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveAurasDueToSpell(SpellIds.LunarInspirationOverride);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectApply.Add(new(AfterApply, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
AfterEffectRemove.Add(new(AfterRemove, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 392315 - Luxuriant Soil
|
|
class spell_dru_luxuriant_soil : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Rejuvenation);
|
|
}
|
|
|
|
static bool CheckProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
return RandomHelper.randChance(aurEff.GetAmount());
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
Unit rejuvCaster = GetTarget();
|
|
|
|
// let's use the ProcSpell's max. range.
|
|
float spellRange = eventInfo.GetSpellInfo().GetMaxRange();
|
|
|
|
List<Unit> targetList = new();
|
|
WorldObjectSpellAreaTargetCheck check = new(spellRange, rejuvCaster, rejuvCaster, rejuvCaster, eventInfo.GetSpellInfo(), SpellTargetCheckTypes.Ally, null, SpellTargetObjectTypes.Unit);
|
|
UnitListSearcher searcher = new(rejuvCaster, targetList, check);
|
|
Cell.VisitAllObjects(rejuvCaster, searcher, spellRange);
|
|
|
|
if (targetList.Empty())
|
|
return;
|
|
|
|
rejuvCaster.CastSpell(targetList.SelectRandom(), SpellIds.Rejuvenation, TriggerCastFlags.IgnoreGCD | TriggerCastFlags.IgnorePowerCost | TriggerCastFlags.IgnoreCastInProgress);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckProc, 0, AuraType.Dummy));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 33917 - Mangle
|
|
class spell_dru_mangle : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.MangleTalent)
|
|
&& ValidateSpellEffect((spellInfo.Id, 2));
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().HasAura(SpellIds.MangleTalent);
|
|
}
|
|
|
|
|
|
void CalculateDamage(SpellEffectInfo spellEffectInfo, Unit victim, ref int damage, ref int flatMod, ref float pctMod)
|
|
{
|
|
if (victim.HasAuraState(AuraStateType.Bleed))
|
|
MathFunctions.AddPct(ref pctMod, GetEffectInfo(2).CalcValue(GetCaster()));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
CalcDamage.Add(new(CalculateDamage));
|
|
}
|
|
}
|
|
|
|
[Script] // 8921 - Moonfire
|
|
class spell_dru_moonfire : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.MoonfireDamage);
|
|
}
|
|
|
|
void HandleOnHit(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.MoonfireDamage, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new(HandleOnHit, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 450347 - Nature's Grace
|
|
class spell_dru_natures_grace : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.NaturesGraceTalent, SpellIds.Dreamstate)
|
|
&& ValidateSpellEffect((spellInfo.Id, 2));
|
|
}
|
|
|
|
public static void Trigger(Unit caster, AuraEffect naturesGraceEffect)
|
|
{
|
|
caster.CastSpell(caster, SpellIds.Dreamstate, new CastSpellExtraArgs()
|
|
{
|
|
SpellValueOverrides = { new(SpellValueMod.AuraStack, naturesGraceEffect.GetAmount()) }
|
|
});
|
|
|
|
}
|
|
|
|
void OnOwnerInCombat(bool isNowInCombat)
|
|
{
|
|
if (isNowInCombat)
|
|
Trigger(GetTarget(), GetEffect(2));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEnterLeaveCombat.Add(new(OnOwnerInCombat));
|
|
}
|
|
}
|
|
|
|
[Script] // 48517 Eclipse (Solar) + 48518 Eclipse (Lunar)
|
|
class spell_dru_natures_grace_eclipse : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Dreamstate)
|
|
&& ValidateSpellEffect((SpellIds.NaturesGraceTalent, 2));
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().HasAuraEffect(SpellIds.NaturesGraceTalent, 2);
|
|
}
|
|
|
|
|
|
void HandleRemoved(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
spell_dru_natures_grace.Trigger(GetTarget(), GetTarget().GetAuraEffect(SpellIds.NaturesGraceTalent, 2));
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectRemove.Add(new(HandleRemoved, 0, AuraType.AddPctModifier, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script("spell_dru_full_moon", 0, SpellIds.HalfMoonOverride)] // 274283 - Full Moon
|
|
[Script("spell_dru_half_moon", SpellIds.HalfMoonOverride, SpellIds.NewMoonOverride)] // 274282 - Half Moon
|
|
[Script("spell_dru_new_moon", SpellIds.NewMoonOverride, 0)] // 274281 - New Moon
|
|
class spell_dru_new_moon(uint newOverrideSpell, uint removeOverrideSpell) : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return (newOverrideSpell == 0 || ValidateSpellInfo(newOverrideSpell))
|
|
&& (removeOverrideSpell == 0 || ValidateSpellInfo(removeOverrideSpell));
|
|
}
|
|
|
|
void OverrideMoon()
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (newOverrideSpell != 0)
|
|
caster.CastSpell(caster, newOverrideSpell, new CastSpellExtraArgs()
|
|
.SetTriggerFlags(TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError)
|
|
.SetTriggeringSpell(GetSpell()));
|
|
|
|
if (removeOverrideSpell != 0)
|
|
caster.RemoveAurasDueToSpell(removeOverrideSpell);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterCast.Add(new(OverrideMoon));
|
|
}
|
|
}
|
|
|
|
[Script] // 16864 - Omen of Clarity
|
|
class spell_dru_omen_of_clarity : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BalanceT10_Bonus, SpellIds.BalanceT10_BonusProc);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
Unit target = GetTarget();
|
|
if (target.HasAura(SpellIds.BalanceT10_Bonus))
|
|
target.CastSpell(null, SpellIds.BalanceT10_BonusProc, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.ProcTriggerSpell));
|
|
}
|
|
}
|
|
|
|
[Script] // 113043 - Omen of Clarity
|
|
class spell_dru_omen_of_clarity_restoration : AuraScript
|
|
{
|
|
bool CheckProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
return RandomHelper.randChance(aurEff.GetAmount());
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckProc, 0, AuraType.ProcTriggerSpell));
|
|
}
|
|
}
|
|
|
|
[Script] // 392303 - Power of the Archdruid
|
|
class spell_dru_power_of_the_archdruid : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellEffect((SpellIds.PowerOfTheArchdruid, 0));
|
|
}
|
|
|
|
static bool CheckProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
return eventInfo.GetActor().HasAuraEffect(SpellIds.PowerOfTheArchdruid, 0);
|
|
}
|
|
|
|
static void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
Unit druid = eventInfo.GetActor();
|
|
Unit procTarget = eventInfo.GetActionTarget();
|
|
|
|
// range is 0's BasePoints.
|
|
float spellRange = aurEff.GetAmount();
|
|
|
|
List<Unit> targetList = new();
|
|
WorldObjectSpellAreaTargetCheck checker = new(spellRange, procTarget, druid, druid, eventInfo.GetSpellInfo(), SpellTargetCheckTypes.Ally, null, SpellTargetObjectTypes.Unit);
|
|
UnitListSearcher searcher = new(procTarget, targetList, checker);
|
|
Cell.VisitAllObjects(procTarget, searcher, spellRange);
|
|
targetList.Remove(procTarget);
|
|
|
|
if (targetList.Empty())
|
|
return;
|
|
|
|
AuraEffect powerOfTheArchdruidEffect = druid.GetAuraEffect(SpellIds.PowerOfTheArchdruid, 0);
|
|
|
|
// max. targets is SpellIds.PowerOfTheArchdruid's 0 BasePoints.
|
|
int maxTargets = powerOfTheArchdruidEffect.GetAmount();
|
|
|
|
targetList.RandomResize((uint)maxTargets);
|
|
|
|
foreach (Unit chosenTarget in targetList)
|
|
druid.CastSpell(chosenTarget, eventInfo.GetProcSpell().GetSpellInfo().Id, aurEff);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckProc, 0, AuraType.Dummy));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 5215 - Prowl
|
|
class spell_dru_prowl : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.CatForm);
|
|
}
|
|
|
|
void HandleOnCast()
|
|
{
|
|
// Change into cat form
|
|
if (GetCaster().GetShapeshiftForm() != ShapeShiftForm.CatForm)
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.CatForm, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
BeforeCast.Add(new(HandleOnCast));
|
|
}
|
|
}
|
|
|
|
[Script] // 1079 - Rip
|
|
class spell_dru_rip : AuraScript
|
|
{
|
|
public override bool Load()
|
|
{
|
|
Unit caster = GetCaster();
|
|
return caster != null && caster.IsPlayer();
|
|
}
|
|
|
|
void CalculateAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
canBeRecalculated = false;
|
|
|
|
Unit caster = GetCaster();
|
|
if (caster != null)
|
|
{
|
|
// 0.01 * $Ap * cp
|
|
int cp = caster.GetPower(PowerType.ComboPoints);
|
|
|
|
// Idol of Feral Shadows. Can't be handled as SpellMod due its dependency from CPs
|
|
AuraEffect auraEffIdolOfFeralShadows = caster.GetAuraEffect(SpellIds.IdolOfFeralShadows, 0);
|
|
if (auraEffIdolOfFeralShadows != null)
|
|
amount += cp * auraEffIdolOfFeralShadows.GetAmount();
|
|
// Idol of Worship. Can't be handled as SpellMod due its dependency from CPs
|
|
else
|
|
{
|
|
AuraEffect auraEffIdolOfWorship = caster.GetAuraEffect(SpellIds.IdolOfWorship, 0);
|
|
if (auraEffIdolOfWorship != null)
|
|
amount += cp * auraEffIdolOfWorship.GetAmount();
|
|
}
|
|
|
|
amount += (int)MathFunctions.CalculatePct(caster.GetTotalAttackPowerValue(WeaponAttackType.BaseAttack), cp);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new(CalculateAmount, 0, AuraType.PeriodicDamage));
|
|
}
|
|
}
|
|
|
|
[Script] // 52610 - Savage Roar
|
|
class spell_dru_savage_roar : SpellScript
|
|
{
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster.GetShapeshiftForm() != ShapeShiftForm.CatForm)
|
|
return SpellCastResult.OnlyShapeshift;
|
|
|
|
return SpellCastResult.SpellCastOk;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new(CheckCast));
|
|
}
|
|
}
|
|
|
|
[Script]
|
|
class spell_dru_savage_roar_aura : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spell)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.SavageRoar);
|
|
}
|
|
|
|
void AfterApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
Unit target = GetTarget();
|
|
target.CastSpell(target, SpellIds.SavageRoar, new CastSpellExtraArgs(aurEff)
|
|
.SetOriginalCaster(GetCasterGUID()));
|
|
}
|
|
|
|
void AfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveAurasDueToSpell(SpellIds.SavageRoar);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectApply.Add(new(AfterApply, 1, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
AfterEffectRemove.Add(new(AfterRemove, 1, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 202342 - Shooting Stars
|
|
class spell_dru_shooting_stars : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.ShootingStarsDamage)
|
|
&& ValidateSpellEffect((SpellIds.MoonfireDamage, 1), (SpellIds.SunfireDamage, 1))
|
|
&& Global.SpellMgr.GetSpellInfo(SpellIds.MoonfireDamage, Difficulty.None).GetEffect(1).IsAura(AuraType.PeriodicDamage)
|
|
&& Global.SpellMgr.GetSpellInfo(SpellIds.SunfireDamage, Difficulty.None).GetEffect(1).IsAura(AuraType.PeriodicDamage);
|
|
}
|
|
|
|
void OnTick(AuraEffect aurEff)
|
|
{
|
|
Unit caster = GetTarget();
|
|
List<Unit> moonfires = new();
|
|
List<Unit> sunfires = new();
|
|
var druid = caster.GetGUID();
|
|
void work(Unit target)
|
|
{
|
|
if (target.HasAuraEffect(SpellIds.MoonfireDamage, 1, druid))
|
|
moonfires.Add(target);
|
|
|
|
if (target.HasAuraEffect(SpellIds.SunfireDamage, 1, druid))
|
|
sunfires.Add(target);
|
|
}
|
|
;
|
|
UnitWorker worker = new(caster, work);
|
|
Cell.VisitAllObjects(caster, worker, 100.0f);
|
|
|
|
ProcessDoT(aurEff, caster, moonfires);
|
|
ProcessDoT(aurEff, caster, sunfires);
|
|
}
|
|
|
|
static void ProcessDoT(AuraEffect aurEff, Unit caster, List<Unit> targets)
|
|
{
|
|
if (targets.Empty())
|
|
return;
|
|
|
|
float chance = (float)(aurEff.GetAmount() * MathF.Sqrt(targets.Count));
|
|
float procs = MathF.Truncate(chance / 100.0f);
|
|
if (RandomHelper.randChance(procs * 100.0f))
|
|
procs += 1.0f;
|
|
|
|
if (procs <= 0.0f)
|
|
return;
|
|
|
|
targets.RandomResize((uint)procs);
|
|
foreach (Unit target in targets)
|
|
{
|
|
caster.CastSpell(target, SpellIds.ShootingStarsDamage, new CastSpellExtraArgs()
|
|
{
|
|
TriggerFlags = TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(OnTick, 0, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 106839 - Skull Bash
|
|
class spell_dru_skull_bash : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.SkullBashCharge, SpellIds.SkullBashInterrupt);
|
|
}
|
|
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.SkullBashCharge, true);
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.SkullBashInterrupt, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 81269 - Efflorescence (Heal)
|
|
class spell_dru_spring_blossoms : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.SpringBlossoms, SpellIds.SpringBlossomsHeal);
|
|
}
|
|
|
|
void HandleOnHit(uint effIndex)
|
|
{
|
|
if (GetCaster().HasAura(SpellIds.SpringBlossoms))
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.SpringBlossomsHeal, TriggerCastFlags.DontReportCastError);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new(HandleOnHit, 0, SpellEffectName.Heal));
|
|
}
|
|
}
|
|
|
|
[Script] // 106898 - Stampeding Roar
|
|
class spell_dru_stampeding_roar : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BearForm);
|
|
}
|
|
|
|
void HandleOnCast()
|
|
{
|
|
// Change into cat form
|
|
if (GetCaster().GetShapeshiftForm() != ShapeShiftForm.BearForm)
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.BearForm, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
BeforeCast.Add(new(HandleOnCast));
|
|
}
|
|
}
|
|
|
|
[Script] // 50286 - Starfall (Dummy)
|
|
class spell_dru_starfall_dummy : SpellScript
|
|
{
|
|
void FilterTargets(List<WorldObject> targets)
|
|
{
|
|
targets.RandomResize(2);
|
|
}
|
|
|
|
void HandleDummy(uint effIndex)
|
|
{
|
|
Unit caster = GetCaster();
|
|
// Shapeshifting into an animal form or mounting cancels the effect
|
|
if (caster.GetCreatureType() == CreatureType.Beast || caster.IsMounted())
|
|
{
|
|
SpellInfo spellInfo = GetTriggeringSpell();
|
|
if (spellInfo != null)
|
|
caster.RemoveAurasDueToSpell(spellInfo.Id);
|
|
return;
|
|
}
|
|
|
|
// Any effect which causes you to lose control of your character will supress the starfall effect.
|
|
if (caster.HasUnitState(UnitState.Controlled))
|
|
return;
|
|
|
|
caster.CastSpell(GetHitUnit(), (uint)GetEffectValue(), true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new(FilterTargets, 0, Targets.UnitDestAreaEnemy));
|
|
OnEffectHitTarget.Add(new(HandleDummy, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 202347 - Stellar Flare
|
|
class spell_dru_stellar_flare : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.StarBurst);
|
|
}
|
|
|
|
void HandleDispel(DispelInfo dispelInfo)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster != null)
|
|
caster.CastSpell(dispelInfo.GetDispeller(), SpellIds.StarBurst, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterDispel.Add(new(HandleDispel));
|
|
}
|
|
}
|
|
|
|
// 340694 - Sudden Ambush
|
|
[Script] // 384667 - Sudden Ambush
|
|
class spell_dru_sudden_ambush : AuraScript
|
|
{
|
|
bool CheckProc(AuraEffect aurEff, ProcEventInfo procInfo)
|
|
{
|
|
Spell procSpell = procInfo.GetProcSpell();
|
|
if (procSpell == null)
|
|
return false;
|
|
|
|
var comboPoints = procSpell.GetPowerTypeCostAmount(PowerType.ComboPoints);
|
|
if (!comboPoints.HasValue)
|
|
return false;
|
|
|
|
return RandomHelper.randChance(comboPoints.Value * aurEff.GetAmount());
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckEffectProc.Add(new(CheckProc, 0, AuraType.ProcTriggerSpell));
|
|
}
|
|
}
|
|
|
|
[Script] // 93402 - Sunfire
|
|
class spell_dru_sunfire : SpellScript
|
|
{
|
|
void HandleOnHit(uint effIndex)
|
|
{
|
|
GetCaster().CastSpell(GetHitUnit(), SpellIds.SunfireDamage, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new(HandleOnHit, 0, SpellEffectName.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 61336 - Survival Instincts
|
|
class spell_dru_survival_instincts : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spell)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.SurvivalInstincts);
|
|
}
|
|
|
|
void AfterApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.SurvivalInstincts, true);
|
|
}
|
|
|
|
void AfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
GetTarget().RemoveAurasDueToSpell(SpellIds.SurvivalInstincts);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
AfterEffectApply.Add(new(AfterApply, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
AfterEffectRemove.Add(new(AfterRemove, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 40121 - Swift Flight Form (Passive)
|
|
class spell_dru_swift_flight_passive : AuraScript
|
|
{
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsPlayer();
|
|
}
|
|
|
|
void CalculateAmount(AuraEffect aurEff, ref int amount, ref bool canBeRecalculated)
|
|
{
|
|
Player caster = GetCaster().ToPlayer();
|
|
if (caster != null && caster.GetSkillValue(SkillType.Riding) >= 375)
|
|
amount = 310;
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoEffectCalcAmount.Add(new(CalculateAmount, 1, AuraType.ModIncreaseVehicleFlightSpeed));
|
|
}
|
|
}
|
|
|
|
[Script] // 28744 - Regrowth
|
|
class spell_dru_t3_6p_bonus : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BlessingOfTheClaw);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
eventInfo.GetActor().CastSpell(eventInfo.GetProcTarget(), SpellIds.BlessingOfTheClaw, aurEff);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.OverrideClassScripts));
|
|
}
|
|
}
|
|
|
|
[Script] // 28719 - Healing Touch
|
|
class spell_dru_t3_8p_bonus : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Exhilarate);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
Spell spell = eventInfo.GetProcSpell();
|
|
if (spell == null)
|
|
return;
|
|
|
|
Unit caster = eventInfo.GetActor();
|
|
var manaCost = spell.GetPowerTypeCostAmount(PowerType.Mana);
|
|
if (!manaCost.HasValue)
|
|
return;
|
|
|
|
int amount = MathFunctions.CalculatePct(manaCost.Value, aurEff.GetAmount());
|
|
CastSpellExtraArgs args = new(aurEff);
|
|
args.AddSpellMod(SpellValueMod.BasePoint0, amount);
|
|
caster.CastSpell(null, SpellIds.Exhilarate, args);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
// 37288 - Mana Restore
|
|
[Script] // 37295 - Mana Restore
|
|
class spell_dru_t4_2p_bonus : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Infusion);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
eventInfo.GetActor().CastSpell(null, SpellIds.Infusion, aurEff);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 70723 - Item - Druid T10 Balance 4P Bonus
|
|
class spell_dru_t10_balance_4p_bonus : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.Languish);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
|
|
DamageInfo damageInfo = eventInfo.GetDamageInfo();
|
|
if (damageInfo == null || damageInfo.GetDamage() == 0)
|
|
return;
|
|
|
|
Unit caster = eventInfo.GetActor();
|
|
Unit target = eventInfo.GetProcTarget();
|
|
|
|
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(SpellIds.Languish, GetCastDifficulty());
|
|
int amount = MathFunctions.CalculatePct((int)(damageInfo.GetDamage()), aurEff.GetAmount());
|
|
|
|
Cypher.Assert(spellInfo.GetMaxTicks() > 0);
|
|
amount /= (int)spellInfo.GetMaxTicks();
|
|
|
|
CastSpellExtraArgs args = new(aurEff);
|
|
args.AddSpellMod(SpellValueMod.BasePoint0, amount);
|
|
caster.CastSpell(target, SpellIds.Languish, args);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 70691 - Item T10 Restoration 4P Bonus
|
|
class spell_dru_t10_restoration_4p_bonus : SpellScript
|
|
{
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsPlayer();
|
|
}
|
|
|
|
void FilterTargets(List<WorldObject> targets)
|
|
{
|
|
if (GetCaster().ToPlayer().GetGroup() == null)
|
|
{
|
|
targets.Clear();
|
|
targets.Add(GetCaster());
|
|
}
|
|
else
|
|
{
|
|
targets.Remove(GetExplTargetUnit());
|
|
List<Unit> tempTargets = new();
|
|
foreach (var obj in targets)
|
|
if (obj.IsPlayer() && GetCaster().IsInRaidWith(obj.ToUnit()))
|
|
tempTargets.Add(obj.ToUnit());
|
|
|
|
if (tempTargets.Empty())
|
|
{
|
|
targets.Clear();
|
|
FinishCast(SpellCastResult.DontReport);
|
|
return;
|
|
}
|
|
|
|
Unit target = tempTargets.SelectRandom();
|
|
targets.Clear();
|
|
targets.Add(target);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new(FilterTargets, 0, Targets.UnitDestAreaAlly));
|
|
}
|
|
}
|
|
|
|
[Script] // 70664 - Druid T10 Restoration 4P Bonus (Rejuvenation)
|
|
class spell_dru_t10_restoration_4p_bonus_dummy : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.RejuvenationT10_Proc);
|
|
}
|
|
|
|
bool CheckProc(ProcEventInfo eventInfo)
|
|
{
|
|
SpellInfo spellInfo = eventInfo.GetSpellInfo();
|
|
if (spellInfo == null || spellInfo.Id == SpellIds.RejuvenationT10_Proc)
|
|
return false;
|
|
|
|
HealInfo healInfo = eventInfo.GetHealInfo();
|
|
if (healInfo == null || healInfo.GetHeal() == 0)
|
|
return false;
|
|
|
|
Player caster = eventInfo.GetActor().ToPlayer();
|
|
if (caster == null)
|
|
return false;
|
|
|
|
return caster.GetGroup() != null || caster != eventInfo.GetProcTarget();
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
PreventDefaultAction();
|
|
|
|
CastSpellExtraArgs args = new(aurEff);
|
|
args.AddSpellMod(SpellValueMod.BasePoint0, (int)eventInfo.GetHealInfo().GetHeal());
|
|
eventInfo.GetActor().CastSpell(null, SpellIds.RejuvenationT10_Proc, args);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new(CheckProc));
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 77758 - Thrash
|
|
class spell_dru_thrash : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.ThrashBearAura);
|
|
}
|
|
|
|
void HandleOnHitTarget(uint effIndex)
|
|
{
|
|
Unit hitUnit = GetHitUnit();
|
|
if (hitUnit != null)
|
|
{
|
|
Unit caster = GetCaster();
|
|
|
|
caster.CastSpell(hitUnit, SpellIds.ThrashBearAura, TriggerCastFlags.FullMask);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectHitTarget.Add(new(HandleOnHitTarget, 0, SpellEffectName.SchoolDamage));
|
|
}
|
|
}
|
|
|
|
[Script] // 192090 - Thrash (Aura) - SpellIds.ThrashBearAura
|
|
class spell_dru_thrash_aura : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.BloodFrenzyAura, SpellIds.BloodFrenzyRageGain);
|
|
}
|
|
|
|
void HandlePeriodic(AuraEffect aurEff)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster != null)
|
|
if (caster.HasAura(SpellIds.BloodFrenzyAura))
|
|
caster.CastSpell(caster, SpellIds.BloodFrenzyRageGain, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(HandlePeriodic, 0, AuraType.PeriodicDamage));
|
|
}
|
|
}
|
|
|
|
// 1066 - Aquatic Form
|
|
// 33943 - Flight Form
|
|
// 40120 - Swift Flight Form
|
|
[Script] // 165961 - Stag Form
|
|
class spell_dru_travel_form : AuraScript
|
|
{
|
|
uint triggeredSpellId = 0;
|
|
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.FormStag, SpellIds.FormAquaticPassive, SpellIds.FormAquatic, SpellIds.FormFlight, SpellIds.FormSwiftFlight);
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsPlayer();
|
|
}
|
|
|
|
void OnRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
// If it stays 0, it removes Travel Form dummy in AfterRemove.
|
|
triggeredSpellId = 0;
|
|
|
|
// We should only handle aura interrupts.
|
|
if (GetTargetApplication().GetRemoveMode() != AuraRemoveMode.Interrupt)
|
|
return;
|
|
|
|
// Check what form is appropriate
|
|
triggeredSpellId = GetFormSpellId(GetTarget().ToPlayer(), GetCastDifficulty(), true);
|
|
|
|
// If chosen form is current aura, just don't remove it.
|
|
if (triggeredSpellId == m_scriptSpellId)
|
|
PreventDefaultAction();
|
|
}
|
|
|
|
void AfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
if (triggeredSpellId == m_scriptSpellId)
|
|
return;
|
|
|
|
Player player = GetTarget().ToPlayer();
|
|
|
|
if (triggeredSpellId != 0) // Apply new form
|
|
player.CastSpell(player, triggeredSpellId, aurEff);
|
|
else // If not set, simply remove Travel Form dummy
|
|
player.RemoveAura(SpellIds.TravelForm);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectRemove.Add(new(OnRemove, 0, AuraType.ModShapeshift, AuraEffectHandleModes.Real));
|
|
AfterEffectRemove.Add(new(AfterRemove, 0, AuraType.ModShapeshift, AuraEffectHandleModes.Real));
|
|
}
|
|
|
|
public static uint GetFormSpellId(Player player, Difficulty difficulty, bool requiresOutdoor)
|
|
{
|
|
// Check what form is appropriate
|
|
if (player.HasSpell(SpellIds.FormAquaticPassive) && player.IsInWater()) // Aquatic form
|
|
return SpellIds.FormAquatic;
|
|
|
|
if (!player.IsInCombat() && player.GetSkillValue(SkillType.Riding) >= 225 && CheckLocationForForm(player, difficulty, requiresOutdoor, SpellIds.FormFlight) == SpellCastResult.SpellCastOk) // Flight form
|
|
return player.GetSkillValue(SkillType.Riding) >= 300 ? SpellIds.FormSwiftFlight : SpellIds.FormFlight;
|
|
|
|
if (!player.IsInWater() && CheckLocationForForm(player, difficulty, requiresOutdoor, SpellIds.FormStag) == SpellCastResult.SpellCastOk) // Stag form
|
|
return SpellIds.FormStag;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static SpellCastResult CheckLocationForForm(Player targetPlayer, Difficulty difficulty, bool requireOutdoors, uint spell_id)
|
|
{
|
|
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(spell_id, difficulty);
|
|
|
|
if (requireOutdoors && !targetPlayer.IsOutdoors())
|
|
return SpellCastResult.OnlyOutdoors;
|
|
|
|
return spellInfo.CheckLocation(targetPlayer.GetMapId(), targetPlayer.GetZoneId(), targetPlayer.GetAreaId(), targetPlayer);
|
|
}
|
|
}
|
|
|
|
[Script] // 783 - Travel Form (dummy)
|
|
class spell_dru_travel_form_dummy : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.FormAquaticPassive, SpellIds.FormAquatic, SpellIds.FormStag);
|
|
}
|
|
|
|
SpellCastResult CheckCast()
|
|
{
|
|
Player player = GetCaster().ToPlayer();
|
|
if (player == null)
|
|
return SpellCastResult.CustomError;
|
|
|
|
uint spellId = (player.HasSpell(SpellIds.FormAquaticPassive) && player.IsInWater()) ? SpellIds.FormAquatic : SpellIds.FormStag;
|
|
|
|
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(spellId, GetCastDifficulty());
|
|
return spellInfo.CheckLocation(player.GetMapId(), player.GetZoneId(), player.GetAreaId(), player);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnCheckCast.Add(new(CheckCast));
|
|
}
|
|
}
|
|
|
|
[Script]
|
|
class spell_dru_travel_form_dummy_aura : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.FormStag, SpellIds.FormAquatic, SpellIds.FormFlight, SpellIds.FormSwiftFlight);
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().IsPlayer();
|
|
}
|
|
|
|
void OnApply(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
Player player = GetTarget().ToPlayer();
|
|
|
|
// Outdoor check already passed - Travel Form (dummy) has SpellATTR0_OutdoorsOnly attribute.
|
|
uint triggeredSpellId = spell_dru_travel_form.GetFormSpellId(player, GetCastDifficulty(), false);
|
|
|
|
player.CastSpell(player, triggeredSpellId, aurEff);
|
|
}
|
|
|
|
void AfterRemove(AuraEffect aurEff, AuraEffectHandleModes mode)
|
|
{
|
|
// No need to check remove mode, it's safe for auras to remove each other in AfterRemove hook.
|
|
GetTarget().RemoveAura(SpellIds.FormStag);
|
|
GetTarget().RemoveAura(SpellIds.FormAquatic);
|
|
GetTarget().RemoveAura(SpellIds.FormFlight);
|
|
GetTarget().RemoveAura(SpellIds.FormSwiftFlight);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectApply.Add(new(OnApply, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
AfterEffectRemove.Add(new(AfterRemove, 0, AuraType.Dummy, AuraEffectHandleModes.Real));
|
|
}
|
|
}
|
|
|
|
[Script] // 252216 - Tiger Dash
|
|
class spell_dru_tiger_dash : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.CatForm);
|
|
}
|
|
|
|
void HandleOnCast()
|
|
{
|
|
// Change into cat form
|
|
if (GetCaster().GetShapeshiftForm() != ShapeShiftForm.CatForm)
|
|
GetCaster().CastSpell(GetCaster(), SpellIds.CatForm, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
BeforeCast.Add(new(HandleOnCast));
|
|
}
|
|
}
|
|
|
|
[Script] // 252216 - Tiger Dash (Aura)
|
|
class spell_dru_tiger_dash_aura : AuraScript
|
|
{
|
|
void HandlePeriodic(AuraEffect aurEff)
|
|
{
|
|
AuraEffect effRunSpeed = GetEffect(0);
|
|
if (effRunSpeed != null)
|
|
{
|
|
int reduction = aurEff.GetAmount();
|
|
effRunSpeed.ChangeAmount(effRunSpeed.GetAmount() - reduction);
|
|
}
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(HandlePeriodic, 1, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 393763 - Umbral Embrace
|
|
class spell_dru_umbral_embrace : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EclipseLunarAura, SpellIds.EclipseSolarAura);
|
|
}
|
|
|
|
static bool CheckEclipse(ProcEventInfo eventInfo)
|
|
{
|
|
return eventInfo.GetActor().HasAura(SpellIds.EclipseLunarAura) || eventInfo.GetActor().HasAura(SpellIds.EclipseSolarAura);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
DoCheckProc.Add(new(CheckEclipse));
|
|
}
|
|
}
|
|
|
|
[Script] // 393763 - Umbral Embrace (attached to 190984 - Wrath and 194153 - Starfire)
|
|
class spell_dru_umbral_embrace_damage : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.EclipseLunarAura, SpellIds.EclipseSolarAura)
|
|
&& ValidateSpellEffect((SpellIds.UmbralEmbrace, 0));
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetCaster().HasAura(SpellIds.EclipseLunarAura) || GetCaster().HasAura(SpellIds.EclipseSolarAura);
|
|
}
|
|
|
|
|
|
void HandleDamage(SpellEffectInfo spellEffectInfo, Unit victim, ref int damage, ref int flatMod, ref float pctMod)
|
|
{
|
|
AuraEffect umbralEmbrace = GetCaster().GetAuraEffect(SpellIds.UmbralEmbrace, 0);
|
|
if (umbralEmbrace != null)
|
|
MathFunctions.AddPct(ref pctMod, umbralEmbrace.GetAmount());
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
CalcDamage.Add(new(HandleDamage));
|
|
}
|
|
}
|
|
|
|
[Script] // Called by 393763 - Umbral Embrace
|
|
class spell_dru_umbral_inspiration : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.UmbralInspirationTalent, SpellIds.UmbralInspirationAura);
|
|
}
|
|
|
|
public override bool Load()
|
|
{
|
|
return GetUnitOwner().HasAura(SpellIds.UmbralInspirationTalent);
|
|
}
|
|
|
|
void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
Unit target = GetTarget();
|
|
target.CastSpell(target, SpellIds.UmbralInspirationAura, new CastSpellExtraArgs()
|
|
{
|
|
TriggerFlags = TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError,
|
|
TriggeringAura = aurEff
|
|
});
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 2, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 377210 - Ursoc's Fury
|
|
class spell_dru_ursocs_fury : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.UrsocsFuryShield);
|
|
}
|
|
|
|
static void HandleProc(AuraEffect aurEff, ProcEventInfo eventInfo)
|
|
{
|
|
DamageInfo damageInfo = eventInfo.GetDamageInfo();
|
|
if (damageInfo == null || damageInfo.GetDamage() == 0)
|
|
return;
|
|
|
|
Unit caster = eventInfo.GetActor();
|
|
int amount = (int)MathFunctions.CalculatePct(damageInfo.GetDamage(), aurEff.GetAmount());
|
|
|
|
caster.CastSpell(caster, SpellIds.UrsocsFuryShield, new CastSpellExtraArgs()
|
|
{
|
|
TriggerFlags = TriggerCastFlags.IgnoreCastInProgress | TriggerCastFlags.DontReportCastError,
|
|
SpellValueOverrides = { new(SpellValueMod.BasePoint0, amount) }
|
|
});
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectProc.Add(new(HandleProc, 0, AuraType.Dummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 48438 - Wild Growth
|
|
class spell_dru_wild_growth : SpellScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellEffect((spellInfo.Id, 1), (SpellIds.TreeOfLife, 2));
|
|
}
|
|
|
|
void FilterTargets(List<WorldObject> targets)
|
|
{
|
|
Unit caster = GetCaster();
|
|
int maxTargets = GetEffectInfo(1).CalcValue(caster);
|
|
|
|
AuraEffect treeOfLife = caster.GetAuraEffect(SpellIds.TreeOfLife, 2);
|
|
if (treeOfLife != null)
|
|
maxTargets += treeOfLife.GetAmount();
|
|
|
|
// Note: Wild Growth became a smart heal which prioritizes players and their pets in their group before any unit outside their group.
|
|
SelectRandomInjuredTargets(targets, (uint)maxTargets, true, caster);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new(FilterTargets, 0, Targets.UnitDestAreaAlly));
|
|
}
|
|
}
|
|
|
|
[Script]
|
|
class spell_dru_wild_growth_aura : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.RestorationT10_2PBonus);
|
|
}
|
|
|
|
void HandleTickUpdate(AuraEffect aurEff)
|
|
{
|
|
Unit caster = GetCaster();
|
|
if (caster == null)
|
|
return;
|
|
|
|
// calculate from base damage, not from aurEff.GetAmount() (already modified)
|
|
float damage = caster.CalculateSpellDamage(GetUnitOwner(), aurEff.GetSpellEffectInfo());
|
|
|
|
// Wild Growth = first tick gains a 6% bonus, reduced by 2% each tick
|
|
float reduction = 2.0f;
|
|
AuraEffect bonus = caster.GetAuraEffect(SpellIds.RestorationT10_2PBonus, 0);
|
|
if (bonus != null)
|
|
reduction -= MathFunctions.CalculatePct(reduction, bonus.GetAmount());
|
|
reduction *= (aurEff.GetTickNumber() - 1);
|
|
|
|
MathFunctions.AddPct(ref damage, 6.0f - reduction);
|
|
aurEff.SetAmount((int)damage);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectUpdatePeriodic.Add(new(HandleTickUpdate, 0, AuraType.PeriodicHeal));
|
|
}
|
|
}
|
|
|
|
[Script] // 145108 - Ysera's Gift
|
|
class spell_dru_yseras_gift : AuraScript
|
|
{
|
|
public override bool Validate(SpellInfo spellInfo)
|
|
{
|
|
return ValidateSpellInfo(SpellIds.YserasGiftHealSelf, SpellIds.YserasGiftHealParty);
|
|
}
|
|
|
|
void HandleEffectPeriodic(AuraEffect aurEff)
|
|
{
|
|
int healAmount = (int)GetTarget().CountPctFromMaxHealth(aurEff.GetAmount());
|
|
|
|
if (!GetTarget().IsFullHealth())
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.YserasGiftHealSelf, new CastSpellExtraArgs(aurEff).AddSpellMod(SpellValueMod.BasePoint0, healAmount));
|
|
else
|
|
GetTarget().CastSpell(GetTarget(), SpellIds.YserasGiftHealParty, new CastSpellExtraArgs(aurEff).AddSpellMod(SpellValueMod.BasePoint0, healAmount));
|
|
}
|
|
|
|
|
|
public override void Register()
|
|
{
|
|
OnEffectPeriodic.Add(new(HandleEffectPeriodic, 0, AuraType.PeriodicDummy));
|
|
}
|
|
}
|
|
|
|
[Script] // 145110 - Ysera's Gift (heal)
|
|
class spell_dru_yseras_gift_group_heal : SpellScript
|
|
{
|
|
void SelectTargets(List<WorldObject> targets)
|
|
{
|
|
SelectRandomInjuredTargets(targets, 1, true);
|
|
}
|
|
|
|
public override void Register()
|
|
{
|
|
OnObjectAreaTargetSelect.Add(new(SelectTargets, 0, Targets.UnitCasterAreaRaid));
|
|
}
|
|
} |