BITKit/Src/Unity/Scripts/Entity/Components/Health/EntityHealth.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Remoting.Contexts;
using UnityEngine;
using UnityEngine.Events;
namespace BITKit.Entities
{
    public interface IHealth
    {
        /// <summary>
        /// 当设置HP时的回调
        /// </summary>
        public event Action<int> OnSetHealthPoint;
        /// <summary>
        /// 当设置生存状态时的回调
        /// </summary>
        public event Action<bool> OnSetAlive;
        /// <summary>
        /// 当受到伤害时的回调
        /// </summary>
        public event Func<DamageMessage,int,int> OnDamageFactory;
        /// <summary>
        /// 收到伤害时的回调
        /// </summary>
        public event Action<DamageMessage> OnDamageRelease;
        /// <summary>
        /// 当伤害被阻止时的回调
        /// </summary>
        public event Action<DamageMessage> OnDamageVoid; 
        
        int HealthPoint { get; set; }
        int MaxHealthPoint { get; set; }
        bool IsAlive { get; }
    }
    [CustomType(typeof(IHealth))]
    public class EntityHealth : EntityBehavior, IHealth,IEntityBinaryComponent
    {
        [Header(Constant.Header.Settings)]
        [SerializeField] private int healthPoint = 100;
        [SerializeField] private int maxHealthPoint = 100;

        public int Id { get; } = 84946486;
        
        public event Action<int> OnSetHealthPoint;
        public event Action<bool> OnSetAlive;
        public event Func<DamageMessage,int, int> OnDamageFactory;
        public event Action<DamageMessage> OnDamageRelease;
        public event Action<DamageMessage> OnDamageVoid;

        public int HealthPoint
        {
            get => healthPoint;
            set => OnHealthPointChangedInternal(healthPoint, value);
        }
        public int MaxHealthPoint
        {
            get => maxHealthPoint;
            set => maxHealthPoint = value;
        }
        public bool IsAlive { get; private set; }
        public override void OnAwake()
        {
            UnityEntity.AddListener<DamageMessage>(OnGetDamage);
        }

        public override void OnStart()
        {
            IsAlive = healthPoint >= 0;
            OnSetAliveInternal(IsAlive);
            OnHealthPointChangedInternal(0, healthPoint);
        }

        private void OnHealthPointChangedInternal(int old, int newHP)
        {
            healthPoint =Mathf.Clamp(newHP,-1,maxHealthPoint) ;
            var _isAlive = newHP >= 0;
            if (_isAlive != IsAlive)
            {
                OnSetAliveInternal(IsAlive = _isAlive);
            }
            OnSetHealthPoint?.Invoke(newHP);
        }

        private void OnSetAliveInternal(bool alive)
        {
            IsAlive = alive;
            OnSetAlive?.Invoke(alive);
        }

        private void OnGetDamage(DamageMessage damageMessage)
        {
            if (damageMessage.Target != UnityEntity) return;
            if (IsAlive is false)
            {
                OnDamageVoid?.Invoke(damageMessage);
            }
            else
            {
                var damage = damageMessage.Damage;
                foreach (var x in OnDamageFactory.CastAsFunc())
                {
                    damage = x.Invoke(damageMessage, damage);
                    if (damage <= 0)
                    {
                        OnDamageVoid?.Invoke(damageMessage);
                        break;
                    }
                }

                damageMessage.Damage = damage;
                if (Data.Get<bool>("god") is false)
                {
                    healthPoint-=damage;
                }
                
                IsAlive = healthPoint >= 0;
                
                OnSetHealthPoint?.Invoke(healthPoint);
                
                OnDamageRelease?.Invoke(damageMessage);
                
                if (!IsAlive)
                {
                    OnSetAliveInternal(false);
                }
            }
        }
#if UNITY_EDITOR
        [BIT]
        public void SetAlive()
        {
            BITAppForUnity.ThrowIfNotPlaying();
            OnHealthPointChangedInternal(-1, 100);
        }

        [BIT]
        public void SetDead()
        {
            BITAppForUnity.ThrowIfNotPlaying();
            OnHealthPointChangedInternal(100, -1);
        }
#endif
      
        public void Serialize(BinaryWriter writer)
        {
            writer.Write(HealthPoint);
        }

        public void Deserialize(BinaryReader reader)
        {
            var newHealthPoint = reader.ReadInt32();
            if (HealthPoint != newHealthPoint)
                HealthPoint = newHealthPoint;
        }
    }
}