private void DamageTarget(GameLiving target, GameLiving caster)
{
int damage = 300;
GamePlayer player = caster as GamePlayer;
if (player != null)
{
player.Out.SendMessage("You hit " + target.Name + " for " + damage + " points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Crush;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
private void DamageTarget(GameLiving target, GameLiving caster)
{
int damage = 300;
if (caster is GamePlayer player)
{
player.Out.SendMessage($"You hit {target.Name} for {damage} points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
if (target is GamePlayer targetPlayer)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
AttackData ad = new AttackData
{
AttackResult = GameLiving.eAttackResult.HitUnstyled,
Attacker = caster,
Target = target,
DamageType = eDamageType.Crush,
Damage = damage
};
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
protected virtual void OnSpellResist(GameLiving target)
{
m_lastdamage -= m_lastdamage / 4;
SendEffectAnimation(target, 0, false, 0);
if (target is GameNPC)
{
IControlledBrain brain = ((GameNPC)target).Brain as IControlledBrain;
if (brain != null)
{
GamePlayer owner = brain.GetPlayerOwner();
//Worthless checks
if (owner != null /* && owner.ControlledNpc != null && target == owner.ControlledNpc.Body*/)
{
MessageToLiving(owner, "Your " + target.Name + " resists the effect!", eChatType.CT_SpellResisted);
}
}
}
else
{
MessageToLiving(target, "You resist the effect!", eChatType.CT_SpellResisted);
}
MessageToCaster(target.GetName(0, true) + " resists the effect!", eChatType.CT_SpellResisted);
if (Spell.Damage != 0)
{
// notify target about missed attack for spells with damage
AttackData ad = new AttackData();
ad.Attacker = Caster;
ad.Target = target;
ad.AttackType = AttackData.eAttackType.Spell;
ad.AttackResult = GameLiving.eAttackResult.Missed;
ad.SpellHandler = this;
target.OnAttackedByEnemy(ad);
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, Caster);
}
else if (Spell.CastTime > 0)
{
target.StartInterruptTimer(target.SpellInterruptDuration, AttackData.eAttackType.Spell, Caster);
}
if (target is GameNPC)
{
IOldAggressiveBrain aggroBrain = ((GameNPC)target).Brain as IOldAggressiveBrain;
if (aggroBrain != null)
{
aggroBrain.AddToAggroList(Caster, 1);
}
}
if (target.Realm == 0 || Caster.Realm == 0)
{
target.LastAttackedByEnemyTickPvE = target.CurrentRegion.Time;
Caster.LastAttackTickPvE = Caster.CurrentRegion.Time;
}
else
{
target.LastAttackedByEnemyTickPvP = target.CurrentRegion.Time;
Caster.LastAttackTickPvP = Caster.CurrentRegion.Time;
}
}
private void DamageTarget(GameLiving target, GameLiving caster)
{
double modifier = 0.5 + (caster.GetModifiedSpecLevel("Soulrending") * 0.01);
int basedamage = (int)(250 * modifier);
int resist = basedamage * target.GetResist(eDamageType.Spirit) / -100;
int damage = basedamage + resist;
int heal = (int)(damage * 0.75);
int modheal = caster.MaxHealth - caster.Health;
if (modheal > heal)
{
modheal = heal;
}
caster.Health += modheal;
if (caster is GamePlayer player)
{
player.Out.SendMessage($"You hit {target.Name} for {damage}({resist}) points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
if (caster is GamePlayer gamePlayer && modheal > 0)
{
gamePlayer.Out.SendMessage($"Your Soul Quench returns {modheal} lifepoints to you", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
}
if (target is GamePlayer targetPlayer)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 1145, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
// target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData
{
AttackResult = GameLiving.eAttackResult.HitUnstyled,
Attacker = caster,
Target = target,
DamageType = eDamageType.Spirit,
Damage = damage
};
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
private void DamageTarget(GameLiving target, GameLiving caster, double counter)
{
int level = caster.GetModifiedSpecLevel("Stormcalling");
if (level > 50)
{
level = 50;
}
modifier = 0.5 + (level * 0.01) * Math.Pow(0.75, counter);
basedamage = (int)(450 * modifier);
resist = basedamage * target.GetResist(eDamageType.Energy) / -100;
damage = basedamage + resist;
GamePlayer player = caster as GamePlayer;
if (player != null)
{
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 3505, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Energy;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
private void DamageTarget(GameLiving target, GameLiving caster, double counter)
{
int level = caster.GetModifiedSpecLevel("Stormcalling");
if (level > 50)
{
level = 50;
}
_modifier = 0.5 + (level * 0.01) * Math.Pow(0.75, counter);
_basedamage = (int)(450 * _modifier);
_resist = _basedamage * target.GetResist(eDamageType.Energy) / -100;
_damage = _basedamage + _resist;
if (caster is GamePlayer player)
{
player.Out.SendMessage($"You hit {target.Name} for {_damage}({_resist}) points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
if (target is GamePlayer targetPlayer)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 3505, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
// target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData
{
AttackResult = GameLiving.eAttackResult.HitUnstyled,
Attacker = caster,
Target = target,
DamageType = eDamageType.Energy,
Damage = _damage
};
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
private void DamageTarget(GameLiving target, GameLiving caster)
{
int resist = 251 * target.GetResist(eDamageType.Crush) / -100;
int damage = 251 + resist;
GamePlayer player = caster as GamePlayer;
if (player != null)
{
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 7043, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Crush;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
if (target.EffectList.GetOfType <WhirlingStaffEffect>() == null)
{
WhirlingStaffEffect effect = new WhirlingStaffEffect();
effect.Start(target);
}
}
private void DamageTarget(GameLiving target, GameLiving caster)
{
double modifier = 0.5 + (caster.GetModifiedSpecLevel("Soulrending") * 0.01);
int basedamage = (int)(250 * modifier);
int resist = basedamage * target.GetResist(eDamageType.Spirit) / -100;
int damage = basedamage + resist;
int heal = (int)(damage * 0.75);
int modheal = caster.MaxHealth - caster.Health;
if (modheal > heal)
modheal = heal;
caster.Health += modheal;
GamePlayer player = caster as GamePlayer;
if (player != null)
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
if (caster is GamePlayer && modheal > 0)
((GamePlayer)caster).Out.SendMessage("Your Soul Quench returns " + modheal + " lifepoints to you", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
targetPlayer.Stealth(false);
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 1145, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Spirit;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
private void DamageTarget(GameLiving target, GameLiving caster)
{
int resist = 251 * target.GetResist(eDamageType.Crush) / -100;
int damage = 251 + resist;
GamePlayer player = caster as GamePlayer;
if (player != null)
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
targetPlayer.Stealth(false);
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 7043, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Crush;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
if (target.EffectList.GetOfType<WhirlingStaffEffect>() == null)
{
WhirlingStaffEffect effect = new WhirlingStaffEffect();
effect.Start(target);
}
}
private void DamageTarget(GameLiving target, GameLiving caster)
{
int damage = 300;
GamePlayer player = caster as GamePlayer;
if (player != null)
player.Out.SendMessage("You hit " + target.Name + " for " + damage + " points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
targetPlayer.Stealth(false);
}
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Crush;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
protected override void OnTick()
{
GameLiving target = m_arrowTarget;
GameLiving caster = (GameLiving)m_actionSource;
if (target == null || !target.IsAlive || target.ObjectState != GameObject.eObjectState.Active || target.CurrentRegionID != caster.CurrentRegionID)
{
return;
}
int missrate = 100 - m_handler.CalculateToHitChance(target);
// add defence bonus from last executed style if any
AttackData targetAD = (AttackData)target.TempProperties.getProperty <object>(GameLiving.LAST_ATTACK_DATA, null);
if (targetAD != null &&
targetAD.AttackResult == GameLiving.eAttackResult.HitStyle &&
targetAD.Style != null)
{
missrate += targetAD.Style.BonusToDefense;
}
// half of the damage is magical
// subtract any spelldamage bonus and re-calculate after half damage is calculated
AttackData ad = m_handler.CalculateDamageToTarget(target, 0.5 - (caster.GetModified(eProperty.SpellDamage) * 0.01));
// check for bladeturn miss
if (ad.AttackResult == GameLiving.eAttackResult.Missed)
{
return;
}
if (Util.Chance(missrate))
{
ad.AttackResult = GameLiving.eAttackResult.Missed;
m_handler.MessageToCaster("You miss!", eChatType.CT_YouHit);
m_handler.MessageToLiving(target, caster.GetName(0, false) + " missed!", eChatType.CT_Missed);
target.OnAttackedByEnemy(ad);
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, caster);
if (target is GameNPC)
{
IOldAggressiveBrain aggroBrain = ((GameNPC)target).Brain as IOldAggressiveBrain;
if (aggroBrain != null)
{
aggroBrain.AddToAggroList(caster, 1);
}
}
return;
}
ad.Damage = (int)((double)ad.Damage * (1.0 + caster.GetModified(eProperty.SpellDamage) * 0.01));
bool arrowBlock = false;
if (target is GamePlayer && !target.IsStunned && !target.IsMezzed && !target.IsSitting && m_handler.Spell.LifeDrainReturn != (int)Archery.eShotType.Critical)
{
GamePlayer player = (GamePlayer)target;
InventoryItem lefthand = player.Inventory.GetItem(eInventorySlot.LeftHandWeapon);
if (lefthand != null && (player.AttackWeapon == null || player.AttackWeapon.Item_Type == Slot.RIGHTHAND || player.AttackWeapon.Item_Type == Slot.LEFTHAND))
{
if (target.IsObjectInFront(caster, 180) && lefthand.Object_Type == (int)eObjectType.Shield)
{
// TODO: shield size vs number of attackers not calculated
double shield = 0.5 * player.GetModifiedSpecLevel(Specs.Shields);
double blockchance = ((player.Dexterity * 2) - 100) / 40.0 + shield + (0 * 3) + 5;
blockchance += 30;
blockchance -= target.GetConLevel(caster) * 5;
if (blockchance >= 100)
{
blockchance = 99;
}
if (blockchance <= 0)
{
blockchance = 1;
}
if (target.IsEngaging)
{
EngageEffect engage = target.EffectList.GetOfType <EngageEffect>();
if (engage != null && target.AttackState && engage.EngageTarget == caster)
{
// Engage raised block change to 85% if attacker is engageTarget and player is in attackstate
// You cannot engage a mob that was attacked within the last X seconds...
if (engage.EngageTarget.LastAttackedByEnemyTick > engage.EngageTarget.CurrentRegion.Time - EngageAbilityHandler.ENGAGE_ATTACK_DELAY_TICK)
{
if (engage.Owner is GamePlayer)
{
(engage.Owner as GamePlayer).Out.SendMessage(engage.EngageTarget.GetName(0, true) + " has been attacked recently and you are unable to engage.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
}
} // Check if player has enough endurance left to engage
else if (engage.Owner.Endurance < EngageAbilityHandler.ENGAGE_DURATION_LOST)
{
engage.Cancel(false); // if player ran out of endurance cancel engage effect
}
else
{
engage.Owner.Endurance -= EngageAbilityHandler.ENGAGE_DURATION_LOST;
if (engage.Owner is GamePlayer)
{
(engage.Owner as GamePlayer).Out.SendMessage("You concentrate on blocking the blow!", eChatType.CT_Skill, eChatLoc.CL_SystemWindow);
}
if (blockchance < 85)
{
blockchance = 85;
}
}
}
}
if (blockchance >= Util.Random(1, 100))
{
arrowBlock = true;
m_handler.MessageToLiving(player, "You block " + caster.GetName(0, false) + "'s arrow!", eChatType.CT_System);
if (m_handler.Spell.Target.ToLower() != "area")
{
m_handler.MessageToCaster(player.GetName(0, true) + " blocks your arrow!", eChatType.CT_System);
m_handler.DamageTarget(ad, false, 0x02);
}
}
}
}
}
if (arrowBlock == false)
{
// now calculate the magical part of arrow damage (similar to bolt calculation). Part 1 Physical, Part 2 Magical
double damage = m_handler.Spell.Damage / 2; // another half is physical damage
if (target is GamePlayer)
{
ad.ArmorHitLocation = ((GamePlayer)target).CalculateArmorHitLocation(ad);
}
InventoryItem armor = null;
if (target.Inventory != null)
{
armor = target.Inventory.GetItem((eInventorySlot)ad.ArmorHitLocation);
}
double ws = (caster.Level * 8 * (1.0 + (caster.GetModified(eProperty.Dexterity) - 50) / 200.0));
damage *= ((ws + 90.68) / (target.GetArmorAF(ad.ArmorHitLocation) + 20 * 4.67));
damage *= 1.0 - Math.Min(0.85, ad.Target.GetArmorAbsorb(ad.ArmorHitLocation));
ad.Modifier = (int)(damage * (ad.Target.GetResist(ad.DamageType) + SkillBase.GetArmorResist(armor, ad.DamageType)) / -100.0);
damage += ad.Modifier;
double effectiveness = caster.Effectiveness;
effectiveness += (caster.GetModified(eProperty.SpellDamage) * 0.01);
damage = damage * effectiveness;
damage *= (1.0 + RelicMgr.GetRelicBonusModifier(caster.Realm, eRelicType.Magic));
if (damage < 0)
{
damage = 0;
}
ad.Damage += (int)damage;
if (caster.AttackWeapon != null)
{
// Quality
ad.Damage -= (int)(ad.Damage * (100 - caster.AttackWeapon.Quality) * .01);
// Condition
ad.Damage = (int)((double)ad.Damage * Math.Min(1.0, (double)caster.AttackWeapon.Condition / (double)caster.AttackWeapon.MaxCondition));
// Patch Note: http://support.darkageofcamelot.com/kb/article.php?id=931
// - The Damage Per Second (DPS) of your bow will have an effect on your damage for archery shots. If the effective DPS
// of your equipped bow is less than that of your max DPS for the level of archery shot you are using, the damage of your
// shot will be reduced. Max DPS for a particular level can be found by using this equation: (.3 * level) + 1.2
int spellRequiredDPS = 12 + 3 * m_handler.Spell.Level;
if (caster.AttackWeapon.DPS_AF < spellRequiredDPS)
{
double percentReduction = (double)caster.AttackWeapon.DPS_AF / (double)spellRequiredDPS;
ad.Damage = (int)(ad.Damage * percentReduction);
}
}
if (ad.Damage < 0)
{
ad.Damage = 0;
}
ad.UncappedDamage = ad.Damage;
ad.Damage = (int)Math.Min(ad.Damage, m_handler.DamageCap(effectiveness));
if (ad.CriticalDamage > 0)
{
if (m_handler.Spell.Target.ToLower() == "area")
{
ad.CriticalDamage = 0;
}
else
{
int critMax = (target is GamePlayer) ? ad.Damage / 2 : ad.Damage;
ad.CriticalDamage = Util.Random(critMax / 10, critMax);
}
}
target.ModifyAttack(ad);
m_handler.SendDamageMessages(ad);
m_handler.DamageTarget(ad, false, 0x14);
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, caster);
}
if (m_handler.Spell.SubSpellID != 0)
{
Spell subspell = SkillBase.GetSpellByID(m_handler.Spell.SubSpellID);
if (subspell != null)
{
subspell.Level = m_handler.Spell.Level;
ISpellHandler spellhandler = ScriptMgr.CreateSpellHandler(m_handler.Caster, subspell, SkillBase.GetSpellLine(GlobalSpellsLines.Combat_Styles_Effect));
if (spellhandler != null)
{
spellhandler.StartSpell(target);
}
}
}
if (arrowBlock == false && m_handler.Caster.AttackWeapon != null && GlobalConstants.IsBowWeapon((eObjectType)m_handler.Caster.AttackWeapon.Object_Type))
{
if (ad.AttackResult == GameLiving.eAttackResult.HitUnstyled || ad.AttackResult == GameLiving.eAttackResult.HitStyle)
{
caster.CheckWeaponMagicalEffect(ad, m_handler.Caster.AttackWeapon);
}
}
}
protected override void OnTick()
{
GameLiving target = m_boltTarget;
GameLiving caster = (GameLiving)m_actionSource;
if (target == null || target.CurrentRegionID != caster.CurrentRegionID || target.ObjectState != GameObject.eObjectState.Active || !target.IsAlive)
{
return;
}
if (target is GameNPC || target.Mana > 0)
{
int power;
if (target is GameNPC)
{
power = (int)Math.Round((target.Level * m_handler.Spell.Value * 2) / 100);
}
else
{
power = (int)Math.Round(target.MaxMana * (m_handler.Spell.Value / 250));
}
if (target.Mana < power)
{
power = target.Mana;
}
caster.Mana += power;
if (target is GamePlayer gamePlayer)
{
target.Mana -= power;
gamePlayer.Out.SendMessage($"{caster.Name} takes {power} power!", eChatType.CT_YouWereHit, eChatLoc.CL_SystemWindow);
}
if (caster is GamePlayer player)
{
player.Out.SendMessage($"You receive {power} power from {target.Name}!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
}
}
else
{
((GamePlayer)caster).Out.SendMessage($"You did not receive any power from {target.Name}!", eChatType.CT_Spell, eChatLoc.CL_SystemWindow);
}
// Place the caster in combat
if (target is GamePlayer)
{
caster.LastAttackTickPvP = caster.CurrentRegion.Time;
}
else
{
caster.LastAttackTickPvE = caster.CurrentRegion.Time;
}
// create the attack data for the bolt
AttackData ad = new AttackData
{
Attacker = caster,
Target = target,
DamageType = eDamageType.Heat,
AttackType = AttackData.eAttackType.Spell,
AttackResult = GameLiving.eAttackResult.HitUnstyled,
SpellHandler = m_handler
};
target.OnAttackedByEnemy(ad);
target.StartInterruptTimer(target.SpellInterruptDuration, AttackData.eAttackType.Spell, caster);
}
/// <summary>
/// Send Spell Attack Data Notification to Target when Spell is Resisted
/// </summary>
/// <param name="target"></param>
public virtual void SendSpellResistNotification(GameLiving target)
{
// Report resisted spell attack data to any type of living object, no need
// to decide here what to do. For example, NPCs will use their brain.
// "Just the facts, ma'am, just the facts."
AttackData ad = new AttackData();
ad.Attacker = Caster;
ad.Target = target;
ad.AttackType = AttackData.eAttackType.Spell;
ad.SpellHandler = this;
ad.AttackResult = GameLiving.eAttackResult.Missed;
ad.IsSpellResisted = true;
target.OnAttackedByEnemy(ad);
}
private void DamageTarget(GameLiving target)
{
if (!GameServer.ServerRules.IsAllowedToAttack(_owner, target, true))
{
return;
}
if (!target.IsAlive)
{
return;
}
if (_ticktimer.IsAlive)
{
_ticktimer.Stop();
removeHandlers();
}
int dist = target.GetDistanceTo(new Point3D(_traparea.X, _traparea.Y, _traparea.Z));
double mod = 1;
if (dist > 0)
{
mod = 1 - ((double)dist / 350);
}
int basedamage = (int)(_effectiveness * mod);
int resist = (int)(basedamage * target.GetModified(eProperty.Resist_Energy) * -0.01);
int damage = basedamage + resist;
if (_owner is GamePlayer player)
{
player.Out.SendMessage($"You hit {target.Name} for {damage}({resist}) points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
if (target is GamePlayer targetPlayer)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(_owner, target, 7026, 0, false, 1);
p.Out.SendCombatAnimation(_owner, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
// target.TakeDamage(owner, eDamageType.Energy, damage, 0);
AttackData ad = new AttackData
{
AttackResult = GameLiving.eAttackResult.HitUnstyled,
Attacker = _owner,
Target = target,
DamageType = eDamageType.Energy,
Damage = damage
};
target.OnAttackedByEnemy(ad);
_owner.DealDamage(ad);
}
private void DamageTarget(GameLiving target, GameLiving caster, double counter)
{
int level = caster.GetModifiedSpecLevel("Stormcalling");
if (level > 50)
level = 50;
modifier = 0.5 + (level * 0.01) * Math.Pow(0.75, counter);
basedamage = (int)(450 * modifier);
resist = basedamage * target.GetResist(eDamageType.Energy) / -100;
damage = basedamage + resist;
GamePlayer player = caster as GamePlayer;
if (player != null)
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
targetPlayer.Stealth(false);
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(caster, target, 3505, 0, false, 1);
p.Out.SendCombatAnimation(caster, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(caster, eDamageType.Spirit, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = caster;
ad.Target = target;
ad.DamageType = eDamageType.Energy;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
caster.DealDamage(ad);
}
/// <summary>
/// When spell was resisted
/// </summary>
/// <param name="target">the target that resisted the spell</param>
protected virtual void OnSpellResisted(GameLiving target)
{
SendEffectAnimation(target, 0, false, 0);
// Deliver message to the target, if the target is a pet, to its
// owner instead.
if (target is GameNPC)
{
IControlledBrain brain = ((GameNPC)target).Brain as IControlledBrain;
if (brain != null)
{
GamePlayer owner = brain.GetPlayerOwner();
if (owner != null)
{
MessageToLiving(owner, "Your " + target.Name + " resists the effect!", eChatType.CT_SpellResisted);
}
}
}
else
{
MessageToLiving(target, "You resist the effect!", eChatType.CT_SpellResisted);
}
// Deliver message to the caster as well.
MessageToCaster(target.GetName(0, true) + " resists the effect!", eChatType.CT_SpellResisted);
// Report resisted spell attack data to any type of living object, no need
// to decide here what to do. For example, NPCs will use their brain.
// "Just the facts, ma'am, just the facts."
AttackData ad = new AttackData();
ad.Attacker = Caster;
ad.Target = target;
ad.AttackType = AttackData.eAttackType.Spell;
ad.SpellHandler = this;
ad.AttackResult = GameLiving.eAttackResult.Missed;
ad.IsSpellResisted = true;
target.OnAttackedByEnemy(ad);
// Spells that would have caused damage or are not instant will still
// interrupt a casting player.
/*if (target is GamePlayer)
{
if (target.IsCasting && (Spell.Damage > 0 || Spell.CastTime > 0))
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, Caster);
}*/
if(!(Spell.SpellType.ToLower().IndexOf("debuff")>=0 && Spell.CastTime==0))
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, Caster);
if (target.Realm == 0 || Caster.Realm == 0)
{
target.LastAttackedByEnemyTickPvE = target.CurrentRegion.Time;
Caster.LastAttackTickPvE = Caster.CurrentRegion.Time;
}
else
{
target.LastAttackedByEnemyTickPvP = target.CurrentRegion.Time;
Caster.LastAttackTickPvP = Caster.CurrentRegion.Time;
}
}
/// <summary>
/// Called on every timer tick
/// </summary>
protected override void OnTick()
{
GameLiving target = m_boltTarget;
GameLiving caster = (GameLiving)m_actionSource;
if (target == null)
{
return;
}
if (target.CurrentRegionID != caster.CurrentRegionID)
{
return;
}
if (target.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (!target.IsAlive)
{
return;
}
// Related to PvP hitchance
// http://www.camelotherald.com/news/news_article.php?storyid=2444
// No information on bolt hitchance against npc's
// Bolts are treated as physical attacks for the purpose of ABS only
// Based on this I am normalizing the miss rate for npc's to be that of a standard spell
int missrate = 0;
if (caster is GamePlayer && target is GamePlayer)
{
if (target.InCombat)
{
foreach (GameLiving attacker in target.Attackers)
{
if (attacker != caster && target.GetDistanceTo(attacker) <= 200)
{
// each attacker within 200 units adds a 20% chance to miss
missrate += 20;
}
}
}
}
if (target is GameNPC || caster is GameNPC)
{
missrate += (int)(ServerProperties.Properties.PVE_SPELL_CONHITPERCENT * caster.GetConLevel(target));
}
// add defence bonus from last executed style if any
AttackData targetAD = (AttackData)target.TempProperties.getProperty <object>(GameLiving.LAST_ATTACK_DATA, null);
if (targetAD != null &&
targetAD.AttackResult == GameLiving.eAttackResult.HitStyle &&
targetAD.Style != null)
{
missrate += targetAD.Style.BonusToDefense;
}
AttackData ad = m_handler.CalculateDamageToTarget(target, 0.5 - (caster.GetModified(eProperty.SpellDamage) * 0.01));
if (Util.Chance(missrate))
{
ad.AttackResult = GameLiving.eAttackResult.Missed;
m_handler.MessageToCaster("You miss!", eChatType.CT_YouHit);
m_handler.MessageToLiving(target, caster.GetName(0, false) + " missed!", eChatType.CT_Missed);
target.OnAttackedByEnemy(ad);
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, caster);
if (target is GameNPC)
{
IOldAggressiveBrain aggroBrain = ((GameNPC)target).Brain as IOldAggressiveBrain;
if (aggroBrain != null)
{
aggroBrain.AddToAggroList(caster, 1);
}
}
return;
}
ad.Damage = (int)((double)ad.Damage * (1.0 + caster.GetModified(eProperty.SpellDamage) * 0.01));
// Block
bool blocked = false;
if (target is GamePlayer)
{ // mobs left out yet
GamePlayer player = (GamePlayer)target;
InventoryItem lefthand = player.Inventory.GetItem(eInventorySlot.LeftHandWeapon);
if (lefthand != null && (player.AttackWeapon == null || player.AttackWeapon.Item_Type == Slot.RIGHTHAND || player.AttackWeapon.Item_Type == Slot.LEFTHAND))
{
if (target.IsObjectInFront(caster, 180) && lefthand.Object_Type == (int)eObjectType.Shield)
{
double shield = 0.5 * player.GetModifiedSpecLevel(Specs.Shields);
double blockchance = ((player.Dexterity * 2) - 100) / 40.0 + shield + 5;
// Removed 30% increased chance to block, can find no clear evidence this is correct - tolakram
blockchance -= target.GetConLevel(caster) * 5;
if (blockchance >= 100)
{
blockchance = 99;
}
if (blockchance <= 0)
{
blockchance = 1;
}
if (target.IsEngaging)
{
EngageEffect engage = target.EffectList.GetOfType <EngageEffect>();
if (engage != null && target.AttackState && engage.EngageTarget == caster)
{
// Engage raised block change to 85% if attacker is engageTarget and player is in attackstate
// You cannot engage a mob that was attacked within the last X seconds...
if (engage.EngageTarget.LastAttackedByEnemyTick > engage.EngageTarget.CurrentRegion.Time - EngageAbilityHandler.ENGAGE_ATTACK_DELAY_TICK)
{
if (engage.Owner is GamePlayer)
{
(engage.Owner as GamePlayer).Out.SendMessage(engage.EngageTarget.GetName(0, true) + " has been attacked recently and you are unable to engage.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
}
} // Check if player has enough endurance left to engage
else if (engage.Owner.Endurance < EngageAbilityHandler.ENGAGE_DURATION_LOST)
{
engage.Cancel(false); // if player ran out of endurance cancel engage effect
}
else
{
engage.Owner.Endurance -= EngageAbilityHandler.ENGAGE_DURATION_LOST;
if (engage.Owner is GamePlayer)
{
(engage.Owner as GamePlayer).Out.SendMessage("You concentrate on blocking the blow!", eChatType.CT_Skill, eChatLoc.CL_SystemWindow);
}
if (blockchance < 85)
{
blockchance = 85;
}
}
}
}
if (blockchance >= Util.Random(1, 100))
{
m_handler.MessageToLiving(player, "You partially block " + caster.GetName(0, false) + "'s spell!", eChatType.CT_Missed);
m_handler.MessageToCaster(player.GetName(0, true) + " blocks!", eChatType.CT_YouHit);
blocked = true;
}
}
}
}
double effectiveness = 1.0 + (caster.GetModified(eProperty.SpellDamage) * 0.01);
// simplified melee damage calculation
if (blocked == false)
{
// TODO: armor resists to damage type
double damage = m_handler.Spell.Damage / 2; // another half is physical damage
if (target is GamePlayer)
{
ad.ArmorHitLocation = ((GamePlayer)target).CalculateArmorHitLocation(ad);
}
InventoryItem armor = null;
if (target.Inventory != null)
{
armor = target.Inventory.GetItem((eInventorySlot)ad.ArmorHitLocation);
}
double ws = (caster.Level * 8 * (1.0 + (caster.GetModified(eProperty.Dexterity) - 50) / 200.0));
damage *= ((ws + 90.68) / (target.GetArmorAF(ad.ArmorHitLocation) + 20 * 4.67));
damage *= 1.0 - Math.Min(0.85, ad.Target.GetArmorAbsorb(ad.ArmorHitLocation));
ad.Modifier = (int)(damage * (ad.Target.GetResist(ad.DamageType) + SkillBase.GetArmorResist(armor, ad.DamageType)) / -100.0);
damage += ad.Modifier;
damage = damage * effectiveness;
damage *= (1.0 + RelicMgr.GetRelicBonusModifier(caster.Realm, eRelicType.Magic));
if (damage < 0)
{
damage = 0;
}
ad.Damage += (int)damage;
}
if (m_handler is SiegeArrow == false)
{
ad.UncappedDamage = ad.Damage;
ad.Damage = (int)Math.Min(ad.Damage, m_handler.DamageCap(effectiveness));
}
ad.Damage = (int)(ad.Damage * caster.Effectiveness);
if (blocked == false && ad.CriticalDamage > 0)
{
int critMax = (target is GamePlayer) ? ad.Damage / 2 : ad.Damage;
ad.CriticalDamage = Util.Random(critMax / 10, critMax);
}
m_handler.SendDamageMessages(ad);
m_handler.DamageTarget(ad, false, (blocked ? 0x02 : 0x14));
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, caster);
}
/// <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);
}
}
/// <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>
/// 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));
}
protected virtual void OnSpellResist(GameLiving target)
{
m_lastdamage -= m_lastdamage / 4;
SendEffectAnimation(target, 0, false, 0);
if (target is GameNPC)
{
IControlledBrain brain = ((GameNPC)target).Brain as IControlledBrain;
if (brain != null)
{
GamePlayer owner = brain.GetPlayerOwner();
//Worthless checks
if (owner != null/* && owner.ControlledNpc != null && target == owner.ControlledNpc.Body*/)
{
MessageToLiving(owner, "Your " + target.Name + " resists the effect!", eChatType.CT_SpellResisted);
}
}
}
else
{
MessageToLiving(target, "You resist the effect!", eChatType.CT_SpellResisted);
}
MessageToCaster(target.GetName(0, true) + " resists the effect!", eChatType.CT_SpellResisted);
if (Spell.Damage != 0)
{
// notify target about missed attack for spells with damage
AttackData ad = new AttackData();
ad.Attacker = Caster;
ad.Target = target;
ad.AttackType = AttackData.eAttackType.Spell;
ad.AttackResult = GameLiving.eAttackResult.Missed;
ad.SpellHandler = this;
target.OnAttackedByEnemy(ad);
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, Caster);
}
else if (Spell.CastTime > 0)
{
target.StartInterruptTimer(target.SpellInterruptDuration, AttackData.eAttackType.Spell, Caster);
}
if (target is GameNPC)
{
IOldAggressiveBrain aggroBrain = ((GameNPC)target).Brain as IOldAggressiveBrain;
if (aggroBrain != null)
aggroBrain.AddToAggroList(Caster, 1);
}
if (target.Realm == 0 || Caster.Realm == 0)
{
target.LastAttackedByEnemyTickPvE = target.CurrentRegion.Time;
Caster.LastAttackTickPvE = Caster.CurrentRegion.Time;
}
else
{
target.LastAttackedByEnemyTickPvP = target.CurrentRegion.Time;
Caster.LastAttackTickPvP = Caster.CurrentRegion.Time;
}
}
private void DamageTarget(GameLiving target)
{
if (!GameServer.ServerRules.IsAllowedToAttack(owner, target, true))
{
return;
}
if (!target.IsAlive)
{
return;
}
if (ticktimer.IsAlive)
{
ticktimer.Stop();
removeHandlers();
}
var dist = Vector3.Distance(target.Position, traparea.Position);
double mod = 1;
if (dist > 0)
{
mod = 1 - ((double)dist / 350);
}
int basedamage = (int)(effectiveness * mod);
int resist = (int)(basedamage * target.GetModified(eProperty.Resist_Energy) * -0.01);
int damage = basedamage + resist;
GamePlayer player = owner as GamePlayer;
if (player != null)
{
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
{
targetPlayer.Stealth(false);
}
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(owner, target, 7026, 0, false, 1);
p.Out.SendCombatAnimation(owner, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(owner, eDamageType.Energy, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = owner;
ad.Target = target;
ad.DamageType = eDamageType.Energy;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
owner.DealDamage(ad);
}
/// <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)
{
if (!(args is AttackFinishedEventArgs atkArgs))
{
return;
}
if (atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitUnstyled &&
atkArgs.AttackData.AttackResult != GameLiving.eAttackResult.HitStyle)
{
return;
}
GameLiving target = atkArgs.AttackData.Target;
if (target?.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (target.IsAlive == false)
{
return;
}
if (!(sender is GameLiving attacker))
{
return;
}
if (attacker.ObjectState != GameObject.eObjectState.Active)
{
return;
}
if (attacker.IsAlive == false)
{
return;
}
var dpsCap = (1.2 + 0.3 * attacker.Level) * 0.7;
double dps = Math.Min(Value, dpsCap);
double damage = dps * atkArgs.AttackData.WeaponSpeed * 0.1;
double damageResisted = damage * target.GetResist(eDamageType.Heat) * -0.01;
AttackData ad = new AttackData
{
Attacker = attacker,
Target = target,
Damage = (int)(damage + damageResisted),
Modifier = (int)damageResisted,
DamageType = eDamageType.Heat,
AttackType = AttackData.eAttackType.Spell,
AttackResult = GameLiving.eAttackResult.HitUnstyled
};
target.OnAttackedByEnemy(ad);
_effectCaster.ChangeMana(_effectOwner, GameLiving.eManaChangeType.Spell, ad.Damage);
(attacker as GamePlayer)?.Out.SendMessage($"You hit {target.Name} for {ad.Damage} extra damage!", PacketHandler.eChatType.CT_Spell, PacketHandler.eChatLoc.CL_SystemWindow);
attacker.DealDamage(ad);
}
/// <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);
}
protected virtual void OnSpellResist(GameLiving target)
{
m_lastdamage -= Convert.ToInt32(m_lastdamage * 0.25);
SendEffectAnimation(target, 0, false, 0);
if (target is GameNPC npc)
{
if (npc.Brain is IControlledBrain brain)
{
GamePlayer owner = brain.GetPlayerOwner();
if (owner != null)
{
MessageToLiving(owner, $"Your {target.Name} resists the effect!", eChatType.CT_SpellResisted);
}
}
}
else
{
MessageToLiving(target, "You resist the effect!", eChatType.CT_SpellResisted);
}
MessageToCaster($"{target.GetName(0, true)} resists the effect!", eChatType.CT_SpellResisted);
if (Spell.Damage != 0)
{
// notify target about missed attack for spells with damage
AttackData ad = new AttackData
{
Attacker = Caster,
Target = target,
AttackType = AttackData.eAttackType.Spell,
AttackResult = GameLiving.eAttackResult.Missed,
SpellHandler = this
};
target.OnAttackedByEnemy(ad);
target.StartInterruptTimer(target.SpellInterruptDuration, ad.AttackType, Caster);
}
else if (Spell.CastTime > 0)
{
target.StartInterruptTimer(target.SpellInterruptDuration, AttackData.eAttackType.Spell, Caster);
}
if (target is GameNPC gameNpc)
{
if (gameNpc.Brain is IOldAggressiveBrain aggroBrain)
{
aggroBrain.AddToAggroList(Caster, 1);
}
}
if (target.Realm == 0 || Caster.Realm == 0)
{
target.LastAttackedByEnemyTickPvE = target.CurrentRegion.Time;
Caster.LastAttackTickPvE = Caster.CurrentRegion.Time;
}
else
{
target.LastAttackedByEnemyTickPvP = target.CurrentRegion.Time;
Caster.LastAttackTickPvP = Caster.CurrentRegion.Time;
}
}
private void DamageTarget(GameLiving target)
{
if (!GameServer.ServerRules.IsAllowedToAttack(owner, target, true))
return;
if (!target.IsAlive)
return;
if (ticktimer.IsAlive)
{
ticktimer.Stop();
removeHandlers();
}
int dist = target.GetDistanceTo( new Point3D( traparea.X, traparea.Y, traparea.Z ) );
double mod = 1;
if (dist > 0)
mod = 1 - ((double)dist / 350);
int basedamage = (int)(effectiveness * mod);
int resist = (int)(basedamage * target.GetModified(eProperty.Resist_Energy) * -0.01);
int damage = basedamage + resist;
GamePlayer player = owner as GamePlayer;
if (player != null)
{
player.Out.SendMessage("You hit " + target.Name + " for " + damage + "(" + resist + ") points of damage!", eChatType.CT_YouHit, eChatLoc.CL_SystemWindow);
}
GamePlayer targetPlayer = target as GamePlayer;
if (targetPlayer != null)
{
if (targetPlayer.IsStealthed)
targetPlayer.Stealth(false);
}
foreach (GamePlayer p in target.GetPlayersInRadius(false, WorldMgr.VISIBILITY_DISTANCE))
{
p.Out.SendSpellEffectAnimation(owner, target, 7026, 0, false, 1);
p.Out.SendCombatAnimation(owner, target, 0, 0, 0, 0, 0x14, target.HealthPercent);
}
//target.TakeDamage(owner, eDamageType.Energy, damage, 0);
AttackData ad = new AttackData();
ad.AttackResult = GameLiving.eAttackResult.HitUnstyled;
ad.Attacker = owner;
ad.Target = target;
ad.DamageType = eDamageType.Energy;
ad.Damage = damage;
target.OnAttackedByEnemy(ad);
owner.DealDamage(ad);
}
