GameplayTasksComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Templates/SubclassOf.h"
#include "UObject/CoreNet.h"
#include "UObject/ScriptInterface.h"
#include "Components/ActorComponent.h"
#include "EngineDefines.h"
#include "GameplayTaskOwnerInterface.h"
#include "GameplayTask.h"
#include "GameplayTaskResource.h"
#include "VisualLogger/VisualLoggerDebugSnapshotInterface.h"
#include "GameplayTasksComponent.generated.h"
 
class AActor;
class Error;
class FOutBunch;
class UActorChannel;
 
enum class EGameplayTaskEvent : uint8
{
    Add,
    Remove,
};
 
UENUM()
enum class EGameplayTaskRunResult : uint8
{
    Error,
    Failed,
    Success_Paused,
    Success_Active,
    Success_Finished,
};
 
struct FGameplayTaskEventData
{
    EGameplayTaskEvent Event;
    UGameplayTask& RelatedTask;
 
    FGameplayTaskEventData(EGameplayTaskEvent InEvent, UGameplayTask& InRelatedTask)
        : Event(InEvent), RelatedTask(InRelatedTask)
    {
 
    }
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnClaimedResourcesChangeSignature, FGameplayResourceSet, NewlyClaimed, FGameplayResourceSet, FreshlyReleased);
 
UCLASS(ClassGroup = GameplayTasks, hidecategories = (Object, LOD, Lighting, Transform, Sockets, TextureStreaming), editinlinenew, meta = (BlueprintSpawnableComponent), MinimalAPI)
class UGameplayTasksComponent : public UActorComponent, public IGameplayTaskOwnerInterface, public IVisualLoggerDebugSnapshotInterface
{
    GENERATED_BODY()
 
private:
 
    friend struct FEventLock;
    int32 EventLockCounter;
 
    uint8 bInEventProcessingInProgress : 1;
 
protected:
    uint8 TopActivePriority;
 
    FGameplayResourceSet CurrentlyClaimedResources;
 
    const TArray<UGameplayTask*>& GetSimulatedTasks()
    {
        return SimulatedTasks;
    }
 
    GAMEPLAYTASKS_API void SetSimulatedTasks(const TArray<UGameplayTask*>& NewSimulatedTasks);
 
    GAMEPLAYTASKS_API bool AddSimulatedTask(UGameplayTask* NewTask);
 
    GAMEPLAYTASKS_API void RemoveSimulatedTask(UGameplayTask* NewTask);
 
    UPROPERTY()
    TArray<TObjectPtr<UGameplayTask>> TaskPriorityQueue;
    
    TArray<FGameplayTaskEventData> TaskEvents;
 
    UPROPERTY()
    TArray<TObjectPtr<UGameplayTask>> TickingTasks;
 
    UPROPERTY(transient)
    TArray<TObjectPtr<UGameplayTask>> KnownTasks;
 
public:
    UPROPERTY(BlueprintReadWrite, Category = "Gameplay Tasks")
    FOnClaimedResourcesChangeSignature OnClaimedResourcesChange;
 
    GAMEPLAYTASKS_API UGameplayTasksComponent(const FObjectInitializer& ObjectInitializer);
    
    UFUNCTION()
    GAMEPLAYTASKS_API void OnRep_SimulatedTasks();
 
    GAMEPLAYTASKS_API virtual void GetLifetimeReplicatedProps(TArray< FLifetimeProperty >& OutLifetimeProps) const override;
    GAMEPLAYTASKS_API virtual bool ReplicateSubobjects(UActorChannel *Channel, FOutBunch* Bunch, FReplicationFlags* RepFlags) override;
 
    GAMEPLAYTASKS_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    GAMEPLAYTASKS_API void UpdateShouldTick();
 
    GAMEPLAYTASKS_API virtual bool GetShouldTick() const;
    
    GAMEPLAYTASKS_API void AddTaskReadyForActivation(UGameplayTask& NewTask);
 
    GAMEPLAYTASKS_API void RemoveResourceConsumingTask(UGameplayTask& Task);
    GAMEPLAYTASKS_API void EndAllResourceConsumingTasksOwnedBy(const IGameplayTaskOwnerInterface& TaskOwner);
 
    GAMEPLAYTASKS_API bool FindAllResourceConsumingTasksOwnedBy(const IGameplayTaskOwnerInterface& TaskOwner, TArray<UGameplayTask*>& FoundTasks) const;
    
    GAMEPLAYTASKS_API UGameplayTask* FindResourceConsumingTaskByName(const FName TaskInstanceName) const;
 
    GAMEPLAYTASKS_API bool HasActiveTasks(UClass* TaskClass) const;
 
    inline FGameplayResourceSet GetCurrentlyUsedResources() const { return CurrentlyClaimedResources; }
 
