ArticyFlowPlayer.h

//  
// Copyright (c) 2023 articy Software GmbH & Co. KG. All rights reserved.  
//
 
#pragma once
 
#include "ArticyRuntimeModule.h"
#include "ArticyDatabase.h"
#include "ArticyGlobalVariables.h"
#include "ArticyRef.h"
#include "Components/BillboardComponent.h"
#include "Containers/Queue.h"
#include "ArticyFlowPlayer.generated.h"
 
class IArticyNode;
class IArticyFlowObject;

UENUM(BlueprintType, meta = (Bitflags))
enum class EArticyPausableType : uint8
{
    FlowFragment,
    Dialogue,
    DialogueFragment,
    Hub,
    Jump,
    Condition,
    Instruction,
    Pin
};
ENUM_CLASS_FLAGS(EArticyPausableType);

USTRUCT(BlueprintType)
struct ARTICYRUNTIME_API FArticyBranch
{
    GENERATED_BODY()
 
public:

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Articy")
    TArray<TScriptInterface<IArticyFlowObject>> Path;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Articy")
    bool bIsValid = true;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Articy")
    int32 Index = -1;

    TScriptInterface<IArticyFlowObject> GetTarget() const;
};

UCLASS(BlueprintType, ClassGroup = "Articy", meta = (BlueprintSpawnableComponent))
class ARTICYRUNTIME_API UArticyFlowPlayer : public UActorComponent
{
    GENERATED_BODY()
 
public:
 
    void BeginPlay() override;
    void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    //---------------------------------------------------------------------------//
 
    //EArticyPausableType
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Setup", meta = (Bitmask, BitmaskEnum = "/Script/ArticyRuntime.EArticyPausableType"))
    uint8 PauseOn = 1 << uint8(EArticyPausableType::DialogueFragment)
        | 1 << uint8(EArticyPausableType::Dialogue)
        | 1 << uint8(EArticyPausableType::FlowFragment);

    template<typename Lambda>
    void ShadowedOperation(Lambda Operation) const;
 
    uint32 GetShadowLevel() const { return ShadowLevel; }
 
    //---------------------------------------------------------------------------//

    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Start Node (ArticyRef)"), Category = "Setup")
    void SetStartNode(FArticyRef NewId);
 
    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Start Node (ArticyID)"), Category = "Setup")
    void SetStartNodeById(FArticyId NewId);

    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Start Node (FlowObject)"), Category = "Setup")
    void SetStartNodeWithFlowObject(TScriptInterface<IArticyFlowObject> Node);

    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Get Start Node"), Category = "Setup")
    FArticyRef GetStartNode() { return StartOn; }

    UFUNCTION(BlueprintCallable, meta = (DisplayName = "Set Ignore Invalid Branches"), Category = "Setup")
    void SetIgnoreInvalidBranches(bool bNewIgnoreInvalidBranches) { bIgnoreInvalidBranches = bNewIgnoreInvalidBranches; }

    UFUNCTION(BlueprintCallable, Category = "Flow")
    void SetCursorTo(TScriptInterface<IArticyFlowObject> Node);

    UFUNCTION(BlueprintCallable, Category = "Flow")
    const TScriptInterface<IArticyFlowObject> GetCursor() const { return Cursor; }

    UFUNCTION(BlueprintCallable, Category = "Flow")
    void Play(int Index = 0);

    UFUNCTION(BlueprintCallable, Category = "Flow")
    void FinishCurrentPausedObject(int PinIndex = 0);

    UFUNCTION(BlueprintCallable, Category = "Flow")
    void PlayBranch(const FArticyBranch& Branch);
 
    //---------------------------------------------------------------------------//

    TArray<FArticyBranch> Explore(IArticyFlowObject* Node, bool bShadowed, int32 Depth, bool IncludeCurrent = true);
 
    void SetPauseOn(EArticyPausableType Types);
    bool ShouldPauseOn(IArticyFlowObject* Node) const;
 
    UFUNCTION(BlueprintCallable, Category = "Flow")
    bool ShouldPauseOn(TScriptInterface<IArticyFlowObject> Node) const;

    UFUNCTION(BlueprintCallable, Category = "Setup")
    UArticyGlobalVariables* GetGVs() const;

    UFUNCTION(BlueprintPure, Category = "Setup")
    UObject* GetMethodsProvider();
 
    //---------------------------------------------------------------------------//

    UFUNCTION(BlueprintCallable, Category = "Flow")
    void UpdateAvailableBranches();

    UFUNCTION(BlueprintCallable, Category = "Flow")
    const TArray<FArticyBranch>& GetAvailableBranches() const { return AvailableBranches; }
 
