beyond/Assets/Scripts/Skills/HealableBushController.cs

using PixelCrushers;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.UI;

namespace Beyond
{
    public enum BushState
    { Overgrown, Destroyed, Healed }

    [System.Serializable]
    public class BushStateData
    {
        public BushState bushState;

        public BushStateData(BushState bushState)
        {
            this.bushState = bushState;
        }
    }

    [System.Serializable]
    public class BushDataContainer
    {
        public List<BushStateData> bushStateData = new();
    }

    public class HealableBushController : MonoBehaviour
    {
        [SerializeField] private SphereCollider validatorCollider;
        [SerializeField] private SphereCollider healingCollider;
        [SerializeField] private bTriggerGenericAction healingTrigger;
        [SerializeField] public bItemListData items;

        public BushState bushState;
        public GameObject dryBush;

        [SerializeField]
        private TriggerEvent validatorEventReceiver;

        [Header("")]
        [SerializeField] private Skills skillRequiredToHeal;

        [HideInInspector] public bItem itemRequiredToHeal;

        [SerializeField] private GameObject infoTextObject;
        [SerializeField] private Text infoText;
        private float effectDelay = 0.8f;

        public List<PlayableDirector> playableDirectors;

        private void Awake()
        {
            SetBushState(BushState.Overgrown);
        }

        public void SetBushState(BushState state)
        {
            bushState = state;
            if (bushState == BushState.Overgrown)
            {
                dryBush.SetActive(true);
                ResetPlaybableDirector();
            }
            else if (bushState == BushState.Destroyed)
            {
                dryBush.SetActive(false);
                ResetPlaybableDirector();
                ActivateHealingValidator();
            }
            else
            {
                dryBush.SetActive(false);
                playableDirectors.ForEach(director =>
                {
                    director.enabled = true;
                    director.initialTime = director.duration;
                    director.Play();
                });
            }
        }

        private void ResetPlaybableDirector()
        {
            playableDirectors.ForEach(director =>
            {
                director.enabled = true;
                director.initialTime = 0;
                director.time = 0;
                StartCoroutine(StopDirectorCoroutine(director));
            });
        }

        private IEnumerator StopDirectorCoroutine(PlayableDirector director)
        {
            yield return new WaitForEndOfFrame();
            director.enabled = false;
        }

        public void TryToHeal()
        {
            PlayerAttribute faithAttribute = Player.Instance.GetAttribute("Faith");
            bItemAttribute itemFaithCost = itemRequiredToHeal.GetItemAttribute(bItemAttributes.Faith);
            if (itemFaithCost.value > faithAttribute.AttributeCurrentValue)
            {
                var text = $"Not enough Faith";
                bItemCollectionDisplay.Instance.FadeText(text, 4, 0.25f);
                Player.Instance.PlayNoFaithClip();
                healingTrigger.playAnimation = "";
                return;
            }
            bushState = BushState.Healed;
            healingTrigger.playAnimation = "Pick_Up";
            faithAttribute.AttributeCurrentValue -= itemFaithCost.value;
            healingCollider.enabled = false;
            bItemManager itemManager = Player.Instance.ItemManager;
            bItem itemToDestroy = itemManager.GetItem(itemRequiredToHeal.id);
            itemManager.UseItem(itemToDestroy);
            StartCoroutine(HealTreeCoroutine());
        }

        private IEnumerator HealTreeCoroutine()
        {
            yield return new WaitForSeconds(effectDelay);
            infoTextObject.SetActive(false);

            playableDirectors.ForEach(director =>
            {
                director.enabled = true;
                director.Play();
            });
        }

        public void ValidateHealingRequirements()
        {
            ValidateHealingRequirements(gameObject);
        }

        public void ValidateHealingRequirements(GameObject gameObject = null)
        {
            if (bushState == BushState.Healed)
            {
                ResetInteractionButtonImage();
                infoTextObject.SetActive(false);
                validatorCollider.enabled = false;
                healingCollider.enabled = false;
                return;
            }
            infoTextObject.SetActive(true);
            int level = SkillsManager.instance.GetSkillLevelOf(Skills.MasterOfScrolls);
            if (level <= 0)
            {
                infoText.text = "Requires " + SkillsManager.instance.GetStringNameOf(Skills.MasterOfScrolls);
                return;
            }

            bItemManager itemManager = Player.Instance.ItemManager;
            if (itemManager.ContainItem(itemRequiredToHeal.id))
            {
                validatorCollider.enabled = false;
                infoText.text = "Heal bush";
                healingCollider.enabled = true;
            }
            else
            {
                infoText.text = "Requires " + itemRequiredToHeal.name;
            }
        }

        public void ActivateHealingValidator()
        {
            EnableHealingValidatorCollider();
            validatorEventReceiver.onTriggerEnter.RemoveAllListeners();
            validatorEventReceiver.onTriggerExit.RemoveAllListeners();
            validatorEventReceiver.onTriggerEnter.AddListener(ValidateHealingRequirements);
            validatorEventReceiver.onTriggerExit.AddListener(EnableHealingValidatorCollider);
        }

        public void EnableHealingValidatorCollider(GameObject gameObject = null)
        {
            EnableHealingValidatorCollider();
        }

        public void EnableHealingValidatorCollider()
        {
            StartCoroutine(EnableHealingValidatorColliderCoroutine());
        }

        private IEnumerator EnableHealingValidatorColliderCoroutine()
        {
            healingCollider.enabled = false;
            validatorCollider.enabled = false;
            infoTextObject.SetActive(false);
            yield return new WaitForSeconds(0.6f);
            validatorCollider.enabled = true;
            healingCollider.enabled = false;
        }

        public void SetHealingInteractionButtonImage()
        {
            Player.Instance.SetInteractableButtonImage(itemRequiredToHeal.icon);
        }

        public void ResetInteractionButtonImage()
        {
            Player.Instance.ResetIntaractableButtonImage();
        }

        public void RotateHealingColliderForProperAnimation()
        {
            Vector3 heading = healingCollider.transform.position - Player.Instance.transform.position;
            float distance = heading.magnitude;
            Vector3 direction = heading / distance; // This is now the normalized direction.
            healingCollider.transform.forward = direction;
        }

        private void OnDestroy()
        {
            if (validatorEventReceiver)
            {
                validatorEventReceiver.onTriggerEnter.RemoveAllListeners();
                validatorEventReceiver.onTriggerExit.RemoveAllListeners();
            }
        }
    }
}