[SmartObject] access to activity tags should go through SmartObjectSlotView

+ Tags Filtering Policy now only affect TagQueries from the definitions and applied to UserTags provided by requests
+ Tags Merging Policy added for Activity Tags
#rnx
#rb josselin.francois
#preflight 621fab91257fd6e0996de3b2

#ROBOMERGE-AUTHOR: yoan.stamant
#ROBOMERGE-SOURCE: CL 19225863 via CL 19236663 via CL 19236832 via CL 19236900
#ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v921-19075845)

[CL 19237559 by yoan stamant in ue5-main branch]

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Private/SmartObjectDefinition.cpp

@@ -12,7 +12,8 @@ namespace UE::SmartObject
 
 USmartObjectDefinition::USmartObjectDefinition(const FObjectInitializer& ObjectInitializer): UDataAsset(ObjectInitializer)
 {
-	TagFilteringPolicy = GetDefault<USmartObjectSettings>()->DefaultTagFilteringPolicy;
+	UserTagsFilteringPolicy = GetDefault<USmartObjectSettings>()->DefaultUserTagsFilteringPolicy;
+	ActivityTagsMergingPolicy = GetDefault<USmartObjectSettings>()->DefaultActivityTagsMergingPolicy;
 }
 
 bool USmartObjectDefinition::Validate() const
@@ -61,6 +62,53 @@ bool USmartObjectDefinition::Validate() const
 	return true;
 }
 
+FBox USmartObjectDefinition::GetBounds() const
+{
+	FBox BoundingBox(ForceInitToZero);
+	for (const FSmartObjectSlotDefinition& Slot : GetSlots())
+	{
+		BoundingBox += Slot.Offset + UE::SmartObject::DefaultSlotSize;
+		BoundingBox += Slot.Offset - UE::SmartObject::DefaultSlotSize;
+	}
+	return BoundingBox;
+}
+
+void USmartObjectDefinition::GetSlotActivityTags(const FSmartObjectSlotIndex& SlotIndex, FGameplayTagContainer& OutActivityTags) const
+{
+	if (ensureMsgf(Slots.IsValidIndex(SlotIndex), TEXT("Requesting activity tags for an out of range slot index: %s"), *LexToString(SlotIndex)))
+	{
+		GetSlotActivityTags(Slots[SlotIndex], OutActivityTags);
+	}
+}
+
+void USmartObjectDefinition::GetSlotActivityTags(const FSmartObjectSlotDefinition& SlotDefinition, FGameplayTagContainer& OutActivityTags) const
+{
+	OutActivityTags = ActivityTags;
+
+	if (ActivityTagsMergingPolicy == ESmartObjectTagMergingPolicy::Combine)
+	{
+		OutActivityTags.AppendTags(SlotDefinition.ActivityTags);
+	}
+	else if (ActivityTagsMergingPolicy == ESmartObjectTagMergingPolicy::Override && !SlotDefinition.ActivityTags.IsEmpty())
+	{
+		OutActivityTags = SlotDefinition.ActivityTags;
+	}
+}
+
+TOptional<FTransform> USmartObjectDefinition::GetSlotTransform(const FTransform& OwnerTransform, const FSmartObjectSlotIndex SlotIndex) const
+{
+	TOptional<FTransform> Transform;
+
+	if (ensureMsgf(Slots.IsValidIndex(SlotIndex), TEXT("Requesting slot transform for an out of range index: %s"), *LexToString(SlotIndex)))
+	{
+		const FSmartObjectSlotDefinition& Slot = Slots[SlotIndex];
+		Transform = FTransform(Slot.Rotation, Slot.Offset) * OwnerTransform;
+	}
+
+	return Transform;
+}
+
+
 const USmartObjectBehaviorDefinition* USmartObjectDefinition::GetBehaviorDefinition(const FSmartObjectSlotIndex& SlotIndex,
 																					const TSubclassOf<USmartObjectBehaviorDefinition>& DefinitionClass) const
 {
@@ -78,29 +126,6 @@ const USmartObjectBehaviorDefinition* USmartObjectDefinition::GetBehaviorDefinit
 	return Definition;
 }
 
