public void AttackedEvent(DOLEvent e, object sender, EventArgs arguments) { GamePlayer player = (GamePlayer)sender; AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; int HalfHP = player.MaxHealth / 2; double ManaHeal = player.MaxMana * 0.25; if (args == null || args.AttackData == null) { return; } if (player.Health <= HalfHP) { if (player.Mana < ManaHeal) { player.Health += player.Mana; player.Mana -= (int)ManaHeal; player.Out.SendMessage("You convert " + player.Mana + " power into hit points!", eChatType.CT_Spell, eChatLoc.CL_ChatWindow); return; } player.Health += (int)ManaHeal; player.Mana -= (int)ManaHeal; player.Out.SendMessage("You convert " + ManaHeal + " power into hit points!", eChatType.CT_Spell, eChatLoc.CL_ChatWindow); return; } }
protected virtual void OnAttacked(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs attackArgs = arguments as AttackedByEnemyEventArgs; GameLiving living = sender as GameLiving; if (attackArgs == null) { return; } if (living == null) { return; } double value; switch (attackArgs.AttackData.AttackType) { case AttackData.eAttackType.Ranged: value = Spell.Value * .01; attackArgs.AttackData.Damage *= (int)value; break; case AttackData.eAttackType.Spell: if (attackArgs.AttackData.SpellHandler.Spell.SpellType == "Archery") { value = Spell.Value * .01; attackArgs.AttackData.Damage *= (int)value; } break; } }
/// <summary> /// Called when a player leaves the game /// </summary> /// <param name="e">The event which was raised</param> /// <param name="sender">Sender of the event</param> /// <param name="args">EventArgs associated with the event</param> protected void OnAttack(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; if (args == null) { return; } if (args.AttackData == null) { return; } AttackData ad = args.AttackData; GameLiving living = sender as GameLiving; if (living == null) { return; } double absorbPercent = ShadowShroudAbility.ABSPERCENT; int damageAbsorbed = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); if (damageAbsorbed > 0) { ad.Damage -= damageAbsorbed; //TODO correct messages MessageToLiving(ad.Target, string.Format("Shadow Shroud Ability absorbs {0} damage!", damageAbsorbed), eChatType.CT_Spell); MessageToLiving(ad.Attacker, string.Format("A barrier absorbs {0} damage of your attack!", damageAbsorbed), eChatType.CT_Spell); } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if ((int)ad.DamageType >= 1 && (int)ad.DamageType <= 3) { int absorb = (int)Math.Round((double)ad.Damage * (double)Spell.Value / 100); int critical = (int)Math.Round((double)ad.CriticalDamage * (double)Spell.Value / 100); ad.Damage -= absorb; ad.CriticalDamage -= critical; if (ad.Attacker is GamePlayer) { (ad.Attacker as GamePlayer).Out.SendMessage("Your target's Ereine charge absorb " + (absorb + critical) + " damages", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow); } if (ad.Target is GamePlayer) { (ad.Target as GamePlayer).Out.SendMessage("Your Ereine charge absorb " + (absorb + critical) + " damages", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow); } } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if ((int)ad.DamageType >= 10 && (int)ad.DamageType <= 15) { if (ad.Attacker is GamePlayer) { (ad.Attacker as GamePlayer).Out.SendMessage("Your target' Ereine Proc absorb " + (ad.Damage + ad.CriticalDamage) + " damages", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow); } if (ad.Target is GamePlayer) { (ad.Target as GamePlayer).Out.SendMessage("Your Ereine Proc absorb " + (ad.Damage + ad.CriticalDamage) + " damages", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow); } ad.Damage = 0; ad.CriticalDamage = 0; GameSpellEffect effect = SpellHandler.FindEffectOnTarget(living, this); if (effect != null) { effect.Cancel(false); } } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } double absorbPercent = 100; int damageAbsorbed = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); int spellAbsorbed = (int)(0.01 * absorbPercent * Spell.Damage); ad.Damage -= damageAbsorbed; ad.Damage -= spellAbsorbed; MessageToLiving(ad.Target, string.Format("You're in a Zephyr and can't be attacked!"), eChatType.CT_Spell); MessageToLiving(ad.Attacker, string.Format("Your target is in a Zephyr and can't be attacked!"), eChatType.CT_Spell); }
/// <summary> /// Owner attacked event /// </summary> /// <param name="e"></param> /// <param name="sender"></param> /// <param name="arguments"></param> protected virtual void OnOwnerAttacked(DOLEvent e, object sender, EventArgs arguments) { // theurgist pets don't help their owner //edit for BD - possibly add support for Theurgist GameNPCs if (Owner is GamePlayer && ((GamePlayer)Owner).CharacterClass.ID == (int)eCharacterClass.Theurgist) { return; } AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; if (args == null) { return; } if (args.AttackData.Target is GamePlayer && (args.AttackData.Target as GamePlayer).ControlledBrain != this) { return; } // react only on these attack results switch (args.AttackData.AttackResult) { case GameLiving.eAttackResult.Blocked: case GameLiving.eAttackResult.Evaded: case GameLiving.eAttackResult.Fumbled: case GameLiving.eAttackResult.HitStyle: case GameLiving.eAttackResult.HitUnstyled: case GameLiving.eAttackResult.Missed: case GameLiving.eAttackResult.Parried: AddToAggroList(args.AttackData.Attacker, args.AttackData.Attacker.EffectiveLevel + args.AttackData.Damage + args.AttackData.CriticalDamage); break; } AttackMostWanted(); }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } // Log.DebugFormat("sender:{0} res:{1} IsMelee:{2} Type:{3}", living.Name, ad.AttackResult, ad.IsMeleeAttack, ad.AttackType); int damagereduction = living.TempProperties.getProperty <int>(Damage_Reduction); double absorbPercent = Spell.Damage; int damageAbsorbed = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); if (damageAbsorbed > damagereduction) { damageAbsorbed = damagereduction; } damagereduction -= damageAbsorbed; ad.Damage -= damageAbsorbed; OnDamageAbsorbed(ad, damageAbsorbed); //TODO correct messages if (ad.Damage > 0) { MessageToLiving(ad.Target, string.Format("The damage reduction absorbs {0} damage!", damageAbsorbed), eChatType.CT_Spell); } MessageToLiving(ad.Attacker, string.Format("A damage reduction absorbs {0} damage of your attack!", damageAbsorbed), eChatType.CT_Spell); if (damageAbsorbed > 0) { MessageToCaster("The barrier returns " + damageAbsorbed + " mana back to you.", eChatType.CT_Spell); } Caster.Mana = Caster.Mana + damageAbsorbed; if (Caster.Mana == Caster.MaxMana) { MessageToCaster("You cannot absorb any more power.", eChatType.CT_SpellResisted); } if (damagereduction <= 0) { GameSpellEffect effect = SpellHandler.FindEffectOnTarget(living, this); if (effect != null) { effect.Cancel(false); } } else { living.TempProperties.setProperty(Damage_Reduction, damagereduction); } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } // Log.DebugFormat("sender:{0} res:{1} IsMelee:{2} Type:{3}", living.Name, ad.AttackResult, ad.IsMeleeAttack, ad.AttackType); if (ad == null || (ad.AttackResult != GameLiving.eAttackResult.HitStyle && ad.AttackResult != GameLiving.eAttackResult.HitUnstyled)) { return; } if (!ad.IsMeleeAttack && ad.AttackType != AttackData.eAttackType.Ranged) { return; } //default is 50% double absorbPercent = 50; //But if the buff has a specified spell damage, use that as the percent. if (Spell.Damage > 0) { absorbPercent = Spell.Damage; } if (absorbPercent > 100) { absorbPercent = 100; } //This only absorbs style damage. int damageAbsorbed = (int)(0.01 * absorbPercent * (ad.StyleDamage)); ad.Damage -= damageAbsorbed; OnDamageAbsorbed(ad, damageAbsorbed); //TODO correct messages MessageToLiving(ad.Target, string.Format("Your style absorbtion absorbs {0} damage!", damageAbsorbed), eChatType.CT_Spell); MessageToLiving(ad.Attacker, string.Format("A barrier absorbs {0} damage of your attack!", damageAbsorbed), eChatType.CT_Spell); }
/// <summary> /// Handles attacks on player/by player /// </summary> /// <param name="e"></param> /// <param name="sender"></param> /// <param name="arguments"></param> private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackFinishedEventArgs attackFinished = arguments as AttackFinishedEventArgs; CastingEventArgs castFinished = arguments as CastingEventArgs; AttackData ad = null; ISpellHandler sp = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } else if (attackFinished != null) { ad = attackFinished.AttackData; } else if (castFinished != null) { sp = castFinished.SpellHandler; ad = castFinished.LastAttackData; } // Speed should drop if the player casts an offensive spell if (sp == null && ad == null) { return; } else if (sp == null && (ad.AttackResult != GameLiving.eAttackResult.HitStyle && ad.AttackResult != GameLiving.eAttackResult.HitUnstyled)) { return; } else if (sp != null && (sp.HasPositiveEffect || ad == null)) { return; } GameSpellEffect speed = SpellHandler.FindEffectOnTarget(living, this); if (speed != null) { speed.Cancel(false); } }
protected virtual void OnAttacked(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs attackArgs = arguments as AttackedByEnemyEventArgs; if (attackArgs == null) { return; } switch (attackArgs.AttackData.AttackResult) { case GameLiving.eAttackResult.HitStyle: case GameLiving.eAttackResult.HitUnstyled: Stop(); break; } }
/// <summary> /// Handler fired whenever effect target is attacked /// </summary> /// <param name="e"></param> /// <param name="sender"></param> /// <param name="arguments"></param> protected override void EventHandler(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; if (args == null || args.AttackData == null || args.AttackData.AttackType == AttackData.eAttackType.Spell) { return; } AttackData ad = args.AttackData; if (ad.AttackResult != GameLiving.eAttackResult.HitUnstyled && ad.AttackResult != GameLiving.eAttackResult.HitStyle) { return; } int baseChance = Spell.Frequency / 100; if (ad.AttackType == AttackData.eAttackType.MeleeDualWield) { baseChance /= 2; } if (baseChance < 1) { baseChance = 1; } if (Util.Chance(baseChance)) { ISpellHandler handler = ScriptMgr.CreateSpellHandler((GameLiving)sender, m_procSpell, m_procSpellLine); if (handler != null) { switch (m_procSpell.Target.ToLower()) { case "enemy": handler.StartSpell(ad.Attacker); break; default: handler.StartSpell(ad.Target); break; } } } }
// [StephenxPimentel] // 1.108 All Damage Recieved while this effect is active is reduced by 25%. public void TakeDamage(DOLEvent e, object sender, EventArgs args) { if (sender is GameLiving) { GameLiving living = sender as GameLiving; AttackedByEnemyEventArgs eDmg = args as AttackedByEnemyEventArgs; if (!living.HasEffect(typeof(BladeBarrierEffect))) { GameEventMgr.RemoveHandler(GameLivingEvent.AttackedByEnemy, TakeDamage); return; } eDmg.AttackData.Damage -= (eDmg.AttackData.Damage * 25) / 100; eDmg.AttackData.CriticalDamage -= (eDmg.AttackData.CriticalDamage * 25) / 100; eDmg.AttackData.StyleDamage -= (eDmg.AttackData.StyleDamage * 25) / 100; } }
private void OnAttacked(DOLEvent e, object sender, EventArgs args) { AttackedByEnemyEventArgs attackArgs = args as AttackedByEnemyEventArgs; if (attackArgs == null) { return; } AttackData ad = null; ad = attackArgs.AttackData; int damageAbsorbed = (int)(ad.Damage + ad.CriticalDamage); //They shouldn't take any damamge at all //if (m_player.Health < (damageAbsorbed + (int)Math.Round((double)m_player.MaxHealth / 20))) m_player.Health += damageAbsorbed; m_player.Health += damageAbsorbed; }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if (ad.Damage + ad.CriticalDamage < 1) { return; } int heal = ad.Damage + ad.CriticalDamage; ad.Damage = 0; ad.CriticalDamage = 0; GamePlayer player = living as GamePlayer; GamePlayer attackplayer = ad.Attacker as GamePlayer; if (attackplayer != null) { attackplayer.Out.SendMessage(living.Name + "'s druidic powers absorb your attack!", eChatType.CT_SpellResisted, eChatLoc.CL_SystemWindow); } int modheal = living.MaxHealth - living.Health; if (modheal > heal) { modheal = heal; } living.Health += modheal; if (player != null) { player.Out.SendMessage("Your druidic powers convert your enemies attack and heal you for " + modheal + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } }
private void OnAttacked(DOLEvent e, object sender, EventArgs args) { AttackedByEnemyEventArgs attackArgs = args as AttackedByEnemyEventArgs; if (attackArgs == null || attackArgs.AttackData == null) { return; } //If the attacker was not a mob, then lets do the reduction! if (attackArgs.AttackData.Attacker.Realm != eRealm.None) { //Damage absorbed from normal attack int damageAbsorbed = (int)(attackArgs.AttackData.Damage * (Spell.Value * .01)); attackArgs.AttackData.Damage -= damageAbsorbed; //Damage absorbed from critical hit damageAbsorbed = (int)(attackArgs.AttackData.CriticalDamage * (Spell.Value * .01)); attackArgs.AttackData.CriticalDamage -= damageAbsorbed; } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { if (!(sender is GameLiving living)) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if (ad.Attacker is GamePlayer player) { ad.Damage = 0; ad.CriticalDamage = 0; player.Out.SendMessage($"{living.Name} is Phaseshifted and can\'t be attacked!", eChatType.CT_Missed, eChatLoc.CL_SystemWindow); } }
/// <summary> /// Handler fired whenever effect target is attacked /// </summary> /// <param name="e"></param> /// <param name="sender"></param> /// <param name="arguments"></param> protected override void EventHandler(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; if (args == null) { return; } if (args.AttackData == null) { return; } if (args.AttackData.SpellHandler != null) { return; } if (args.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled && args.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle) { return; } int baseChance = Spell.Frequency / 100; if (baseChance < 1) { baseChance = 1; } if (Util.Chance(baseChance)) { ISpellHandler handler = ScriptMgr.CreateSpellHandler((GameLiving)sender, m_procSpell, m_procSpellLine); if (handler != null) { handler.StartSpell(args.AttackData.Attacker); } } }
/// <summary> /// Handles attack on buff owner /// </summary> /// <param name="e"></param> /// <param name="sender"></param> /// <param name="arguments"></param> protected virtual void OnAttacked(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs attackArgs = arguments as AttackedByEnemyEventArgs; GameLiving living = sender as GameLiving; if (attackArgs == null) { return; } if (living == null) { return; } switch (attackArgs.AttackData.AttackResult) { case GameLiving.eAttackResult.HitStyle: case GameLiving.eAttackResult.HitUnstyled: living.BuffBonusMultCategory1.Remove((int)eProperty.MaxSpeed, this); SendUpdates(living); break; } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { if (!(sender is GameLiving living)) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if (ad == null || ad.Damage < 1) { return; } if (ad.IsMeleeAttack || ad.AttackType == AttackData.eAttackType.Ranged || (ad.AttackType == AttackData.eAttackType.Spell && attackedByEnemy.AttackData.SpellHandler.Spell.SpellType == "Archery")) { int absorb = (int)(ad.Damage * 0.9); int critic = (int)(ad.CriticalDamage * 0.9); ad.Damage -= absorb; ad.CriticalDamage -= critic; if (living is GamePlayer gamePlayer) { gamePlayer.Out.SendMessage($"Your Shield of Immunity absorbs {absorb + critic} points of damage", eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } if (ad.Attacker is GamePlayer player) { player.Out.SendMessage($"{living.Name}\'s Shield of Immunity absorbs {absorb + critic} points of damage", eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } // Log.DebugFormat("sender:{0} res:{1} IsMelee:{2} Type:{3}", living.Name, ad.AttackResult, ad.IsMeleeAttack, ad.AttackType); // Melee or Magic or Both ? if (!MatchingDamageType(ref ad)) { return; } int ablativehp = living.TempProperties.getProperty <int>(ABLATIVE_HP); double absorbPercent = 25; if (Spell.Damage > 0) { absorbPercent = Spell.Damage; } //because albatives can reach 100% if (absorbPercent > 100) { absorbPercent = 100; } int damageAbsorbed = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); if (damageAbsorbed > ablativehp) { damageAbsorbed = ablativehp; } ablativehp -= damageAbsorbed; ad.Damage -= damageAbsorbed; OnDamageAbsorbed(ad, damageAbsorbed); if (ad.Target is GamePlayer) { (ad.Target as GamePlayer).Out.SendMessage(LanguageMgr.GetTranslation((ad.Target as GamePlayer).Client, "AblativeArmor.Target", damageAbsorbed), eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } if (ad.Attacker is GamePlayer) { (ad.Attacker as GamePlayer).Out.SendMessage(LanguageMgr.GetTranslation((ad.Attacker as GamePlayer).Client, "AblativeArmor.Attacker", damageAbsorbed), eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } if (ablativehp <= 0) { GameSpellEffect effect = SpellHandler.FindEffectOnTarget(living, this); if (effect != null) { effect.Cancel(false); } } else { living.TempProperties.setProperty(ABLATIVE_HP, ablativehp); } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } int reduceddmg = living.TempProperties.getProperty <int>(ConvertDamage); double absorbPercent = Spell.Damage; int damageConverted = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); if (damageConverted > reduceddmg) { damageConverted = reduceddmg; reduceddmg -= damageConverted; ad.Damage -= damageConverted; OndamageConverted(ad, damageConverted); } if (ad.Damage > 0) { MessageToLiving(ad.Target, string.Format("You convert {0} damage into " + damageConverted + " Health.", damageConverted), eChatType.CT_Spell); } MessageToLiving(ad.Attacker, string.Format("A magical spell absorbs {0} damage of your attack!", damageConverted), eChatType.CT_Spell); if (Caster.Health != Caster.MaxHealth) { MessageToCaster("You convert " + damageConverted + " damage into health.", eChatType.CT_Spell); Caster.Health = Caster.Health + damageConverted; #region PVP DAMAGE if (ad.Target is NecromancerPet && ((ad.Target as NecromancerPet).Brain as IControlledBrain).GetPlayerOwner() != null || ad.Target is GamePlayer) { if (ad.Target.DamageRvRMemory > 0) { ad.Target.DamageRvRMemory -= (long)Math.Max(damageConverted, 0); } } #endregion PVP DAMAGE } else { MessageToCaster("You cannot convert anymore health!", eChatType.CT_Spell); } if (Caster.Endurance != Caster.MaxEndurance) { MessageToCaster("You convert " + damageConverted + " damage into endurance", eChatType.CT_Spell); Caster.Endurance = Caster.Endurance + damageConverted; } else { MessageToCaster("You cannot convert anymore endurance!", eChatType.CT_Spell); } if (Caster.Mana != Caster.MaxMana) { MessageToCaster("You convert " + damageConverted + " damage into mana.", eChatType.CT_Spell); Caster.Mana = Caster.Mana + damageConverted; } else { MessageToCaster("You cannot convert anymore mana!", eChatType.CT_Spell); } if (reduceddmg <= 0) { GameSpellEffect effect = SpellHandler.FindEffectOnTarget(living, this); if (effect != null) { effect.Cancel(false); } } }
//public const string ConvertDamage = "Conversion"; private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { GameLiving living = sender as GameLiving; if (living == null) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if (ad.Damage > 0) { switch (attackedByEnemy.AttackData.AttackType) { case AttackData.eAttackType.Spell: { int reduceddmg = living.TempProperties.getProperty <int>(ConvertDamage, 0); double absorbPercent = Spell.Damage; int damageConverted = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); if (damageConverted > reduceddmg) { damageConverted = reduceddmg; reduceddmg -= damageConverted; ad.Damage -= damageConverted; OndamageConverted(ad, damageConverted); } if (reduceddmg <= 0) { GameSpellEffect effect = SpellHandler.FindEffectOnTarget(living, this); if (effect != null) { effect.Cancel(false); } } MessageToLiving(ad.Target, string.Format("You convert {0} damage into " + damageConverted + " Health.", damageConverted), eChatType.CT_Spell); MessageToLiving(ad.Attacker, string.Format("A magical spell absorbs {0} damage of your attack!", damageConverted), eChatType.CT_Spell); if (Caster.Health != Caster.MaxHealth) { MessageToCaster("You convert " + damageConverted + " damage into health.", eChatType.CT_Spell); Caster.Health = Caster.Health + damageConverted; } else { MessageToCaster("You cannot convert anymore health!", eChatType.CT_Spell); } if (Caster.Endurance != Caster.MaxEndurance) { MessageToCaster("You convert " + damageConverted + " damage into endurance", eChatType.CT_Spell); Caster.Endurance = Caster.Endurance + damageConverted; } else { MessageToCaster("You cannot convert anymore endurance!", eChatType.CT_Spell); } if (Caster.Mana != Caster.MaxMana) { MessageToCaster("You convert " + damageConverted + " damage into mana.", eChatType.CT_Spell); Caster.Mana = Caster.Mana + damageConverted; } else { MessageToCaster("You cannot convert anymore mana!", eChatType.CT_Spell); } } break; } } }
protected virtual void OnAttacked(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs attackArgs = arguments as AttackedByEnemyEventArgs; GameLiving living = sender as GameLiving; if (attackArgs == null) { return; } if (living == null) { return; } bool remove = false; if (attackArgs.AttackData.AttackType != AttackData.eAttackType.Spell) { switch (attackArgs.AttackData.AttackResult) { case GameLiving.eAttackResult.HitStyle: case GameLiving.eAttackResult.HitUnstyled: case GameLiving.eAttackResult.Blocked: case GameLiving.eAttackResult.Evaded: case GameLiving.eAttackResult.Fumbled: case GameLiving.eAttackResult.Missed: case GameLiving.eAttackResult.Parried: remove = true; break; } } //If the spell was resisted - then we don't break mezz else if (!attackArgs.AttackData.IsSpellResisted) { //temporary fix for DirectDamageDebuff not breaking mez if (attackArgs.AttackData.SpellHandler is PropertyChangingSpell && attackArgs.AttackData.SpellHandler.HasPositiveEffect == false && attackArgs.AttackData.Damage > 0) { remove = true; } //debuffs/shears dont interrupt mez, neither does recasting mez else if (attackArgs.AttackData.SpellHandler is PropertyChangingSpell || attackArgs.AttackData.SpellHandler is MesmerizeSpellHandler || attackArgs.AttackData.SpellHandler is NearsightSpellHandler || attackArgs.AttackData.SpellHandler.HasPositiveEffect) { return; } if (attackArgs.AttackData.AttackResult == GameLiving.eAttackResult.Missed || attackArgs.AttackData.AttackResult == GameLiving.eAttackResult.HitUnstyled) { remove = true; } } if (remove) { GameSpellEffect effect = SpellHandler.FindEffectOnTarget(living, this); if (effect != null) { effect.Cancel(false); //call OnEffectExpires } } }
private void OnAttack(DOLEvent e, object sender, EventArgs arguments) { if (!(sender is GameLiving living)) { return; } InventoryItem shield = living.Inventory.GetItem(eInventorySlot.LeftHandWeapon); if (shield?.Object_Type != (int)eObjectType.Shield) { return; } if (living.TargetObject == null) { return; } if (living.ActiveWeaponSlot == GameLiving.eActiveWeaponSlot.Distance) { return; } if (living.AttackWeapon.Hand == 1) { return; } AttackedByEnemyEventArgs attackedByEnemy = arguments as AttackedByEnemyEventArgs; AttackData ad = null; if (attackedByEnemy != null) { ad = attackedByEnemy.AttackData; } if (ad == null || ad.Attacker.Realm == 0) { return; } if (ad.Damage < 1) { return; } int absorb = (int)(ad.Damage * 0.9); int critic = (int)(ad.CriticalDamage * 0.9); ad.Damage -= absorb; ad.CriticalDamage -= critic; if (living is GamePlayer player) { player.Out.SendMessage($"Your Testudo Stance reduces the damage by {absorb + critic} points", eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } if (ad.Attacker is GamePlayer gamePlayer) { gamePlayer.Out.SendMessage($"{living.Name}\'s Testudo Stance reducec your damage by {absorb + critic} points", eChatType.CT_Spell, eChatLoc.CL_SystemWindow); } }
/// <summary> /// Handler fired whenever effect target is attacked /// </summary> /// <param name="e"></param> /// <param name="sender"></param> /// <param name="arguments"></param> protected override void EventHandler(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; if (args == null) { return; } if (args.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled && args.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle) { return; } if (!args.AttackData.IsMeleeAttack) { return; } GameLiving attacker = sender as GameLiving; //sender is target of attack, becomes attacker for damage shield if (attacker == null) { return; } if (attacker.ObjectState != GameObject.eObjectState.Active) { return; } if (attacker.IsAlive == false) { return; } GameLiving target = args.AttackData.Attacker; //attacker becomes target for damage shield if (target == null) { return; } if (target.ObjectState != GameObject.eObjectState.Active) { return; } if (target.IsAlive == false) { return; } int spread = m_minDamageSpread; spread += Util.Random(50); double damage = Spell.Damage * target.AttackSpeed(target.AttackWeapon) * spread * 0.00001; double damageResisted = damage * target.GetResist(Spell.DamageType) * -0.01; if (Spell.Damage < 0) { damage = args.AttackData.Damage * Spell.Damage / -100.0; damageResisted = damage * target.GetResist(Spell.DamageType) * -0.01; } AttackData ad = new AttackData(); ad.Attacker = attacker; ad.Target = target; ad.Damage = (int)(damage + damageResisted); ad.Modifier = (int)damageResisted; ad.DamageType = Spell.DamageType; ad.SpellHandler = this; ad.AttackType = AttackData.eAttackType.Spell; ad.AttackResult = GameLiving.eAttackResult.HitUnstyled; GamePlayer owner = null; GameClient attackerClient = null; if (attacker is GamePlayer) { attackerClient = ((GamePlayer)attacker).Client; } if (ad.Attacker is GameNPC) { IControlledBrain brain = ((GameNPC)ad.Attacker).Brain as IControlledBrain; if (brain != null) { owner = brain.GetPlayerOwner(); if (owner != null && owner.ControlledBrain != null && ad.Attacker == owner.ControlledBrain.Body) { MessageToLiving(owner, String.Format(LanguageMgr.GetTranslation(owner.Client, "DamageAddAndShield.EventHandlerDS.YourHitFor"), ad.Attacker.Name, target.GetName(0, false), ad.Damage), eChatType.CT_Spell); } } } else if (attackerClient != null) { MessageToLiving(attacker, String.Format(LanguageMgr.GetTranslation(attackerClient, "DamageAddAndShield.EventHandlerDS.YouHitFor"), target.GetName(0, false), ad.Damage), eChatType.CT_Spell); } GameClient targetClient = null; if (target is GamePlayer) { targetClient = ((GamePlayer)target).Client; } if (targetClient != null) { MessageToLiving(target, String.Format(LanguageMgr.GetTranslation(targetClient, "DamageAddAndShield.EventHandlerDS.DamageToYou"), attacker.GetName(0, false), ad.Damage), eChatType.CT_Spell); } target.OnAttackedByEnemy(ad); attacker.DealDamage(ad); foreach (GamePlayer player in attacker.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE)) { if (player == null) { continue; } player.Out.SendCombatAnimation(null, target, 0, 0, 0, 0, 0x14, target.HealthPercent); } // Log.Debug(String.Format("spell damage: {0}; damage: {1}; resisted damage: {2}; damage type {3}; minSpread {4}.", Spell.Damage, ad.Damage, ad.Modifier, ad.DamageType, m_minDamageSpread)); // Log.Debug(String.Format("dmg {0}; spread: {4}; resDmg: {1}; atkSpeed: {2}; resist: {3}.", damage, damageResisted, target.AttackSpeed(null), ad.Target.GetResist(Spell.DamageType), spread)); }
public void EventHandler(DOLEvent e, object sender, EventArgs arguments) { AttackedByEnemyEventArgs args = arguments as AttackedByEnemyEventArgs; if (args == null) { return; } if (args.AttackData == null) { return; } if (args.AttackData.SpellHandler != null) { return; } if (args.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled && args.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle) { return; } int baseChance = Spell.Frequency / 100; if (baseChance < 1) { baseChance = 1; } if (Util.Chance(baseChance)) { ablativehp = 200; GamePlayer player = sender as GamePlayer; foreach (GamePlayer players in player.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE)) { players.Out.SendSpellEffectAnimation(player, player, 9103, 0, false, 1); } } if (ablativehp != 0) { AttackData ad = args.AttackData; GameLiving living = sender as GameLiving; if (living == null) { return; } if (!MatchingDamageType(ref ad)) { return; } double absorbPercent = 100; int damageAbsorbed = (int)(0.01 * absorbPercent * (ad.Damage + ad.CriticalDamage)); if (damageAbsorbed > ablativehp) { damageAbsorbed = ablativehp; } ablativehp -= damageAbsorbed; ad.Damage -= damageAbsorbed; OnDamageAbsorbed(ad, damageAbsorbed); //TODO correct messages MessageToLiving(ad.Target, string.Format("Your ablative absorbs {0} damage!", damageAbsorbed), eChatType.CT_Spell);//since its not always Melee absorbing MessageToLiving(ad.Attacker, string.Format("A barrier absorbs {0} damage of your attack!", damageAbsorbed), eChatType.CT_Spell); } }