gardens-of-nil-3d-u6/Assets/Scripts/Intrepid/Gameplay/Entities/Player/Sentinel/Cadence/CadenceProfile.cs

using Intrepid.Utilities;
using Sirenix.OdinInspector;
using UnityEngine;

namespace Intrepid.Gameplay.Entities.Player.Sentinel.Cadence
{
    [CreateAssetMenu(fileName = "Cadence Profile", menuName = "GON/Services/Cadence/Cadence Profile")]
    public sealed class CadenceProfile : ScriptableObject
    {
        [SerializeField, Min(1f)] private float totalTimeMS = 370f;
        
        [GroupConfigurations("Normalized Band End Points"), SerializeField, Range(0f, 1f)] private float strainedEndP = 0.25f;
        [GroupConfigurations("Normalized Band End Points"), SerializeField, Range(0f, 1f)] private float alignedEndP = 0.65f;
        [GroupConfigurations("Normalized Band End Points"), SerializeField, Range(0f, 1f)] private float resonantEndP = 1f;

        [GroupConfigurations("Settlement"), SerializeField, Range(0f, 1f)] private float strainedSettlement = 1f;
        [GroupConfigurations("Settlement"), SerializeField, Range(0f, 1f)] private float alignedSettlement = 0.5f;
        [GroupConfigurations("Settlement"), SerializeField, Range(0f, 1f)] private float resonantSettlement;
        [GroupConfigurations("Settlement"), SerializeField, Range(0f, 1f)] private float lateSettlement = 1f;

        [GroupConfigurations("Core Stability"), SerializeField, Range(0, 100)] private float maxCoreCost = 8f;
        [GroupConfigurations("Core Stability"), SerializeField, Range(0, 100)] private float resonantRecovery = 8f;

        public float TotalTimeMS => totalTimeMS;

        public float TotalTime => TotalTimeMS * 0.001f;

        public float StrainedEndP => strainedEndP;
        public float AlignedEndP => alignedEndP;
        public float ResonantEndP => resonantEndP;

        // public float StrainedEndTime => TotalTime * strainedEndP;
        // public float AlignedEndTime => TotalTime * alignedEndP;
        // public float ResonantEndTime => TotalTime * resonantEndP;
        //
        // public float StrainedEndMS => totalTimeMS * strainedEndP;
        // public float AlignedEndMS => totalTimeMS * alignedEndP;
        // public float ResonantEndMS => totalTimeMS * resonantEndP;

        public float StrainedSettlement => strainedSettlement;
        public float AlignedSettlement => alignedSettlement;
        public float ResonantSettlement => resonantSettlement;
        public float LateSettlement => lateSettlement;

        public float MaxCoreCost => maxCoreCost;
        public float ResonantRecovery => resonantRecovery;

        private void OnValidate()
        {
            Validate();
        }

        [GroupDebug, Button(ButtonSizes.Medium)]
        private void Validate()
        {
            totalTimeMS = Mathf.Max(1f, totalTimeMS);

            strainedEndP = Mathf.Clamp01(strainedEndP);
            alignedEndP = Mathf.Clamp01(alignedEndP);
            resonantEndP = Mathf.Clamp01(resonantEndP);

            if (alignedEndP < strainedEndP)
            {
                alignedEndP = strainedEndP;
            }

            if (resonantEndP < alignedEndP)
            {
                resonantEndP = alignedEndP;
            }

            strainedSettlement = Mathf.Clamp01(strainedSettlement);
            alignedSettlement = Mathf.Clamp01(alignedSettlement);
            resonantSettlement = Mathf.Clamp01(resonantSettlement);
            lateSettlement = Mathf.Clamp01(lateSettlement);

            maxCoreCost = Mathf.Max(0f, maxCoreCost);
            resonantRecovery = Mathf.Max(0f, resonantRecovery);
        }

        public CadenceEvaluation Evaluate(float elapsedTime)
        {
            if (TotalTime <= 0f)
            {
                return CadenceEvaluation.None;
            }

            var t = Mathf.Clamp01(elapsedTime / TotalTime);

            if (t < StrainedEndP)
            {
                return new CadenceEvaluation(
                    t,
                    elapsedTime,
                    CadenceBand.Strained,
                    StrainedSettlement,
                    0f
                );
            }

            if (t < AlignedEndP)
            {
                return new CadenceEvaluation(
                    t,
                    elapsedTime,
                    CadenceBand.Aligned,
                    AlignedSettlement,
                    0f
                );
            }

            if (t < ResonantEndP)
            {
                return new CadenceEvaluation(
                    t,
                    elapsedTime,
                    CadenceBand.Resonant,
                    ResonantSettlement,
                    ResonantRecovery
                );
            }

            return new CadenceEvaluation(
                t,
                elapsedTime,
                CadenceBand.Late,
                LateSettlement,
                0f
            );
        }
    }
}