    // BEGIN IGameplayTaskOwnerInterface
    virtual UGameplayTasksComponent* GetGameplayTasksComponent(const UGameplayTask& Task) const { return const_cast<UGameplayTasksComponent*>(this); }
    virtual AActor* GetGameplayTaskOwner(const UGameplayTask* Task) const override { return GetOwner(); }
    virtual AActor* GetGameplayTaskAvatar(const UGameplayTask* Task) const override { return GetOwner(); }
    GAMEPLAYTASKS_API virtual void OnGameplayTaskActivated(UGameplayTask& Task) override;
    GAMEPLAYTASKS_API virtual void OnGameplayTaskDeactivated(UGameplayTask& Task) override;
    // END IGameplayTaskOwnerInterface
 
    // ActorComponent overrides
    GAMEPLAYTASKS_API virtual void ReadyForReplication() override;
 
    UFUNCTION(BlueprintCallable, DisplayName="Run Gameplay Task", meta=(ScriptName="RunGameplayTask"), Category = "Gameplay Tasks", meta = (AutoCreateRefTerm = "AdditionalRequiredResources, AdditionalClaimedResources", AdvancedDisplay = "AdditionalRequiredResources, AdditionalClaimedResources"))
    static GAMEPLAYTASKS_API EGameplayTaskRunResult K2_RunGameplayTask(TScriptInterface<IGameplayTaskOwnerInterface> TaskOwner, UGameplayTask* Task, uint8 Priority, TArray<TSubclassOf<UGameplayTaskResource> > AdditionalRequiredResources, TArray<TSubclassOf<UGameplayTaskResource> > AdditionalClaimedResources);
 
    static GAMEPLAYTASKS_API EGameplayTaskRunResult RunGameplayTask(IGameplayTaskOwnerInterface& TaskOwner, UGameplayTask& Task, uint8 Priority, FGameplayResourceSet AdditionalRequiredResources, FGameplayResourceSet AdditionalClaimedResources);
    
#if WITH_GAMEPLAYTASK_DEBUG
    GAMEPLAYTASKS_API FString GetTickingTasksDescription() const;
    GAMEPLAYTASKS_API FString GetKnownTasksDescription() const;
    GAMEPLAYTASKS_API FString GetTasksPriorityQueueDescription() const;
    static GAMEPLAYTASKS_API FString GetTaskStateName(EGameplayTaskState Value);
#endif // WITH_GAMEPLAYTASK_DEBUG
    using GameplayTaskContainerType = decltype(TickingTasks);
    GAMEPLAYTASKS_API GameplayTaskContainerType::TConstIterator GetTickingTaskIterator() const;
    GAMEPLAYTASKS_API GameplayTaskContainerType::TConstIterator GetKnownTaskIterator() const;
    GAMEPLAYTASKS_API GameplayTaskContainerType::TConstIterator GetPriorityQueueIterator() const;
    GAMEPLAYTASKS_API GameplayTaskContainerType::TConstIterator GetSimulatedTaskIterator() const;
 
#if ENABLE_VISUAL_LOG
    GAMEPLAYTASKS_API virtual void GrabDebugSnapshot(FVisualLogEntry* Snapshot) const override;
    GAMEPLAYTASKS_API void DescribeSelfToVisLog(struct FVisualLogEntry* Snapshot) const;
#endif // ENABLE_VISUAL_LOG
 
protected:
    struct FEventLock
    {
        FEventLock(UGameplayTasksComponent* InOwner);
        ~FEventLock();
 
    protected:
        UGameplayTasksComponent* Owner;
    };
 
    GAMEPLAYTASKS_API void RequestTicking();
    GAMEPLAYTASKS_API void ProcessTaskEvents();
    GAMEPLAYTASKS_API void UpdateTaskActivations();
 
    GAMEPLAYTASKS_API void SetCurrentlyClaimedResources(FGameplayResourceSet NewClaimedSet);
 
private:
    GAMEPLAYTASKS_API void OnTaskEnded(UGameplayTask& Task);
 
    GAMEPLAYTASKS_API void AddTaskToPriorityQueue(UGameplayTask& NewTask);
    GAMEPLAYTASKS_API void RemoveTaskFromPriorityQueue(UGameplayTask& Task);
 
    inline bool CanProcessEvents() const { return !bInEventProcessingInProgress && (EventLockCounter == 0); }
 
    GAMEPLAYTASKS_API void SetSimulatedTasksNetDirty();
 
    UPROPERTY(Transient, ReplicatedUsing = OnRep_SimulatedTasks)
    TArray<TObjectPtr<UGameplayTask>> SimulatedTasks;
 
    TArray<TWeakObjectPtr<UGameplayTask>> PreviousOnRepSimulatedTasks;
 
};
 
typedef UGameplayTasksComponent::GameplayTaskContainerType::TConstIterator FConstGameplayTaskIterator;