GameplayTask.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 "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "UObject/ScriptInterface.h"
#include "UObject/ScriptMacros.h"
#include "GameplayTaskOwnerInterface.h"
#include "UObject/WeakInterfacePtr.h"
#include "GameplayTaskTypes.h"
#include "GameplayTask.generated.h"
 
class AActor;
class UGameplayTaskResource;
class UGameplayTasksComponent;
 
GAMEPLAYTASKS_API DECLARE_LOG_CATEGORY_EXTERN(LogGameplayTasks, Log, All);
 
UENUM()
enum class EGameplayTaskState : uint8
{
    Uninitialized,
    AwaitingActivation,
    Paused,
    Active,
    Finished
};
 
UENUM()
enum class ETaskResourceOverlapPolicy : uint8
{
    StartOnTop,
    StartAtEnd,
    RequestCancelAndStartOnTop,
    RequestCancelAndStartAtEnd,
};
    
USTRUCT(BlueprintType)
struct FGameplayResourceSet
{
    GENERATED_USTRUCT_BODY()
 
    typedef uint16 FFlagContainer;
    typedef uint8 FResourceID;
 
    enum
    {
        MaxResources = sizeof(FFlagContainer)* 8
    };
 
private:
    FFlagContainer Flags;
 
public:
    explicit FGameplayResourceSet(FFlagContainer InFlags = 0) : Flags(InFlags)
    {}
 
    FFlagContainer GetFlags() const
    {
        return Flags;
    }
    bool IsEmpty() const
    {
        return Flags == 0;
    }
    FGameplayResourceSet& AddID(uint8 ResourceID)
    {
        ensure(ResourceID < MaxResources);
        Flags |= (1 << ResourceID);
        return *this;
    }
    FGameplayResourceSet& RemoveID(uint8 ResourceID)
    {
        ensure(ResourceID < MaxResources);
        Flags &= ~(1 << ResourceID);
        return *this;
    }
    bool HasID(uint8 ResourceID) const
    {
        ensure(ResourceID < MaxResources);
        return (Flags & (1 << ResourceID)) != 0;
    }
    FGameplayResourceSet& AddSet(FGameplayResourceSet Other)
    {
        Flags |= Other.Flags;
        return *this;
    }
    FGameplayResourceSet& RemoveSet(FGameplayResourceSet Other)
    {
        Flags &= ~Other.Flags;
        return *this;
    }
    void Clear()
    {
        Flags = FFlagContainer(0);
    }
    bool HasAllIDs(FGameplayResourceSet Other) const
    {
        return (Flags & Other.Flags) == Other.Flags;
    }
    bool HasAnyID(FGameplayResourceSet Other) const
    {
        return (Flags & Other.Flags) != 0;
    }
    FGameplayResourceSet GetOverlap(FGameplayResourceSet Other) const
    {
        return FGameplayResourceSet(Flags & Other.Flags);
    }
    FGameplayResourceSet GetDifference(FGameplayResourceSet Other) const
    {
        return FGameplayResourceSet(Flags & ~(Flags & Other.Flags));
    }
 
    bool operator==(const FGameplayResourceSet& Other) const
    {
        return Flags == Other.Flags;
    }
 
    bool operator!=(const FGameplayResourceSet& Other) const
    {
        return Flags != Other.Flags;
    }
 
    static FGameplayResourceSet AllResources()
    {
        return FGameplayResourceSet(FFlagContainer(-1));
    }
 
    static FGameplayResourceSet NoResources()
    {
        return FGameplayResourceSet(FFlagContainer(0));
    }
 
    GAMEPLAYTASKS_API FString GetDebugDescription() const;
};
 
UCLASS(Abstract, BlueprintType, meta = (ExposedAsyncProxy=AsyncTask), config = Game, MinimalAPI)
class UGameplayTask : public UObject, public IGameplayTaskOwnerInterface
{
    GENERATED_BODY()
 
public:
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE(FGenericGameplayTaskDelegate);
 
    GAMEPLAYTASKS_API UGameplayTask(const FObjectInitializer& ObjectInitializer);
    
    UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true"), Category = "Gameplay Tasks")
    GAMEPLAYTASKS_API void ReadyForActivation();
 
protected:
    GAMEPLAYTASKS_API virtual void Activate();
 
    GAMEPLAYTASKS_API void InitTask(IGameplayTaskOwnerInterface& InTaskOwner, uint8 InPriority);
 
public:
    GAMEPLAYTASKS_API virtual void InitSimulatedTask(UGameplayTasksComponent& InGameplayTasksComponent);
 
    virtual void TickTask(float DeltaTime) {}
 
    GAMEPLAYTASKS_API virtual void ExternalConfirm(bool bEndTask);
 
    GAMEPLAYTASKS_API virtual void ExternalCancel();
 
    void MarkOwnerFinished() { bOwnerFinished = true; }
 
