QuickTweenSequence.h

// Copyright 2025 Juan Pablo Hernandez Mosti. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "CommonValues.h"
#include "QuickTweenable.h"
#include "UObject/Object.h"
#include "../Utils/LoopType.h"
#include "QuickTweenSequence.generated.h"
 
class UQuickTweenBase;
class UQuickTweenSequence;
 
DEFINE_LOG_CATEGORY_STATIC(LogQuickTweenSequence, Log, All);
 
DECLARE_MULTICAST_DELEGATE_OneParam(FNativeDelegateTweenSequence, UQuickTweenSequence*);
DECLARE_DYNAMIC_DELEGATE_OneParam(FDynamicDelegateTweenSequence, UQuickTweenSequence*, TweenSequence);
 

USTRUCT()
struct FQuickTweenSequenceGroup
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    TArray<UQuickTweenable*> Tweens;

    float StartTime = 0.0f;

    float Duration = 0.0f;
};

UCLASS(BlueprintType)
class QUICKTWEEN_API UQuickTweenSequence : public UQuickTweenable
{
    GENERATED_BODY()
 
private:
    UQuickTweenSequence() = default;

    void SetUp(
        const UObject* worldContextObject,
        int32 loops = 1,
        ELoopType loopType = ELoopType::Restart,
        const FString& id = FString(),
        bool bShouldAutoKill = true,
        bool bShouldPlayWhilePaused = false);
 
public:
    virtual ~UQuickTweenSequence() override;
 
#pragma region Sequence Creation

    static UQuickTweenSequence* CreateSequence(
        UObject* worldContextObject,
        int32 loops = 1,
        ELoopType loopType = ELoopType::Restart,
        const FString& id = FString(),
        bool bShouldAutoKill = true,
        bool bShouldPlayWhilePaused = false)
    {
        UQuickTweenSequence* sequence = NewObject<UQuickTweenSequence>(worldContextObject);
        sequence->SetUp(
            worldContextObject,
            loops,
            loopType,
            id,
            bShouldAutoKill,
            bShouldPlayWhilePaused);
        return sequence;
    }

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Sequence"), Category = "Sequence|Creation")
    UQuickTweenSequence* Join(UQuickTweenable* tween);

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Sequence"), Category = "Sequence|Creation")
    UQuickTweenSequence* Append(UQuickTweenable* tween);
 
    virtual void SetOwner(UQuickTweenable* owner) override { Owner = owner; }
#pragma endregion
 
#pragma region Sequence Control
public:
 
    virtual void Play() override;
 
    virtual void Pause() override;
 
    virtual void Reverse() override;
 
    virtual void Complete(bool bSnapToEnd = true) override;
 
    virtual void Restart() override;
 
    virtual void Kill() override;
 
    virtual void Update(float deltaTime) override;
 
    virtual void Evaluate(const FQuickTweenEvaluatePayload& payload, const UQuickTweenable* instigator) override;
 
    [[nodiscard]] virtual bool GetIsPendingKill() const override { return SequenceState == EQuickTweenState::Kill; }
#pragma endregion
 
 
#pragma region Sequence State Queries
public:
 
    [[nodiscard]] virtual bool GetIsPlaying() const override { return SequenceState == EQuickTweenState::Play;}
 
    [[nodiscard]] virtual float GetTimeScale() const override { return 1.0f; }
 
    [[nodiscard]] virtual bool GetIsReversed() const override { return bIsReversed; }
 
    [[nodiscard]] virtual EEaseType GetEaseType() const override { return EEaseType::Linear; }
 
    [[nodiscard]] virtual UCurveFloat* GetEaseCurve() const override { return nullptr; }
 
    [[nodiscard]] virtual bool GetAutoKill() const override { return bAutoKill; }
 
    [[nodiscard]] virtual bool GetIsCompleted() const override { return SequenceState == EQuickTweenState::Complete; }
 
    [[nodiscard]] virtual float GetLoopDuration() const override;
 
    [[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 int32 GetLoops() const override { return Loops; }
 
    [[nodiscard]] virtual int32 GetCurrentLoop() const override { return CurrentLoop; }
 
    [[nodiscard]] virtual ELoopType GetLoopType() const override { return LoopType; }
 
    [[nodiscard]] virtual FString GetTweenTag() const override { return SequenceTweenId; }
 
    [[nodiscard]] virtual bool GetShouldPlayWhilePaused() const override { return bPlayWhilePaused; }

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Sequence"), Category = "Sequence|State")
    [[nodiscard]] int32 GetNumTweens() const;

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Sequence"), Category = "Sequence|State")
    [[nodiscard]] UQuickTweenable* GetTween(int32 index) const;
 
#pragma endregion
 
#pragma region Delegates
public:

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

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

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

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

    UFUNCTION(BlueprintCallable, meta = (Keywords = "Tween | Event"), Category = "Tween|Info")
    void AssignOnLoopEvent(FDynamicDelegateTweenSequence 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);

    FNativeDelegateTweenSequence OnStart;

    FNativeDelegateTweenSequence OnUpdate;

    FNativeDelegateTweenSequence OnComplete;

    FNativeDelegateTweenSequence OnKilled;

    FNativeDelegateTweenSequence OnLoop;
#pragma endregion
 
private:
 
    struct FQuickTweenSequenceStateResult
    {
        int32 Loop = 0;
        float LoopLocalTime = 0.0f;
    };

    FQuickTweenSequenceStateResult ComputeSequenceState(float time) const;

    void SeekTime(float loopLocalTime);
 
    bool InstigatorIsOwner(const UQuickTweenable* instigator) const
    {
        return instigator == Owner;
    }
 
    bool HasOwner() const { return Owner != nullptr; }

    void HandleOnStart();

    void HandleOnComplete();

    void HandleOnKill();

    bool RequestStateTransition(EQuickTweenState newState);

    EQuickTweenState SequenceState = EQuickTweenState::Idle;

    UPROPERTY(Transient)
    TArray<FQuickTweenSequenceGroup> TweenGroups;

    float ElapsedTime = 0.0f;

    bool bIsReversed = false;

    bool bWasActive = false;

    float PreviousLoopLocalTime = 0.0f;

    bool bSnapToEndOnComplete = true;

    bool bTriggerEvents = true;

    int32 CurrentLoop = 1;

    int32 Loops = -1;

    ELoopType LoopType = ELoopType::Restart;

    FString SequenceTweenId;

    bool bAutoKill = true;

    bool bPlayWhilePaused = false;

    UPROPERTY(Transient)
    const UObject* WorldContextObject = nullptr;
 
    UPROPERTY(Transient)
    UQuickTweenable* Owner = nullptr;
 
};