EnvQueryTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "NavFilters/NavigationQueryFilter.h"
#endif
#include "EnvironmentQuery/Items/EnvQueryItemType.h"
#include "EnvironmentQuery/EnvQueryContext.h"
#include "BehaviorTree/BehaviorTreeTypes.h"
#include "EnvQueryTypes.generated.h"
 
class AActor;
class ANavigationData;
class Error;
class UBlackboardComponent;
class UBlackboardData;
class UEnvQuery;
class UEnvQueryGenerator;
class UEnvQueryItemType_ActorBase;
class UEnvQueryItemType_VectorBase;
class UEnvQueryTest;
class UNavigationQueryFilter;
struct FEnvQueryInstance;
 
AIMODULE_API DECLARE_LOG_CATEGORY_EXTERN(LogEQS, Display, All);
 
// If set, execution details will be processed by debugger
#ifndef USE_EQS_DEBUGGER
#define USE_EQS_DEBUGGER                (1 && !(UE_BUILD_SHIPPING || UE_BUILD_TEST))
#endif
 
// If set, execution stats will also gather EQS tick load data (16k memory for each query record)
#define USE_EQS_TICKLOADDATA            (1 && USE_EQS_DEBUGGER && WITH_EDITOR)
 
DECLARE_STATS_GROUP(TEXT("Environment Query"), STATGROUP_AI_EQS, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("Tick"),STAT_AI_EQS_Tick,STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Tick - EQS work"), STAT_AI_EQS_TickWork, STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Tick - OnFinished delegates"), STAT_AI_EQS_TickNotifies, STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Tick - Removal of completed queries"), STAT_AI_EQS_TickQueryRemovals, STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Load Time"),STAT_AI_EQS_LoadTime,STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Execute One Step Time"),STAT_AI_EQS_ExecuteOneStep,STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Generator Time"),STAT_AI_EQS_GeneratorTime,STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Test Time"),STAT_AI_EQS_TestTime,STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("EQS Debug StoreQuery"), STAT_AI_EQS_Debug_StoreQuery, STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("EQS Debug StoreTickTime"), STAT_AI_EQS_Debug_StoreTickTime, STATGROUP_AI_EQS, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("EQS Debug StoreStats"), STAT_AI_EQS_Debug_StoreStats, STATGROUP_AI_EQS, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Num Instances"),STAT_AI_EQS_NumInstances,STATGROUP_AI_EQS, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Num Items"),STAT_AI_EQS_NumItems,STATGROUP_AI_EQS, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("Instance memory"),STAT_AI_EQS_InstanceMemory,STATGROUP_AI_EQS, AIMODULE_API);
DECLARE_FLOAT_COUNTER_STAT_EXTERN(TEXT("Avg Instance Response Time (ms)"), STAT_AI_EQS_AvgInstanceResponseTime, STATGROUP_AI_EQS, );
 
UENUM()
namespace EEnvTestPurpose
{
    enum Type : int
    {
        Filter UMETA(DisplayName="Filter Only"),
        Score UMETA(DisplayName="Score Only"),
        FilterAndScore UMETA(DisplayName="Filter and Score")
    };
}
 
UENUM()
namespace EEnvTestFilterType
{
    enum Type : int
    {
        Minimum,
        Maximum,
        Range,
        Match
    };
}
 
UENUM()
namespace EEnvTestScoreEquation
{
    enum Type : int
    {
        Linear,
        Square,
        InverseLinear,
        SquareRoot,
 
        Constant
        // What other curve shapes should be supported?  At first I was thinking we'd have parametric (F*V^P + C), but
        // many versions of that curve would violate the [0, 1] output range which I think we should preserve.  So instead
        // I think we should define these by "curve shape".  I'm not sure if we need to allow full tweaks to the curves,
        // such as supporting other "Exponential" curves (positive even powers).  However, I think it's likely that we'll
        // want to support "smooth LERP" / S-shaped curve of the form 2x^3 - 3x^2, and possibly a "sideways" version of
        // the same S-curve.  We also might want to allow "Sine" curves, basically adjusted to match the range and then
        // simply offset by some amount to allow a peak or valley in the middle or on the ends.  (Four Sine options are
        // probably sufficient.)  I'm not sure if Sine is really needed though, so probably we should only add it if
        // there's a need identified.  One other curve shape we might want is "Square Root", which might optionally
        // support any positive fractional power (if we also supported any positive even number for an "Exponential"
        // type.
    };
}
 
UENUM()
namespace EEnvTestWeight
{
    enum Type : int
    {
        None,
        Square,
        Inverse,
        Unused          UMETA(Hidden),
        Constant,
        Skip            UMETA(DisplayName = "Do not weight"),
    };
}
 
UENUM()
namespace EEnvTestCost
{
    enum Type : int
    {
        Low,
        Medium,
        High,
    };
}
 
UENUM()
namespace EEnvTestFilterOperator
{
    enum Type : int
    {
        AllPass         UMETA(Tooltip = "All contexts must pass condition"),
        AnyPass         UMETA(Tooltip = "At least one context must pass condition"),
    };
}
 
UENUM()
namespace EEnvTestScoreOperator
{
    enum Type : int
    {
        AverageScore    UMETA(Tooltip = "Use average score from all contexts"),
        MinScore        UMETA(Tooltip = "Use minimum score from all contexts"),
        MaxScore        UMETA(Tooltip = "Use maximum score from all contexts"),
        Multiply        UMETA(Tooltip = "Multiply scores from all contexts"),
    };
}
 
