public void TakeDamage(int damageAmount)
{
//Ignore damage if already dead
if (isDead)
{
return;
}
if (isInvulnerable)
{
OnHitWhileInvulnerable.Invoke();
return;
}
//Finally take damage
isInvulnerable = true;
currentHP -= damageAmount;
if (currentHP <= 0)
{
OnDeath.Invoke();
Death();
}
else
{
OnReceiveDamage.Invoke();
Hit();
}
}
public void ApplyDamage(DamageMessage data)
{
if (currentHitPoints <= 0)
{//ignore damage if already dead. TODO : may have to change that if we want to detect hit on death...
return;
}
if (isInvulnerable)
{
OnHitWhileInvulnerable.Invoke();
return;
}
Vector3 forward = transform.forward;
forward = Quaternion.AngleAxis(hitForwardRotation, transform.up) * forward;
//we project the direction to damager to the plane formed by the direction of damage
Vector3 positionToDamager = data.damageSource - transform.position;
positionToDamager -= transform.up * Vector3.Dot(transform.up, positionToDamager);
if (Vector3.Angle(forward, positionToDamager) > hitAngle * 0.5f)
return;
isInvulnerable = true;
MyInstantAttributeUpdateSystem.CreateAttributeModifier(dstManager, new MyInstantGameplayAttributeModifier()
{
Attribute = EMyPlayerAttribute.Health,
Operator = EMyAttributeModifierOperator.Add,
Value = (half)(-data.amount)
}, new GameplayAbilitySystem.AttributeSystem.Components.GameplayEffectContextComponent()
{
Source = Entity.Null,
Target = this.attributeEntity
});
// Create a poison effect, that does 1 damage every 1s tick
var poisonEntity = dstManager.CreateEntity(typeof(DotGameplayEffect), typeof(DurationStateComponent), typeof(TimeDurationComponent), typeof(GameplayEffectContextComponent));
dstManager.SetComponentData(poisonEntity, new DotGameplayEffect()
{
DamagePerTick = 1f
});
dstManager.SetComponentData(poisonEntity, new GameplayEffectContextComponent()
{
Target = this.attributeEntity,
Source = Entity.Null
});
dstManager.SetComponentData(poisonEntity, TimeDurationComponent.New(1f, 10f));
damageMessagesToAction.Add(data);
}
public void ApplyDamage(DamageMessage data)
{
if (currentHitPoints <= 0)
{//ignore damage if already dead. TODO : may have to change that if we want to detect hit on death...
return;
}
if (isInvulnerable)
{
OnHitWhileInvulnerable.Invoke();
return;
}
Vector3 forward = transform.forward;
forward = Quaternion.AngleAxis(hitForwardRotation, transform.up) * forward;
//we project the direction to damager to the plane formed by the direction of damage
Vector3 positionToDamager = data.damageSource - transform.position;
positionToDamager -= transform.up * Vector3.Dot(transform.up, positionToDamager);
if (Vector3.Angle(forward, positionToDamager) > hitAngle * 0.5f)
{
return;
}
isInvulnerable = true;
currentHitPoints -= data.amount;
if (currentHitPoints <= 0)
{
schedule += OnDeath.Invoke; //This avoid race condition when objects kill each other.
myOnDeath.Invoke(this, data);
}
else
{
OnReceiveDamage.Invoke();
myOnDamageReceived?.Invoke(this, data);
}
var messageType = currentHitPoints <= 0 ? MessageType.DEAD : MessageType.DAMAGED;
for (var i = 0; i < onDamageMessageReceivers.Count; ++i)
{
var receiver = onDamageMessageReceivers[i] as IMessageReceiver;
receiver.OnReceiveMessage(messageType, this, data);
}
}
public void ApplyDamage(DamageMessage data)
{
if (currentHitPoints <= 0)
{
return;
}
if (isInvulnerable)
{
OnHitWhileInvulnerable.Invoke();
return;
}
Vector3 forward = transform.forward;
forward = Quaternion.AngleAxis(hitForwardRotation, transform.up) * forward;
//将受击方向投影到xz平面上
Vector3 positionToDamager = data.damageSource - transform.position;
positionToDamager -= transform.up * Vector3.Dot(transform.up, positionToDamager);
//判断攻击是否在hitAngle范围内
if (Vector3.Angle(positionToDamager, forward) > hitAngle * 0.5f)
{
return;
}
isInvulnerable = true;
currentHitPoints -= data.amount;
if (currentHitPoints <= 0)
{
schedule += OnDeath.Invoke;
}
else
{
OnReceiveDamage.Invoke();
}
var message = currentHitPoints <= 0 ? MessageType.DEAD : MessageType.DAMAGED;
for (var i = 0; i < onDamageMessageReceivers.Count; ++i)
{
var receiver = onDamageMessageReceivers[i] as IMessageReceiver;
receiver.OnReceiveMessage(message, this, data);
}
}
public void TakeDamage(Damager damager, bool ignoreInvincible = false)
{
//ignore damage if already dead. TODO : may have to change that if we want to detect hit on death...
if ((m_Invulnerable && !ignoreInvincible) || m_CurrentHealth <= 0)
{
return;
}
if (m_Invulnerable && !ignoreInvincible)
{
OnHitWhileInvulnerable.Invoke();
return;
}
Vector3 forward = transform.forward;
forward = Quaternion.AngleAxis(hitForwardRotation, transform.up) * forward;
//we project the direction to damager to the plane formed by the direction of damage
Vector3 positionToDamager = damager.transform.position - transform.position;
positionToDamager -= transform.up * Vector3.Dot(transform.up, positionToDamager);
if (Vector3.Angle(forward, positionToDamager) > hitAngle * 0.5f)
{
return;
}
m_Invulnerable = true;
m_CurrentHealth -= damager.damage;
if (m_CurrentHealth <= 0)
{
schedule += OnDeath.Invoke;
}
else
{
OnReceiveDamage.Invoke();
if (invulnerableAfterDamage)
{
EnableInvulnerability();
}
}
}
public void ApplyDamage(DamageInfo info)
{
if (currentHitPoints <= 0)
{
return;
}
if (isInvulnerable)
{
OnHitWhileInvulnerable.Invoke();
return;
}
var forward = transform.forward;
forward = Quaternion.AngleAxis(hitForwardRotation, transform.up) * forward;
Vector3 positionToDamager = info.damageSource - transform.position;
positionToDamager -= transform.up * Vector3.Dot(transform.up, positionToDamager);
if (Vector3.Angle(forward, positionToDamager) > hitAngle * 0.5f)
{
return;
}
isInvulnerable = true;
currentHitPoints -= info.amount;
if (currentHitPoints <= 0)
{
schedule += OnDeath.Invoke;
}
else
{
OnReceiveDamage.Invoke();
}
}
public void ApplyDamage(DamageMessage data)
{
if (currentHitPoints <= 0)
{//ignore damage if already dead. TODO : may have to change that if we want to detect hit on death...
return;
}
if (isInvulnerable)
{
OnHitWhileInvulnerable.Invoke();
return;
}
Vector3 forward = transform.forward;
forward = Quaternion.AngleAxis(hitForwardRotation, transform.up) * forward;
//we project the direction to damager to the plane formed by the direction of damage
Vector3 positionToDamager = data.damageSource - transform.position;
positionToDamager -= transform.up * Vector3.Dot(transform.up, positionToDamager);
if (Vector3.Angle(forward, positionToDamager) > hitAngle * 0.5f)
{
return;
}
isInvulnerable = true;
currentHitPoints -= data.amount;
if (currentHitPoints <= 0)
{
schedule += OnDeath.Invoke; //This avoid race condition when objects kill each other.
if (this.gameObject.layer == 9) //Player
{
if (data.damager.gameObject.name == "BodyDamager")
{
PlayerDeathEvent?.Invoke(ENEMY_TYPE.CHOMPER);
}
else if (data.damager.gameObject.name == "Spit(Clone)")
{
PlayerDeathEvent?.Invoke(ENEMY_TYPE.SPITTER);
}
}
else if (this.gameObject.layer == 23) // Enemy
{
if (gameObject.name == "Chomper")
{
EnemyDeathEvent?.Invoke(gameObject, ENEMY_TYPE.CHOMPER);
}
else if (gameObject.name == "Spitter")
{
EnemyDeathEvent?.Invoke(gameObject, ENEMY_TYPE.SPITTER);
}
}
}
else
{
if (data.damager.gameObject.name == "BodyDamager")
{
PlayerHurtEvent?.Invoke(ENEMY_TYPE.CHOMPER);
}
else if (data.damager.gameObject.name == "Spit(Clone)")
{
PlayerHurtEvent?.Invoke(ENEMY_TYPE.SPITTER);
}
OnReceiveDamage.Invoke();
}
var messageType = currentHitPoints <= 0 ? MessageType.DEAD : MessageType.DAMAGED;
for (var i = 0; i < onDamageMessageReceivers.Count; ++i)
{
var receiver = onDamageMessageReceivers[i] as IMessageReceiver;
receiver.OnReceiveMessage(messageType, this, data);
}
}
