Added GTWeen

GTweensGodot/GTweens/Source/Tweens/GTween.cs

@@ -0,0 +1,423 @@
+using System;
+using GTweens.Easings;
+using GTweens.Enums;
+using GTweens.TweenBehaviours;
+
+namespace GTweens.Tweens
+{
+    /// <summary>
+    /// Represents the core item for building tweening animations.
+    /// </summary>
+    public sealed class GTween 
+    {
+        public event Action? OnStartAction;
+        public event Action? OnTickAction;
+        public event Action? OnLoopAction;
+        public event Action? OnResetAction;
+        public event Action? OnCompleteAction;
+        public event Action? OnKillAction;
+        public event Action? OnCompleteOrKillAction;
+        public event Action<float>? OnTimeScaleChangedAction;
+        
+        public ITweenBehaviour Behaviour { get; }
+        public float TimeScale { get; private set; } = 1;
+        
+        public float Delay { get; private set; } 
+
+        public int Loops { get; private set; }
+        public ResetMode LoopResetMode { get; private set; }
+
+        public bool IsNested { get; set; }
+
+        public bool IsPlaying { get; private set; }
+        public bool IsPaused { get; private set; }
+        public bool IsCompleted { get; private set; }
+        public bool IsKilled { get; private set; }
+        public bool IsCompletedOrKilled => IsCompleted || IsKilled;
+
+        public bool IsAlive { get; set; }
+
+        float _delayRemaining;
+        int _loopsRemaining;
+
+        public GTween(ITweenBehaviour behaviour)
+        {
+            Behaviour = behaviour;
+        }
+
+        /// <summary>
+        /// Starts the tween.
+        /// </summary>
+        /// <param name="isCompletingInstantly">Determines if the tween should complete instantly.</param>
+        public void Start(bool isCompletingInstantly = false)
+        {
+            if (IsPlaying)
+            {
+                Kill();
+            }
+
+            IsPlaying = true;
+            IsCompleted = false;
+            IsKilled = false;
+
+            _delayRemaining = Delay;
+            _loopsRemaining = Loops;
+
+            Behaviour.Start(isCompletingInstantly);
+   
+            OnStartAction?.Invoke();
+        }
+        
+        /// <summary>
+        /// Advances the tween by a given delta time.
+        /// </summary>
+        /// <param name="deltaTime">The elapsed time since the last update.</param>
+        public void Tick(float deltaTime)
+        {
+            if (!IsPlaying)
+            {
+                return;
+            }
+
+            if (IsPaused)
+            {
+                return;
+            }
+
+            float deltaTimeWithTimeScale = TimeScale * deltaTime;
+
+            if (_delayRemaining > 0f)
+            {
+                _delayRemaining -= deltaTime;
+                return;
+            }
+            
+            Behaviour.Tick(deltaTimeWithTimeScale);
+            
+            OnTickAction?.Invoke();
+
+            bool isFinished = Behaviour.GetFinished();
+
+            if (!isFinished)
+            {
+                return;
+            }
+            
+            bool needsToLoop = _loopsRemaining > 0 && Behaviour.GetLoopable();
+
+            if(needsToLoop)
+            {
+                Loop(LoopResetMode);
+            }
+            else
+            {
+                MarkFinished();
+            }
+        }
+
+        /// <summary>
+        /// Sets if the tween can continue updating or not. Has effect even if the tween has not startet playing.
+        /// If you start a paused tween, it will not update until it's unpaused.
+        /// </summary>
+        public GTween SetPaused(bool paused)
+        {
+            IsPaused = paused;
+            return this;
+        }
+
+        /// <summary>
+        /// Instantly reaches the final state of the tween, and stops playing.
+        /// </summary>
+        public void Complete()
+        {
+            if (!IsPlaying && !IsCompleted)
+            {
+                Start(true);
+            }
+
+            Behaviour.Complete();
+
+            _loopsRemaining = 0;
+
+            MarkFinished();
+        }
+
+        /// <summary>
+        /// Kills the tween. This means that the tween will stop playing, leaving it at its current state.
+        /// </summary>
+        public void Kill()
+        {
+            if (!IsPlaying)
+            {
+                return;
+            }
+
+            IsPlaying = false;
+            IsCompleted = false;
+            IsKilled = true;
+
+            Behaviour.Kill();
+
+            OnKillAction?.Invoke();
+            OnCompleteOrKillAction?.Invoke();
+        }
+
+        /// <summary>
+        /// Resets the tween, optionally killing it and specifying the reset mode.
+        /// </summary>
+        /// <param name="kill">Whether to kill the tween.</param>
+        /// <param name="resetMode">The reset mode to use.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween Reset(bool kill, ResetMode resetMode = ResetMode.InitialValues)
+        {
+            if (kill)
+            {
+                Kill();
+                IsPlaying = false;
+            }
+
+            IsCompleted = false;
+            IsKilled = false;
+
+            _delayRemaining = Delay;
+
+            Behaviour.Reset(kill, resetMode);
+
+            OnResetAction?.Invoke();
+
+            return this;
+        }
+
+        /// <summary>
+        /// Simulates the progress of a GTween animation for a specified duration.
+        /// </summary>
+        /// <param name="time">The simulated time in seconds.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween Simulate(float time)
+        {
+            if (!IsPlaying)
+            {
+                Start();
+            }
+
+            bool loops = Loops > 0;
+
+            float simulationTime = loops ? 
+                time % Behaviour.GetDuration() : 
+                Math.Min(time, Behaviour.GetDuration());
+            
+            float progress = Behaviour.GetElapsed();
+
+            while (simulationTime > 0)
+            {
+                Tick(simulationTime);
+
+                float newProgress = Behaviour.GetElapsed();
+                float tickElapsed = newProgress - progress;
+                progress = newProgress;
+
+                simulationTime -= tickElapsed;
+            }
+            
+            return this;
+        }
+        
+        /// <summary>
+        /// Adds some delay (in seconds) at the begining of the tween.
+        /// </summary>
+        public GTween SetDelay(float delaySeconds)
+        {
+            Delay = delaySeconds;
+            return this;
+        }
+        
+        /// <summary>
+        /// Sets the time scale for the tween, affecting its speed.
+        /// By default time scale is 1.0f. If you decrease this number, the tween
+        /// will update slower. If you increase it, the tween will update faster.
+        /// </summary>
+        /// <param name="timeScale">The time scale to set.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween SetTimeScale(float timeScale)
+        {
+            TimeScale = timeScale;
+            OnTimeScaleChangedAction?.Invoke(timeScale);
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the easing function for the tween.
+        /// </summary>
+        /// <param name="easingFunction">The custom easing function to use.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween SetEasing(EasingDelegate easingFunction)
+        {
+            Behaviour.SetEasing(easingFunction);
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the predefined easing function for the tween.
+        /// </summary>
+        /// <param name="easing">The predefined easing to use.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween SetEasing(Easing easing)
+        {
+            return SetEasing(PresetEasingDelegateFactory.GetEaseDelegate(easing));
+        }
+
+        /// <summary>
+        /// Sets the number of loops and the reset mode for the tween.
+        /// </summary>
+        /// <param name="loops">The number of loops.</param>
+        /// <param name="resetMode">The reset mode to use when looping.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween SetLoops(int loops, ResetMode resetMode = ResetMode.InitialValues)
+        {
+            Loops = Math.Max(loops, 0);
+            LoopResetMode = resetMode;
+            return this;
+        }
+        
+        /// <summary>
+        /// Sets the tween to have and almost infinite amount of loops with the specified reset mode.
+        /// </summary>
+        /// <param name="resetMode">The reset mode to use when looping.</param>
+        /// <returns>The current GTween instance for method chaining.</returns>
+        public GTween SetMaxLoops(ResetMode resetMode = ResetMode.InitialValues)
+        {
+            return SetLoops(int.MaxValue, resetMode);
+        }
+        
+        /// <summary>
+        /// Calculates the total duration of the tween.
+        /// </summary>
+        public float GetDuration()
+        {
+            return Behaviour.GetDuration();
+        }
+
+        /// <summary>
+        /// Calculates the time elapsed since the tween started playing.
+        /// </summary>
+        public float GetElapsed()
+        {
+            if(!IsPlaying && !IsCompleted)
+            {
+                return 0f;
+            }
+            
+            if(!IsPlaying && IsCompleted)
+            {
+                return GetDuration();
+            }
+
+            return Behaviour.GetElapsed();
+        }
+
+        /// <summary>
+        /// Gets the time left remaining on the tween (duration - elapsed).
+        /// </summary>
+        public float GetRemaining()
+        {
+            if(!IsPlaying && !IsCompleted)
+            {
+                return GetDuration();
+            }
+            
+            if(!IsPlaying && IsCompleted)
+            {
+                return 0f;
+            }
+            
+            return Behaviour.GetRemaining();
+        }
+        
+        public GTween OnStart(Action action)
+        {
+            OnStartAction += action;
+            return this;
+        }
+        
+        public GTween OnTick(Action action)
+        {
+            OnTickAction += action;
+            return this;
+        }
+        
+        public GTween OnLoop(Action action)
+        {
+            OnLoopAction += action;
+            return this;
+        }
+        
+        public GTween OnReset(Action action)
+        {
+            OnResetAction += action;
+            return this;
+        }
+        
+        public GTween OnComplete(Action action)
+        {
+            OnCompleteAction += action;
+            return this;
+        }
+        
+        public GTween OnKill(Action action)
+        {
+            OnKillAction += action;
+            return this;
+        }
+        
+        public GTween OnCompleteOrKill(Action action)
+        {
+            OnCompleteOrKillAction += action;
+            return this;
+        }
+        
+        public GTween OnTimeScaleChanged(Action<float> action)
+        {
+            OnTimeScaleChangedAction += action;
+            return this;
+        }
+        
+        void Loop(ResetMode loopResetMode)
+        {
+            bool needsToLoop = _loopsRemaining > 0;
+
+            if(!needsToLoop || !Behaviour.GetLoopable())
+            {
+                return;
+            }
+
+            --_loopsRemaining;
+
+            Reset(kill: false, loopResetMode);
+            
+            IsPlaying = true;
+            IsCompleted = false;
+            IsKilled = false;
+            
+            Behaviour.Start(false);
+            
+            OnLoopAction?.Invoke();
+        }
+
+        void MarkFinished()
+        {
+            if (!IsPlaying)
+            {
+                return;
+            }
+            
+            IsPlaying = false;
+            IsCompleted = true;
+            IsKilled = false;
+
+            Behaviour.Complete();
+
+            OnCompleteAction?.Invoke();
+            OnCompleteOrKillAction?.Invoke();
+        }
+    }
+}