namespace EEnvItemStatus
{
    enum Type
    {
        Passed,
        Failed,
    };
}
 
UENUM(BlueprintType)
namespace EEnvQueryStatus
{
    enum Type : int
    {
        Processing,
        Success,
        Failed,
        Aborted,
        OwnerLost,
        MissingParam,
    };
}
 
UENUM()
namespace EEnvQueryRunMode
{
    enum Type : int
    {
        SingleResult    UMETA(Tooltip="Pick first item with the best score", DisplayName="Single Best Item"),
        RandomBest5Pct  UMETA(Tooltip="Pick random item with score 95% .. 100% of max", DisplayName="Single Random Item from Best 5%"),
        RandomBest25Pct UMETA(Tooltip="Pick random item with score 75% .. 100% of max", DisplayName="Single Random Item from Best 25%"),
        AllMatching     UMETA(Tooltip="Get all items that match conditions"),
    };
}
 
UENUM()
enum class EEnvQueryResultNormalizationOption : uint8
{
    Default,
    Normalized,
    Unaltered
};
 
UENUM()
namespace EEnvQueryParam
{
    enum Type : int
    {
        Float,
        Int,
        Bool,
    };
}
 
UENUM()
enum class EAIParamType : uint8
{
    Float,
    Int,
    Bool,
    MAX UMETA(Hidden)
};
 
UENUM()
namespace EEnvQueryTrace
{
    enum Type : int
    {
        None,
        Navigation,
        GeometryByChannel,
        GeometryByProfile,
        NavigationOverLedges
    };
}
 
UENUM()
namespace EEnvTraceShape
{
    enum Type : int
    {
        Line,
        Box,
        Sphere,
        Capsule,
    };
}
 
UENUM()
namespace EEnvOverlapShape
{
    enum Type : int
    {
        Box,
        Sphere,
        Capsule,
    };
}
 
UENUM(meta=(ScriptName="EnvDirectionType"))
namespace EEnvDirection
{
    enum Type : int
    {
        TwoPoints   UMETA(DisplayName="Two Points",ToolTip="Direction from location of one context to another."),
        Rotation    UMETA(ToolTip="Context's rotation will be used as a direction."),
    };
}
 
UENUM()
namespace EEnvQueryTestClamping
{
    enum Type : int
    {
        None,           
        SpecifiedValue,
        FilterThreshold
    };
}
 
USTRUCT(BlueprintType)
struct FEnvNamedValue
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Param)
    FName ParamName;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Param)
    EAIParamType ParamType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Param)
    float Value;
 
    FEnvNamedValue()
        : ParamType(EAIParamType::Float), Value(0.f)
    {}
};
 
USTRUCT()
struct FEnvDirection
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditDefaultsOnly, Category=Direction)
    TSubclassOf<UEnvQueryContext> LineFrom;
 
    UPROPERTY(EditDefaultsOnly, Category=Direction)
    TSubclassOf<UEnvQueryContext> LineTo;
 
    UPROPERTY(EditDefaultsOnly, Category=Direction)
    TSubclassOf<UEnvQueryContext> Rotation;
 
    UPROPERTY(EditDefaultsOnly, Category=Direction, meta=(DisplayName="Mode"))
    TEnumAsByte<EEnvDirection::Type> DirMode = EEnvDirection::Type::TwoPoints;
 
    AIMODULE_API FText ToText() const;
};
 
USTRUCT()
struct FEnvTraceData
{
    GENERATED_USTRUCT_BODY()
 
    enum EDescriptionMode
    {
        Brief,
        Detailed,
    };
 
    AIMODULE_API FEnvTraceData();
 
    UPROPERTY()
    int32 VersionNum;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    TSubclassOf<UNavigationQueryFilter> NavigationFilter;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, meta=(UIMin=0, ClampMin=0))
    float ProjectDown;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, meta=(UIMin=0, ClampMin=0))
    float ProjectUp;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, meta=(UIMin=0, ClampMin=0))
    float ExtentX;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, meta=(UIMin=0, ClampMin=0))
    float ExtentY;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, meta=(UIMin=0, ClampMin=0))
    float ExtentZ;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    float PostProjectionVerticalOffset;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    TEnumAsByte<enum ETraceTypeQuery> TraceChannel;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    TEnumAsByte<enum ECollisionChannel> SerializedChannel;
 
    UPROPERTY(EditDefaultsOnly, Category = Trace)
    FName TraceProfileName;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    TEnumAsByte<EEnvTraceShape::Type> TraceShape;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    TEnumAsByte<EEnvQueryTrace::Type> TraceMode;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, AdvancedDisplay)
    uint32 bTraceComplex : 1;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace, AdvancedDisplay)
    uint32 bOnlyBlockingHits : 1;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    uint32 bCanTraceOnNavMesh : 1;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    uint32 bCanTraceOnGeometry : 1;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    uint32 bCanDisableTrace : 1;
 
    UPROPERTY(EditDefaultsOnly, Category=Trace)
    uint32 bCanProjectDown : 1;
 
    AIMODULE_API FText ToText(EDescriptionMode DescMode) const;
 
    AIMODULE_API void SetGeometryOnly();
    AIMODULE_API void SetNavmeshOnly();
    
    AIMODULE_API void OnPostLoad();
};
 
