protected void attackEventHandler(DOLEvent e, object sender, EventArgs args)
{
if (args == null)
{
return;
}
AttackFinishedEventArgs ag = args as AttackFinishedEventArgs;
if (ag == null)
{
return;
}
if (ag.AttackData == null)
{
return;
}
switch (ag.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:
Stop(); break;
}
}
/// <summary>
/// Called when a player is inflicted in an combat action
/// </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>
private void AttackFinished(DOLEvent e, object sender, EventArgs args)
{
AttackFinishedEventArgs afea = (AttackFinishedEventArgs)args;
if (m_owner != afea.AttackData.Attacker || afea.AttackData.AttackType == AttackData.eAttackType.Spell)
{
return;
}
//only affect this onto players
if (!(afea.AttackData.Target is GamePlayer))
{
return;
}
GamePlayer target = afea.AttackData.Target as GamePlayer;
Database.InventoryItem armor = target.Inventory.GetItem((eInventorySlot)((int)afea.AttackData.ArmorHitLocation));
if (armor == null || armor.SPD_ABS == 0)
{
return;
}
//cap at 50%
int bonusPercent = Math.Min(armor.SPD_ABS, 50);
//add 2times percentual of abs, one time will be substracted later
afea.AttackData.Damage = (int)(armor.SPD_ABS * (bonusPercent * 2 + 100) * 0.01);
}
protected void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
}
/// <summary>
/// Called when the effectowner attacked an enemy
/// </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>
private static void AttackFinished(DOLEvent e, object sender, EventArgs args)
{
GamePlayer player = (GamePlayer)sender;
if (e == GameLivingEvent.CastFinished)
{
CastingEventArgs cfea = args as CastingEventArgs;
if (cfea.SpellHandler.Caster != player)
{
return;
}
//cancel if the effectowner casts a non-positive spell
if (!cfea.SpellHandler.HasPositiveEffect)
{
SpeedOfSoundEffect effect = player.EffectList.GetOfType <SpeedOfSoundEffect>();
if (effect != null)
{
effect.Cancel(false);
}
}
}
else if (e == GameLivingEvent.AttackFinished)
{
AttackFinishedEventArgs afargs = args as AttackFinishedEventArgs;
if (afargs == null)
{
return;
}
if (afargs.AttackData.Attacker != player)
{
return;
}
switch (afargs.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:
SpeedOfSoundEffect effect = player.EffectList.GetOfType <SpeedOfSoundEffect>();
if (effect != null)
{
effect.Cancel(false);
}
break;
}
}
}
public void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
AttackData ad = args.AttackData;
if (ad.AttackResult != GameLiving.eAttackResult.HitUnstyled && ad.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
int baseChance = 0;
if (ad.AttackType == AttackData.eAttackType.Ranged)
{
baseChance = (int)(Spell.Frequency * .0001);
}
else if (ad.IsMeleeAttack)
{
baseChance = ((int)Spell.Frequency);
if (sender is GamePlayer)
{
GamePlayer player = (GamePlayer)sender;
InventoryItem leftWeapon = player.Inventory.GetItem(eInventorySlot.LeftHandWeapon);
// if we can use left weapon, we have currently a weapon in left hand and we still have endurance,
// we can assume that we are using the two weapons.
if (player.CanUseLefthandedWeapon && leftWeapon != null && leftWeapon.Object_Type != (int)eObjectType.Shield)
{
baseChance /= 2;
}
}
}
if (Util.Chance(15))
{
Spell m_procSpell = SkillBase.GetSpellByID((int)Spell.Value);
ISpellHandler handler = ScriptMgr.CreateSpellHandler((GameLiving)sender, m_procSpell, SkillBase.GetSpellLine(GlobalSpellsLines.Reserved_Spells));
if (handler != null)
{
if (m_procSpell.Target == "Enemy")
{
handler.StartSpell(ad.Target);
}
else if (m_procSpell.Target == "Self")
{
handler.StartSpell(ad.Attacker);
}
}
}
}
/// <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)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
if (args.AttackData.SpellHandler != null)
{
return;
}
if (args.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled &&
args.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
AttackData ad = args.AttackData;
GameLiving living = sender as GameLiving;
if (living == null)
{
return;
}
if (!MatchingDamageType(ref ad))
{
return;
}
double healPercent = BloodDrinkingAbility.HEALPERCENT;
int healAbsorbed = (int)(0.01 * healPercent * (ad.Damage + ad.CriticalDamage));
if (healAbsorbed > 0)
{
if (living.Health < living.MaxHealth)
{
//TODO correct messages
MessageToLiving(living, string.Format("Blooddrinking ability is healing you for {0} health points!", healAbsorbed), eChatType.CT_Spell);
foreach (GamePlayer p in EffectOwner.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
//heal effect
p.Out.SendSpellEffectAnimation(EffectOwner, EffectOwner, 3011, 0, false, 1);
}
living.Health = living.Health + healAbsorbed;
}
else
{
MessageToLiving(living, string.Format("You are already fully healed!"), eChatType.CT_Spell);
}
}
}
private void CastInterrupted(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs attackFinished = arguments as AttackFinishedEventArgs;
if (attackFinished != null && attackFinished.AttackData.Attacker != sender)
{
return;
}
player.TempProperties.setProperty(NM_CAST_SUCCESS, false);
foreach (GamePlayer i_player in player.GetPlayersInRadius(WorldMgr.INFO_DISTANCE))
{
i_player.Out.SendInterruptAnimation(player);
}
}
/// <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)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
if (args.AttackData.Target.Realm == eRealm.None)
{
base.EventHandler(e, sender, arguments);
}
}
/// <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);
}
}
/// <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)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
GameNPC target = args.AttackData.Target as GameNPC;
if (target != null && !(target.Brain is IControlledBrain && ((IControlledBrain)target.Brain).GetPlayerOwner() != null))
{
base.EventHandler(e, sender, arguments);
}
}
/// <summary>
/// Handler fired whenever effect target attacks
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="arguments"></param>
protected override void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
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.Target);
break;
default:
handler.StartSpell(ad.Attacker);
break;
}
}
}
}
protected void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
if (_trap == null)
{
_trap = MakeTrap();
}
if (Util.Chance(99))
{
_trap.CastSpell(args.AttackData.Target);
}
}
protected void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
// Spirit procs lifetap when hitting ennemy
if (_trap == null)
{
_trap = MakeTrap();
}
if (Util.Chance(50))
{
_trap.CastSpell(args.AttackData.Target);
}
}
/// <summary>
/// Handler fired whenever effect target attacks
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="arguments"></param>
protected override void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
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 (ad.Attacker == ad.Attacker as GameNPC) // Add support for multiple procs - Unty
{
Spell baseSpell = null;
GameNPC pet = ad.Attacker as GameNPC;
var procSpells = new List <Spell>();
foreach (Spell spell in pet.Spells)
{
if (pet.GetSkillDisabledDuration(spell) == 0)
{
if (spell.SpellType.ToLower() == "offensiveproc")
{
procSpells.Add(spell);
}
}
}
if (procSpells.Count > 0)
{
baseSpell = procSpells[Util.Random((procSpells.Count - 1))];
}
m_procSpell = SkillBase.GetSpellByID((int)baseSpell.Value);
}
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.Target);
break;
default:
handler.StartSpell(ad.Attacker);
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)
{
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null || args.AttackData == null)
{
return;
}
AttackData ad = args.AttackData;
if (ad.AttackResult != GameLiving.eAttackResult.HitUnstyled && ad.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
int baseChance = Spell.Frequency / 100;
if (ad.IsMeleeAttack)
{
if (sender is GamePlayer)
{
GamePlayer player = (GamePlayer)sender;
InventoryItem leftWeapon = player.Inventory.GetItem(eInventorySlot.LeftHandWeapon);
// if we can use left weapon, we have currently a weapon in left hand and we still have endurance,
// we can assume that we are using the two weapons.
if (player.CanUseLefthandedWeapon && leftWeapon != null && leftWeapon.Object_Type != (int)eObjectType.Shield)
{
baseChance /= 2;
}
}
}
if (baseChance < 1)
{
baseChance = 1;
}
if (Util.Chance(baseChance))
{
ISpellHandler handler = ScriptMgr.CreateSpellHandler((GameLiving)sender, m_procSpell, m_procSpellLine);
if (handler != null)
{
if (m_procSpell.Target.ToLower() == "enemy")
{
handler.StartSpell(ad.Target);
}
else if (m_procSpell.Target.ToLower() == "self")
{
handler.StartSpell(ad.Attacker);
}
else if (m_procSpell.Target.ToLower() == "group")
{
GamePlayer player = Caster as GamePlayer;
if (Caster is GamePlayer)
{
if (player.Group != null)
{
foreach (GameLiving groupPlayer in player.Group.GetMembersInTheGroup())
{
if (player.IsWithinRadius(groupPlayer, m_procSpell.Range))
{
handler.StartSpell(groupPlayer);
}
}
}
else
{
handler.StartSpell(player);
}
}
}
else
{
log.Warn("Skipping " + m_procSpell.Target + " proc " + m_procSpell.Name + " on " + ad.Target.Name + "; Realm = " + ad.Target.Realm);
}
}
}
}
/// <summary>
/// We need an event after an attack is finished so we know when players are unreachable by archery
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="arguments"></param>
public static void AttackFinished(DOLEvent e, object sender, EventArgs arguments)
{
GameKeepGuard guard = sender as GameKeepGuard;
if (guard.TargetObject == null)
{
return;
}
if (!guard.AttackState)
{
return;
}
if (guard is GuardArcher == false && guard is GuardLord == false && guard is GuardCaster == false)
{
return;
}
AttackFinishedEventArgs afargs = arguments as AttackFinishedEventArgs;
if (guard.ActiveWeaponSlot != eActiveWeaponSlot.Distance && !guard.IsMoving)
{
eAttackResult result = afargs.AttackData.AttackResult;
if (result == eAttackResult.OutOfRange)
{
guard.StopAttack();
lock (guard.Attackers)
{
foreach (GameLiving living in guard.Attackers)
{
if (guard.IsWithinRadius(living, guard.AttackRange))
{
guard.StartAttack(living);
return;
}
}
}
if (guard.IsWithinRadius(guard.TargetObject, guard.AttackRangeDistance))
{
if (guard.MaxSpeedBase == 0 || (guard is GuardArcher && !guard.BeenAttackedRecently))
{
guard.SwitchToRanged(guard.TargetObject);
}
}
}
return;
}
if (guard.ActiveWeaponSlot == eActiveWeaponSlot.Distance)
{
if (GameServer.ServerRules.IsAllowedToAttack(guard, guard.TargetObject as GameLiving, true) == false)
{
guard.StopAttack();
return;
}
if (!guard.IsWithinRadius(guard.TargetObject, guard.AttackRange))
{
guard.StopAttack();
return;
}
}
GamePlayer player = null;
if (guard.TargetObject is GamePlayer)
{
player = guard.TargetObject as GamePlayer;
}
else if (guard.TargetObject is GameNPC)
{
GameNPC npc = (guard.TargetObject as GameNPC);
if (npc.Brain != null && ((npc is GameKeepGuard) == false) && npc.Brain is IControlledBrain)
{
player = (npc.Brain as IControlledBrain).GetPlayerOwner();
}
}
if (player != null)
{
player.Out.SendCheckLOS(guard, guard.TargetObject, new CheckLOSResponse(guard.GuardStopAttackCheckLOS));
}
}
private void OnAttack(DOLEvent e, object sender, EventArgs arguments)
{
GameLiving living = sender as GameLiving;
if (living == null)
{
return;
}
AttackFinishedEventArgs args = arguments as AttackFinishedEventArgs;
if (args == null)
{
return;
}
if (args.AttackData == null)
{
return;
}
int extra = 0;
if (args.AttackData.StyleDamage > 0)
{
extra = args.AttackData.StyleDamage;
args.AttackData.Damage += args.AttackData.StyleDamage;
args.AttackData.StyleDamage *= 2;
}
GamePlayer player = sender as GamePlayer;
if (player == null)
{
return;
}
if (player.Group == null)
{
return;
}
if (extra > 0)
{
player.Out.SendMessage("Your Fury enables you to strike " + args.AttackData.Target.Name + " for " + extra + " additional points of damage", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
}
Hashtable injuredTargets = new Hashtable();
GamePlayer mostInjuredLiving = null;
foreach (GamePlayer p in player.Group.GetPlayersInTheGroup())
{
if (p == player)
{
continue;
}
mostInjuredLiving = p;
break;
}
if (mostInjuredLiving == null)
{
return;
}
double mostInjuredPercent = mostInjuredLiving.Health / (float)mostInjuredLiving.MaxHealth;
int groupHealCap = args.AttackData.Damage;
int targetHealCap = args.AttackData.Damage;
if (player.Group.MemberCount > 2)
{
groupHealCap *= (player.Group.MemberCount);
targetHealCap *= 2;
foreach (GamePlayer p in player.Group.GetPlayersInTheGroup())
{
if (!p.IsAlive)
{
continue;
}
if (p == player)
{
continue;
}
if (p.IsWithinRadius(player, 2000))
{
double playerHealthPercent = p.Health / (double)p.MaxHealth;
if (playerHealthPercent < 1)
{
injuredTargets.Add(p, playerHealthPercent);
if (playerHealthPercent < mostInjuredPercent)
{
mostInjuredLiving = p;
mostInjuredPercent = playerHealthPercent;
}
}
}
}
}
else
{
if (mostInjuredPercent < 1)
{
injuredTargets.Add(mostInjuredLiving, mostInjuredPercent);
}
}
if (mostInjuredPercent >= 1)
{
player.Out.SendMessage("Your group is fully healed!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
return;
}
double bestHealPercent = targetHealCap / (double)mostInjuredLiving.MaxHealth;
double totalHealed = 0;
Hashtable healAmount = new Hashtable();
IDictionaryEnumerator iter = injuredTargets.GetEnumerator();
//calculate heal for all targets
while (iter.MoveNext())
{
GameLiving healTarget = iter.Key as GameLiving;
double targetHealthPercent = (double)iter.Value;
//targets hp percent after heal is same as mostInjuredLiving
double targetHealPercent = bestHealPercent + mostInjuredPercent - targetHealthPercent;
int targetHeal = (int)(healTarget.MaxHealth * targetHealPercent);
//DOLConsole.WriteLine("SpreadHeal: targetHealPercent=" + targetHealPercent + "; uncapped targetHeal=" + targetHeal + "; bestHealPercent=" + bestHealPercent + "; mostInjuredPercent=" + mostInjuredPercent + "; targetHealthPercent=" + targetHealthPercent);
if (targetHeal > 0)
{
totalHealed += targetHeal;
healAmount.Add(healTarget, targetHeal);
}
}
iter = healAmount.GetEnumerator();
//reduce healed hp according to targetHealCap and heal targets
while (iter.MoveNext())
{
GameLiving healTarget = iter.Key as GameLiving;
if (!healTarget.IsAlive)
{
continue;
}
double uncappedHeal = (int)iter.Value;
int reducedHeal = (int)Math.Min(targetHealCap, uncappedHeal * (groupHealCap / totalHealed));
//heal target
int baseheal = healTarget.MaxHealth - healTarget.Health;
if (reducedHeal < baseheal)
{
baseheal = reducedHeal;
}
healTarget.ChangeHealth(player, GameLiving.eHealthChangeType.Spell, baseheal);
player.Out.SendMessage("You heal " + healTarget.Name + " for " + baseheal + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
if (healTarget is GamePlayer)
{
((GamePlayer)healTarget).Out.SendMessage(player.Name + " heals you for " + baseheal + "!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
}
}
return;
}
/// <summary>
/// Handler fired on every melee attack by effect target
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="arguments"></param>
protected override void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs atkArgs = arguments as AttackFinishedEventArgs;
if (atkArgs == null)
{
return;
}
if (atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled &&
atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
GameLiving target = atkArgs.AttackData.Target;
if (target == null)
{
return;
}
if (target.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (target.IsAlive == false)
{
return;
}
if (target is GameKeepComponent || target is GameKeepDoor)
{
return;
}
GameLiving attacker = sender as GameLiving;
if (attacker == null)
{
return;
}
if (attacker.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (attacker.IsAlive == false)
{
return;
}
int spread = m_minDamageSpread;
spread += Util.Random(50);
double dpsCap = DPSCap(attacker.Level);
double dps = IgnoreDamageCap ? Spell.Damage : Math.Min(Spell.Damage, dpsCap);
double damage = dps * atkArgs.AttackData.WeaponSpeed * spread * 0.001; // attack speed is 10 times higher (2.5spd=25)
double damageResisted = damage * target.GetResist(Spell.DamageType) * -0.01;
// log.DebugFormat("dps: {0}, damage: {1}, damageResisted: {2}, minDamageSpread: {3}, spread: {4}", dps, damage, damageResisted, m_minDamageSpread, spread);
if (Spell.Damage < 0)
{
damage = atkArgs.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.AttackType = AttackData.eAttackType.Spell;
ad.SpellHandler = this;
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
if (ad.Attacker is GameNPC)
{
IControlledBrain brain = ((GameNPC)ad.Attacker).Brain as IControlledBrain;
if (brain != null)
{
GamePlayer owner = brain.GetPlayerOwner();
if (owner != null)
{
MessageToLiving(owner, String.Format(LanguageMgr.GetTranslation(owner.Client, "DamageAddAndShield.EventHandlerDA.YourHitFor"), ad.Attacker.Name, target.GetName(0, false), ad.Damage), eChatType.CT_Spell);
}
}
}
else
{
GameClient attackerClient = null;
if (attacker is GamePlayer)
{
attackerClient = ((GamePlayer)attacker).Client;
}
if (attackerClient != null)
{
MessageToLiving(attacker, String.Format(LanguageMgr.GetTranslation(attackerClient, "DamageAddAndShield.EventHandlerDA.YouHitExtra"), 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.EventHandlerDA.DamageToYou"), attacker.GetName(0, false), ad.Damage), eChatType.CT_Spell);
}
target.OnAttackedByEnemy(ad);
attacker.DealDamage(ad);
foreach (GamePlayer player in ad.Attacker.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
if (player == null)
{
continue;
}
player.Out.SendCombatAnimation(null, target, 0, 0, 0, 0, 0x0A, target.HealthPercent);
}
}
/// <summary>
/// Called when a player is inflicted in an combat action
/// </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>
private void AttackFinished(DOLEvent e, object sender, EventArgs args)
{
AttackFinishedEventArgs atkArgs = args as AttackFinishedEventArgs;
if (atkArgs == null)
{
return;
}
if (atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled &&
atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
if (atkArgs.AttackData.Target == null)
{
return;
}
GameLiving target = atkArgs.AttackData.Target;
if (target == null)
{
return;
}
if (target.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (target.IsAlive == false)
{
return;
}
GameLiving attacker = sender as GameLiving;
if (attacker == null)
{
return;
}
if (attacker.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (attacker.IsAlive == false)
{
return;
}
double dpsCap;
dpsCap = (1.2 + 0.3 * attacker.Level) * 0.7;
double dps = Math.Min(RealmAbilities.MarkOfPreyAbility.VALUE, dpsCap);
double damage = dps * atkArgs.AttackData.WeaponSpeed * 0.1;
double damageResisted = damage * target.GetResist(eDamageType.Heat) * -0.01;
AttackData ad = new AttackData();
ad.Attacker = attacker;
ad.Target = target;
ad.Damage = (int)(damage + damageResisted);
ad.Modifier = (int)damageResisted;
ad.DamageType = eDamageType.Heat;
ad.AttackType = AttackData.eAttackType.Spell;
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
target.OnAttackedByEnemy(ad);
EffectCaster.ChangeMana(EffectOwner, GameLiving.eManaChangeType.Spell, (int)ad.Damage);
if (attacker is GamePlayer)
{
(attacker as GamePlayer).Out.SendMessage(string.Format("You hit {0} for {1} extra damage!", target.Name, ad.Damage), DOL.GS.PacketHandler.eChatType.CT_Spell, DOL.GS.PacketHandler.eChatLoc.CL_SystemWindow);
}
attacker.DealDamage(ad);
}
/// <summary>
/// Handler fired on every melee attack by effect target
/// </summary>
/// <param name="e"></param>
/// <param name="sender"></param>
/// <param name="arguments"></param>
protected void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs atkArgs = arguments as AttackFinishedEventArgs;
if (atkArgs == null)
{
return;
}
if (atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled &&
atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
if (atkArgs.AttackData.Target == null)
{
return;
}
GameLiving target = atkArgs.AttackData.Target;
if (target == null)
{
return;
}
if (target.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (target.IsAlive == false)
{
return;
}
GameLiving attacker = sender as GameLiving;
if (attacker == null)
{
return;
}
if (attacker.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (attacker.IsAlive == false)
{
return;
}
if (atkArgs.AttackData.IsOffHand)
{
return; // only react to main hand
}
if (atkArgs.AttackData.Weapon == null)
{
return; // no weapon attack
}
int modifier = 100;
// double dpsCap = (1.2 + 0.3 * attacker.Level) * 0.7;
// double dps = Math.Min(atkArgs.AttackData.Weapon.DPS_AF/10.0, dpsCap);
double baseDamage = atkArgs.AttackData.Weapon.DPS_AF / 10.0 *
atkArgs.AttackData.WeaponSpeed;
modifier += (int)(25 * atkArgs.AttackData.Target.GetConLevel(atkArgs.AttackData.Attacker));
modifier = Math.Min(300, modifier);
modifier = Math.Max(75, modifier);
double damage = baseDamage * modifier * 0.001; // attack speed is 10 times higher (2.5spd=25)
double damageResisted = damage * target.GetResist(eDamageType.Body) * -0.01;
AttackData ad = new AttackData();
ad.Attacker = attacker;
ad.Target = target;
ad.Damage = (int)(damage + damageResisted);
ad.Modifier = (int)damageResisted;
ad.DamageType = eDamageType.Body;
ad.AttackType = AttackData.eAttackType.MeleeOneHand;
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.WeaponSpeed = atkArgs.AttackData.WeaponSpeed;
GamePlayer owner = attacker as GamePlayer;
if (owner != null)
{
owner.Out.SendMessage(LanguageMgr.GetTranslation(owner.Client, "Effects.TripleWieldEffect.MBHitsExtraDamage", target.GetName(0, false), ad.Damage), eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
GamePlayer playerTarget = target as GamePlayer;
if (playerTarget != null)
{
playerTarget.Out.SendMessage(LanguageMgr.GetTranslation(playerTarget.Client, "Effects.TripleWieldEffect.XMBExtraDamageToYou", attacker.GetName(0, false), ad.Damage), eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
}
}
target.OnAttackedByEnemy(ad);
attacker.DealDamage(ad);
foreach (GamePlayer player in ad.Attacker.GetPlayersInRadius(WorldMgr.VISIBILITY_DISTANCE))
{
player.Out.SendCombatAnimation(null, target, 0, 0, 0, 0, 0x0A, target.HealthPercent);
}
}
protected void EventHandler(DOLEvent e, object sender, EventArgs arguments)
{
AttackFinishedEventArgs atkArgs = arguments as AttackFinishedEventArgs;
if (atkArgs == null)
{
return;
}
if (atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled &&
atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
if (atkArgs.AttackData.Target == null)
{
return;
}
GameLiving target = atkArgs.AttackData.Target;
if (target == null)
{
return;
}
if (target.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (target.IsAlive == false)
{
return;
}
GameLiving attacker = sender as GameLiving;
if (attacker == null)
{
return;
}
if (attacker.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (attacker.IsAlive == false)
{
return;
}
if (atkArgs.AttackData.IsOffHand)
{
return; // only react to main hand
}
if (atkArgs.AttackData.Weapon == null)
{
return; // no weapon attack
}
DTdetrimentalEffect dt = target.EffectList.GetOfType <DTdetrimentalEffect>();
if (dt == null)
{
new DTdetrimentalEffect().Start(target);
// Log.Debug("Effect Started from dirty tricks handler on " + target.Name);
}
}
