public override void AddCooldown(Spell spell, Item casterItem) { bool flag = casterItem != null && casterItem.Template.UseSpell != null; int millis = 0; if (flag) { millis = casterItem.Template.UseSpell.Cooldown; } if (millis == 0) { millis = spell.GetCooldown(this.Owner); } if (millis <= 0) { return; } SpellIdCooldown spellIdCooldown = new SpellIdCooldown() { SpellId = spell.Id, Until = DateTime.Now + TimeSpan.FromMilliseconds((double)millis) }; if (flag) { spellIdCooldown.ItemId = casterItem.Template.Id; } this.m_idCooldowns.Add((ISpellIdCooldown)spellIdCooldown); this.OwnerChar.Map.CallDelayed(500, (Action)(() => Asda2SpellHandler.SendSetSkillCooldownResponse(this.OwnerChar, spell))); this.OwnerChar.Map.CallDelayed(millis, (Action)(() => Asda2SpellHandler.SendClearCoolDown(this.OwnerChar, spell.RealId))); }
public override void AddCooldown(Spell spell, Item casterItem) { var itemSpell = casterItem != null && casterItem.Template.UseSpell != null; var cd = 0; if (itemSpell) { cd = casterItem.Template.UseSpell.Cooldown; } if (cd == 0) { cd = spell.GetCooldown(Owner); } if (cd > 0) { var idCooldown = new SpellIdCooldown { SpellId = spell.Id, Until = (DateTime.Now + TimeSpan.FromMilliseconds(cd)) }; if (itemSpell) { idCooldown.ItemId = casterItem.Template.Id; } m_idCooldowns.Add(idCooldown); OwnerChar.Map.CallDelayed(500, () => Asda2SpellHandler.SendSetSkillCooldownResponse(OwnerChar, spell)); OwnerChar.Map.CallDelayed(cd, () => Asda2SpellHandler.SendClearCoolDown(OwnerChar, spell.RealId)); } }
/// <summary>Removes all of this Aura's occupied fields</summary> protected void RemoveFromClient() { if (!IsVisible) { return; } Character owner1 = Owner as Character; NPC owner2 = Owner as NPC; if (owner2 != null) { Asda2CombatHandler.SendMonstrStateChangedResponse(owner2, Asda2NpcState.Ok); } if (owner1 == null) { return; } Asda2SpellHandler.SendBuffEndedResponse(owner1, Spell.RealId); if (owner1.IsInGroup) { Asda2GroupHandler.SendPartyMemberBuffInfoResponse(owner1); } if (owner1.SoulmateCharacter == null) { return; } Asda2SoulmateHandler.SendSoulmateBuffUpdateInfoResponse(owner1); }
public override void OnAttack(WCell.RealmServer.Misc.DamageAction action) { if (action.Spell != null) { return; } if (Owner.SplinterEffect > 0) { var targets = Owner.GetObjectsInRadius(2.5f, ObjectTypes.Attackable, false); foreach (var worldObject in targets) { if (!Owner.IsHostileWith(worldObject) || ReferenceEquals(worldObject, Owner)) { continue; } if (Utility.Random(0, 100000) > Owner.SplinterEffectChange) { continue; } var targetChr = worldObject as Character; var targetNpc = worldObject as NPC; var a = Owner.GetUnusedAction(); a.Damage = (int)(Owner.RandomDamage * Owner.SplinterEffect); a.Attacker = worldObject as Unit; a.Victim = worldObject as Unit; a.DoAttack(); if (Owner is Character) { Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(null, targetChr, targetNpc, a.ActualDamage); } action.OnFinished(); } } base.OnAttack(action); }
protected override void Apply() { IList <WorldObject> objectsInRadius = this.Owner.GetObjectsInRadius <Unit>(6f, ObjectTypes.Unit, false, int.MaxValue); if (objectsInRadius == null) { return; } foreach (WorldObject worldObject in (IEnumerable <WorldObject>)objectsInRadius) { Unit unit = worldObject as Unit; if (unit != null && this.Owner != null && (this.m_aura != null && unit.IsHostileWith((IFactionMember)this.Owner))) { DamageAction damageAction = unit.DealSpellDamage(this.Owner, this.SpellEffect, (int)((double)this.Owner.RandomDamage * (double)this.SpellEffect.MiscValue / 100.0), true, true, false, false); if (damageAction != null) { Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(this.m_aura.CasterUnit as Character, unit as Character, unit as NPC, damageAction.ActualDamage); damageAction.OnFinished(); } } } }
public override void OnAttack(DamageAction action) { if (action.Spell == null || action.SpellEffect.AuraType == AuraType.ExplosiveArrow) { return; } foreach (WorldObject objectsInRadiu in (IEnumerable <WorldObject>)action.Victim.GetObjectsInRadius <Unit>(6f, ObjectTypes.Unit, false, int.MaxValue)) { if (objectsInRadiu.IsHostileWith((IFactionMember)action.Attacker)) { Unit unit = objectsInRadiu as Unit; if (unit != null) { DamageAction damageAction = unit.DealSpellDamage(action.Attacker, this.SpellEffect, (int)((double)action.Attacker.RandomDamage * (double)this.SpellEffect.MiscValue / 100.0), true, true, false, false); if (damageAction != null) { Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse( this.m_aura.CasterUnit as Character, this.Owner as Character, unit as NPC, damageAction.ActualDamage); action.OnFinished(); } } } } }
/// <summary> /// Removes all of this Aura's occupied fields /// </summary> protected void RemoveFromClient() { if (!IsVisible) { return; } var character = Owner as Character; var owner = Owner as NPC; if (owner != null) { Asda2CombatHandler.SendMonstrStateChangedResponse(owner, Asda2NpcState.Ok); } if (character != null) { Asda2SpellHandler.SendBuffEndedResponse(character, Spell.RealId); if (character.IsInGroup) { Asda2GroupHandler.SendPartyMemberBuffInfoResponse(character); } if (character.SoulmateCharacter != null) { Asda2SoulmateHandler.SendSoulmateBuffUpdateInfoResponse(character); } } //AuraHandler.SendRemoveAura(m_auras.Owner, this); }
protected override void Remove(bool cancelled) { Unit casterUnit = m_aura.CasterUnit; if (casterUnit == null) { return; } foreach (WorldObject objectsInRadiu in Owner.GetObjectsInRadius(6f, ObjectTypes.Unit, false, int.MaxValue)) { if (casterUnit.IsHostileWith(objectsInRadiu)) { Unit unit = objectsInRadiu as Unit; if (unit != null) { DamageAction damageAction = unit.DealSpellDamage(casterUnit, SpellEffect, (int)(casterUnit.RandomDamage * (double)SpellEffect.MiscValue / 100.0), true, true, false, false); if (damageAction != null) { Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse( m_aura.CasterUnit as Character, Owner as Character, unit as NPC, damageAction.ActualDamage); damageAction.OnFinished(); } } } } }
public static void SendAuraUpdate(Unit owner, Aura aura) { if (owner is NPC) { Asda2CombatHandler.SendNpcBuffedResponse((NPC)owner, aura); } else { if (!(owner is Character)) { return; } Character character = (Character)owner; if (!character.CanMove) { Asda2MovmentHandler.SendEndMoveByFastInstantRegularMoveResponse(character); } Asda2SpellHandler.SendCharacterBuffedResponse(character, aura); if (character.IsInGroup) { Asda2GroupHandler.SendPartyMemberBuffInfoResponse(character); } if (character.SoulmateCharacter == null) { return; } Asda2SoulmateHandler.SendSoulmateBuffUpdateInfoResponse(character); } }
public static void SendAuraUpdate(Unit owner, Aura aura) { if (owner is NPC) { Asda2CombatHandler.SendNpcBuffedResponse((NPC)owner, aura); } else if (owner is Character) { var chr = (Character)owner; if (!chr.CanMove) { Asda2MovmentHandler.SendEndMoveByFastInstantRegularMoveResponse(chr); } Asda2SpellHandler.SendCharacterBuffedResponse(chr, aura); if (chr.IsInGroup) { Asda2GroupHandler.SendPartyMemberBuffInfoResponse(chr); } if (chr.SoulmateCharacter != null) { Asda2SoulmateHandler.SendSoulmateBuffUpdateInfoResponse(chr); } } /*if (!owner.IsAreaActive) return; * using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_AURA_UPDATE)) * { * owner.EntityId.WritePacked(packet); * * WriteAura(aura, packet); * * owner.SendPacketToArea(packet); * }*/ }
public override void OnAttack(DamageAction action) { if (action.Spell != null) { return; } if ((double)this.Owner.SplinterEffect > 0.0) { foreach (WorldObject objectsInRadiu in (IEnumerable <WorldObject>) this.Owner.GetObjectsInRadius <Unit>( 2.5f, ObjectTypes.Attackable, false, int.MaxValue)) { if (this.Owner.IsHostileWith((IFactionMember)objectsInRadiu) && !object.ReferenceEquals((object)objectsInRadiu, (object)this.Owner) && Utility.Random(0, 100000) <= this.Owner.SplinterEffectChange) { Character targetChr = objectsInRadiu as Character; NPC targetNpc = objectsInRadiu as NPC; DamageAction unusedAction = this.Owner.GetUnusedAction(); unusedAction.Damage = (int)((double)this.Owner.RandomDamage * (double)this.Owner.SplinterEffect); unusedAction.Attacker = objectsInRadiu as Unit; unusedAction.Victim = objectsInRadiu as Unit; int num = (int)unusedAction.DoAttack(); if (this.Owner is Character) { Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse((Character)null, targetChr, targetNpc, unusedAction.ActualDamage); } action.OnFinished(); } } } base.OnAttack(action); }
public override void OnDefend(DamageAction action) { action.Victim.AddMessage((Action)(() => { if (!action.Victim.MayAttack((IFactionMember)action.Attacker)) { return; } action.Attacker.DealSpellDamage(action.Victim, this.SpellEffect, action.Damage * (this.SpellEffect.MiscValue / 100), true, true, false, true); Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(this.m_aura.CasterUnit as Character, this.Owner as Character, this.Owner as NPC, action.ActualDamage); })); if (this.SpellEffect.MiscValueB == 0) { action.Resisted = action.Damage; } else { if (this.SpellEffect.MiscValueB != 20) { return; } Character casterUnit = this.m_aura.CasterUnit as Character; if (casterUnit == null || !casterUnit.IsInGroup) { return; } foreach (GroupMember groupMember in casterUnit.Group) { groupMember.Character.Heal(action.Damage * this.SpellEffect.MiscValue / 100, (Unit)null, (SpellEffect)null); } } }
/// <summary> /// Teaches a new spell to the unit. Also sends the spell learning animation, if applicable. /// </summary> private void AddSpell(Spell spell, bool sendPacket) { if (spell.Ability != null) { Skill skill = this.OwnerChar.Skills[spell.Ability.Skill.Id] ?? this.OwnerChar.Skills.Add(spell.Ability.Skill, true); if (skill.CurrentTierSpell == null || skill.CurrentTierSpell.SkillTier < spell.SkillTier) { skill.CurrentTierSpell = spell; } } if (!this.m_byId.ContainsKey(spell.SpellId)) { Character ownerChar = this.OwnerChar; int specIndex = this.GetSpecIndex(spell); List <SpellRecord> spellList = this.GetSpellList(spell); SpellRecord record = new SpellRecord(spell.SpellId, ownerChar.EntityId.Low, specIndex); record.SaveLater(); spellList.Add(record); base.AddSpell(spell); } if (!this.m_sendPackets || !sendPacket) { return; } if (spell.Level == 1) { Asda2SpellHandler.SendSkillLearnedFirstTimeResponse(this.OwnerChar.Client, spell.RealId, spell.CooldownTime); } Asda2SpellHandler.SendSkillLearnedResponse(SkillLearnStatus.Ok, this.OwnerChar, (uint)spell.RealId, spell.Level); }
protected override void Apply() { Unit owner = Owner; if (!owner.IsAlive) { return; } float num = (float)(SpellEffect.MiscValue * (m_aura.CasterUnit != null ? (m_aura.CasterUnit.Class == ClassId.AtackMage || m_aura.CasterUnit.Class == ClassId.SupportMage || m_aura.CasterUnit.Class == ClassId.HealMage ? m_aura.CasterUnit.RandomMagicDamage : m_aura.CasterUnit.RandomDamage) : 666.0) / 100.0 * 3.0); if (m_aura.Spell.Mechanic == SpellMechanic.Bleeding) { int bleedBonusPercent = m_aura.Auras.GetBleedBonusPercent(); num += (float)((num * (double)bleedBonusPercent + 50.0) / 100.0); m_aura.Owner.IncMechanicCount(SpellMechanic.Bleeding, false); } DamageAction damageAction = owner.DealSpellDamage(m_aura.CasterUnit, m_spellEffect, (int)num, true, true, false, false); if (damageAction == null) { return; } Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(m_aura.CasterUnit as Character, Owner as Character, Owner as NPC, damageAction.ActualDamage); damageAction.OnFinished(); }
protected override void Apply() { IList <WorldObject> objectsInRadius = this.Owner.GetObjectsInRadius <Unit>(3f, ObjectTypes.Unit, false, int.MaxValue); bool flag = false; foreach (WorldObject worldObject in (IEnumerable <WorldObject>)objectsInRadius) { Unit unit = worldObject as Unit; if (unit != null && unit.IsHostileWith((IFactionMember)this.Owner)) { flag = true; break; } } if (!flag) { return; } foreach (WorldObject objectsInRadiu in (IEnumerable <WorldObject>) this.Owner.GetObjectsInRadius <Unit>(12f, ObjectTypes.Unit, false, int.MaxValue)) { Unit pos = objectsInRadiu as Unit; if (pos != null && pos.IsHostileWith((IFactionMember)this.Owner)) { if (this.SpellEffect.MiscValueB == 1) { Spell spell = SpellHandler.Get(775U); pos.Auras.CreateAndStartAura(this.Owner.SharedReference, spell, false, (Item)null); } else if (this.SpellEffect.MiscValueB == 0) { float dist = pos.GetDist((IHasPosition)this.Owner); float num = 1f; if ((double)dist >= 3.0) { num /= (float)Math.Pow((double)dist, 0.600000023841858); } DamageAction damageAction = pos.DealSpellDamage(this.Owner, this.SpellEffect, (int)((double)this.Owner.RandomDamage * (double)this.SpellEffect.MiscValue / 100.0 * (double)num), true, true, false, false); if (damageAction != null) { if (this.m_aura != null) { Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse( this.m_aura.CasterUnit as Character, objectsInRadiu as Character, objectsInRadiu as NPC, damageAction.ActualDamage); } damageAction.OnFinished(); } } } } this.Aura.Cancel(); }
/// <summary> /// Teaches a new spell to the unit. Also sends the spell learning animation, if applicable. /// </summary> void AddSpell(Spell spell, bool sendPacket) { // make sure the char knows the skill that this spell belongs to if (spell.Ability != null) { var skill = OwnerChar.Skills[spell.Ability.Skill.Id]; if (skill == null) { // learn new skill skill = OwnerChar.Skills.Add(spell.Ability.Skill, true); } if (skill.CurrentTierSpell == null || skill.CurrentTierSpell.SkillTier < spell.SkillTier) { // upgrade tier skill.CurrentTierSpell = spell; } } if (!m_byId.ContainsKey(spell.SpellId)) { var owner = OwnerChar; var specIndex = GetSpecIndex(spell); var spells = GetSpellList(spell); var newRecord = new SpellRecord(spell.SpellId, owner.EntityId.Low, specIndex); newRecord.SaveLater(); spells.Add(newRecord); base.AddSpell(spell); } if (m_sendPackets && sendPacket) { if (spell.Level == 1) { Asda2SpellHandler.SendSkillLearnedFirstTimeResponse(OwnerChar.Client, spell.RealId, spell.CooldownTime); } Asda2SpellHandler.SendSkillLearnedResponse(SkillLearnStatus.Ok, OwnerChar, (uint)spell.RealId, spell.Level); //SpellHandler.SendLearnedSpell(owner.Client, spell.Id); /*if (!spell.IsPassive) * { * SpellHandler.SendVisual(owner, 362); // ouchy: Unnamed constants * }*/ } }
/// <summary> /// Clears all pending spell cooldowns. /// </summary> public override void ClearCooldowns() { // send cooldown updates to client foreach (var cd in m_idCooldowns) { Asda2SpellHandler.SendClearCoolDown(OwnerChar, (SpellId)cd.SpellId); } foreach (var spell in m_byId.Values) { foreach (var cd in m_categoryCooldowns) { if (spell.Category == cd.CategoryId) { Asda2SpellHandler.SendClearCoolDown(OwnerChar, spell.SpellId); break; } } } // remove and delete all cooldowns var cds = m_idCooldowns.ToArray(); var catCds = m_categoryCooldowns.ToArray(); m_idCooldowns.Clear(); m_categoryCooldowns.Clear(); RealmServer.IOQueue.AddMessage(new Message(() => { foreach (var cooldown in cds) { if (cooldown is ActiveRecordBase) { ((ActiveRecordBase)cooldown).Delete(); } } foreach (var cooldown in catCds) { if (cooldown is ActiveRecordBase) { ((ActiveRecordBase)cooldown).Delete(); } } })); }
/// <summary>Clears all pending spell cooldowns.</summary> public override void ClearCooldowns() { foreach (ISpellIdCooldown idCooldown in this.m_idCooldowns) { Asda2SpellHandler.SendClearCoolDown(this.OwnerChar, (SpellId)idCooldown.SpellId); } foreach (Spell spell in this.m_byId.Values) { foreach (ISpellCategoryCooldown categoryCooldown in this.m_categoryCooldowns) { if ((int)spell.Category == (int)categoryCooldown.CategoryId) { Asda2SpellHandler.SendClearCoolDown(this.OwnerChar, spell.SpellId); break; } } } ISpellIdCooldown[] cds = this.m_idCooldowns.ToArray(); ISpellCategoryCooldown[] catCds = this.m_categoryCooldowns.ToArray(); this.m_idCooldowns.Clear(); this.m_categoryCooldowns.Clear(); ServerApp <WCell.RealmServer.RealmServer> .IOQueue.AddMessage((IMessage) new Message((Action)(() => { foreach (ISpellIdCooldown spellIdCooldown in cds) { if (spellIdCooldown is ActiveRecordBase) { ((ActiveRecordBase)spellIdCooldown).Delete(); } } foreach (ISpellCategoryCooldown categoryCooldown in catCds) { if (categoryCooldown is ActiveRecordBase) { ((ActiveRecordBase)categoryCooldown).Delete(); } } }))); }
protected override void Apply() { int dmg = Owner.Health * SpellEffect.MiscValue / 100; NPC owner = Owner as NPC; if (owner != null && owner.Entry.IsBoss) { return; } DamageAction damageAction = Owner.DealSpellDamage(Owner, SpellEffect, dmg, true, true, false, false); if (damageAction == null || m_aura == null) { return; } Asda2SpellHandler.SendMonstrTakesDamageSecondaryResponse(m_aura.CasterUnit as Character, Owner as Character, Owner as NPC, damageAction.ActualDamage); damageAction.OnFinished(); Aura.Cancel(); }
/// <summary>Clears the cooldown for this spell</summary> public override void ClearCooldown(Spell cooldownSpell, bool alsoCategory = true) { Character ownerChar = this.OwnerChar; Asda2SpellHandler.SendClearCoolDown(ownerChar, cooldownSpell.SpellId); if (alsoCategory && cooldownSpell.Category != 0U) { foreach (Spell spell in this.m_byId.Values) { if ((int)spell.Category == (int)cooldownSpell.Category) { Asda2SpellHandler.SendClearCoolDown(ownerChar, spell.SpellId); } } } ISpellIdCooldown idCooldown = this.m_idCooldowns.RemoveFirst <ISpellIdCooldown>( (Func <ISpellIdCooldown, bool>)(cd => (int)cd.SpellId == (int)cooldownSpell.Id)); ISpellCategoryCooldown catCooldown = this.m_categoryCooldowns.RemoveFirst <ISpellCategoryCooldown>( (Func <ISpellCategoryCooldown, bool>)(cd => (int)cd.CategoryId == (int)cooldownSpell.Category)); if (!(idCooldown is ActiveRecordBase) && !(catCooldown is ActiveRecordBase)) { return; } ServerApp <WCell.RealmServer.RealmServer> .IOQueue.AddMessage((IMessage) new Message((Action)(() => { if (idCooldown is ActiveRecordBase) { ((ActiveRecordBase)idCooldown).Delete(); } if (!(catCooldown is ActiveRecordBase)) { return; } ((ActiveRecordBase)catCooldown).Delete(); }))); }
/// <summary> /// Clears the cooldown for this spell /// </summary> public override void ClearCooldown(Spell cooldownSpell, bool alsoCategory = true) { var ownerChar = OwnerChar; // send cooldown update to client Asda2SpellHandler.SendClearCoolDown(ownerChar, cooldownSpell.SpellId); if (alsoCategory && cooldownSpell.Category != 0) { foreach (var spell in m_byId.Values) { if (spell.Category == cooldownSpell.Category) { Asda2SpellHandler.SendClearCoolDown(ownerChar, spell.SpellId); } } } // remove and delete ISpellIdCooldown idCooldown = m_idCooldowns.RemoveFirst(cd => cd.SpellId == cooldownSpell.Id); ISpellCategoryCooldown catCooldown = m_categoryCooldowns.RemoveFirst(cd => cd.CategoryId == cooldownSpell.Category); // enqueue task if (idCooldown is ActiveRecordBase || catCooldown is ActiveRecordBase) { RealmServer.IOQueue.AddMessage(new Message(() => { if (idCooldown is ActiveRecordBase) { ((ActiveRecordBase)idCooldown).Delete(); } if (catCooldown is ActiveRecordBase) { ((ActiveRecordBase)catCooldown).Delete(); } } )); } }
/// <summary> /// Apply the effect (by default to all targets of the targettype) /// Returns the reason for why it went wrong or SpellFailedReason.None /// </summary> public virtual void Apply() { if (m_targets != null) { var npc = Cast.CasterObject as NPC; var chr = Cast.CasterChar; DamageAction[] actions = null; for (CurrentTargetNo = 0; CurrentTargetNo < m_targets.Count; CurrentTargetNo++) { var target = m_targets[CurrentTargetNo]; if (!target.IsInContext) { continue; } Apply(target, ref actions); if (m_cast == null) { // spell got cancelled return; } } if (actions == null && Effect.Spell.Effect0_EffectType != SpellEffectType.DamageFromPrcAtack && Effect.Spell.Effect0_EffectType != SpellEffectType.InstantKill) { //animate without actions if (chr != null) { Asda2SpellHandler.SendAnimateSkillStrikeResponse(chr, Effect.Spell.RealId, null, InitialTarget); } else if (npc != null) { Asda2SpellHandler.SendMonstrUsedSkillResponse(npc, Effect.Spell.RealId, InitialTarget, actions); } return; } if (Effect.EffectType != SpellEffectType.CastAnotherSpell && actions != null) { if (chr != null) { Asda2SpellHandler.SendAnimateSkillStrikeResponse(chr, Effect.Spell.RealId, actions, InitialTarget); } else if (npc != null) { Asda2SpellHandler.SendMonstrUsedSkillResponse(npc, Effect.Spell.RealId, InitialTarget, actions); } else { Cast.CasterObject.SendMessageToArea( string.Format( "Spell {0} has wrong target[{1}] or caster[{2}]. Please report to developers.", Effect.Spell, InitialTarget, m_cast.CasterUnit), Color.LightGray); } } } else { log.Warn("SpellEffectHandler has no targets, but Apply() is not overridden: " + this); } }
/// <summary> /// Apply the effect (by default to all targets of the targettype) /// Returns the reason for why it went wrong or SpellFailedReason.None /// </summary> public virtual void Apply() { if (this.m_targets != null) { NPC casterObject = this.Cast.CasterObject as NPC; Character casterChar = this.Cast.CasterChar; DamageAction[] actions = (DamageAction[])null; for (this.CurrentTargetNo = 0; this.CurrentTargetNo < this.m_targets.Count; ++this.CurrentTargetNo) { WorldObject target = this.m_targets[this.CurrentTargetNo]; if (target.IsInContext) { this.Apply(target, ref actions); if (this.m_cast == null) { return; } } } if (actions == null && this.Effect.Spell.Effect0_EffectType != SpellEffectType.DamageFromPrcAtack && this.Effect.Spell.Effect0_EffectType != SpellEffectType.InstantKill) { if (casterChar != null) { Asda2SpellHandler.SendAnimateSkillStrikeResponse(casterChar, this.Effect.Spell.RealId, (DamageAction[])null, this.InitialTarget); } else { if (casterObject == null) { return; } Asda2SpellHandler.SendMonstrUsedSkillResponse(casterObject, this.Effect.Spell.RealId, this.InitialTarget, actions); } } else { if (this.Effect.EffectType == SpellEffectType.CastAnotherSpell || actions == null) { return; } if (casterChar != null) { Asda2SpellHandler.SendAnimateSkillStrikeResponse(casterChar, this.Effect.Spell.RealId, actions, this.InitialTarget); } else if (casterObject != null) { Asda2SpellHandler.SendMonstrUsedSkillResponse(casterObject, this.Effect.Spell.RealId, this.InitialTarget, actions); } else { this.Cast.CasterObject.SendMessageToArea( string.Format( "Spell {0} has wrong target[{1}] or caster[{2}]. Please report to developers.", (object)this.Effect.Spell, (object)this.InitialTarget, (object)this.m_cast.CasterUnit), Color.LightGray); } } } else { SpellEffectHandler.log.Warn("SpellEffectHandler has no targets, but Apply() is not overridden: " + (object)this); } }