USTRUCT()
struct FEnvOverlapData
{
    GENERATED_USTRUCT_BODY()
 
    FEnvOverlapData() :
        ExtentX(10.0f),
        ExtentY(10.0f),
        ExtentZ(10.0f),
        ShapeOffset(FVector::ZeroVector),
        OverlapChannel(ECC_WorldStatic),
        OverlapShape(EEnvOverlapShape::Box),
        bOnlyBlockingHits(true),
        bOverlapComplex(false),
        bSkipOverlapQuerier(false)
    {
    }
 
    UPROPERTY(EditDefaultsOnly, Category = Trace, meta = (UIMin = 0, ClampMin = 0))
    float ExtentX;
 
    UPROPERTY(EditDefaultsOnly, Category = Trace, meta = (UIMin = 0, ClampMin = 0))
    float ExtentY;
 
    UPROPERTY(EditDefaultsOnly, Category = Trace, meta = (UIMin = 0, ClampMin = 0))
    float ExtentZ;
 
    UPROPERTY(EditDefaultsOnly, Category = Trace, AdvancedDisplay, Meta =
        (Tooltip="Offset from the item location at which to test the overlap.  For example, you may need to offset vertically to avoid overlaps with flat ground."))
    FVector ShapeOffset;
 
    UPROPERTY(EditDefaultsOnly, Category = Overlap)
    TEnumAsByte<enum ECollisionChannel> OverlapChannel;
 
    UPROPERTY(EditDefaultsOnly, Category = Overlap)
    TEnumAsByte<EEnvOverlapShape::Type> OverlapShape;
 
    UPROPERTY(EditDefaultsOnly, Category = Overlap, AdvancedDisplay)
    uint32 bOnlyBlockingHits : 1;
 
    UPROPERTY(EditDefaultsOnly, Category = Overlap, AdvancedDisplay)
    uint32 bOverlapComplex : 1;
 
    UPROPERTY(EditDefaultsOnly, Category = Overlap, AdvancedDisplay)
    uint32 bSkipOverlapQuerier : 1;
};
 
// Returned results
 
struct FEnvQueryItem
{
    float Score;
 
    int32 DataOffset:31;
 
    uint32 bIsDiscarded:1;
 
    inline bool IsValid() const { return DataOffset >= 0 && !bIsDiscarded; }
    inline void Discard() { bIsDiscarded = true; }
 
    bool operator<(const FEnvQueryItem& Other) const
    {
        // sort by validity
        if (IsValid() != Other.IsValid())
        {
            // self not valid = less important
            return !IsValid();
        }
 
        // sort by score if not equal. As last resort sort by DataOffset to achieve stable sort.
        return Score != Other.Score ? Score < Other.Score : DataOffset < Other.DataOffset;
    }
 
    FEnvQueryItem() : Score(0.0f), DataOffset(-1), bIsDiscarded(false) {}
    FEnvQueryItem(int32 InOffset) : Score(0.0f), DataOffset(InOffset), bIsDiscarded(false) {}
};
 
template <> struct TIsZeroConstructType<FEnvQueryItem> { enum { Value = true }; };
 
USTRUCT(BlueprintType)
struct FEnvQueryResult
{
    GENERATED_USTRUCT_BODY()
 
    TArray<FEnvQueryItem> Items;
 
    UPROPERTY(BlueprintReadOnly, Category = "EQS")
    TSubclassOf<UEnvQueryItemType> ItemType;
 
    TArray<uint8> RawData;
 
private:
    EEnvQueryStatus::Type Status;
 
public:
    UPROPERTY(BlueprintReadOnly, Category = "EQS")
    int32 OptionIndex;
 
    UPROPERTY(BlueprintReadOnly, Category = "EQS")
    int32 QueryID;
 
    TWeakObjectPtr<UObject> Owner;
 
    inline float GetItemScore(int32 Index) const { return Items.IsValidIndex(Index) ? Items[Index].Score : 0.0f; }
 
    AIMODULE_API AActor* GetItemAsActor(int32 Index) const;
    AIMODULE_API FVector GetItemAsLocation(int32 Index) const;
 
    template<typename TItemType>
    const typename TItemType::FValueType& GetItemAsTypeChecked(const int32 Index) const
    {
        check(Items.IsValidIndex(Index) 
            && ItemType.Get()
            && ItemType->IsChildOf(TItemType::StaticClass()));
 
        return TItemType::template GetValueFromMemory<typename TItemType::FValueType>(GetItemRawMemory(Index));
    }
 
    AIMODULE_API void GetAllAsActors(TArray<AActor*>& OutActors) const;
    AIMODULE_API void GetAllAsLocations(TArray<FVector>& OutLocations) const;
 
    const uint8* GetItemRawMemory(const int32 Index) const
    {
        check(Items.IsValidIndex(Index));
        return RawData.GetData() + Items[Index].DataOffset;
    }
 
    FEnvQueryResult() : ItemType(NULL), Status(EEnvQueryStatus::Processing), OptionIndex(0), QueryID(0) {}
    FEnvQueryResult(const EEnvQueryStatus::Type& InStatus) : ItemType(NULL), Status(InStatus), OptionIndex(0), QueryID(0) {}
 
