protected float CalculateLifestealModifier(SourcedDamage damage)
{
var args = new AttackLifestealEventArgs(damage);
OnLifestealModifiers(args);
return(args.LifestealAmount);
}
protected SourcedDamage CalculateCritDamage(SourcedDamage damage)
{
var args = new AttackCritEventArgs(damage);
OnCritModifiers(args);
return(args.FinalDamage);
}
private void Cast(Actor caster, Actor target)
{
//Deal damage
var damagePerTick = new Damage(_tickDamage, DamageType.Magical, DamageFlags.Ability);
var damage = new SourcedDamage(caster, damagePerTick);
var damageable = target.GetModule <IDamageable>();
void InternalTick()
{
damageable.TakeDamage(damage);
}
var tickWrapper = new TickAction
{
Callback = InternalTick,
TickCount = _tickCount,
TickInterval = _tickInterval
};
if (target.TryGetModule <IKillable>(out var killable))
{
killable.Died += RemoveTick;
}
void RemoveTick(object sender, DeathEventArgs args)
{
killable.Died -= RemoveTick;
Ticks.Remove(tickWrapper);
}
Ticks.Add(tickWrapper);
ApplyFX(target.transform, _tickInterval * _tickCount);
}
private void TryHitActor(Actor target)
{
var damage = new SourcedDamage(Self, new Damage(_damage, DamageType.Pure, DamageFlags.Ability));
if (target.TryGetModule <IDamageable>(out var damageable))
{
damageable.TakeDamage(damage);
}
}
void CastBlackRoseLifeTap(IDamageable damageable)
{
var dmgVal = new Damage(_brDamage, DamageType.Magical, DamageFlags.Ability);
var damage = new SourcedDamage(Self, dmgVal);
damageable.TakeDamage(damage);
var selfHeal = new SourcedHeal(Self, _brSelfHeal);
Modules.Healable.Heal(selfHeal);
}
public virtual SourcedDamage ResistDamage(SourcedDamage damage)
{
OnResisting(damage);
damage = CalculateDamageMitigation(damage);
var reduction = CalculateReduction(damage);
//Reduction, so negate the value
var reducedDamage = damage.ModifyDamageValue(-reduction, true);
damage = reducedDamage;
var resisted = new ChangedEventArgs <SourcedDamage>(damage, reducedDamage);
OnResisted(resisted);
return(damage);
}
public virtual bool TakeDamage(SourcedDamage damage)
{
OnDamaging(damage);
//ARMORABLE
if (_armorable != null)
{
damage = _armorable.ResistDamage(damage);
}
damage = CalculateDamageModifiers(damage);
_healthable.Value -= damage.Value.Value;
OnDamaged(damage);
var killed = _healthable.Value.SafeEquals(0f);
if (killed)
{
Killable.Die(damage.Source);
}
return(killed);
}
public float CalculateReduction(SourcedDamage damage)
{
var value = damage.Value.Value;
switch (damage.Value.Type)
{
case DamageType.Physical:
return(Physical.CalculateReduction(value));
case DamageType.Magical:
return(Magical.CalculateReduction(value));
case DamageType.Pure:
return(0f);
default:
throw new ArgumentOutOfRangeException();
}
}
private void InternalPerformAttack(Actor actor, IDamageable damageTarget, Damage damage, bool useCooldown = true)
{
var sourceDamage = new SourcedDamage(Actor, damage);
var attackArgs = new AttackerableEventArgs(sourceDamage, actor);
OnAttacking(attackArgs);
var critDamage = CalculateCritDamage(sourceDamage);
var lifesteal = CalculateLifestealModifier(sourceDamage);
damageTarget.TakeDamage(critDamage);
if (Actor.TryGetModule <IHealthable>(out var healthable))
{
healthable.Value += lifesteal;
}
if (useCooldown)
{
PutAttackOnCooldown();
}
var attackedArgs = new AttackerableEventArgs(critDamage, Actor);
OnAttacked(attackedArgs);
}
protected SourcedDamage CalculateDamageModifiers(SourcedDamage e) => DamageMitigation.CalculateChange(this, e);
protected virtual void OnDamaging(SourcedDamage e) => Damaging?.Invoke(this, e);
protected virtual SourcedDamage CalculateDamageMitigation(SourcedDamage e) => DamageMitigation.CalculateChange(this, e);
protected virtual void OnResisting(SourcedDamage e)
{
Resisting?.Invoke(this, e);
}
public AttackerableEventArgs(SourcedDamage damage, Actor defender)
{
Defender = defender;
Damage = damage;
}
public AttackLifestealEventArgs(SourcedDamage source)
{
Damage = source;
}
public AttackCritEventArgs(SourcedDamage damage)
{
Damage = damage;
}
