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);
}
}