    inline bool IsFinished() const { return Status != EEnvQueryStatus::Processing; }
    inline bool IsAborted() const { return Status == EEnvQueryStatus::Aborted; }
    inline bool IsSuccessful() const { return Status == EEnvQueryStatus::Success; }
    inline void MarkAsMissingParam() { Status = EEnvQueryStatus::MissingParam; }
    inline void MarkAsAborted() { Status = EEnvQueryStatus::Aborted; }
    inline void MarkAsFailed() { Status = EEnvQueryStatus::Failed; }
    inline void MarkAsFinishedWithoutIssues() { Status = EEnvQueryStatus::Success; }
    inline void MarkAsOwnerLost() { Status = EEnvQueryStatus::OwnerLost; }
 
    inline EEnvQueryStatus::Type GetRawStatus() const { return Status; }
 
    UE_DEPRECATED(5.0, "FEnvQueryResult::IsSuccsessful is deprecated. Use FEnvQueryResult::IsSuccessful instead.")
    inline bool IsSuccsessful() const { return IsSuccessful(); }
};
 
 
// Runtime processing structures
 
DECLARE_DELEGATE_OneParam(FQueryFinishedSignature, TSharedPtr<FEnvQueryResult>);
 
struct FEnvQuerySpatialData
{
    FVector Location;
    FRotator Rotation;
};
 
struct FEnvQueryItemDetails
{
    TArray<float> TestResults;
 
#if USE_EQS_DEBUGGER
    TArray<float> TestWeightedScores;
 
    int32 FailedTestIndex;
    int32 ItemIndex;
    FString FailedDescription;
#endif // USE_EQS_DEBUGGER
 
    FEnvQueryItemDetails() {}
    FEnvQueryItemDetails(int32 NumTests, int32 InItemIndex)
    {
        TestResults.AddZeroed(NumTests);
#if USE_EQS_DEBUGGER
        TestWeightedScores.AddZeroed(NumTests);
        ItemIndex = InItemIndex;
        FailedTestIndex = INDEX_NONE;
#endif
    }
 
    inline uint32 GetAllocatedSize() const
    {
        return sizeof(*this) +
#if USE_EQS_DEBUGGER
            TestWeightedScores.GetAllocatedSize() +
#endif
            TestResults.GetAllocatedSize();
    }
};
 
USTRUCT()
struct FEnvQueryContextData
{
    GENERATED_BODY()
 
    
    UPROPERTY(Transient)
    TSubclassOf<UEnvQueryItemType> ValueType;
 
    int32 NumValues;
 
    TArray<uint8> RawData;
 
    FEnvQueryContextData()
        : NumValues(0)
    {}
 
    inline uint32 GetAllocatedSize() const { return sizeof(*this) + RawData.GetAllocatedSize(); }
};
 
USTRUCT()
struct FEnvQueryOptionInstance
{
    GENERATED_BODY()
 
    
    UPROPERTY(transient)
    TObjectPtr<UEnvQueryGenerator> Generator;
 
    UPROPERTY(transient)
    TArray<TObjectPtr<UEnvQueryTest>> Tests;
 
    int32 SourceOptionIndex;
 
    UPROPERTY(transient)
    TSubclassOf<UEnvQueryItemType> ItemType;
 
    uint32 bHasNavLocations : 1;
 
    uint32 GetAllocatedSize() const
    {
        return sizeof(*this) + Tests.GetAllocatedSize();
    }
};
 
#if NO_LOGGING
#define EQSHEADERLOG(...)
#else
#define EQSHEADERLOG(msg) Log(msg)
#endif // NO_LOGGING
 
struct FEnvQueryDebugProfileData
{
    struct FStep
    {
        float ExecutionTime;
        int32 NumProcessedItems;
 
        FStep() : ExecutionTime(0.0f), NumProcessedItems(0) {}
    };
 
    // runtime stats, can be merged
    struct FOptionStat
    {
        TArray<FStep> StepData;
        int32 NumRuns;
 
        FOptionStat() : NumRuns(0) {}
    };
 
    // setup data
    struct FOptionData
    {
        int32 NumGenerators;
        TArray<FName> GeneratorNames;
 
        int32 OptionIdx;
        TArray<int32> TestIndices;
 
        FOptionData() : NumGenerators(1), OptionIdx(INDEX_NONE) {}
    };
 
    TArray<FOptionStat> OptionStats;
    TArray<FOptionData> OptionData;
 
    void Add(const FEnvQueryDebugProfileData& Other);
};
 
FArchive& operator<<(FArchive& Ar, FEnvQueryDebugProfileData::FStep& Data);
FArchive& operator<<(FArchive& Ar, FEnvQueryDebugProfileData::FOptionStat& Data);
FArchive& operator<<(FArchive& Ar, FEnvQueryDebugProfileData::FOptionData& Data);
FArchive& operator<<(FArchive& Ar, FEnvQueryDebugProfileData& Data);
 
struct FEnvQueryDebugData : public FEnvQueryDebugProfileData
{
    TArray<FEnvQueryItem> DebugItems;
    TArray<FEnvQueryItemDetails> DebugItemDetails;
    TArray<uint8> RawData;
    TArray<FString> PerformedTestNames;
 
    // indicates the query was run in a single-item mode and that it has been found
    uint32 bSingleItemResult : 1;
 
    int32 CurrentOptionGeneratorIdx = INDEX_NONE;
 
