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 TakeDamage(float amount)
{
if (amount < 0)
{
throw new System.Exception("You can't deal a negative damage value to the character health");
}
if (OnReceiveDamage != null)
{
OnReceiveDamage.Invoke(amount);
}
_health -= amount;
_health = Mathf.Clamp(_health, 0, maxHealth);
if (OnHealthChange != null)
{
OnHealthChange.Invoke(_health);
}
if (_health == 0 && OnDie != null)
{
OnDie.Invoke();
}
}
// Token: 0x0600191F RID: 6431 RVA: 0x0007E7E0 File Offset: 0x0007C9E0
public void OnStomped()
{
OnReceiveDamage onReceiveDamage = (OnReceiveDamage)this.Controller.StateMachine.CurrentTrigger;
this.PlatformMovement.WorldSpeed = onReceiveDamage.Damage.Force * 8f;
if (this.PlatformMovement.IsOnGround && this.PlatformMovement.LocalSpeedY < 0f)
{
this.PlatformMovement.LocalSpeedY *= -0.5f;
}
this.m_thrownDirection = onReceiveDamage.Damage.Force.normalized;
base.FaceLeft = (this.PlatformMovement.LocalSpeedX < 0f);
}
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);
}
}
void Update()
{
m_currentHitPoints = (int)(dstManager.GetComponentData<AttributeValues>(this.attributeEntity).CurrentValue.Health);
if (isInvulnerable)
{
m_timeSinceLastHit += Time.deltaTime;
if (m_timeSinceLastHit > invulnerabiltyTime)
{
m_timeSinceLastHit = 0.0f;
isInvulnerable = false;
OnBecomeVulnerable.Invoke();
}
}
// This logic is to delay the processing of hp checks by a frame, since the
// attribute update logic runs after one frame
if (wasDamaged)
{
wasDamaged = false;
for (var j = 0; j < damageMessagesToAction.Count; j++)
{
var data = damageMessagesToAction[j];
if (currentHitPoints <= 0)
schedule += OnDeath.Invoke; //This avoid race condition when objects kill each other.
else
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);
}
}
damageMessagesToAction.Clear();
}
if (damageMessagesToAction.Count > 0)
{
wasDamaged = true;
}
}
public void ApplyDamage(DamageMessage data)
{
if (currentHitPoints <= 0)
{
return;
}
currentHitPoints -= data.amount;
if (currentHitPoints <= 0)
{
OnDeath.Invoke();
}
else
{
OnReceiveDamage.Invoke();
}
}
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(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;
}
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;
}
currentHitPoints -= data.amount;
if (currentHitPoints <= 0)
{
//schedule += OnDeath.Invoke; //This avoid race condition when objects kill each other.
// OnDeath can only be called once
Debug.Log(string.Format("{0} die", gameObject.name));
}
else
{
OnReceiveDamage.Invoke();
}
var messageType = currentHitPoints <= 0 ? MsgType.DEAD : MsgType.DAMAGED;
for (var i = 0; i < onDamageMessageReceivers.Count; ++i)
{
var receiver = onDamageMessageReceivers[i] as IMessageReceiver;
receiver.OnReceiveMessage(messageType, this, data);
}
}
protected override void Damaged(int dam)
{
int d = dam;
if (dam > ShieldCurrent)
{
dam = dam - ShieldCurrent;
ShieldCurrent = 0;
}
else
{
ShieldCurrent -= dam;
dam = 0;
}
CurrentHeath -= dam;
if (PlayerCurrent == this && d != 0)
{
OnReceiveDamage?.Invoke();
}
lastTimeReceivedamage = Time.time;
}
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);
}
}
// Token: 0x0600191D RID: 6429 RVA: 0x0007E6F4 File Offset: 0x0007C8F4
public bool ShouldStomped()
{
OnReceiveDamage onReceiveDamage = (OnReceiveDamage)this.Controller.StateMachine.CurrentTrigger;
return(onReceiveDamage.Damage.Type == DamageType.StompBlast);
}
// Token: 0x0600191C RID: 6428 RVA: 0x00079B78 File Offset: 0x00077D78
public bool ShouldThrow()
{
OnReceiveDamage onReceiveDamage = (OnReceiveDamage)this.Controller.StateMachine.CurrentTrigger;
return(onReceiveDamage.Damage.Type == DamageType.Bash);
}
public void TakeHit(Damager damager)
{
//for hit angle and stuff
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;
}
//check invulnerability
if (m_Invulnerable)
{
return;
}
//damage
currentHealth -= damager.damage;
if (currentHealth > 0)
{
actor.Damaged(damager);
OnReceiveDamage.Invoke();
//status
if (damager.appliedStatus > 0)
{
actor.ApplyStatus(damager.appliedStatus, damager.statusDuration);
}
//physical impact
knockOutBuildUp += damager.hitPower;
if (knockOutLimit > 0 && knockOutThreshold > 0 && knockOutBuildUp >= knockOutLimit && damager.hitPower >= knockOutThreshold)
{
knockOutBuildUp = 0;
actor.ApplyImpact(damager, "KnockOut");
}
else if (knockBackThreshold > 0 && damager.hitPower >= knockBackThreshold)
{
actor.ApplyImpact(damager, "KnockBack");
}
else if (flinchThreshold > 0 && damager.hitPower >= flinchThreshold)
{
actor.ApplyImpact(damager, "Flinch");
}
if (invulnerableAfterDamage)
{
StartCoroutine(AfterHitInvulnerability(invulnerabilityDuration));
}
}
else
{
schedule += OnDeath.Invoke;
}
}