private void MaybeThorns(EntityDamagedEventData data)
{
if (!CanBeReflected(data.Victim, data.Attacker, data.Damage))
{
return;
}
var thorns = this.properties.Get(PropertyType.Thorns).Value();
if (thorns < 1)
{
return;
}
Timer.Instance.Wait(0.5f, () =>
{
data.Attacker.GetComponent <HealthComponent>().Damage(
gameObject, new Damage(
thorns,
DamageType.Piercing,
DamageFlags.CantBeCritical | DamageFlags.CantBeBlocked | DamageFlags.CantBeDodged,
DamageInfoFlags.Reflected
)
);
});
}
private void MaybeReflect(EntityDamagedEventData data)
{
if (!CanBeReflected(data.Victim, data.Attacker, data.Damage))
{
return;
}
var reflection = this.properties.Get(PropertyType.DamageReflection).Value();
if (reflection < 0.01)
{
return;
}
var flags = data.Damage.Flags | DamageFlags.CantBeCritical | DamageFlags.CantBeBlocked |
DamageFlags.CantBeDodged;
var reflected = new Damage(
data.Damage.Amount, data.Damage.Type, data.Damage.WeaponSound, flags, DamageInfoFlags.Reflected);
if (reflected < 1)
{
return;
}
Timer.Instance.Wait(0.5f, () =>
{
data.Attacker.GetComponent <HealthComponent>()
.Damage(gameObject, reflected * reflection);
});
}
private void OnDealDamage(EntityDamagedEventData data)
{
if (data.Damage.Amount < 1)
{
return;
}
Timer.Instance.WaitForFixedUpdate(() =>
{
foreach (var behaviour in Behaviours.Where(
behaviour => behaviour.Flags.HasFlag(BehaviourFlags.BreaksOnDealDamage)).ToList())
{
RemoveStack(behaviour, behaviour.StackCount);
}
if (!data.Damage.Flags.HasFlag(DamageFlags.DOT))
{
foreach (var behaviour in Behaviours.Where(
behaviour => behaviour.Flags.HasFlag(BehaviourFlags.BreaksOnDealDirectDamage)).ToList())
{
RemoveStack(behaviour, behaviour.StackCount);
}
}
});
}
private void OnEntityDamaged(EntityDamagedEventData data)
{
if (data.Damage.Amount < 1 && Mathf.Approximately(0, data.Damage.Absorbed) || data.Attacker == data.Victim)
{
return;
}
if (data.Attacker != Target ||
this.data.DamageFlags != DamageFlags.None &&
(data.Damage.Flags & this.data.DamageFlags) == 0 ||
this.data.DamageInfoFlags != DamageInfoFlags.None &&
(data.Damage.InfoFlags & this.data.DamageInfoFlags) == 0)
{
return;
}
if ((this.data.ExcludeDamageFlags & data.Damage.Flags) > 0 ||
(this.data.ExcludeDamageInfoFlags & data.Damage.InfoFlags) > 0)
{
return;
}
if (this.data.DamageTypes.Count > 0 && !this.data.DamageTypes.Contains(data.Damage.Type))
{
return;
}
if (!this.Validators.All(v => v.Validate(data.Attacker, data.Victim)))
{
return;
}
this.effect.Clone().Apply(Caster, EventSubject == BehaviourEventSubject.Me ? Target : data.Victim);
}
private void OnDamaged(EntityDamagedEventData data)
{
var movement = GetComponent <MovementComponent>();
if (movement != null && movement.IsMoving)
{
return;
}
if (data.Damage.IsBlocked())
{
AudioManager.Instance.PlayBlock();
PlayAnimation("block");
return;
}
if (data.Damage.IsDodged())
{
AudioManager.Instance.PlayDodge();
PlayAnimation("dodge");
return;
}
PlayAnimation("hit");
}
private void OnEntityDamaged(EntityDamagedEventData data)
{
if (data.Attacker != gameObject)
{
return;
}
Restore(ResourceType.Rage, data.Damage.Amount / CalculatePower() * 100);
}
private void OnDamaged(EntityDamagedEventData data)
{
if (this.health.HealthFraction >= this.data.Fraction)
{
return;
}
this.effectRepository.FindOrFail(this.data.EffectId)
.Apply(Caster, this.data.EventSubject == BehaviourEventSubject.Me ? Target : data.Attacker);
}
private void OnAnyEntityDamaged(EntityDamagedEventData data)
{
if (data.Victim == gameObject)
{
OnTakeDamage(data);
}
else if (data.Attacker == gameObject)
{
OnDealDamage(data);
}
}
private void OnEntityDamaged(EntityDamagedEventData data)
{
if (data.Attacker.IsOwnedByPlayer())
{
this.damageDealt += data.Damage;
}
else
{
this.damageTaken += data.Damage;
}
}
private void OnAnyEntityDamaged(EntityDamagedEventData data)
{
if (data.Attacker != Owner || !data.Damage.IsMagic())
{
return;
}
if (this.Data.DamageType != data.Damage.Type)
{
return;
}
Experience.Add(1);
}
private void OnAnyEntityDamaged(EntityDamagedEventData data)
{
if (data.Attacker != Owner || !data.Damage.IsWeapon())
{
return;
}
if (WearingItemOfRequiredType().Count == 0)
{
return;
}
Experience.Add(1);
}
private void OnAnyEntityDamaged(EntityDamagedEventData data)
{
var armorSound = data.Victim.GetComponent <UnitComponent>().ArmorSound;
if (armorSound == ArmorSound.None ||
data.Damage.WeaponSound == WeaponSound.None ||
data.Damage.InfoFlags.HasFlag(DamageInfoFlags.Reflected) ||
data.Damage.InfoFlags.HasFlag(DamageInfoFlags.Cleave))
{
return;
}
AudioManager.Instance.PlayOneShot($"event:/SFX/Weapon/{data.Damage.WeaponSound}_On_{armorSound}");
}
private void OnEntityDamaged(EntityDamagedEventData data)
{
if ((data.Damage < 1 && data.Damage.Absorbed > 0) || data.Attacker != gameObject || data.Attacker == data.Victim ||
data.Damage.InfoFlags.HasFlag(DamageInfoFlags.Reflected))
{
return;
}
var vampirism = this.properties.Get(PropertyType.Vampirism).Value();
if (Math.Abs(vampirism) < 0.01)
{
return;
}
// Note: Shield Explode deals damage then removes shields, to prevent "overheal"
// shield removal we need to wait a little bit.
Timer.Instance.WaitForFixedUpdate(() =>
{
this.health.Heal(gameObject, new Healing(data.Damage * vampirism, HealingFlags.Vampirism));
});
}
private void OnAnyEntityDamaged(EntityDamagedEventData data)
{
if (data.Attacker != Target || !data.Damage.Flags.HasFlag(DamageFlags.Melee) || data.Damage.Amount < 1)
{
return;
}
if (isCleaving)
{
return;
}
isCleaving = true;
var cleaveDamage = data.Damage * this.data.Fraction;
cleaveDamage.Flags |= DamageFlags.CantBeBlocked;
cleaveDamage.Flags |= DamageFlags.CantBeDodged;
cleaveDamage.InfoFlags |= DamageInfoFlags.Cleave;
foreach (var cell in this.boardNavigator.WithinCleave(Target.transform.position, data.Victim.transform.position))
{
if (!cell.IsOccupied)
{
continue;
}
if (cell.OccupiedBy.IsDummy() || cell.OccupiedBy == data.Victim || cell.OccupiedBy.IsAllyOf(Target))
{
continue;
}
cell.OccupiedBy.GetComponent <HealthComponent>().Damage(Target, cleaveDamage);
}
isCleaving = false;
}
private void OnEntityDamaged(EntityDamagedEventData data)
{
if (!Game.Instance.State.IsScenario)
{
return;
}
if (data.Damage < 1)
{
if (data.Damage.Absorbed > 0)
{
Enqueue(data.Victim, I18N.Instance.Get("ui_absorb"), Color.white);
}
else if (data.Damage.InfoFlags.HasFlag(DamageInfoFlags.Dodged))
{
Enqueue(data.Victim, I18N.Instance.Get("ui_dodge") + "!\n", Color.white);
}
return;
}
var text = "";
if (data.Damage.InfoFlags.HasFlag(DamageInfoFlags.Critical))
{
text = I18N.Instance.Get("ui_critical") + "!\n";
}
if (data.Damage.InfoFlags.HasFlag(DamageInfoFlags.Blocked))
{
text = I18N.Instance.Get("ui_block") + "!\n";
}
text += (int)data.Damage;
Enqueue(data.Victim, text, Color.white);
}
private void OnEntityDamaged(EntityDamagedEventData data)
{
var row = $"<color=#888888>[{DateTime.Now.ToLongTimeString()}]</color> " +
I18N.Instance.Get("ui_combat_log_damage")
.ToString(new object[]
{
ColorYellow + data.Attacker.GetComponent <UnitComponent>().Name + EndColor,
ColorYellow + data.Victim.GetComponent <UnitComponent>().Name + EndColor,
ColorRed + (int)data.Damage + EndColor,
data.Damage.Type
});
var flags = new List <string>();
if (data.Damage.IsCritical())
{
flags.Add(I18N.Instance.Get("ui_critical"));
}
if (data.Damage.IsBlocked())
{
flags.Add(I18N.Instance.Get("ui_block"));
}
if (data.Damage.IsDodged())
{
flags.Add(I18N.Instance.Get("ui_dodge"));
}
if (flags.Count > 0)
{
row += $" ({string.Join(", ", flags)})";
}
AddRow(row);
}
private void OnDamage(EntityDamagedEventData data)
{
AdjustFillAmount(false);
}
private void OnAnyEntityDamaged(EntityDamagedEventData data)
{
MaybeThorns(data);
MaybeReflect(data);
}