    FEnvQueryDebugData() : bSingleItemResult(false) {}
    
    void Store(const FEnvQueryInstance& QueryInstance, const float ExecutionTime, const bool bStepDone);
    void PrepareOption(const FEnvQueryInstance& QueryInstance, const TArray<UEnvQueryGenerator*>& Generators, const int32 NumTests);
};
 
// This struct is now deprecated, please use FEnvQueryDebugData instead.
struct FEQSQueryDebugData : public FEnvQueryDebugData
{
};
 
UCLASS(Abstract, MinimalAPI)
class UEnvQueryTypes : public UObject
{
    GENERATED_BODY()
 
public:
    static AIMODULE_API const float SkippedItemValue;
 
    static AIMODULE_API float UnlimitedStepTime;
 
    static AIMODULE_API FText GetShortTypeName(const UObject* Ob);
    static AIMODULE_API FText DescribeContext(TSubclassOf<UEnvQueryContext> ContextClass);
};
 
USTRUCT()
struct FEnvQueryInstanceContextCacheItem
{
    GENERATED_BODY()
 
    UPROPERTY(transient)
    TObjectPtr<UClass> Class;
 
    UPROPERTY(transient)
    FEnvQueryContextData ContextData;
};
 
USTRUCT()
struct FEnvQueryInstance : public FEnvQueryResult
{
    GENERATED_BODY()
 
    typedef float FNamedParamValueType;
 
    FString QueryName;
 
    FName UniqueName;
 
    UPROPERTY(transient)
    TObjectPtr<UWorld> World;
 
    FQueryFinishedSignature FinishDelegate;
 
    TMap<FName, FNamedParamValueType> NamedParams;
 
    UPROPERTY(transient)
    TArray<FEnvQueryInstanceContextCacheItem> ContextCache;
 
    UPROPERTY(transient)
    TArray<FEnvQueryOptionInstance> Options;
 
    int32 CurrentTest;
 
    int32 CurrentTestStartingItem;
 
    TArray<FEnvQueryItemDetails> ItemDetails;
 
    int32 NumValidItems;
 
    uint16 ValueSize;
 
#if USE_EQS_DEBUGGER
    int32 NumProcessedItems;
 
    uint8 bStoreDebugInfo : 1;
#endif // USE_EQS_DEBUGGER
 
    uint8 bFoundSingleResult : 1;
 
    uint8 bPassOnSingleResult : 1;
 
    uint8 bHasLoggedTimeLimitWarning : 1;
 
    uint8 bIsCurrentlyRunningAsync : 1;
 
    double StartTime;
 
    double TotalExecutionTime;
 
    double CurrentStepTimeLimit;
 
#if !UE_BUILD_SHIPPING
    double GenerationTimeWarningSeconds = 0.01f;
#endif // UE_BUILD_SHIPPING
 
    EEnvQueryRunMode::Type Mode;
 
    UPROPERTY(transient)
    TObjectPtr<UEnvQueryItemType_VectorBase> ItemTypeVectorCDO;
 
    UPROPERTY(transient)
    TObjectPtr<UEnvQueryItemType_ActorBase> ItemTypeActorCDO;
 
    AIMODULE_API FEnvQueryInstance();
    AIMODULE_API FEnvQueryInstance(const FEnvQueryInstance& Other);
    AIMODULE_API ~FEnvQueryInstance();
 
    AIMODULE_API void ExecuteOneStep(double TimeLimit);
 
    AIMODULE_API bool PrepareContext(UClass* Context, FEnvQueryContextData& ContextData);
 
    AIMODULE_API bool PrepareContext(UClass* Context, TArray<FEnvQuerySpatialData>& Data);
    AIMODULE_API bool PrepareContext(UClass* Context, TArray<FVector>& Data);
    AIMODULE_API bool PrepareContext(UClass* Context, TArray<FRotator>& Data);
    AIMODULE_API bool PrepareContext(UClass* Context, TArray<AActor*>& Data);
    
    bool IsInSingleItemFinalSearch() const { return !!bPassOnSingleResult; }
    bool CanBatchTest() const { return !IsInSingleItemFinalSearch(); }
 
    bool IsCurrentlyRunningAsync() const { return bIsCurrentlyRunningAsync; }
 
    AIMODULE_API void ReserveItemData(int32 NumAdditionalItems);
 
    template<typename TypeItem>
    void AddItemData(typename TypeItem::FValueType ItemValue)
    {
        DEC_MEMORY_STAT_BY(STAT_AI_EQS_InstanceMemory, RawData.GetAllocatedSize() + Items.GetAllocatedSize());
 
        // ItemValue's size must match what is expected by class doing memory write
        check(GetDefault<TypeItem>()->GetValueSize() == sizeof(typename TypeItem::FValueType));
        // writer must fit into block allocated for single item (not 'equal' on purpose, check UEnvQueryGenerator_Composite.bAllowDifferentItemTypes)
        check(GetDefault<TypeItem>()->GetValueSize() <= ValueSize);
 
        const int32 DataOffset = RawData.AddZeroed(ValueSize);
        TypeItem::SetValue(RawData.GetData() + DataOffset, ItemValue);
        Items.Add(FEnvQueryItem(DataOffset));
 
        INC_MEMORY_STAT_BY(STAT_AI_EQS_InstanceMemory, RawData.GetAllocatedSize() + Items.GetAllocatedSize());
    }
 
