public override void Initialize(ref SpellFailedReason failReason)
{
if (m_cast.InitialTargets == null || m_cast.InitialTargets.Length == 0 || !(m_cast.InitialTargets[0] is Unit))
{
failReason = SpellFailedReason.NoValidTargets;
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (target.MaxPower == 0 || target.PowerType != (PowerType)m_spellEffect.MiscValue)
{
failReason = SpellFailedReason.BadTargets;
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (m_cast.CasterChar.ActivePet == null)
{
failReason = SpellFailedReason.NoPet;
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (m_cast.UsedItem.Amount < Effect.MinValue)
{
failReason = SpellFailedReason.NeedMoreItems;
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
{
if (!(target is NPC))
{
failReason = SpellFailedReason.BadTargets;
}
if (casterRef != null && casterRef.Object is Unit)
{
var caster = (Unit)casterRef.Object;
//if (target.Target == caster)
//{
// failReason = SpellFailedReason.NoValidTargets;
//}
//else
{
var spell = m_aura.Spell;
var hasSingleFriendTarget = spell.HasBeneficialEffects && !spell.IsAreaSpell && spell.HasTargets;
if (hasSingleFriendTarget && caster.Target != null && caster.IsFriendlyWith(caster.Target))
{
// taunting a friend, means we want to taunt his attackers
// needed for Righteous defense, amongst others
if (target.Target != caster.Target)
{
failReason = SpellFailedReason.NoValidTargets;
}
}
}
}
}
protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
{
if (target.MaxPower == 0 || target.PowerType != (PowerType)m_spellEffect.MiscValue)
{
failReason = SpellFailedReason.BadTargets;
}
}
protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character))
{
failReason = SpellFailedReason.TargetNotPlayer;
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
Caster = casterReference.Object as Unit;
if (Caster == null || Caster is Vehicle)
{
log.Warn("Invalid SpellCaster \"{0}\" for Spell: {1}", Caster, SpellEffect.Spell);
failReason = SpellFailedReason.Error;
return;
}
Vehicle = target as Vehicle;
if (Vehicle == null)
{
failReason = SpellFailedReason.BadTargets;
}
else
{
Seat = Vehicle.GetSeatFor(Caster);
if (Seat == null)
{
// must never happen since Vehicle is unclickable when full
failReason = SpellFailedReason.BadTargets;
}
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
{
var caster = creatingCast.CasterReference.Object as Unit;
if (caster == null)
{
failReason = SpellFailedReason.BadTargets;
}
else
{
if (caster.Charm != null)
{
failReason = SpellFailedReason.AlreadyHaveCharm;
}
else if (target.HasMaster)
{
failReason = SpellFailedReason.CantDoThatRightNow;
}
else if (caster.HasMaster)
{
failReason = SpellFailedReason.Possessed;
}
else if (caster is Character)
{
if (((Character)caster).ActivePet != null)
{
failReason = SpellFailedReason.AlreadyHaveSummon;
}
}
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character))
{
failReason = SpellFailedReason.TargetNotPlayer;
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (m_targets != null && m_targets.Count > 0)
{
firstTarget = (Unit)m_targets[0];
}
}
internal void Collect(SpellTargetCollection targets, ref SpellFailedReason failReason)
{
if (Adder != null)
{
Adder(targets, Filter, ref failReason);
}
}
/// <summary>
/// Duel target type
/// </summary>
/// <param name="targets"></param>
/// <param name="target"></param>
/// <param name="failedReason"></param>
public static void IsHostileOrHealable(SpellEffectHandler effectHandler, WorldObject target, ref SpellFailedReason failedReason)
{
var caster = effectHandler.Cast.CasterObject;
var spell = effectHandler.Cast.Spell;
var isHarmful = spell.HasHarmfulEffects;
var isHarmfulAndBeneficial = spell.HasHarmfulEffects == spell.HasBeneficialEffects;
if (!isHarmfulAndBeneficial)
{
if (isHarmful != caster.MayAttack(target))
{
if (isHarmful)
{
failedReason = SpellFailedReason.TargetFriendly;
}
else
{
failedReason = SpellFailedReason.TargetEnemy;
}
}
else if (isHarmful && !target.CanBeHarmed)
{
failedReason = SpellFailedReason.NotHere;
}
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (m_cast.TargetItem == null)
{
failReason = SpellFailedReason.ItemGone;
return;
}
if (m_cast.TargetItem.Template.Level < Effect.Spell.BaseLevel)
{
failReason = SpellFailedReason.TargetLowlevel;
return;
}
enchantEntry = EnchantMgr.GetEnchantmentEntry((uint)Effect.MiscValue);
if (enchantEntry == null)
{
log.Error("Spell {0} refers to invalid EnchantmentEntry {1}", Effect.Spell, Effect.MiscValue);
failReason = SpellFailedReason.Error;
}
else if (!enchantEntry.CheckRequirements(m_cast.CasterUnit))
{
failReason = SpellFailedReason.MinSkill;
}
}
public static void IsFriendly(SpellEffectHandler effectHandler, WorldObject target, ref SpellFailedReason failedReason)
{
if (effectHandler.Cast.CasterObject.MayAttack(target))
{
failedReason = SpellFailedReason.TargetEnemy;
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (Effect.TriggerSpell == null)
{
failReason = SpellFailedReason.Error;
log.Warn("Tried to cast Spell \"{0}\" which has invalid TriggerSpellId {1}", Effect.Spell, Effect.TriggerSpellId);
}
}
public static void IsSameClass(SpellEffectHandler effectHandler, WorldObject target, ref SpellFailedReason failedReason)
{
var caster = effectHandler.Cast.CasterUnit;
if (caster == null || !(target is Unit) || caster.Class != ((Unit)target).Class)
{
failedReason = SpellFailedReason.BadTargets;
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if(Effect.BasePoints < 0)
{
Effect.BasePoints = 0;
}
base.Initialize(ref failReason);
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (target.Class != ClassId.Hunter)
{
failReason = SpellFailedReason.BadTargets;
return;
}
}
internal void NotifyCancelled(SpellCast cast, SpellFailedReason reason)
{
var evt = Cancelling;
if (evt != null)
{
evt(cast, reason);
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (m_spellEffect.TriggerSpell == null)
{
failReason = SpellFailedReason.Error;
log.Warn("Tried to cast Spell \"{0}\" which has invalid TriggerSpellId {1}", m_spellEffect.Spell, m_spellEffect.TriggerSpellId);
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
var rival = m_cast.Selected as Character;
if (rival != null)
{
failReason = Duel.CheckRequirements(m_cast.CasterChar, rival);
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (Effect.AffectSpellSet == null)
{
failReason = SpellFailedReason.Error;
LogManager.GetCurrentClassLogger().Warn("Tried to use {0} in Spell \"{1}\" with an empty SpellEffect.AffectSpellSet", GetType(), Effect.Spell);
}
}
protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character)) return;
var chr = (Character)target;
if (chr.Class != ClassId.Hunter)
{
failReason = SpellFailedReason.BadTargets;
}
}
protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
{
caster = casterInfo.Caster as Unit;
if (!(target is NPC) || caster == null)
{
failReason = SpellFailedReason.BadTargets;
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character)) return;
var chr = (Character)target;
if (chr.Class != ClassId.Hunter)
{
failReason = SpellFailedReason.BadTargets;
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
if (!m_cast.UsedItem.Template.Flags.HasFlag(ItemFlags.Millable))
{
failReason = SpellFailedReason.CantBeMilled;
}
else
{
base.Initialize(ref failReason);
}
}
public override void Initialize(ref SpellFailedReason failReason)
{
var id = (NPCId)Effect.MiscValue;
entry = NPCMgr.GetEntry(id);
if (entry == null)
{
LogManager.GetCurrentClassLogger().Warn("The NPC for Summon-Spell {0} does not exist: {1} (Are NPCs loaded?)", Effect.Spell, id);
failReason = SpellFailedReason.Error;
return;
}
}
protected internal override void CheckInitialize(CasterInfo casterInfo, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character))
{
failReason = SpellFailedReason.TargetNotPlayer;
}
else if (((Character)target).CurrentTracker != null)
{
((Character)target).CurrentTracker.Remove(true);
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (target is Character)
{
var chr = (Character)target;
if (!chr.CanFly)
{
failReason = SpellFailedReason.NotHere;
}
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character))
{
return;
}
var chr = (Character)target;
if (chr.Class != ClassId.THS)
{
failReason = SpellFailedReason.BadTargets;
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterRef, Unit target, ref SpellFailedReason failReason)
{
var caster = creatingCast.CasterReference.Object as Unit;
if (caster == null)
{
failReason = SpellFailedReason.BadTargets;
}
else
{
if (!(target is NPC))
{
LogManager.GetCurrentClassLogger().Warn("{0} tried to Charm {1} which is not an NPC, but Player charming is not yet supported.", caster, target);
failReason = SpellFailedReason.BadTargets;
}
if (caster.Charm != null)
{
failReason = SpellFailedReason.AlreadyHaveCharm;
}
else if (target.HasMaster)
{
failReason = SpellFailedReason.CantBeCharmed;
}
//else if (caster.Level < EffectValue)
//{
// failReason = SpellFailedReason.Highlevel;
//}
else if (caster.HasMaster)
{
failReason = SpellFailedReason.Charmed;
}
else if (caster is Character)
{
if (((Character)caster).ActivePet != null)
{
failReason = SpellFailedReason.AlreadyHaveSummon;
}
}
}
}
public AuraEffectHandler CreateAuraEffectHandler(ObjectReference caster,
Unit target, ref SpellFailedReason failedReason)
{
return(CreateAuraEffectHandler(caster, target, ref failedReason, null));
}
public static void IsInFrontAndFriendly(SpellEffectHandler effectHandler, WorldObject target,
ref SpellFailedReason failedReason)
{
IsInFrontOfCaster(effectHandler, target, ref failedReason,
IsFriendly);
}
private void CreateHandler(SpellEffect effect, int h, SpellEffectHandler[] handlers, ref SpellTargetCollection targets, ref SpellFailedReason failReason)
{
var handler = effect.SpellEffectHandlerCreator(this, effect);
handlers[h] = handler;
handler.InitialTarget = (Unit)SelectedTarget;
if (targets == null)
{
targets = CreateSpellTargetCollection();
}
// make sure, we have the right Caster-Type
/*handler.CheckCasterType(ref failReason);
* if (failReason != SpellFailedReason.Ok)
* {
* return;
* }
*
* // find targets and amount SpellTargetCollection if effects have same ImplicitTargetTypes
* if (InitialTargets != null)
* {
* // do we have given targets?
* if (targets == null)
* {
* targets = CreateSpellTargetCollection();
* }
* }
* else if (handler.HasOwnTargets)
* {
* // see if targets are shared between effects
* targets = null;
*
* for (var j = 0; j < h; j++)
* {
* var handler2 = handlers[j];
* if (handler.Effect.SharesTargetsWith(handler2.Effect))
* {
* // same targets -> share target collection
* targets = handler2.m_targets;
* break;
* }
* }
*
* if (targets == null)
* {
* targets = CreateSpellTargetCollection();
* }
* }*/
if (targets != null)
{
handler.m_targets = targets;
targets.m_handlers.Add(handler);
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
form = (ShapeshiftForm)SpellEffect.MiscValue;
if (target.ShapeshiftForm == form)
{
// stances can't be undone:
if (form != ShapeshiftForm.BattleStance &&
form != ShapeshiftForm.BerserkerStance &&
form != ShapeshiftForm.DefensiveStance)
{
if (Aura != null)
{
target.Auras.RemoveWhere(aura => aura.Spell.Id == Aura.Spell.Id);
}
failReason = SpellFailedReason.DontReport;
}
}
}
/// <summary>Triggers a new tick</summary>
protected void Tick(int timeElapsed)
{
++this.m_ticks;
SpellCast cast = this.m_cast;
if (cast == null || !cast.IsCasting)
{
return;
}
Spell spell = cast.Spell;
List <SpellEffectHandler> channelHandlers = this.m_channelHandlers;
if (spell.PowerPerSecond > 0)
{
int amount = spell.PowerPerSecond;
if (this.m_amplitude != 1000 && this.m_amplitude != 0)
{
amount = (int)((double)amount * ((double)this.m_amplitude / 1000.0));
}
SpellFailedReason reason = cast.ConsumePower(amount);
if (reason != SpellFailedReason.Ok)
{
this.m_cast.Cancel(reason);
return;
}
}
foreach (SpellEffectHandler spellEffectHandler in channelHandlers)
{
spellEffectHandler.OnChannelTick();
if (!this.m_channeling)
{
return;
}
}
if (this.m_auras != null)
{
this.m_auras.RemoveAll((Predicate <IAura>)(aura =>
{
if (!aura.IsAdded)
{
return(true);
}
aura.Apply();
return(!aura.IsAdded);
}));
}
if (!this.m_channeling)
{
return;
}
Action <SpellChannel> ticked = SpellChannel.Ticked;
if (ticked != null)
{
ticked(this);
}
if (this.m_maxTicks > 0 && this.m_ticks < this.m_maxTicks)
{
return;
}
this.Close(false);
if (!cast.IsCasting)
{
return;
}
cast.Cleanup();
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (!(target is Character))
{
failReason = SpellFailedReason.TargetNotPlayer;
}
}
internal bool PrepareStackOrOverride(ObjectReference caster, Aura oldAura, Spell spell, ref SpellFailedReason err, SpellCast triggeringCast = null)
{
var status = oldAura.GetOverrideStatus(caster, spell);
if (status == Aura.AuraOverrideStatus.Replace)
{
status = oldAura.TryRemove(true) ? Aura.AuraOverrideStatus.NotPresent : Aura.AuraOverrideStatus.Bounced;
}
switch (status)
{
case Aura.AuraOverrideStatus.NotPresent:
return(true); // no obstacles in the way
case Aura.AuraOverrideStatus.Refresh:
oldAura.Refresh(caster);
return(false); // don't need to create a new one
default:
err = SpellFailedReason.AuraBounced; // cannot help it
return(false);
}
}
/// <summary>
///
/// </summary>
public static void IsNotPlayer(SpellEffectHandler effectHandler, WorldObject target,
ref SpellFailedReason failedReason)
{
failedReason = target is Character ? SpellFailedReason.TargetIsPlayer : SpellFailedReason.Ok;
}
/// <summary>
/// Stack or removes the Aura represented by the given spell, if possible.
/// Returns true if there is no incompatible Aura or if the Aura could be removed.
/// <param name="err">Ok, if stacked or no incompatible Aura is blocking a new Aura</param>
/// </summary>
internal bool PrepareStackOrOverride(ObjectReference caster, AuraIndexId id, Spell spell, ref SpellFailedReason err, SpellCast triggeringCast = null)
{
var oldAura = GetAura(caster, id, spell);
if (oldAura != null)
{
return(PrepareStackOrOverride(caster, oldAura, spell, ref err, triggeringCast));
}
return(true);
}
/// <summary>
/// This is sent to caster if spell fails
/// </summary>
internal static void SendCastFailed(IPacketReceiver client, byte castId, Spell spell, SpellFailedReason result)
{
var len = (result == SpellFailedReason.RequiresSpellFocus || result == SpellFailedReason.RequiresArea ? 10 : 6);
using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_CAST_FAILED, len))
{
//packet.Write((uint)spellId);
//packet.Write((byte)2);
//packet.WriteByte((byte)result);
packet.Write(castId);
packet.Write(spell.Id);
packet.Write((byte)result);
if (result == SpellFailedReason.RequiresSpellFocus)
{
packet.Write((uint)spell.RequiredSpellFocus);
}
else if (result == SpellFailedReason.RequiresArea)
{
packet.Write(spell.AreaGroupId);
}
client.Send(packet);
}
}
protected internal override void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference, Unit target, ref SpellFailedReason failReason)
{
if (target.Class != ClassId.Hunter)
{
failReason = SpellFailedReason.BadTargets;
return;
}
}
/// <summary>
/// Check whether this handler can be applied to the given target.
/// m_aura, as well as some other fields are not set when this method gets called.
/// </summary>
protected internal virtual void CheckInitialize(SpellCast creatingCast, ObjectReference casterReference,
Unit target, ref SpellFailedReason failReason)
{
}