    GAMEPLAYTASKS_API virtual FString GetDebugString() const;
 
    GAMEPLAYTASKS_API virtual UWorld* GetWorld() const override;
 
    GAMEPLAYTASKS_API AActor* GetOwnerActor() const;
 
    GAMEPLAYTASKS_API AActor* GetAvatarActor() const;
 
    template <class T>
    inline static T* NewTask(UObject* WorldContextObject, FName InstanceName = FName())
    {
        return WorldContextObject != nullptr ? NewTask<T>(*WorldContextObject, InstanceName) : nullptr;
    }
 
    template <class T>
    inline static T* NewTask(TScriptInterface<IGameplayTaskOwnerInterface> TaskOwner, FName InstanceName = FName())
    {
        return TaskOwner.GetInterface() != nullptr ? NewTask<T>(*TaskOwner, InstanceName) : nullptr;
    }
 
    template <class T>
    inline static T* NewTask(UObject& WorldContextObject, FName InstanceName = FName());
 
    template <class T>
    inline static T* NewTask(IGameplayTaskOwnerInterface& TaskOwner, FName InstanceName = FName());
 
    template <class T>
    inline static T* NewTaskUninitialized()
    {
        return NewObject<T>();
    }
 
    GAMEPLAYTASKS_API void TaskOwnerEnded();
 
    UFUNCTION(BlueprintCallable, Category="GameplayTasks")
    GAMEPLAYTASKS_API void EndTask();
    
    virtual bool IsSupportedForNetworking() const override { return bSimulatedTask; }
 
    inline FName GetInstanceName() const { return InstanceName; }
    inline bool IsTickingTask() const { return (bTickingTask != 0); }
    inline bool IsSimulatedTask() const { return (bSimulatedTask != 0); }
    inline bool IsSimulating() const { return (bIsSimulating != 0); }
    inline bool IsPausable() const { return (bIsPausable != 0); }
    inline bool HasOwnerFinished() const {  return (bOwnerFinished != 0); }
    inline uint8 GetPriority() const { return Priority; }
    inline bool RequiresPriorityOrResourceManagement() const { return bCaresAboutPriority == true || RequiredResources.IsEmpty() == false || ClaimedResources.IsEmpty() == false; }
    inline FGameplayResourceSet GetRequiredResources() const { return RequiredResources; }
    inline FGameplayResourceSet GetClaimedResources() const { return ClaimedResources; }
    
    inline EGameplayTaskState GetState() const { return TaskState; }
    inline bool IsActive() const { return (TaskState == EGameplayTaskState::Active); }
    inline bool IsPaused() const { return (TaskState == EGameplayTaskState::Paused); }
    inline bool IsFinished() const { return (TaskState == EGameplayTaskState::Finished); }
    
    UGameplayTask* GetChildTask() const { return ChildTask; }
    IGameplayTaskOwnerInterface* GetTaskOwner() const { return TaskOwner.IsValid() ? &(*TaskOwner) : nullptr; }
    UGameplayTasksComponent* GetGameplayTasksComponent() { return TasksComponent.Get(); }
    UGameplayTasksComponent* GetGameplayTasksComponent() const { return TasksComponent.Get(); }
    bool IsOwnedByTasksComponent() const { return bOwnedByTasksComponent; }
 
    template <class T>
    inline void AddRequiredResource()
    {
        AddRequiredResource(T::StaticClass());
    }
 
    template <class T>
    inline void AddClaimedResource()
    {
        AddClaimedResource(T::StaticClass());
    }
 
    GAMEPLAYTASKS_API void AddRequiredResource(TSubclassOf<UGameplayTaskResource> RequiredResource);
    GAMEPLAYTASKS_API void AddRequiredResourceSet(const TArray<TSubclassOf<UGameplayTaskResource> >& RequiredResourceSet);
    GAMEPLAYTASKS_API void AddRequiredResourceSet(FGameplayResourceSet RequiredResourceSet);
 
    GAMEPLAYTASKS_API void AddClaimedResource(TSubclassOf<UGameplayTaskResource> ClaimedResource);
    GAMEPLAYTASKS_API void AddClaimedResourceSet(const TArray<TSubclassOf<UGameplayTaskResource> >& AdditionalResourcesToClaim);
    GAMEPLAYTASKS_API void AddClaimedResourceSet(FGameplayResourceSet AdditionalResourcesToClaim);
 
    ETaskResourceOverlapPolicy GetResourceOverlapPolicy() const { return ResourceOverlapPolicy; }
 
    virtual bool IsWaitingOnRemotePlayerdata() const { return false; }
 
    virtual bool IsWaitingOnAvatar() const { return false; }
 
protected:
    GAMEPLAYTASKS_API virtual void OnDestroy(bool bInOwnerFinished);
 
