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>
|
/// 魔法护盾值改变
|
/// </summary>
|
public event Action<HealthChangeInfo> ShieldWallHealthChanged;
|
|
/// <summary>
|
/// Gets the current health.
|
/// </summary>
|
public float currentHealth { protected set; get; }
|
|
/// <summary>
|
/// 设置无敌状态.
|
/// </summary>
|
public bool bInvincible { get; set; }
|
|
/// <summary>
|
/// 是否存在魔法护盾
|
/// </summary>
|
public bool IsExistShieldWall { get; set; }
|
|
/// <summary>
|
/// 0 -> 和agent的生命周期一致，直到死亡， > 0 （单位s）*时间内生效
|
/// </summary>
|
public float ShieldWallEffectiveTime { get; set; }
|
|
/// <summary>
|
/// 魔法护盾生效剩余时间，这个只针对 ShieldWallEffectTime > 0 才生效
|
/// </summary>
|
public float ShieldWallRemainTime { get; set; }
|
|
/// <summary>
|
/// 魔法护盾最大生命值，即初始生命值
|
/// </summary>
|
public float ShieldWallMaxHealth { get; set; }
|
|
/// <summary>
|
/// 魔法护盾当前生命值，当 <= 0时直接移除护盾效果
|
/// </summary>
|
public float ShieldWallCurrentHealth { 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>
|
/// 清理魔法护盾
|
/// </summary>
|
public void ClearShieldWall()
|
{
|
IsExistShieldWall = false;
|
ShieldWallMaxHealth = 0;
|
ShieldWallCurrentHealth = 0;
|
ShieldWallRemainTime = 0;
|
ShieldWallEffectiveTime = 0;
|
}
|
|
/// <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 < 0.00001f; }
|
}
|
|
/// <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>
|
/// 获得一个魔法护盾
|
/// </summary>
|
/// <param name="maxHealth">护盾的最大生命值</param>
|
/// <param name="effectiveTime">生效时间 0 -> 和Agent生命周期一致，> 0 *（单位ms）时间内生效</param>
|
public void AddShieldWall(float maxHealth, float effectiveTime)
|
{
|
// 如果重复获得护盾，直接全部重置数据，移除之前的护盾效果，重新获得一个护盾
|
IsExistShieldWall = true;
|
ShieldWallEffectiveTime = effectiveTime;
|
|
if (effectiveTime > 0)
|
ShieldWallRemainTime = effectiveTime / 1000f;
|
|
ShieldWallMaxHealth = ShieldWallCurrentHealth = maxHealth;
|
|
HealthChangeInfo info = new HealthChangeInfo
|
{
|
damageable = this,
|
ShieldWallMaxHealth = maxHealth,
|
ShieldWallCurrentHealth = maxHealth,
|
IsExistShieldWall = true
|
};
|
|
if (ShieldWallHealthChanged != null)
|
{
|
ShieldWallHealthChanged(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)
|
{
|
bool changeHealth = false;
|
float increment = healthIncrement;
|
|
if (IsExistShieldWall)
|
{
|
info.ShieldWallOldHealth = ShieldWallCurrentHealth;
|
ShieldWallCurrentHealth += healthIncrement;
|
|
if (ShieldWallCurrentHealth == 0)
|
info.IsExistShieldWall = IsExistShieldWall = false;
|
else if (ShieldWallCurrentHealth < 0)
|
{
|
changeHealth = true;
|
info.IsExistShieldWall = IsExistShieldWall = false;
|
// 护盾血量不够减
|
increment = ShieldWallCurrentHealth;
|
info.ShieldWallCurrentHealth = ShieldWallCurrentHealth = 0;
|
}
|
}
|
else
|
changeHealth = true;
|
|
if (changeHealth)
|
{
|
info.oldHealth = currentHealth;
|
currentHealth += increment;
|
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);
|
}
|
}
|
}
|
}
|
