public void StrikeNormal()
{
HitFlags = HitFlags.PlayWoundAnimation;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.NormalHit;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeNormal()
{
this.HitFlags = HitFlags.PlayWoundAnimation;
this.VictimState = VictimState.Wound;
this.ProcHitFlags |= ProcHitFlags.NormalHit;
this.Blocked = 0;
this.IsCritical = false;
this.DoStrike();
}
public void Dodge()
{
Damage = 0;
VictimState = VictimState.Dodge;
HitFlags = HitFlags.Miss;
ProcHitFlags |= ProcHitFlags.Dodge;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeGlancing()
{
Damage = (int)(Damage * CalcGlancingBlowDamageFactor());
VictimState = VictimState.Wound;
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Glancing;
ProcHitFlags |= ProcHitFlags.NormalHit;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeCrushing()
{
Damage = (Damage * 10 + 5) / 15; // == Damage * 1.5f
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Crushing;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.NormalHit;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void Dodge()
{
this.Damage = 0;
this.VictimState = VictimState.Dodge;
this.HitFlags = HitFlags.Miss;
this.ProcHitFlags |= ProcHitFlags.Dodge;
this.Blocked = 0;
this.IsCritical = false;
this.DoStrike();
}
public void Parry()
{
Damage = 0;
VictimState = VictimState.Parry;
HitFlags = HitFlags.Miss;
ProcHitFlags |= ProcHitFlags.Parry;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeCritical()
{
IsCritical = Victim.StandState == StandState.Stand;
SetCriticalDamage();
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.ResistType1 | HitFlags.ResistType2 | HitFlags.CriticalStrike;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.CriticalHit;
Blocked = 0;
// Automatic double damage against sitting target - but doesn't proc crit abilities
DoStrike();
}
public void StrikeCritical()
{
this.IsCritical = this.Victim.StandState == StandState.Stand;
this.SetCriticalDamage();
this.HitFlags = HitFlags.PlayWoundAnimation | HitFlags.ResistType1 | HitFlags.ResistType2 |
HitFlags.CriticalStrike;
this.VictimState = VictimState.Wound;
this.ProcHitFlags |= ProcHitFlags.CriticalHit;
this.Blocked = 0;
this.DoStrike();
}
public void StrikeCritical()
{
IsCritical = Victim.StandState == StandState.Stand;
SetCriticalDamage();
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.ResistType1 | HitFlags.ResistType2 |
HitFlags.CriticalStrike;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.CriticalHit;
Blocked = 0;
DoStrike();
}
public void Block()
{
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Block;
VictimState = VictimState.Block;
ProcHitFlags |= ProcHitFlags.Block;
Blocked = CalcBlockDamage();
if (Damage == Blocked)
{
ProcHitFlags |= ProcHitFlags.FullBlock;
}
IsCritical = false;
DoStrike();
}
public void Block()
{
this.HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Block;
this.VictimState = VictimState.Block;
this.ProcHitFlags |= ProcHitFlags.Block;
this.Blocked = this.CalcBlockDamage();
if (this.Damage == this.Blocked)
{
this.ProcHitFlags |= ProcHitFlags.FullBlock;
}
this.IsCritical = false;
this.DoStrike();
}
public void StrikeCritical()
{
IsCritical = Victim.StandState == StandState.Stand;
SetCriticalDamage();
HitFlags = HitFlags.NormalSwingAnim | HitFlags.Resist_1 | HitFlags.Resist_2 | HitFlags.CriticalStrike;
VictimState = VictimState.Wound;
Blocked = 0;
// Automatic double damage against sitting target - but doesn't proc crit abilities
DoStrike();
}
public void StrikeCrushing()
{
Damage = (Damage * 10 + 5) / 15; // == Damage * 1.5f
HitFlags = HitFlags.NormalSwingAnim | HitFlags.Crushing;
VictimState = VictimState.Wound;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void Parry()
{
Damage = 0;
VictimState = VictimState.Parry;
HitFlags = HitFlags.Miss;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeGlancing()
{
Damage = (int)(Damage * CalcGlancingBlowDamageFactor());
VictimState = VictimState.Wound;
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Glancing;
ProcHitFlags |= ProcHitFlags.NormalHit;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public static bool HasAnyFlag(this HitFlags flags, HitFlags otherFlags)
{
return((flags & otherFlags) != 0);
}
public void Dodge()
{
Damage = 0;
VictimState = VictimState.Dodge;
HitFlags = HitFlags.Miss;
ProcHitFlags |= ProcHitFlags.Dodge;
Blocked = 0;
IsCritical = false;
DoStrike();
}
/// <summary>
/// Strikes the target
/// </summary>
public void DoStrike()
{
if (Damage > 0)
{
var level = Attacker.Level;
var res = Victim.GetResistance(UsedSchool) - Attacker.GetTargetResistanceMod(UsedSchool);
if (res > 0)
{
// This formula only applies for armor
if (UsedSchool == DamageSchool.Physical)
{
if (level < 60)
{
ResistPct = (res / (res + 400f + 85f * level)) * 100f;
}
else
{
ResistPct = (res / (res - 22167.5f + 467.5f * level)) * 100f;
}
}
else
{
// Magical damageschool
ResistPct = Victim.GetResistChancePct(Attacker, UsedSchool);
}
}
else
{
ResistPct = 0;
}
if (ResistPct > 75)
{
ResistPct = 75;
}
if (ResistPct < 0)
{
ResistPct = 0;
}
Victim.DeathPrevention++;
Attacker.DeathPrevention++;
try
{
// add mods and call events
AddDamageMods();
Victim.OnDefend(this);
Attacker.OnAttack(this);
Resisted = MathUtil.RoundInt(ResistPct * Damage / 100f);
if (Absorbed > 0)
{
HitFlags |= HitFlags.Absorb_1 | HitFlags.Absorb_2;
}
else
{
Absorbed = Resisted = 0;
}
if (Weapon == Attacker.OffHandWeapon)
{
HitFlags |= HitFlags.LeftSwing;
}
Victim.DoRawDamage(this);
}
finally
{
Victim.DeathPrevention--;
Attacker.DeathPrevention--;
}
}
//if ()
//CombatHandler.SendMeleeDamage(attacker, this, schools, hitInfo, (uint)totalDamage,
//(uint)absorbed, (uint)resisted, (uint)blocked, victimState);
if (SpellEffect != null)
{
CombatLogHandler.SendMagicDamage(this);
}
else
{
CombatHandler.SendAttackerStateUpdate(this);
}
}
/// <summary>
/// Whether the given flags has any of the specified flags
/// </summary>
/// <param name="flags"></param>
/// <param name="toCheck"></param>
/// <returns></returns>
public static bool HasAny(this HitFlags flags, HitFlags toCheck)
{
return (flags & toCheck) != 0;
}
public void StrikeCritical()
{
Damage = Attacker.CalcCritDamage(Damage, Victim, SpellEffect).RoundInt();
HitFlags = HitFlags.NormalSwingAnim | HitFlags.Resist_1 | HitFlags.Resist_2 | HitFlags.CriticalStrike;
VictimState = VictimState.Wound;
Blocked = 0;
// Automatic double damage against sitting target - but doesn't proc crit abilities
IsCritical = Victim.StandState == StandState.Stand;
DoStrike();
}
public static bool HasAnyFlag(this HitFlags flags, HitFlags otherFlags)
{
return (flags & otherFlags) != 0;
}
/// <summary>
/// Strikes the target
/// </summary>
public void DoStrike()
{
if (Damage > 0)
{
var level = Attacker.Level;
var res = Victim.GetResistance(UsedSchool) - Attacker.GetTargetResistanceMod(UsedSchool);
if (res > 0)
{
ProcHitFlags |= ProcHitFlags.Resist;
// This formula only applies for armor
if (UsedSchool == DamageSchool.Physical)
{
if (level < 60)
{
ResistPct = (res / (res + 400f + 85f * level)) * 100f;
}
else
{
ResistPct = (res / (res - 22167.5f + 467.5f * level)) * 100f;
}
}
else
{
// Magical damageschool
ResistPct = Victim.GetResistChancePct(Attacker, UsedSchool);
}
}
else
{
ResistPct = 0;
}
if (ResistPct > 75)
{
ResistPct = 75;
}
if (ResistPct < 0)
{
ResistPct = 0;
}
Victim.DeathPrevention++;
Attacker.DeathPrevention++;
try
{
// add mods and call events
AddDamageMods();
Victim.OnDefend(this);
Attacker.OnAttack(this);
Resisted = MathUtil.RoundInt(ResistPct * Damage / 100f);
if (Absorbed > 0)
{
HitFlags |= HitFlags.AbsorbType1 | HitFlags.AbsorbType2;
ProcHitFlags |= ProcHitFlags.Absorb;
}
else
{
Absorbed = Resisted = 0;
}
if (Weapon == Attacker.OffHandWeapon)
{
HitFlags |= HitFlags.OffHand;
}
Victim.DoRawDamage(this);
}
finally
{
Victim.DeathPrevention--;
Attacker.DeathPrevention--;
}
}
//if ()
//CombatHandler.SendMeleeDamage(attacker, this, schools, hitInfo, (uint)totalDamage,
//(uint)absorbed, (uint)resisted, (uint)blocked, victimState);
if (SpellEffect != null)
{
CombatLogHandler.SendMagicDamage(this);
}
else
{
CombatHandler.SendAttackerStateUpdate(this);
}
TriggerProcOnStrike();
}
public void StrikeCrushing()
{
Damage = (Damage * 10 + 5) / 15; // == Damage * 1.5f
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Crushing;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.NormalHit;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeCritical()
{
IsCritical = Victim.StandState == StandState.Stand;
SetCriticalDamage();
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.ResistType1 | HitFlags.ResistType2 | HitFlags.CriticalStrike;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.CriticalHit;
Blocked = 0;
// Automatic double damage against sitting target - but doesn't proc crit abilities
DoStrike();
}
public void StrikeGlancing()
{
Damage = (int)(Damage * CalcGlancingBlowDamageFactor());
VictimState = VictimState.Wound;
HitFlags = HitFlags.NormalSwingAnim | HitFlags.Glancing;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void StrikeNormal()
{
HitFlags = HitFlags.NormalSwingAnim;
VictimState = VictimState.Wound;
Blocked = 0;
IsCritical = false;
DoStrike();
}
public void Block()
{
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Block;
VictimState = VictimState.Block;
ProcHitFlags |= ProcHitFlags.Block;
Blocked = CalcBlockDamage();
if (Damage == Blocked)
{
ProcHitFlags |= ProcHitFlags.FullBlock;
}
IsCritical = false;
DoStrike();
}
/// <summary>
/// Return the top-most widget at the given screen coords.
/// </summary>
/// <param name="pt">The screen coords.</param>
/// <param name="hitflags">The set of flags to check for.</param>
/// <returns>The found widget, or null.</returns>
public Widget ChildAtPoint(Point pt, HitFlags hitflags)
{
for (int i = children.Count - 1; i >= 0; i--)
{
Widget child = children[i].ChildAtPoint(pt, hitflags);
if (child != null)
return child;
}
return (HitFlags & hitflags) != 0 && CalculatedBoundsI.Contains(pt) ? this : null;
}
/// <summary>
/// Strikes the target
/// </summary>
public void DoStrike()
{
if (Damage > 0)
{
var level = Attacker.Level;
float resPct;
var res = Victim.GetResistance(UsedSchool) - Attacker.GetTargetResistanceMod(UsedSchool);
if (res > 0)
{
// This formula only applies for armor
if (UsedSchool == DamageSchool.Physical)
{
if (level < 60)
{
resPct = (res/(res + 400f + 85f*level))*100f;
}
else
{
resPct = (res/(res - 22167.5f + 467.5f*level))*100f;
}
}
else
{
// Magical damageschool
resPct = Victim.GetResistChance(Attacker, UsedSchool);
}
}
else
{
resPct = 0;
}
if (resPct > 75)
{
resPct = 75;
}
if (resPct < 0)
{
resPct = 0;
}
Damage = Attacker.AddDamageMods(Damage, SpellEffect, UsedSchool);
Resisted = (resPct * Damage / 100f).RoundInt();
Absorbed = Victim.Absorb(UsedSchool, Damage);
if (Absorbed > 0)
{
HitFlags |= HitFlags.Absorb_1 | HitFlags.Absorb_2;
}
}
else
{
Absorbed = Resisted = 0;
}
if (Weapon == Attacker.OffHandWeapon)
{
HitFlags |= HitFlags.LeftSwing;
}
Victim.DoRawDamage(this);
//if ()
//CombatHandler.SendMeleeDamage(attacker, this, schools, hitInfo, (uint)totalDamage,
//(uint)absorbed, (uint)resisted, (uint)blocked, victimState);
if (SpellEffect != null)
{
CombatLogHandler.SendMagicDamage(this);
}
else
{
CombatHandler.SendAttackerStateUpdate(this);
}
// reset Target
Victim = null;
}
public static bool HasAnyFlag(this HitFlags flags, HitFlags otherFlags)
{
return((flags & otherFlags) != HitFlags.NormalSwing);
}
public void Block()
{
HitFlags = HitFlags.NormalSwingAnim | HitFlags.Block;
VictimState = VictimState.Block;
Blocked = CalcBlockDamage();
IsCritical = false;
DoStrike();
}
public void Block()
{
HitFlags = HitFlags.PlayWoundAnimation | HitFlags.Block;
VictimState = VictimState.Block;
Blocked = CalcBlockDamage();
IsCritical = false;
DoStrike();
}
public void StrikeNormal()
{
HitFlags = HitFlags.PlayWoundAnimation;
VictimState = VictimState.Wound;
ProcHitFlags |= ProcHitFlags.NormalHit;
Blocked = 0;
IsCritical = false;
DoStrike();
}
