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