    //---------------------------------------------------------------------------//

    UFUNCTION(BlueprintCallable, Category = "Setup")
    bool IgnoresInvalidBranches() const { return bIgnoreInvalidBranches; }
 
    bool OnTick(float DeltaTime);
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnPushState);
    DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnPopState);
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPlayerPaused, TScriptInterface<IArticyFlowObject>, PausedOn);
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnBranchesUpdated, const TArray<FArticyBranch>&, AvailableBranches);
 

    UPROPERTY(BlueprintAssignable, Category = "Flow")
    FOnPushState OnShadowOpStart;

    UPROPERTY(BlueprintAssignable, Category = "Flow")
    FOnPopState OnShadowOpEnd;

    UPROPERTY(BlueprintAssignable, Category = "Flow")
    FOnPlayerPaused OnPlayerPaused;

    UPROPERTY(BlueprintAssignable, Category = "Flow")
    FOnBranchesUpdated OnBranchesUpdated;
 
protected:
 
    //========================================//

     // [Alewinn] : no valid reference in code, limit most probably set at Articy side.
     //UPROPERTY(EditAnywhere, Category = "Setup", meta=(ClampMin=0))
     //int32 BranchLimit = 32;

    UPROPERTY(EditAnywhere, Category = "Setup", meta = (ClampMin = 0))
    int32 ExploreLimit = 128;

    UPROPERTY(EditAnywhere, Category = "Setup")
    uint8 ShadowLevelLimit = 10;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Setup")
    bool bIgnoreInvalidBranches = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Setup", meta = (ArticyClassRestriction = "ArticyNode"))
    FArticyRef StartOn;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Flow")
    TArray<FArticyBranch> AvailableBranches;
 
    //---------------------------------------------------------------------------//

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Setup")
    UArticyAlternativeGlobalVariables* OverrideGV = nullptr;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Setup")
    mutable UObject* UserMethodsProvider;
 
private:
    UPROPERTY(Transient, VisibleAnywhere, Category = "Debug")
    mutable uint32 ShadowLevel = 0;
 
    TQueue<FArticyBranch> BranchQueue;
    FTSTicker::FDelegateHandle TickerHandle;
 
    UArticyExpressoScripts* CachedExpressoInstance = nullptr;
 
private:
    void UpdateAvailableBranchesInternal(bool Startup);

    UPROPERTY(Transient)
    TScriptInterface<IArticyFlowObject> Cursor = nullptr;

    void SetCursorToStartNode();

    bool FastForwardToPause();

    IArticyFlowObject* GetUnshadowedNode(IArticyFlowObject* Node);
 
    UArticyDatabase* GetDB() const;
};
 
//---------------------------------------------------------------------------//
// TEMPLATED METHODS
//---------------------------------------------------------------------------//

template<typename Lambda>
void UArticyFlowPlayer::ShadowedOperation(Lambda Operation) const
{
    if (std::is_null_pointer<Lambda>::value)
        return;
    if (!ensure(GetGVs()))
    {
        UE_LOG(LogArticyRuntime, Warning, TEXT("FlowPlayer cannot get GVs!"));
        return;
    }
    if (!ensure(ShadowLevel < ShadowLevelLimit))
    {
        UE_LOG(LogArticyRuntime, Warning, TEXT("More than 100 nested ShadowedOperations, probably there's an infinite loop in the Flow!"));
        return;
    }
 
    //push shadow state
    ++ShadowLevel;
 
    //notify on push
    GetGVs()->PushState(ShadowLevel);
    GetGVs()->PushSeen();
    UArticyDatabase::Get(this)->PushState(ShadowLevel);
    OnShadowOpStart.Broadcast();
 
    //execute the operation
    Operation();
 
    //notify on pop
    OnShadowOpEnd.Broadcast();
    UArticyDatabase::Get(this)->PopState(ShadowLevel);
    GetGVs()->PopSeen();
    GetGVs()->PopState(ShadowLevel);
 
    //pop shadow state
    if (ensure(ShadowLevel > 0))
        --ShadowLevel;
}

UCLASS(BlueprintType, HideCategories = (Replication, Physics, Rendering, Input, Collision, Actor, LOD, Cooking))
class AArticyFlowDebugger : public AActor
{
    GENERATED_BODY()
 
public:
    AArticyFlowDebugger();
public:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Articy")
    UArticyFlowPlayer* FlowPlayer = nullptr;
private:
 
    UPROPERTY()
    UBillboardComponent* ArticyImporterIcon = nullptr;
};