CapersProject/Assets/02.Scripts/BlueWater/Prop/Tycoon/Barrel.cs

using System;
using DDD.Items;
using DDD.Players;
using UnityEngine;

namespace DDD.Tycoons
{
    public abstract class Barrel : InteractionFurniture
    {
        [SerializeField]
        protected SpineController SpineController;
        
        [SerializeField]
        private string Idx;

        [SerializeField]
        protected LiquidData LiquidData;

        [SerializeField]
        protected int MaxFill = 3000;

        [field: SerializeField]
        public int CurrentAmount { get; private set; }
        
        [field: SerializeField]
        public bool IsStatue { get; private set; }

        [field: SerializeField]
        public bool IsActivated { get; private set; }
        
        [field: SerializeField]
        public bool IsAutoSupply { get; private set; }
        
        protected float SupplyElapsedTime;
        
        public static Action<Barrel> OnBarrelInteracted;
        public static Action OnBarrelCancelInteracted;

        protected override void Awake()
        {
            base.Awake();
            
            SpineController = GetComponent<SpineController>();
            //LiquidData = ItemManager.Instance.LiquidDataSo.GetDataByIdx(Idx);

            if (!IsStatue)
            {
                EventManager.OnAddBarrels += AddCurrentAmount;
            }
            EventManager.OnAutoSupplyBarrels += AutoSupply;
        }

        protected override void Start()
        {
            base.Start();

            SetCurrentAmount(0);
        }

        protected override void OnDestroy()
        {
            if (!IsStatue)
            {
                EventManager.OnAddBarrels -= AddCurrentAmount;
            }
            EventManager.OnAutoSupplyBarrels -= AutoSupply;
        }

        public abstract override void Interaction();
        public abstract bool CanMakingCocktailCrew(int amount);
        public abstract bool CanMold();
        public abstract void Mold();

        public bool CanConsume(int amount)
        {
            return CurrentAmount > 0 && CurrentAmount - amount >= 0;
        }

        public virtual void Consume(int amount)
        {
            if (CurrentAmount == int.MaxValue)
            {
                return;
            }

            var consumeAmount = CurrentAmount - amount;
            SetCurrentAmount(consumeAmount);
        }

        public bool TryConsume(int amount)
        {
            if (!CanConsume(amount)) return false;

            Consume(amount);
            return true;
        }

        public LiquidData GetLiquidData() => LiquidData;

        public virtual void SetCurrentAmount(int amount)
        {
            if (IsStatue)
            {
                if (CurrentAmount == int.MaxValue) return;
                
                CurrentAmount = int.MaxValue;
                return;
            }
            
            CurrentAmount = Mathf.Clamp(amount, 0, MaxFill);
            
            if (!ES3.Load(SaveData.TutorialH, false) && IsActivated && CurrentAmount == 0)
            {
                EventManager.InvokeTutorial(TutorialName.TutorialH);
                ES3.Save(SaveData.TutorialH, true);
            }
        }

        public virtual void Activate()
        {
            IsActivated = true;
            SetCurrentAmount(LiquidData.GetMaxAmount());
        }

        public void AutoSupply()
        {
            IsAutoSupply = true;
        }

        public virtual void AddCurrentAmount(int addedValue)
        {
            if (!IsActivated) return;

            SetCurrentAmount(CurrentAmount + addedValue);
        }
    }
}