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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Remoting.Contexts;
using UnityEngine;
using UnityEngine.Events;
namespace BITKit.Entities
{
    public interface IHealthCallback
    {
        void OnSetAlive(bool alive);
        void OnSetHP(int hp);
    }
    [Serializable]
    public class UnityEventHealthCallback : IHealthCallback
    {
        [SerializeField] private UnityEvent<int> onSetHP;
        [SerializeField] private UnityEvent onSetAlive;
        [SerializeField] private UnityEvent onSetDead;
        public void OnSetAlive(bool alive)
        {
            if (alive)
            {
                onSetAlive.Invoke();
            }
            else
            {
                onSetDead.Invoke();
            }
        }

        public void OnSetHP(int hp)
        {
            onSetHP.Invoke(hp);
        }
    }

    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> OnDamage;  
        int HealthPoint { get; set; }
        int MaxHealthPoint { get; set; }
        bool IsAlive { get; }
    }
    [CustomType(typeof(IHealth))]
    public class EntityHealth : EntityComponent, IHealth
    {
        [Header(Constant.Header.Settings)]
        [SerializeField] private int healthPoint = 100;
        [SerializeField] private int maxHealthPoint = 100;

        [Header(Constant.Header.Providers)] [SerializeField, SerializeReference, SubclassSelector]
        [Obsolete]
        private IHealthCallback[] additiveCallback;

        public event Action<int> OnSetHealthPoint;
        public event Action<bool> OnSetAlive;
        public event Func<DamageMessage,int, int> OnDamage;

        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()
        {
            entity.AddListener<DamageMessage>(OnGetDamage);
        }

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

        private void OnHealthPointChangedInternal(int old, int newHP)
        {
            healthPoint = newHP;
            var _isAlive = newHP >= 0;
            if (_isAlive != IsAlive)
            {
                OnSetAliveInternal(IsAlive = _isAlive);
            }
            foreach (var x in entity.GetCallbacks<IHealthCallback>())
            {
                x.OnSetHP(newHP);
            }

            OnSetHealthPoint?.Invoke(newHP);
        }

        private void OnSetAliveInternal(bool alive)
        {
            IsAlive = alive;
            foreach (var x in entity.GetCallbacks<IHealthCallback>())
            {
                x.OnSetAlive(alive);
            }
            // foreach (var x in additiveCallback)
            // {
            //     x.OnSetAlive(alive);
            // }
            OnSetAlive?.Invoke(alive);
        }

        private void AddHP(int hp)
        {
            OnHealthPointChangedInternal(healthPoint, healthPoint += hp);
        }

        private void OnGetDamage(DamageMessage damageMessage)
        {
            if (damageMessage.target != entity) return;
            var damage = damageMessage.damage;
            foreach (var x in OnDamage.CastAsFunc())
            {
                damage = x.Invoke(damageMessage,damage);
            }
            AddHP(-damage);
        }
#if UNITY_EDITOR
        [BIT]
        public void SetAlive()
        {
            BITAppForUnity.ThrowIfNotPlaying();
            OnHealthPointChangedInternal(-1, 100);
        }

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

    }
}