Net.Like.Xue.Tokyo/Packages-Local/Com.Project.B.Unity/Survival/UnitySurvivalService.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using BITKit;
using BITKit.Entities;
using Cysharp.Threading.Tasks;
using Net.Project.B.Buff;
using Net.Project.B.Damage;
using Net.Project.B.Health;
using Net.Project.B.Inventory;
using Project.B.Item;
using UnityEngine;

namespace Net.Project.B.Survival
{
    public class UnitySurvivalService:IDisposable
    {
        private readonly IDamageService _damageService;
        private readonly IHealthService _healthService;
        private readonly IEntitiesService _entitiesService;
        private readonly ITicker _ticker;
        private readonly IntervalUpdate _intervalUpdate=new(1);

        private readonly Dictionary<int, ScriptableItem> _items;

        public UnitySurvivalService(ITicker ticker, IEntitiesService entitiesService, IDamageService damageService, IHealthService healthService)
        {
            _ticker = ticker;
            _entitiesService = entitiesService;
            _damageService = damageService;
            _healthService = healthService;

            _ticker.Add(OnTick);

            _entitiesService.OnAdd += OnAdd;

            _items = _entitiesService.QueryComponents<ScriptableItem>().ToArray().ToDictionary(x => x.Id, x => x);
        }

        private void OnAdd(IEntity obj)
        {
            if(obj.ServiceProvider.QueryComponents(out IPlayerInventory playerInventory) is false)return;

            playerInventory.ConsumeFactory += ConsumeFactory;
            
            playerInventory.OnConsumedItem += OnConsumedItem;
            
            return;
             void OnConsumedItem(IRuntimeItem item)
            {
                if(obj.ServiceProvider.QueryComponents(out IBuffComponent buffComponent) is false)return;
                if(_items.TryGetValue(item.ScriptableId,out var scriptableItem) is false)return;
                var buffs = buffComponent.Buffs.Span;
                foreach (var property in scriptableItem.Properties.Values)
                {
                    switch (property)
                    {
                        case AddHp addHp:
                        {
                            _healthService.AddHealth(obj.Id, addHp.value,this);
                        }
                            /*
                            for (var i = 0; i < buffs.Length; i++)
                            {
                                ref var buff = ref buffs[i];
                                if (buff is Buff.AddHp addHp)
                                {
                                    buff.Value += addHp.Value;
                                }
                            }*/
                            break;
                        case AddHunger hunger:
                            for (var i = 0; i < buffs.Length; i++)
                            {
                                ref var buff = ref buffs[i];
                                if (buff is Hunger)
                                {
                                    buff.Value += hunger.value;
                                }
                            }
                            break;
                        case AddThirsty thirsty:
                            for (var i = 0; i < buffs.Length; i++)
                            {
                                ref var buff = ref buffs[i];
                                if (buff is Thirsty)
                                {
                                    buff.Value += thirsty.value;
                                }
                            }
                            break;
                    }
                }
            }
        }
        private bool ConsumeFactory(IRuntimeItem obj)
        {
            if (_items.TryGetValue(obj.ScriptableId, out var scriptableItem) is false) return false;
            foreach (var scriptableItemProperty in scriptableItem.Properties.Values)
            {
                switch (scriptableItemProperty)
                {
                    case AddHp:
                        case AddHunger:
                            case AddThirsty:
                                return true;
                }
            }
            return false;
        }
        private void OnTick(float obj)
        {
            if(_intervalUpdate.AllowUpdate is false)return;
            foreach (var (entity,buffComponent,healthComponent) in  _entitiesService.QueryComponents<IEntity,IBuffComponent,IHealthComponent>()   )
            {
                foreach (var buff in buffComponent.Buffs.Span)
                {
                    if (buff.Value <= 0)
                    {
                        switch (buff)
                        {
                            case Hunger:
                                Damage();
                                break;
                                case Thirsty:
                                Damage();
                                break;
                        }
                    }
                    continue;

                    void Damage()
                    {
                        _damageService.CreateDamageAsync(entity.Id, entity.Id, 1, null,default).Forget();
                    }
                }
            }
        }

        public void Dispose()
        {
            _ticker.Remove(OnTick);
        }
    }

}