-FBox USmartObjectDefinition::GetBounds() const
-{
-	FBox BoundingBox(ForceInitToZero);
-	for (const FSmartObjectSlotDefinition& Slot : GetSlots())
-	{
-		BoundingBox += Slot.Offset + UE::SmartObject::DefaultSlotSize;
-		BoundingBox += Slot.Offset - UE::SmartObject::DefaultSlotSize;
-	}
-	 return BoundingBox;
-}
-
-TOptional<FTransform> USmartObjectDefinition::GetSlotTransform(const FTransform& OwnerTransform, const FSmartObjectSlotIndex SlotIndex) const
-{
-	TOptional<FTransform> Transform;
-
-	if (ensureMsgf(Slots.IsValidIndex(SlotIndex), TEXT("Requesting slot transform for an out of range index: %s"), *LexToString(SlotIndex)))
-	{
-		const FSmartObjectSlotDefinition& Slot = Slots[SlotIndex];
-		Transform = FTransform(Slot.Rotation, Slot.Offset) * OwnerTransform;
-	}
-
-	return Transform;
-}
 
 const USmartObjectBehaviorDefinition* USmartObjectDefinition::GetBehaviorDefinitionByType(const TArray<USmartObjectBehaviorDefinition*>& BehaviorDefinitions,
 																				 const TSubclassOf<USmartObjectBehaviorDefinition>& DefinitionClass)

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Private/SmartObjectSubsystem.cpp

@@ -640,32 +640,6 @@ TOptional<FTransform> USmartObjectSubsystem::GetSlotTransform(const FSmartObject
 	return TOptional<FTransform>();
 }
 
