QuickTweenBase.h

// Copyright 2025 Juan Pablo Hernandez Mosti. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "CommonValues.h"
#include "QuickTweenable.h"
#include "../Utils/EaseType.h"
#include "../Utils/LoopType.h"
#include "QuickTweenBase.generated.h"
 
class UQuickTweenSequence;
class UQuickTweenBase;
 
DEFINE_LOG_CATEGORY_STATIC(LogQuickTweenBase, Log, All);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FNativeDelegateTween, UQuickTweenBase*);
DECLARE_DYNAMIC_DELEGATE_OneParam(FDynamicDelegateTween, UQuickTweenBase*, Tween);

UCLASS(Blueprintable, BlueprintType, Abstract)
class QUICKTWEEN_API UQuickTweenBase : public UQuickTweenable
{
    GENERATED_BODY()
public:
    virtual ~UQuickTweenBase();
#pragma region Tween Creation
    void SetUp(
        const UObject* worldContextObject,
        float duration,
        float timeScale,
        EEaseType easeType,
        UCurveFloat* easeCurve,
        int32 loops,
        ELoopType loopType,
        const FString& tweenTag = FString(),
        bool bShouldAutoKill = true,
        bool bShouldPlayWhilePaused = false,
        bool bShouldAutoPlay = false);
 
    virtual void SetOwner(UQuickTweenable* owner) override { Owner = owner; }
 
#pragma endregion
 
#pragma region Tween Control
public:
 
    virtual void Play() override;
 
    virtual void Pause() override;
 
    virtual void Reverse() override;
 
    virtual void Restart() override;
 
    virtual void Complete(bool bSnapToEnd = true) override;
 
    virtual void Kill() override;
 
    virtual void Update(float deltaTime) override;
 
    virtual void Evaluate(const FQuickTweenEvaluatePayload& payload, const UQuickTweenable* instigator) override;
 
#pragma endregion
 
#pragma region Tween State Queries
public:
 
    [[nodiscard]] virtual bool GetIsPendingKill() const override { return TweenState == EQuickTweenState::Kill; }
 
    [[nodiscard]] virtual float GetLoopDuration() const override { return Duration;}
 
    [[nodiscard]] virtual float GetTotalDuration() const override
    {
        if (Loops == INFINITE_LOOPS)
        {
            return TNumericLimits<float>::Max();
        }
        return GetLoopDuration() * GetLoops() / GetTimeScale();
    }
 
    [[nodiscard]] virtual float GetElapsedTime() const override { return ElapsedTime; }
 
    [[nodiscard]] virtual float GetTimeScale() const override { return TimeScale; }
 
    [[nodiscard]] virtual bool GetIsPlaying() const override { return TweenState == EQuickTweenState::Play; }
 
    [[nodiscard]] virtual bool GetIsCompleted() const override { return TweenState == EQuickTweenState::Complete; }
 
    [[nodiscard]] virtual bool GetIsReversed() const override { return bIsReversed; }
 
    [[nodiscard]] virtual EEaseType GetEaseType() const override { return EaseType; }
 
    [[nodiscard]] virtual UCurveFloat* GetEaseCurve() const override { return EaseCurve; }
 
    [[nodiscard]] virtual int32 GetLoops() const override{ return Loops; }
 
    [[nodiscard]] virtual ELoopType GetLoopType() const override { return LoopType; }
 
    [[nodiscard]] virtual FString GetTweenTag() const override { return TweenTag; }
 
    [[nodiscard]] virtual int32 GetCurrentLoop() const override { return CurrentLoop; }
 
    [[nodiscard]] virtual bool GetAutoKill() const override { return bAutoKill; }
 
    [[nodiscard]] virtual bool GetShouldPlayWhilePaused() const override {return bPlayWhilePaused;}
 
    [[nodiscard]] bool GetSnapToEndOnComplete() const { return bSnapToEndOnComplete; }
#pragma endregion
 
    bool InstigatorIsOwner(const UQuickTweenable* instigator) const { return instigator == Owner; }
    
    bool HasOwner() const { return Owner != nullptr; }

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void AssignOnStartEvent(FDynamicDelegateTween callback);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void AssignOnUpdateEvent(FDynamicDelegateTween callback);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void AssignOnCompleteEvent(FDynamicDelegateTween callback);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void AssignOnKilledEvent(FDynamicDelegateTween callback);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void AssignOnLoopEvent(FDynamicDelegateTween callback);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void RemoveAllOnStartEvent(const UObject* object);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void RemoveAllOnUpdateEvent(const UObject* object);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void RemoveAllOnCompleteEvent(const UObject* object);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void RemoveAllOnKilledEvent(const UObject* object);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void RemoveAllOnLoopEvent(const UObject* object);

    FNativeDelegateTween OnStart;

    FNativeDelegateTween OnUpdate;

    FNativeDelegateTween OnComplete;

    FNativeDelegateTween OnKilled;

    FNativeDelegateTween OnLoop;
 
protected:

    virtual void ApplyAlphaValue(float alpha);

    virtual void HandleOnStart();

    virtual void HandleOnComplete();

    virtual void HandleOnKill();
private:
 
    struct FQuickTweenStateResult
    {
        int32 Loop = 0;
        float Alpha = 0.0f;
    };
 

    FQuickTweenStateResult ComputeTweenState(float time) const;

    bool RequestStateTransition(EQuickTweenState newState);

    EQuickTweenState TweenState = EQuickTweenState::Idle;

    float ElapsedTime = 0.0f;

    float Duration = 0.0f;

    float TimeScale = 1.0f;

    bool bIsReversed = false;

    bool bWasActive = false;

    bool bSnapToEndOnComplete = true;

    bool bTriggerEvents = true;

    EEaseType EaseType = EEaseType::Linear;

    UPROPERTY(Transient)
    UCurveFloat* EaseCurve = nullptr;

    int32 CurrentLoop = 0;

    int32 Loops = -1;

    ELoopType LoopType = ELoopType::Restart;

    FString TweenTag = FString();

    UPROPERTY()
    UQuickTweenable* Owner = nullptr;

    bool bAutoKill = true;

    bool bPlayWhilePaused = false;
 
    UPROPERTY()
    const UObject* WorldContextObject = nullptr;
};