FleshMobProductions/SpringMotion.cs

  public static void CalcDampedSimpleHarmonicMotion (
            ref float value, 
            ref float velocity, 
            float equilibriumPosition, 
            float deltaTime, 
            float angularFrequency, 
            float dampingRatio
        )
        {

            float x = value - equilibriumPosition;
            velocity += (-dampingRatio * velocity) - (angularFrequency * x);
            value += velocity * deltaTime ;
        }

    protected float value;
    protected float velocity;

    public float targetValue; //Set in inspector


  private void Update()
    {
        float deltaTime = Time.deltaTime;
        
        CodeExtensions.SpringMotion.CalcDampedSimpleHarmonicMotion(ref value, 
            ref velocity,
            targetValue,
            deltaTime,
            angularFrequency,
            dampingRatio);
        
        SetValue(value);
    }


 protected override void SetValue(float value)
    {
        text.fontSize = value;
    }

#region ChangeLines
        
        
        [Space(30)] [Header("Change Lines")] 
        [SerializeField]       private    List<Vector3>    lines;
        [Tooltip("Input Delay in Second")]                                      [Range(0,1f)]
        [SerializeField]       private    float            inputDelay            =  0.2f;
        [SerializeField]       private    int              initialLine           =     0;
        [SerializeField]       private    float            lineChangeSpeed       =    3f;
        [SerializeField]       private    float            lineChangeSpeedSmooth =  0.2f;
        [SerializeField]       private    AnimationCurve   lineChangeCurve;
        [SerializeField]       private    AnimationCurve   lineChangeSmoothCurve;
        
        private     float           _inputDelay;
        private     Vector3         _currentTargetedLine;
        public      int             CurrentLineIdx {get; private set;}
        private     bool            _canMoveLR;
        private     Transform       mesh;
        private     bool            _overRideQuaternion;
        private     bool            _isPressingBtn;

        /// <summary>
        /// Jump Initial SetUp on Awake
        /// </summary>
        private void InitChangeLines() 
        { 
          Utilities.QuickSort(0, lines.Count - 1, ref lines, (lhs, rhs) => lhs.x < rhs.x  );
          CurrentLineIdx      =    initialLine;
          _inputDelay         =    inputDelay;
          _canMoveLR          =    true;
          mesh                =    transform.GetChild(0);
          _overRideQuaternion =    false;
        }

        private void ChangeLines () 
        {
            int flag;
            
            #if UNITY_EDITOR
             if (Input.GetKey(KeyCode.LeftArrow)) { flag = -1; }
             else if (Input.GetKey(KeyCode.RightArrow)) { flag = 1; }
             else flag = 0;
            #else
             if (leftBtn.isPressing) { flag = -1; }
             else if (rightBtn.isPressing) { flag = 1; }
             else flag = 0;
            #endif

            _isPressingBtn = flag != 0;
            
            if (flag == 0 || CurrentLineIdx == 0 || CurrentLineIdx == (lines.Count - 1)) Idle();
            MoveX(flag);
            MoveTowardsCurrentLine(flag);
        }

        /// <summary>
        /// -1 left & 1 right
        /// </summary>
        /// <param name="flag"></param>
        public void MoveX (int flag) 
        {
            if (!_canMoveLR) return;
            if (inputDelay >= 0) inputDelay -= Time.deltaTime;
            if (inputDelay > 0 || flag == 0) return;
            inputDelay = _inputDelay;

            if (flag == 1) MoveRight(flag);
            else if (flag == -1) MoveLeft(flag);
        } 
        
        // Helper Functions
        private void MoveLeft(int flag) 
        {
            CurrentLineIdx = Mathf.Clamp((CurrentLineIdx - 1), 0, lines.Count - 1);
            SetCurrentLine(lines[CurrentLineIdx]);
            if (CurrentLineIdx == 0) 
            {
                Idle(); 
            }
            else 
            {
                // mesh.DORotate(new Vector3(0, -45, 0), 0.3f);
                // .OnComplete(() => {
                //     if (flag == 0) mesh.DORotate(new Vector3(0, 0, 0), 1f);
                // });   
            }
        }
        
        private void MoveRight(int flag) 
        {
            CurrentLineIdx = Mathf.Clamp((CurrentLineIdx + 1), 0, lines.Count - 1);
            SetCurrentLine(lines[CurrentLineIdx]);
            if (CurrentLineIdx == (lines.Count - 1)) 
            {
                Idle(); 
            }
            else {
                // mesh.DORotate(new Vector3(0, 45, 0), 0.3f);
                // .OnComplete(() => {
                //     if (flag == 0) mesh.DORotate(new Vector3(0, 0, 0), 1f);
                // });
            }
        }

        private void Idle() 
        {
            if (_overRideQuaternion) return;
            mesh.rotation = Quaternion.Lerp(mesh.rotation, Quaternion.Euler(0,0,0), Time.deltaTime * 8f);
            // mesh.DORotate(new Vector3(0, 0, 0), 1f);
        }
        
        private void SetCurrentLine (Vector3 line) 
        {
            inputDelay = _inputDelay;
            OnLineChange?.Invoke(lines, CurrentLineIdx);
            _currentTargetedLine = line;
        }
        
        private void MoveTowardsCurrentLine (int moveFlag) 
        {
            var targetPos = Utilities.VectorX(transform, _currentTargetedLine.x);
            if (!_isPressingBtn) 
            { 
                transform.position = Vector3.Lerp(transform.position, targetPos, lineChangeCurve
                    .Evaluate(Time.deltaTime * lineChangeSpeed));     
            }
            else 
            {
                transform.position = Vector3.Lerp(transform.position, targetPos,
                    lineChangeSmoothCurve.Evaluate(Time.smoothDeltaTime * lineChangeSpeedSmooth));
                // transform.position = Vector3.MoveTowards (transform.position, targetPos, lineChangeSpeedSmooth * Time.deltaTime);
            }
        }

        #endregion

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using Randoms.Motions.Spring;
using UnityEngine.Events;
using UnityEngine.UI;