-const FGameplayTagContainer& USmartObjectSubsystem::GetActivityTags(const FSmartObjectRequestResult& Result) const
-{
-	if (ensureMsgf(Result.IsValid(), TEXT("Requesting ActivityTags from an invalid request result.")))
-	{
-		return GetActivityTags(Result.SmartObjectHandle);
-	}
-
-	return FGameplayTagContainer::EmptyContainer;
-}
-
-const FGameplayTagContainer& USmartObjectSubsystem::GetActivityTags(const FSmartObjectHandle Handle) const
-{
-	if (!ensureMsgf(Handle.IsValid(), TEXT("Must provide a valid smart object handle.")))
-	{
-		return FGameplayTagContainer::EmptyContainer;
-	}
-
-	const FSmartObjectRuntime* SmartObjectRuntime = RuntimeSmartObjects.Find(Handle);
-	if (!ensureMsgf(SmartObjectRuntime != nullptr, TEXT("A SmartObjectRuntime must be created for %s"), *LexToString(Handle)))
-	{
-		return FGameplayTagContainer::EmptyContainer;
-	}
-
-	return SmartObjectRuntime->GetDefinition().GetActivityTags();
-}
-
 FSmartObjectSlotClaimState* USmartObjectSubsystem::GetMutableSlotState(const FSmartObjectClaimHandle& ClaimHandle)
 {
 	return RuntimeSlotStates.Find(ClaimHandle.SlotHandle);
@@ -798,7 +772,7 @@ void USmartObjectSubsystem::FindSlots(const FSmartObjectRuntime& SmartObjectRunt
 
 void USmartObjectSubsystem::FindMatchingSlotDefinitionIndices(const USmartObjectDefinition& Definition, const FSmartObjectRequestFilter& Filter, TArray<int32>& OutValidIndices)
 {
-	const ESmartObjectTagFilteringPolicy TagFilteringPolicy = Definition.GetTagFilteringPolicy();
+	const ESmartObjectTagFilteringPolicy UserTagsFilteringPolicy = Definition.GetUserTagsFilteringPolicy();
 
 	// Define our Tags filtering predicate
 	auto MatchesTagQueryFunc = [](const FGameplayTagQuery& Query, const FGameplayTagContainer& Tags){ return Query.IsEmpty() || Query.Matches(Tags); };
@@ -806,7 +780,7 @@ void USmartObjectSubsystem::FindMatchingSlotDefinitionIndices(const USmartObject
 	// When filter policy is to use combined we can validate the user tag query of the parent object first
 	// since they can't be merge so we need to apply them one after the other.
 	// For activity requirements we have to merge parent and slot tags together before testing.
-	if (TagFilteringPolicy == ESmartObjectTagFilteringPolicy::Combine
+	if (UserTagsFilteringPolicy == ESmartObjectTagFilteringPolicy::Combine
 		&& !MatchesTagQueryFunc(Definition.GetUserTagFilter(), Filter.UserTags))
 	{
 		return;
@@ -826,34 +800,27 @@ void USmartObjectSubsystem::FindMatchingSlotDefinitionIndices(const USmartObject
 			continue;
 		}
 
-		// Filter out slots based on their tags and tag query:
-		//  - override: we only test slot tags and query if they are present otherwise we use those of the parent object
-		//  - combine: we test slot query (parent filters were applied before processing individual slots) and merge parent and slot tags together
-		if (TagFilteringPolicy == ESmartObjectTagFilteringPolicy::Combine)
+		// Filter out slots based on their activity tags
+		FGameplayTagContainer ActivityTags;
+		Definition.GetSlotActivityTags(Slot, ActivityTags);
+		if (!MatchesTagQueryFunc(Filter.ActivityRequirements, ActivityTags))
 		{
-			FGameplayTagContainer CombinedActivityTags = Slot.ActivityTags;
-			CombinedActivityTags.AppendTags(Definition.GetActivityTags());
-			if (!MatchesTagQueryFunc(Filter.ActivityRequirements, CombinedActivityTags))
-			{
-				continue;
-			}
-
-			if (!MatchesTagQueryFunc(Slot.UserTagFilter, Filter.UserTags))
-			{
-				continue;
-			}
+			continue;
 		}
-		else if (TagFilteringPolicy == ESmartObjectTagFilteringPolicy::Override)
-		{
-			if (!MatchesTagQueryFunc(Filter.ActivityRequirements, (Slot.ActivityTags.IsEmpty() ? Definition.GetActivityTags() : Slot.ActivityTags)))
-			{
-				continue;
-			}
 
-			if (!MatchesTagQueryFunc((Slot.UserTagFilter.IsEmpty() ? Definition.GetUserTagFilter() : Slot.UserTagFilter), Filter.UserTags))
-			{
-				continue;
-			}
+		// Filter out slots based on their TagQuery applied on provided User Tags
+		//  - override: we only run query from the slot if provided otherwise we run the one from the parent object
+		//  - combine: we run slot query (parent query was applied before processing individual slots)
+		if (UserTagsFilteringPolicy == ESmartObjectTagFilteringPolicy::Combine
+			&& !MatchesTagQueryFunc(Slot.UserTagFilter, Filter.UserTags))
+		{
+			continue;
+		}
+
+		if (UserTagsFilteringPolicy == ESmartObjectTagFilteringPolicy::Override
+			&& !MatchesTagQueryFunc((Slot.UserTagFilter.IsEmpty() ? Definition.GetUserTagFilter() : Slot.UserTagFilter), Filter.UserTags))
+		{
+			continue;
 		}
 
 		OutValidIndices.Add(i);

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Public/SmartObjectDefinition.h

@@ -10,6 +10,7 @@
 
 class UGameplayBehaviorConfig;
 enum class ESmartObjectTagFilteringPolicy: uint8;
+enum class ESmartObjectTagMergingPolicy: uint8;
 
 /**
  * Abstract class that can be extended to bind a new type of behavior framework
@@ -151,6 +152,20 @@ public:
 	 */
 	TOptional<FTransform> GetSlotTransform(const FTransform& OwnerTransform, const FSmartObjectSlotIndex SlotIndex) const;
 
+	/**
+	 * Fills the provided GameplayTagContainer with the activity tags associated to the slot according to the tag merging policy.
+	 * @param SlotIndex	Index of the slot for which the tags are requested
+	 * @param OutActivityTags Tag container to fill with the activity tags associated to the slot
+	 */
+	void GetSlotActivityTags(const FSmartObjectSlotIndex& SlotIndex, FGameplayTagContainer& OutActivityTags) const;
+
+	/**
+	 * Fills the provided GameplayTagContainer with the activity tags associated to the slot according to the tag merging policy.
+	 * @param SlotDefinition Definition of the slot for which the tags are requested
+	 * @param OutActivityTags Tag container to fill with the activity tags associated to the slot
+	 */
+	void GetSlotActivityTags(const FSmartObjectSlotDefinition& SlotDefinition, FGameplayTagContainer& OutActivityTags) const;
+
 	/** Returns the tag query to run on the user tags provided by a request to accept this definition */
 	const FGameplayTagQuery& GetUserTagFilter() const { return UserTagFilter; }
 
@@ -169,11 +184,17 @@ public:
 	/** Sets the list of tags describing the activity associated to this definition */
 	void SetActivityTags(const FGameplayTagContainer& InActivityTags) { ActivityTags = InActivityTags; }
 
-	/** Returns the tag filtering policy used by this definition */
-	ESmartObjectTagFilteringPolicy GetTagFilteringPolicy() const { return TagFilteringPolicy; }
+	/** Returns the tag filtering policy that should be applied on User tags by this definition */
+	ESmartObjectTagFilteringPolicy GetUserTagsFilteringPolicy() const { return UserTagsFilteringPolicy; }
 
-	/** Sets the tag filtering policy to apply on this definition */
-	void SetTagFilteringPolicy(const ESmartObjectTagFilteringPolicy InTagFilteringPolicy) { TagFilteringPolicy = InTagFilteringPolicy; }
+	/** Sets the tag filtering policy to apply on User tags by this definition */
+	void SetUserTagsFilteringPolicy(const ESmartObjectTagFilteringPolicy InUserTagsFilteringPolicy) { UserTagsFilteringPolicy = InUserTagsFilteringPolicy; }
+
+	/** Returns the tag merging policy to apply on Activity tags from this definition */
+	ESmartObjectTagMergingPolicy GetActivityTagsMergingPolicy() const { return ActivityTagsMergingPolicy; }
+
+	/** Sets the tag merging policy to apply on Activity tags from this definition */
+	void SetActivityTagsMergingPolicy(const ESmartObjectTagMergingPolicy InActivityTagsMergingPolicy) { ActivityTagsMergingPolicy = InActivityTagsMergingPolicy; }
 
 	/**
 	 *	Performs validation and logs errors if any. An object using an invalid definition
@@ -233,12 +254,13 @@ private:
 	UPROPERTY(EditDefaultsOnly, Category = SmartObject)
 	FGameplayTagContainer ActivityTags;
 
-	/**
-	 * Indicates how Tags and TagQueries (User and Activity) from slots and parent object will be processed for find requests.
-	 * Tag Queries (ObjectTagFilter) from definitions tested against SmartObject instances tags are not affected.
-	 */
+	/** Indicates how Tags from slots and parent object are combined to be evaluated by a TagQuery from a find request. */
 	UPROPERTY(EditAnywhere, Category = SmartObject, AdvancedDisplay)
-	ESmartObjectTagFilteringPolicy TagFilteringPolicy;
+	ESmartObjectTagMergingPolicy ActivityTagsMergingPolicy;
+
+	/** Indicates how TagQueries from slots and parent object will be processed against User Tags from a find request. */
+	UPROPERTY(EditAnywhere, Category = SmartObject, AdvancedDisplay)
+	ESmartObjectTagFilteringPolicy UserTagsFilteringPolicy;
 
 	mutable TOptional<bool> bValid;
 };

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Public/SmartObjectRuntime.h

@@ -245,6 +245,20 @@ public:
 		return *(EntityView.GetConstSharedFragmentData<FSmartObjectSlotDefinitionFragment>().SlotDefinition);
 	}
 
+	/**
+	 * Fills the provided GameplayTagContainer with the activity tags associated to the slot according to the tag filtering policy.
+	 * Method will fail a check if called on an invalid SlotView.
+	 */
+	void GetActivityTags(FGameplayTagContainer& OutActivityTags) const
+	{
+		checkf(EntityView.IsSet(), TEXT("Definition can only be accessed through a valid SlotView"));
+		const FSmartObjectSlotDefinitionFragment& DefinitionFragment = EntityView.GetConstSharedFragmentData<FSmartObjectSlotDefinitionFragment>();
+		checkf(DefinitionFragment.SmartObjectDefinition != nullptr, TEXT("SmartObjectDefinition should always be valid in a valid SlotView"));
+		checkf(DefinitionFragment.SlotDefinition != nullptr, TEXT("SlotDefinition should always be valid in a valid SlotView"));
+
+		DefinitionFragment.SmartObjectDefinition->GetSlotActivityTags(*DefinitionFragment.SlotDefinition, OutActivityTags);
+	}
+
 	/**
 	 * Returns a reference to the definition data of the specified type from the main slot definition.
 	 * Method will fail a check if the slot definition doesn't contain the given type.

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Public/SmartObjectSettings.h

@@ -13,10 +13,16 @@ class SMARTOBJECTSMODULE_API USmartObjectSettings : public UDeveloperSettings
 
 public:
 	/**
-	 * Default TagFiltering policy to use for newly created SmartObjectDefinitions.
-	 * Indicates how Tags and TagQueries (User and Activity) from slots and parent object will be processed for find requests.
-	 * Tag Queries (ObjectTagFilter) from definitions tested against SmartObject instances tags are not affected.
+	 * Default filtering policy to use for TagQueries applied on User Tags in newly created SmartObjectDefinitions.
+	 * Indicates how TagQueries from slots and parent object will be processed against User Tags from a find request.
 	 */
 	UPROPERTY(EditAnywhere, config, Category = SmartObject)
-	ESmartObjectTagFilteringPolicy DefaultTagFilteringPolicy = ESmartObjectTagFilteringPolicy::Override;
+	ESmartObjectTagFilteringPolicy DefaultUserTagsFilteringPolicy = ESmartObjectTagFilteringPolicy::Override;
+
+	/**
+	 * Default merging policy to use for Activity Tags in newly created SmartObjectDefinitions.
+	 * Indicates how Activity Tags from slots and parent object are combined to be evaluated by an Activity TagQuery from a find request.
+	 */
+	UPROPERTY(EditAnywhere, config, Category = SmartObject)
+	ESmartObjectTagMergingPolicy DefaultActivityTagsMergingPolicy = ESmartObjectTagMergingPolicy::Override;
 };

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Public/SmartObjectSubsystem.h

@@ -317,24 +317,6 @@ public:
 	 */
 	TOptional<FTransform> GetSlotTransform(FSmartObjectSlotHandle SlotHandle) const;
 
-	/**
-	 * Returns the Activity GameplayTagContainer of the smartobject definition associated to the given request result.
-	 * @param Result A valid request result (Result.IsValid() returns true) returned by any of the Find methods.
-	 * @return FGameplayTagContainer of the SmartObject definition associated to Result.
-	 * @note Method will ensure on invalid FSmartObjectRequestResult.
-	 * @note Can also be retrieve using FSlotView.GetSmartObjectDefinition().GetActivityTags()
-	 */
-	const FGameplayTagContainer& GetActivityTags(const FSmartObjectRequestResult& Result) const;
-
-	/**
-	 * Returns the Activity GameplayTagContainer of the smartobject definition represented by the provided handle.
-	 * @param Handle Handle to the SmartObject.
-	 * @return FGameplayTagContainer of the SmartObject definition associated to Handle.
-	 * @note Method will ensure on invalid FSmartObjectHandle.
-	 * @note Can also be retrieve using FSlotView.GetSmartObjectDefinition().GetActivityTags()
-	 */
-	const FGameplayTagContainer& GetActivityTags(const FSmartObjectHandle Handle) const;
-
 	/**
 	 *	Register a callback to be notified if the claimed slot is no longer available and user need to perform cleanup.
 	 *	@param ClaimHandle Handle to identify the object and slot. Error will be reported if the handle is invalid.

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsModule/Public/SmartObjectTypes.h

@@ -13,28 +13,26 @@ class FDebugRenderSceneProxy;
 
 SMARTOBJECTSMODULE_API DECLARE_LOG_CATEGORY_EXTERN(LogSmartObject, Warning, All);
 
-/**
- * Indicates how Tags and TagQueries (User and Activity) from slots and parent object will be processed for find requests.
- * Tag Queries (ObjectTagFilter) from definitions tested against SmartObject instances tags are not affected.
- */
+/** Indicates how Tags from slots and parent object are combined to be evaluated by a TagQuery from a find request. */
+UENUM()
+enum class ESmartObjectTagMergingPolicy : uint8
+{
+	/** Tags are combined (parent object and slot) and TagQuery from the request will be run against the combined list. */
+	Combine,
+	/** Tags in slot (if any) will be used instead of the parent object Tags when running the TagQuery from a request. Empty Tags on a slot indicates no override. */
+	Override
+};
+
+
+/** Indicates how TagQueries from slots and parent object will be processed against Tags from a find request. */
 UENUM()
 enum class ESmartObjectTagFilteringPolicy : uint8
 {
-	/**
-	 * Tags and TagQueries stored in the object and slot definitions are not used by the framework to filter results.
-	 * Users can access them and perform its own filtering.
-	 */
+	/** TagQueries in the object and slot definitions are not used by the framework to filter results. Users can access them and perform its own filtering. */
 	NoFilter,
-	/**
-	 * Activity Tags are combined (parent object and slot) and Activity TagQuery from the request will be run against the combined list.
-	 * Both User TagQueries (parent object and slot) will be applied to the User Tags provided by a request.
-	 */
+	/** Both TagQueries (parent object and slot) will be applied to the Tags provided by a request. */
 	Combine,
-	/**
-	 * Activity Tags in slot (if any) will be used instead of the parent object Activity Tags when running the Activity TagQuery from a request.
-	 * User TagQuery in slot (if any) will be used instead of the parent object TagQuery to run against the User Tags provided by a request.
-	 * Empty Tags, or empty TagQuery on a slot indicates no override.
-	 */
+	/** TagQuery in slot (if any) will be used instead of the parent object TagQuery to run against the Tags provided by a request. EmptyTagQuery on a slot indicates no override. */
 	Override
 };
 

Engine/Plugins/Runtime/SmartObjects/Source/SmartObjectsTestSuite/Private/SmartObjectsTest.cpp

@@ -382,7 +382,7 @@ struct FSlotCustomData : FSmartObjectTestBase
 };
 IMPLEMENT_AI_INSTANT_TEST(FSlotCustomData, "System.AI.SmartObjects.Slot custom data");
 
-struct FActivityTagsFilterPolicy : FSmartObjectTestBase
+struct FActivityTagsMergingPolicy : FSmartObjectTestBase
 {
 	virtual bool SetupDefinition() override
 	{
@@ -406,58 +406,16 @@ struct FActivityTagsFilterPolicy : FSmartObjectTestBase
 	}
 };
 
-struct FActivityTagsFilterPolicyNoFilter : FActivityTagsFilterPolicy
+struct FActivityTagsMergingPolicyCombine : FActivityTagsMergingPolicy
 {
 	virtual bool SetupDefinition() override
 	{
-		if (!FActivityTagsFilterPolicy::SetupDefinition())
+		if (!FActivityTagsMergingPolicy::SetupDefinition())
 		{
 			return false;
 		}
 
-		Definition->SetTagFilteringPolicy(ESmartObjectTagFilteringPolicy::NoFilter);
-		return true;
-	}
-
-	virtual bool InstantTest() override
-	{
-#if WITH_SMARTOBJECT_DEBUG
-		FSmartObjectRequest DefaultRequest(FBox(EForceInit::ForceInit).ExpandBy(FVector(HALF_WORLD_MAX), FVector(HALF_WORLD_MAX)), TestFilter);
-
-		{
-			TArray<FSmartObjectRequestResult> Results;
-			Subsystem->FindSmartObjects(DefaultRequest, Results);
-			AITEST_EQUAL("Results.Num() using 'NoFilter' policy with an empty query", Results.Num(), NumCreatedSlots);
-		}
-		{
-			// Adding activity requirements to the query
-			FSmartObjectRequest ModifiedRequest = DefaultRequest;
-			ModifiedRequest.Filter.ActivityRequirements = FGameplayTagQuery::BuildQuery(
-				FGameplayTagQueryExpression()
-				.NoTagsMatch()
-				.AddTag(FNativeGameplayTags::Get().TestTag1)
-			);
-			TArray<FSmartObjectRequestResult> Results;
-			Subsystem->FindSmartObjects(ModifiedRequest, Results);
-			AITEST_EQUAL("Results.Num() using 'NoFilter' policy with NoMatch(TestTag1)", Results.Num(), NumCreatedSlots);
-		}
-#endif // WITH_SMARTOBJECT_DEBUG
-
-		return true;
-	}
-};
-IMPLEMENT_AI_INSTANT_TEST(FActivityTagsFilterPolicyNoFilter, "System.AI.SmartObjects.Filter policy 'NoFilter' on ActivityTags");
-
-struct FActivityTagsFilterPolicyCombine : FActivityTagsFilterPolicy
-{
-	virtual bool SetupDefinition() override
-	{
-		if (!FActivityTagsFilterPolicy::SetupDefinition())
-		{
-			return false;
-		}
-
-		Definition->SetTagFilteringPolicy(ESmartObjectTagFilteringPolicy::Combine);
+		Definition->SetActivityTagsMergingPolicy(ESmartObjectTagMergingPolicy::Combine);
 		return true;
 	}
 
@@ -518,18 +476,18 @@ struct FActivityTagsFilterPolicyCombine : FActivityTagsFilterPolicy
 		return true;
 	}
 };
-IMPLEMENT_AI_INSTANT_TEST(FActivityTagsFilterPolicyCombine, "System.AI.SmartObjects.Filter policy 'Combine' on ActivityTags");
+IMPLEMENT_AI_INSTANT_TEST(FActivityTagsMergingPolicyCombine, "System.AI.SmartObjects.Merging policy 'Combine' on ActivityTags");
 
-struct FActivityTagsFilterPolicyOverride : FActivityTagsFilterPolicy
+struct FActivityTagsMergingPolicyOverride : FActivityTagsMergingPolicy
 {
 	virtual bool SetupDefinition() override
 	{
-		if (!FActivityTagsFilterPolicy::SetupDefinition())
+		if (!FActivityTagsMergingPolicy::SetupDefinition())
 		{
 			return false;
 		}
 
-		Definition->SetTagFilteringPolicy(ESmartObjectTagFilteringPolicy::Override);
+		Definition->SetActivityTagsMergingPolicy(ESmartObjectTagMergingPolicy::Override);
 		return true;
 	}
 
@@ -576,7 +534,7 @@ struct FActivityTagsFilterPolicyOverride : FActivityTagsFilterPolicy
 		return true;
 	}
 };
-IMPLEMENT_AI_INSTANT_TEST(FActivityTagsFilterPolicyOverride, "System.AI.SmartObjects.Filter policy 'Override' on ActivityTags");
+IMPLEMENT_AI_INSTANT_TEST(FActivityTagsMergingPolicyOverride, "System.AI.SmartObjects.Merging policy 'Override' on ActivityTags");
 
 struct FUserTagsFilterPolicy : FSmartObjectTestBase
 {
@@ -631,7 +589,7 @@ struct FUserTagsFilterPolicyNoFilter : FUserTagsFilterPolicy
 			return false;
 		}
 
-		Definition->SetTagFilteringPolicy(ESmartObjectTagFilteringPolicy::NoFilter);
+		Definition->SetUserTagsFilteringPolicy(ESmartObjectTagFilteringPolicy::NoFilter);
 		return true;
 	}
 
@@ -663,7 +621,7 @@ struct FUserTagsFilterPolicyCombine : FUserTagsFilterPolicy
 			return false;
 		}
 
-		Definition->SetTagFilteringPolicy(ESmartObjectTagFilteringPolicy::Combine);
+		Definition->SetUserTagsFilteringPolicy(ESmartObjectTagFilteringPolicy::Combine);
 		return true;
 	}
 
@@ -717,7 +675,7 @@ struct FUserTagsFilterPolicyOverride : FUserTagsFilterPolicy
 			return false;
 		}
 
-		Definition->SetTagFilteringPolicy(ESmartObjectTagFilteringPolicy::Override);
+		Definition->SetUserTagsFilteringPolicy(ESmartObjectTagFilteringPolicy::Override);
 		return true;
 	}