    template<typename TypeItem>
    void AddItemData(TArray<typename TypeItem::FValueType>& ItemCollection)
    {
        if (ItemCollection.Num() > 0)
        {
            DEC_MEMORY_STAT_BY(STAT_AI_EQS_InstanceMemory, RawData.GetAllocatedSize() + Items.GetAllocatedSize());
 
            // ItemValue's size must match what is expected by class doing memory write
            check(GetDefault<TypeItem>()->GetValueSize() == sizeof(typename TypeItem::FValueType));
            // writer must fit into block allocated for single item (not 'equal' on purpose, check UEnvQueryGenerator_Composite.bAllowDifferentItemTypes)
            check(GetDefault<TypeItem>()->GetValueSize() <= ValueSize);
 
            int32 DataOffset = RawData.AddZeroed(ValueSize * ItemCollection.Num());
            Items.Reserve(Items.Num() + ItemCollection.Num());
 
            for (typename TypeItem::FValueType& Item : ItemCollection)
            {
                TypeItem::SetValue(RawData.GetData() + DataOffset, Item);
                Items.Add(FEnvQueryItem(DataOffset));
                DataOffset += ValueSize;
            }
 
            INC_MEMORY_STAT_BY(STAT_AI_EQS_InstanceMemory, RawData.GetAllocatedSize() + Items.GetAllocatedSize());
        }
    }
 
    template<typename TypeItem, typename TypeValue>
    void AddItemData(TypeValue ItemValue)
    {
        AddItemData<TypeItem>((typename TypeItem::FValueType)(ItemValue));
    }
 
    template<typename TypeItem, typename TypeValue>
    void AddItemData(TArray<TypeValue>& ItemCollection)
    {
        for (auto& Item : ItemCollection)
        {
            AddItemData<TypeItem>((typename TypeItem::FValueType)(Item));
        }
    }
 
protected:
 
    AIMODULE_API void FinalizeGeneration();
 
    AIMODULE_API void FinalizeTest();
    
    AIMODULE_API void FinalizeQuery();
 
    AIMODULE_API void NormalizeScores();
 
    AIMODULE_API void SortScores();
 
    AIMODULE_API void PickRandomItemOfScoreAtLeast(float MinScore);
 
    AIMODULE_API void PickSingleItem(int32 ItemIndex);
 
public:
 
    AIMODULE_API void StripRedundantData();
 
#if STATS
    inline void IncStats()
    {
        INC_MEMORY_STAT_BY(STAT_AI_EQS_InstanceMemory, GetAllocatedSize());
        INC_DWORD_STAT_BY(STAT_AI_EQS_NumItems, Items.Num());
    }
 
    inline void DecStats()
    {
        DEC_MEMORY_STAT_BY(STAT_AI_EQS_InstanceMemory, GetAllocatedSize()); 
        DEC_DWORD_STAT_BY(STAT_AI_EQS_NumItems, Items.Num());
    }
 
