using System;
|
using UnityEngine;
|
|
namespace Core.Health
|
{
|
/// <summary>
|
/// Damageable class for handling health using events
|
/// Could be used on Players or enemies or even destructable world objects
|
/// </summary>
|
[Serializable]
|
public class Damageable
|
{
|
/// <summary>
|
/// The max health of this instance
|
/// </summary>
|
public float maxHealth;
|
|
public float startingHealth;
|
|
/// <summary>
|
/// The alignment of the damager
|
/// </summary>
|
public SerializableIAlignmentProvider alignment;
|
|
// events
|
public event Action reachedMaxHealth;
|
|
// 当前的Entity用于响应各种血量相关的事件。
|
public event Action<HealthChangeInfo> damaged, healed, died, healthChanged;
|
|
|
/// <summary>
|
/// Gets the current health.
|
/// </summary>
|
public float currentHealth { protected set; get; }
|
|
/// <summary>
|
/// 设置无敌状态.
|
/// </summary>
|
public bool bInvincible { get; set; }
|
|
/// <summary>
|
/// Gets the normalised health.
|
/// </summary>
|
public float normalisedHealth
|
{
|
get
|
{
|
if (Math.Abs(maxHealth) <= Mathf.Epsilon)
|
{
|
Debug.LogError("Max Health is 0");
|
maxHealth = 1f;
|
}
|
return currentHealth / maxHealth;
|
}
|
}
|
|
/// <summary>
|
/// Gets the <see cref="IAlignmentProvider"/> of this instance
|
/// </summary>
|
public IAlignmentProvider alignmentProvider
|
{
|
get
|
{
|
return alignment != null ? alignment.GetInterface() : null;
|
}
|
}
|
|
/// <summary>
|
/// Gets whether this instance is dead.
|
/// </summary>
|
public bool isDead
|
{
|
get { return currentHealth < 1.0f; }
|
}
|
|
/// <summary>
|
/// Gets whether this instance is at max health.
|
/// </summary>
|
public bool isAtMaxHealth
|
{
|
get { return Mathf.Approximately(currentHealth, maxHealth); }
|
}
|
|
|
/// <summary>
|
/// Init this instance
|
/// </summary>
|
public virtual void Init()
|
{
|
currentHealth = startingHealth;
|
}
|
|
/// <summary>
|
/// Sets the max health and starting health to the same value
|
/// </summary>
|
public void SetMaxHealth(float health)
|
{
|
if (health <= 0)
|
{
|
return;
|
}
|
maxHealth = startingHealth = health;
|
}
|
|
/// <summary>
|
/// Sets the max health and starting health separately
|
/// </summary>
|
public void SetMaxHealth(float health, float startingHealth)
|
{
|
if (health <= 0)
|
{
|
return;
|
}
|
maxHealth = health;
|
this.startingHealth = startingHealth;
|
}
|
|
/// <summary>
|
/// Sets this instance's health directly.
|
/// </summary>
|
/// <param name="health">
|
/// The value to set <see cref="currentHealth"/> to
|
/// </param>
|
public void SetHealth(float health)
|
{
|
var info = new HealthChangeInfo
|
{
|
damageable = this,
|
newHealth = health,
|
oldHealth = currentHealth
|
};
|
|
currentHealth = health;
|
info.oldHealth = health;
|
|
if (healthChanged != null)
|
{
|
healthChanged(info);
|
}
|
}
|
|
/// <summary>
|
/// Use the alignment to see if taking damage is a valid action
|
/// </summary>
|
/// <param name="damage">
|
/// The damage to take
|
/// </param>
|
/// <param name="damageAlignment">
|
/// The alignment of the other combatant
|
/// </param>
|
/// <param name="output">
|
/// The output data if there is damage taken
|
/// </param>
|
/// <returns>
|
/// <value>true if this instance took damage</value>
|
/// <value>false if this instance was already dead, or the alignment did not allow the damage</value>
|
/// </returns>
|
public bool TakeDamage(float damage, IAlignmentProvider damageAlignment, ref HealthChangeInfo output)
|
{
|
|
/*output = new HealthChangeInfo
|
{
|
damageAlignment = damageAlignment, damageable = this,
|
newHealth = currentHealth, oldHealth = currentHealth
|
};*/
|
output.damageAlignment = damageAlignment;
|
output.damageable = this;
|
output.newHealth = currentHealth;
|
output.oldHealth = currentHealth;
|
|
// 无敌状态下，不可伤害.
|
if (this.bInvincible)
|
return false;
|
|
bool canDamage = damageAlignment == null || alignmentProvider == null ||
|
damageAlignment.CanHarm(alignmentProvider);
|
|
if (isDead || !canDamage)
|
{
|
return false;
|
}
|
|
ChangeHealth(-damage, ref output);
|
SafelyDoAction(damaged, output);
|
if (isDead)
|
{
|
SafelyDoAction(died, output);
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// Logic for increasing the health.
|
/// </summary>
|
/// <param name="health">Health.</param>
|
public HealthChangeInfo IncreaseHealth(float health)
|
{
|
var info = new HealthChangeInfo {damageable = this};
|
ChangeHealth(health, ref info);
|
SafelyDoAction(healed, info);
|
if (isAtMaxHealth)
|
{
|
SafelyDoAction(reachedMaxHealth);
|
}
|
|
return info;
|
}
|
|
/// <summary>
|
/// Changes the health.
|
/// </summary>
|
/// <param name="healthIncrement">Health increment.</param>
|
/// <param name="info">HealthChangeInfo for this change</param>
|
protected void ChangeHealth(float healthIncrement, ref HealthChangeInfo info)
|
{
|
info.oldHealth = currentHealth;
|
currentHealth += healthIncrement;
|
currentHealth = Mathf.Clamp(currentHealth, 0f, maxHealth);
|
info.newHealth = currentHealth;
|
|
if (healthChanged != null)
|
{
|
healthChanged(info);
|
}
|
}
|
|
/// <summary>
|
/// A helper method for null checking actions
|
/// </summary>
|
/// <param name="action">Action to be done</param>
|
protected void SafelyDoAction(Action action)
|
{
|
if (action != null)
|
{
|
action();
|
}
|
}
|
|
/// <summary>
|
/// A helper method for null checking actions
|
/// </summary>
|
/// <param name="action">Action to be done</param>
|
/// <param name="info">The HealthChangeInfo to be passed to the Action</param>
|
protected void SafelyDoAction(Action<HealthChangeInfo> action, HealthChangeInfo info)
|
{
|
if (action != null)
|
{
|
action(info);
|
}
|
}
|
}
|
}
|