public class BtnController : MonoBehaviour, IPointerDownHandler, IPointerUpHandler
{
    [HideInInspector] public bool isPressing;
    
    [SerializeField] private Vector2Spring spring;
    [SerializeField]   Vector2  targetValue;
    [SerializeField] private RectTransform obj;
    [SerializeField] private float getDowndelay = 1f;
    
    bool isInitized = true;
    internal Vector2 _targetValue;
    internal Vector2 initialValue;
    
    internal float delay = 1f;

    public UnityEvent onClick;  
    void Start ()
    {
        initialValue = obj.localScale;
        _targetValue = targetValue;
        spring.GetSpringValues (targetValue, Time.deltaTime);
    }
    
    void SetValue (Vector2 value)
    {
        obj.localScale = value;
    }
    
    public bool wasPressed = false;

    void Update ()
    {
        _targetValue = isPressing ? targetValue : initialValue;
        
        Vector2 springValue = spring.GetSpringValues (_targetValue, Time.deltaTime);

        if (isPressing)
        {
            wasPressed = true;
        }
        else 
        {
            // calculate delay
            if (wasPressed && springValue == initialValue)
            {
                wasPressed = false;
                onClick?.Invoke ();
                // getDowndelay -= Time.deltaTime;
                // if (getDowndelay < 0)
                // {
                //     onClick?.Invoke ();
                //     wasPressed = false;
                // }
            }
        }


        if (delay > 0)
        {
            delay -= Time.deltaTime;
        } 
        else
        {
            SetValue (springValue);
        }
        
    }
    
    public void OnPointerDown (PointerEventData eventData)
    {
       isPressing = true;
    }

    public void OnPointerUp (PointerEventData eventData)
    {
       isPressing = false;
    }
}