    AIMODULE_API uint32 GetAllocatedSize() const;
    AIMODULE_API uint32 GetContextAllocatedSize() const;
#else
    inline uint32 GetAllocatedSize() const { return 0; }
    inline uint32 GetContextAllocatedSize() const { return 0; }
    inline void IncStats() {}
    inline void DecStats() {}
#endif // STATS
 
#if !NO_LOGGING
    AIMODULE_API void Log(const FString Msg) const;
#endif // #if !NO_LOGGING
 
#if USE_EQS_DEBUGGER
#   define  UE_EQS_DBGMSG(Condition, Format, ...) \
                    if (Condition) \
                    { \
                        Instance.ItemDetails[CurrentItem].FailedDescription = FString::Printf(Format, ##__VA_ARGS__); \
                    }
 
#   define UE_EQS_LOG(CategoryName, Verbosity, Format, ...) \
                    UE_LOG(CategoryName, Verbosity, Format, ##__VA_ARGS__); \
                    UE_EQS_DBGMSG(true, Format, ##__VA_ARGS__); 
#else
#   define UE_EQS_DBGMSG(Condition, Format, ...)
#   define UE_EQS_LOG(CategoryName, Verbosity, Format, ...) UE_LOG(CategoryName, Verbosity, Format, ##__VA_ARGS__); 
#endif
 
    AIMODULE_API FString GetExecutionTimeDescription() const;
 
#if CPP || UE_BUILD_DOCS
    struct FConstItemIterator
    {
        FConstItemIterator(FEnvQueryInstance& QueryInstance, int32 StartingItemIndex = INDEX_NONE)
            : Instance(QueryInstance)
            , CurrentItem(StartingItemIndex != INDEX_NONE ? StartingItemIndex : QueryInstance.CurrentTestStartingItem)
        {
            if (StartingItemIndex != INDEX_NONE)
            {
                CurrentItem = StartingItemIndex;
            }
            else
            {
                CurrentItem = QueryInstance.CurrentTestStartingItem;
                if (Instance.Items.IsValidIndex(CurrentItem) == false || Instance.Items[CurrentItem].IsValid() == false)
                {
                    ++(*this);
                }
            }
        }
 
        uint8* GetItemData()
        {
            return Instance.RawData.GetData() + Instance.Items[CurrentItem].DataOffset;
        }
 
        int32 GetIndex() const
        {
            return CurrentItem;
        }
 
        inline explicit operator bool() const
        {
            return CurrentItem < Instance.Items.Num();
        }
 
        void operator++()
        {
            ++CurrentItem;
            for (; CurrentItem < Instance.Items.Num() && !Instance.Items[CurrentItem].IsValid(); ++CurrentItem)
                ;
        }
 
    protected:
 
        FEnvQueryInstance& Instance;
        int32 CurrentItem;
    };
 
    struct FItemIterator : public FConstItemIterator
    {
        AIMODULE_API FItemIterator(const UEnvQueryTest* QueryTest, FEnvQueryInstance& QueryInstance, int32 StartingItemIndex = INDEX_NONE);
 
        ~FItemIterator()
        {
            Instance.CurrentTestStartingItem = CurrentItem;
        }
 
        void SetScore(EEnvTestPurpose::Type TestPurpose, EEnvTestFilterType::Type FilterType, float Score, float FilterMin, float FilterMax)
        {
            if (bForced)
            {
                return;
            }
 
            bool bPassedTest = true;
 
            if (TestPurpose != EEnvTestPurpose::Score)  // May need to filter results!
            {
                switch (FilterType)
                {
                    case EEnvTestFilterType::Maximum:
                        bPassedTest = (Score <= FilterMax);
                        UE_EQS_DBGMSG(!bPassedTest, TEXT("Value %f is above maximum value set to %f"), Score, FilterMax);
                        break;
 
                    case EEnvTestFilterType::Minimum:
                        bPassedTest = (Score >= FilterMin);
                        UE_EQS_DBGMSG(!bPassedTest, TEXT("Value %f is below minimum value set to %f"), Score, FilterMin);
                        break;
 
                    case EEnvTestFilterType::Range:
                        bPassedTest = (Score >= FilterMin) && (Score <= FilterMax);
                        UE_EQS_DBGMSG(!bPassedTest, TEXT("Value %f is out of range set to (%f, %f)"), Score, FilterMin, FilterMax);
                        break;
 
                    case EEnvTestFilterType::Match:
                        UE_EQS_LOG(LogEQS, Error, TEXT("Filtering Type set to 'Match' for floating point test.  Will consider test as failed in all cases."));
                        bPassedTest = false;
                        break;
 
                    default:
                        UE_EQS_LOG(LogEQS, Error, TEXT("Filtering Type set to invalid value for floating point test.  Will consider test as failed in all cases."));
                        bPassedTest = false;
                        break;
                }
            }
 
            if (bPassedTest)
            {
                SetScoreInternal(Score);
                NumPassedForItem++;
            }
 
            NumTestsForItem++;
        }
 
        void SetScore(EEnvTestPurpose::Type TestPurpose, EEnvTestFilterType::Type FilterType, bool bScore, bool bExpected)
        {
            if (bForced)
            {
                return;
            }
 
            bool bPassedTest = true;
            switch (FilterType)
            {
                case EEnvTestFilterType::Match:
                    bPassedTest = (bScore == bExpected);
                    UE_EQS_DBGMSG(!bPassedTest, TEXT("Boolean score doesn't match (expected %s and got %s)"), bExpected ? TEXT("TRUE") : TEXT("FALSE"), bScore ? TEXT("TRUE") : TEXT("FALSE"));
                    break;
 
                case EEnvTestFilterType::Maximum:
                    UE_EQS_LOG(LogEQS, Error, TEXT("Filtering Type set to 'Maximum' for boolean test.  Will consider test as failed in all cases."));
                    bPassedTest = false;
                    break;
 
                case EEnvTestFilterType::Minimum:
                    UE_EQS_LOG(LogEQS, Error, TEXT("Filtering Type set to 'Minimum' for boolean test.  Will consider test as failed in all cases."));
                    bPassedTest = false;
                    break;
 
                case EEnvTestFilterType::Range:
                    UE_EQS_LOG(LogEQS, Error, TEXT("Filtering Type set to 'Range' for boolean test.  Will consider test as failed in all cases."));
                    bPassedTest = false;
                    break;
 
                default:
                    UE_EQS_LOG(LogEQS, Error, TEXT("Filtering Type set to invalid value for boolean test.  Will consider test as failed in all cases."));
                    bPassedTest = false;
                    break;
            }
 
            if (bPassedTest || !bIsFiltering)
            {
                // even if the item's result is different than expected
                // but we're not filtering those items out, we still want
                // to treat this as successful test, just with different score
                SetScoreInternal(bPassedTest ? 1.0f : 0.f);
                NumPassedForItem++;
            }
 
            NumTestsForItem++;
        }
 
        void ForceItemState(const EEnvItemStatus::Type InStatus, const float Score = UEnvQueryTypes::SkippedItemValue)
        {
            bForced = true;
            bPassed = (InStatus == EEnvItemStatus::Passed);
            ItemScore = Score;
        }
 
        FItemIterator& IgnoreTimeLimit()
        {
            Deadline = -1.0f;
            return *this;
        }
 
        inline explicit operator bool() const
        {
            return CurrentItem < Instance.Items.Num() && !Instance.bFoundSingleResult && (Deadline < 0 || FPlatformTime::Seconds() < Deadline);
        }
 
        void operator++()
        {
            StoreTestResult();
            if (!Instance.bFoundSingleResult)
            {
                InitItemScore();
                FConstItemIterator::operator++();
            }
        }
 
    protected:
 
        double Deadline;
        float ItemScore;
        int16 NumPassedForItem;
        int16 NumTestsForItem;
        uint8 CachedFilterOp;
        uint8 CachedScoreOp;
        uint8 bPassed : 1;
        uint8 bForced : 1;
        uint8 bIsFiltering : 1;
 
        void InitItemScore()
        {
            NumPassedForItem = 0;
            NumTestsForItem = 0;
            ItemScore = 0.0f;
            bPassed = true;
            bForced = false;
        }
 
        AIMODULE_API void HandleFailedTestResult();
        AIMODULE_API void StoreTestResult();
 
        inline void SetScoreInternal(float Score)
        {
            switch (CachedScoreOp)
            {
            case EEnvTestScoreOperator::AverageScore:
                ItemScore += Score;
                break;
 
            case EEnvTestScoreOperator::MinScore:
                if (!NumPassedForItem || ItemScore > Score)
                {
                    ItemScore = Score;
                }
                break;
 
            case EEnvTestScoreOperator::MaxScore:
                if (!NumPassedForItem || ItemScore < Score)
                {
                    ItemScore = Score;
                }
                break;
            case EEnvTestScoreOperator::Multiply:
                // ItemScore defaults to 0, so for first test we need to initialize the score, otherwise we end up constantly multiplying by 0
                ItemScore = (NumTestsForItem == 0) ? Score : (ItemScore * Score);
                break;
            }
        }
 
        inline void CheckItemPassed()
        {
            if (!bForced)
            {
                if (NumTestsForItem == 0)
                {
                    bPassed = false;
                }
                else if (!bIsFiltering)
                {
                    bPassed = true;
                }
                else if (CachedFilterOp == EEnvTestFilterOperator::AllPass)
                {
                    bPassed = bPassed && (NumPassedForItem == NumTestsForItem);
                }
                else
                {
                    bPassed = bPassed && (NumPassedForItem > 0);
                }
            }
        }
    };
    typedef FItemIterator ItemIterator;
#endif
 
#undef UE_EQS_LOG
#undef UE_EQS_DBGMSG
 
#if USE_EQS_DEBUGGER
    FEnvQueryDebugData DebugData;
    static AIMODULE_API bool bDebuggingInfoEnabled;
#endif // USE_EQS_DEBUGGER
 
#if STATS
    TStatId StatId;
#endif
 
    AIMODULE_API FBox GetBoundingBox() const;
};
 
namespace FEQSHelpers
{
    AIMODULE_API const ANavigationData* FindNavigationDataForQuery(FEnvQueryInstance& QueryInstance);
}
 
USTRUCT(BlueprintType)
struct FAIDynamicParam
{
    GENERATED_USTRUCT_BODY();
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = EQS)
    FName ParamName;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = EQS)
    EAIParamType ParamType;
 
    UPROPERTY(BlueprintReadWrite, Category = EQS)
    uint8 bAllowBBKey : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = EQS)
    float Value;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = EQS, meta=(EditCondition="bAllowBBKey", EditConditionHides))
    FBlackboardKeySelector BBKey;
 
 
    FAIDynamicParam()
    {
        ParamType = EAIParamType::Float;
        Value = 0.f;
        BBKey.AllowNoneAsValue(true);
        bAllowBBKey = true;
    }
 
    AIMODULE_API void ConfigureBBKey(UObject &QueryOwner);
 
    static AIMODULE_API void GenerateConfigurableParamsFromNamedValues(UObject &QueryOwner, TArray<FAIDynamicParam>& OutQueryConfig, TArray<FEnvNamedValue>& InQueryParams);
};
 
