EnvQueryTest.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 "EnvironmentQuery/Items/EnvQueryItemType.h"
#include "EnvironmentQuery/EnvQueryContext.h"
#include "EnvironmentQuery/EnvQueryTypes.h"
#include "DataProviders/AIDataProvider.h"
#include "EnvironmentQuery/EnvQueryNode.h"
#include "EnvQueryTest.generated.h"
 
class AActor;
 
#if WITH_EDITOR
struct FPropertyChangedEvent;
#endif // WITH_EDITOR
 
UENUM()
enum class EEQSNormalizationType : uint8
{
    // Use 0 as the base of normalization range.
    Absolute,
    // Use lowest item score as the base of normalization range.
    RelativeToScores
};
 
namespace EnvQueryTestVersion
{
    inline const int32 Initial = 0;
    inline const int32 DataProviders = 1;
    inline const int32 ReferenceValueFix = 2;
 
    inline const int32 Latest = ReferenceValueFix;
}
 
#if WITH_EDITORONLY_DATA
struct FEnvQueryTestScoringPreview
{
    enum 
    {
        // used for built-in functions (@see EEnvTestScoreEquation)
        DefaultSamplesCount = 21
    };
 
    TArray<float> Samples;
    float FilterLow;
    float FilterHigh;
    float ClampMin;
    float ClampMax;
    uint32 bShowFilterLow : 1;
    uint32 bShowFilterHigh : 1;
    uint32 bShowClampMin : 1;
    uint32 bShowClampMax : 1;
};
#endif
 
UCLASS(Abstract, MinimalAPI)
class UEnvQueryTest : public UEnvQueryNode
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY()
    int32 TestOrder;
 
    UPROPERTY(EditDefaultsOnly, Category=Test)
    TEnumAsByte<EEnvTestPurpose::Type> TestPurpose;
 
    UPROPERTY(EditDefaultsOnly, Category=Test)
    FString TestComment;
 
    UPROPERTY(EditDefaultsOnly, Category=Filter, AdvancedDisplay)
    TEnumAsByte<EEnvTestFilterOperator::Type> MultipleContextFilterOp;
 
    UPROPERTY(EditDefaultsOnly, Category = Score, AdvancedDisplay)
    TEnumAsByte<EEnvTestScoreOperator::Type> MultipleContextScoreOp;
 
    UPROPERTY(EditDefaultsOnly, Category=Filter)
    TEnumAsByte<EEnvTestFilterType::Type> FilterType;
 
    UPROPERTY(EditDefaultsOnly, Category=Filter)
    FAIDataProviderBoolValue BoolValue;
 
    UPROPERTY(EditDefaultsOnly, Category=Filter)
    FAIDataProviderFloatValue FloatValueMin;
 
    UPROPERTY(EditDefaultsOnly, Category=Filter)
    FAIDataProviderFloatValue FloatValueMax;
 
    TEnumAsByte<EEnvTestCost::Type> Cost;
 
    UPROPERTY(EditDefaultsOnly, Category=Score)
    TEnumAsByte<EEnvTestScoreEquation::Type> ScoringEquation;
 
    UPROPERTY(EditDefaultsOnly, Category=Score)
    TEnumAsByte<EEnvQueryTestClamping::Type> ClampMinType;
 
    UPROPERTY(EditDefaultsOnly, Category=Score)
    TEnumAsByte<EEnvQueryTestClamping::Type> ClampMaxType;
 
    UPROPERTY(EditDefaultsOnly, Category = Score)
    EEQSNormalizationType NormalizationType;
 
    UPROPERTY(EditDefaultsOnly, Category=Score)
    FAIDataProviderFloatValue ScoreClampMin;
 
    UPROPERTY(EditDefaultsOnly, Category=Score)
    FAIDataProviderFloatValue ScoreClampMax;
 
    UPROPERTY(EditDefaultsOnly, Category=Score, Meta=(ClampMin="0.001", UIMin="0.001"))
    FAIDataProviderFloatValue ScoringFactor;
 
    UPROPERTY(EditDefaultsOnly, Category = Score, Meta=(EditCondition = "bDefineReferenceValue"))
    FAIDataProviderFloatValue ReferenceValue;
 
    UPROPERTY(EditDefaultsOnly, Category = Score, meta=(InlineEditConditionToggle))
    bool bDefineReferenceValue;
    
    TSubclassOf<UEnvQueryItemType> ValidItemType;
 
#if WITH_EDITORONLY_DATA
    FEnvQueryTestScoringPreview PreviewData;
#endif
 
    AIMODULE_API void SetWorkOnFloatValues(bool bWorkOnFloats);
    inline bool GetWorkOnFloatValues() const { return bWorkOnFloatValues; }
 
    inline bool CanRunAsFinalCondition() const 
    { 
        return (TestPurpose != EEnvTestPurpose::Score)                          // We are filtering and...
                && ((TestPurpose == EEnvTestPurpose::Filter)                    // Either we are NOT scoring at ALL or...
                    || (ScoringEquation == EEnvTestScoreEquation::Constant));   // We are giving a constant score value for passing.
    }
 
private:
    UPROPERTY()
    uint32 bWorkOnFloatValues : 1;
 
public:
 
    virtual void RunTest(FEnvQueryInstance& QueryInstance) const { checkNoEntry(); }
 
    bool IsSupportedItem(TSubclassOf<UEnvQueryItemType> ItemType) const;
 
    AIMODULE_API bool IsContextPerItem(TSubclassOf<UEnvQueryContext> CheckContext) const;
 
    AIMODULE_API FVector GetItemLocation(FEnvQueryInstance& QueryInstance, int32 ItemIndex) const;
 
    inline FVector GetItemLocation(FEnvQueryInstance& QueryInstance, const FEnvQueryInstance::ItemIterator& Iterator) const
    {
        return GetItemLocation(QueryInstance, Iterator.GetIndex());
    }
 
    AIMODULE_API FRotator GetItemRotation(FEnvQueryInstance& QueryInstance, int32 ItemIndex) const;
 
    inline FRotator GetItemRotation(FEnvQueryInstance& QueryInstance, const FEnvQueryInstance::ItemIterator& Iterator) const
    {
        return GetItemRotation(QueryInstance, Iterator.GetIndex());
    }
 
    AIMODULE_API AActor* GetItemActor(FEnvQueryInstance& QueryInstance, int32 ItemIndex) const;
        
    inline AActor* GetItemActor(FEnvQueryInstance& QueryInstance, const FEnvQueryInstance::ItemIterator& Iterator) const
    {
        return GetItemActor(QueryInstance, Iterator.GetIndex());
    }
 
    AIMODULE_API void NormalizeItemScores(FEnvQueryInstance& QueryInstance);
 
    inline bool IsScoring() const { return (TestPurpose != EEnvTestPurpose::Filter); } 
    inline bool IsFiltering() const { return (TestPurpose != EEnvTestPurpose::Score); }
 
    AIMODULE_API FText DescribeFloatTestParams() const;
    AIMODULE_API FText DescribeBoolTestParams(const FString& ConditionDesc) const;
 
    AIMODULE_API virtual void PostLoad() override;
 
    AIMODULE_API virtual void UpdateNodeVersion() override;
 
#if WITH_EDITOR
    AIMODULE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
    AIMODULE_API void UpdatePreviewData();
};
 
// Inlines
 
inline bool UEnvQueryTest::IsSupportedItem(TSubclassOf<UEnvQueryItemType> ItemType) const
{
    return ItemType && (ItemType == ValidItemType || ItemType->IsChildOf(ValidItemType));
};