    static GAMEPLAYTASKS_API IGameplayTaskOwnerInterface* ConvertToTaskOwner(UObject& OwnerObject);
    static GAMEPLAYTASKS_API IGameplayTaskOwnerInterface* ConvertToTaskOwner(AActor& OwnerActor);
 
    // protected by design. Not meant to be called outside from GameplayTaskComponent mechanics
    GAMEPLAYTASKS_API virtual void Pause();
    GAMEPLAYTASKS_API virtual void Resume();
 
    // IGameplayTaskOwnerInterface BEGIN
    GAMEPLAYTASKS_API virtual UGameplayTasksComponent* GetGameplayTasksComponent(const UGameplayTask& Task) const override;
    GAMEPLAYTASKS_API virtual AActor* GetGameplayTaskOwner(const UGameplayTask* Task) const override;
    GAMEPLAYTASKS_API virtual AActor* GetGameplayTaskAvatar(const UGameplayTask* Task) const override;
    GAMEPLAYTASKS_API virtual uint8 GetGameplayTaskDefaultPriority() const override;
    GAMEPLAYTASKS_API virtual void OnGameplayTaskInitialized(UGameplayTask& Task) override;
    GAMEPLAYTASKS_API virtual void OnGameplayTaskDeactivated(UGameplayTask& Task) override;
    // IGameplayTaskOwnerInterface END
 
    GAMEPLAYTASKS_API virtual void RegisterReplicationFragments(UE::Net::FFragmentRegistrationContext& Context, UE::Net::EFragmentRegistrationFlags RegistrationFlags) override;
 
private:
    friend UGameplayTasksComponent;
 
    GAMEPLAYTASKS_API void ActivateInTaskQueue();
    GAMEPLAYTASKS_API void PauseInTaskQueue();
    
    GAMEPLAYTASKS_API void PerformActivation();
    
protected:
 
    UPROPERTY()
    FName InstanceName;
 
    uint8 Priority;
 
    EGameplayTaskState TaskState;
 
    UPROPERTY(config)
    ETaskResourceOverlapPolicy ResourceOverlapPolicy;
 
    uint32 bTickingTask : 1;
 
    uint32 bSimulatedTask : 1;
 
    uint32 bIsSimulating : 1;
 
    uint32 bIsPausable : 1;
 
    uint32 bCaresAboutPriority : 1;
 
    uint32 bOwnedByTasksComponent : 1;
 
    uint32 bClaimRequiredResources : 1;
    
    uint32 bOwnerFinished : 1;
 
    FGameplayResourceSet RequiredResources;
 
    FGameplayResourceSet ClaimedResources;
 
    TWeakInterfacePtr<IGameplayTaskOwnerInterface> TaskOwner;
 
    TWeakObjectPtr<UGameplayTasksComponent> TasksComponent;
 
    UPROPERTY()
    TObjectPtr<UGameplayTask> ChildTask;
 
#if WITH_GAMEPLAYTASK_DEBUG
    mutable FString DebugDescription;
public:
    const FString& GetDebugDescription() const
    {
        if (DebugDescription.IsEmpty())
        {
            DebugDescription = GenerateDebugDescription();
        }
        return DebugDescription;
    }
    GAMEPLAYTASKS_API virtual FString GenerateDebugDescription() const;
    GAMEPLAYTASKS_API FString GetTaskStateName() const;
#endif // WITH_GAMEPLAYTASK_DEBUG
};
 
template <class T>
T* UGameplayTask::NewTask(UObject& WorldContextObject, FName InstanceName)
{
    IGameplayTaskOwnerInterface* TaskOwner = ConvertToTaskOwner(WorldContextObject);
    return (TaskOwner) ? NewTask<T>(*TaskOwner, InstanceName) : nullptr;
}
 
template <class T>
T* UGameplayTask::NewTask(IGameplayTaskOwnerInterface& TaskOwner, FName InstanceName)
{
    T* MyObj = NewObject<T>();
    MyObj->InstanceName = InstanceName;
    MyObj->InitTask(TaskOwner, TaskOwner.GetGameplayTaskDefaultPriority());
    return MyObj;
}
 
//For searching through lists of task instances
struct FGameplayTaskInstanceNamePredicate
{
    FGameplayTaskInstanceNamePredicate(FName DesiredInstanceName)
    {
        InstanceName = DesiredInstanceName;
    }
 
    bool operator()(const UGameplayTask* A) const
    {
        return (A && !A->GetInstanceName().IsNone() && A->GetInstanceName().IsValid() && (A->GetInstanceName() == InstanceName));
    }
 
    FName InstanceName;
};
 
 
struct FGameplayTaskInstanceClassPredicate
{
    FGameplayTaskInstanceClassPredicate(TSubclassOf<UGameplayTask> Class)
    {
        TaskClass = Class;
    }
 
    bool operator()(const UGameplayTask* A) const
    {
        return (A && (A->GetClass() == TaskClass));
    }
 
    TSubclassOf<UGameplayTask> TaskClass;
};