USTRUCT()
struct FEQSParametrizedQueryExecutionRequest
{
    GENERATED_USTRUCT_BODY()
 
    AIMODULE_API FEQSParametrizedQueryExecutionRequest();
 
    UPROPERTY(Category = Node, EditAnywhere, meta = (EditCondition = "!bUseBBKeyForQueryTemplate"))
    TObjectPtr<UEnvQuery> QueryTemplate;
 
    UPROPERTY(Category = Node, EditAnywhere)
    TArray<FAIDynamicParam> QueryConfig;
    
    UPROPERTY(EditAnywhere, Category = Blackboard, meta = (EditCondition = "bUseBBKeyForQueryTemplate"))
    FBlackboardKeySelector EQSQueryBlackboardKey;
 
    UPROPERTY(Category = Node, EditAnywhere)
    TEnumAsByte<EEnvQueryRunMode::Type> RunMode;
 
    UPROPERTY(Category = Node, EditAnywhere, meta=(InlineEditConditionToggle))
    uint32 bUseBBKeyForQueryTemplate : 1;
 
    uint32 bInitialized : 1;
 
    AIMODULE_API void InitForOwnerAndBlackboard(UObject& Owner, UBlackboardData* BBAsset);
 
    bool IsValid() const { return bInitialized; }
 
    AIMODULE_API int32 Execute(UObject& QueryOwner, const UBlackboardComponent* BlackboardComponent, FQueryFinishedSignature& QueryFinishedDelegate);
 
#if WITH_EDITOR
    AIMODULE_API void PostEditChangeProperty(UObject& Owner, struct FPropertyChangedEvent& PropertyChangedEvent);
#endif // WITH_EDITOR
};