4560 lines
165 KiB
C++
4560 lines
165 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "AITestsCommon.h"
|
|
#include "BTBuilder.h"
|
|
#include "BehaviorTree/BTCompositeNode.h"
|
|
#include "BehaviorTree/Decorators/BTDecorator_Cooldown.h"
|
|
#include "BehaviorTree/Decorators/BTDecorator_ForceSuccess.h"
|
|
#include "BehaviorTree/Decorators/BTDecorator_TimeLimit.h"
|
|
#include "BehaviorTree/TestBTDecorator_CantExecute.h"
|
|
#include "BehaviorTree/TestBTTask_TimerBasedLatent.h"
|
|
#include "BehaviorTree/TestBTTask_RunBehavior.h"
|
|
#include "Engine/World.h"
|
|
#include "MockAI_BT.h"
|
|
#include "TimerManager.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "AITestSuite_BTTest"
|
|
|
|
//----------------------------------------------------------------------//
|
|
// FAITest_SimpleBT
|
|
//----------------------------------------------------------------------//
|
|
struct FAITest_SimpleBT : public FAITestBase
|
|
{
|
|
TArray<int32> ExpectedResult;
|
|
UBehaviorTree* BTAsset;
|
|
UMockAI_BT* AIBTUser;
|
|
bool bUseSystemTicking;
|
|
|
|
FAITest_SimpleBT()
|
|
{
|
|
bUseSystemTicking = false;
|
|
|
|
BTAsset = &FBTBuilder::CreateBehaviorTree();
|
|
if (BTAsset)
|
|
{
|
|
AddAutoDestroyObject(*BTAsset);
|
|
}
|
|
}
|
|
|
|
virtual bool SetUp() override
|
|
{
|
|
FAITestBase::SetUp();
|
|
|
|
AIBTUser = NewAutoDestroyObject<UMockAI_BT>();
|
|
|
|
UMockAI_BT::ExecutionLog.Reset();
|
|
|
|
if (AIBTUser && BTAsset)
|
|
{
|
|
AIBTUser->RunBT(*BTAsset, EBTExecutionMode::SingleRun);
|
|
AIBTUser->SetEnableTicking(bUseSystemTicking);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
virtual bool Update() override
|
|
{
|
|
FAITestHelpers::UpdateFrameCounter();
|
|
|
|
if (AIBTUser != nullptr)
|
|
{
|
|
// Some tests rely on timers, so we need to manually tick the world timer manager
|
|
// if it was not ticked in the frame (e.g., the editor world not ticking if viewport is not set to 'realtime')
|
|
FTimerManager& TimerManager = GetWorld().GetTimerManager();
|
|
if (!TimerManager.HasBeenTickedThisFrame())
|
|
{
|
|
TimerManager.Tick(FAITestHelpers::TickInterval);
|
|
}
|
|
|
|
if (bUseSystemTicking == false)
|
|
{
|
|
AIBTUser->TickMe(FAITestHelpers::TickInterval);
|
|
}
|
|
|
|
if (AIBTUser->IsRunning())
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
VerifyResults();
|
|
return true;
|
|
}
|
|
|
|
bool VerifyResults()
|
|
{
|
|
const bool bMatch = (ExpectedResult == UMockAI_BT::ExecutionLog);
|
|
//ensure(bMatch && "VerifyResults failed!");
|
|
if (!bMatch)
|
|
{
|
|
FString DescriptionResult;
|
|
for (int32 Idx = 0; Idx < UMockAI_BT::ExecutionLog.Num(); Idx++)
|
|
{
|
|
DescriptionResult += TTypeToString<int32>::ToString(UMockAI_BT::ExecutionLog[Idx]);
|
|
if (Idx < (UMockAI_BT::ExecutionLog.Num() - 1))
|
|
{
|
|
DescriptionResult += TEXT(", ");
|
|
}
|
|
}
|
|
|
|
FString DescriptionExpected;
|
|
for (int32 Idx = 0; Idx < ExpectedResult.Num(); Idx++)
|
|
{
|
|
DescriptionExpected += TTypeToString<int32>::ToString(ExpectedResult[Idx]);
|
|
if (Idx < (ExpectedResult.Num() - 1))
|
|
{
|
|
DescriptionExpected += TEXT(", ");
|
|
}
|
|
}
|
|
|
|
UE_LOG(LogBehaviorTreeTest, Error, TEXT("Test scenario failed to produce expected results!\nExecution log: %s\nExpected values: %s"), *DescriptionResult, *DescriptionExpected);
|
|
}
|
|
return bMatch;
|
|
}
|
|
};
|
|
|
|
//----------------------------------------------------------------------//
|
|
// TESTS
|
|
//----------------------------------------------------------------------//
|
|
struct FAITest_BTBasicSelector : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTBasicSelector()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Failed);
|
|
|
|
FBTBuilder::AddTask(CompNode, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 2, EBTNodeResult::Succeeded, 2);
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTBasicSelector, "System.AI.Behavior Trees.Composite node: selector")
|
|
|
|
struct FAITest_BTSearchSequenceForceSuccessTask : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSearchSequenceForceSuccessTask()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
// First decorator will deny execution of Task 2 but ForceSuccess will only sequence to continue
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode);
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(CompNode);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, Task3Execute, EBTNodeResult::Failed);
|
|
|
|
FBTBuilder::AddTask(CompNode, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task3Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSearchSequenceForceSuccessTask, "System.AI.Behavior Trees.Composite node: search sequence with force success child task")
|
|
|
|
struct FAITest_BTDeepSearchSequenceForceSuccessSelf : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDeepSearchSequenceForceSuccessSelf()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& Selector = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(Selector);
|
|
{
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
// Force success must allow sequence to continue even if the search root node is not its associate node or its immediate parent.
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(MainSequence);
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(MainSequence);
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(Task2Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDeepSearchSequenceForceSuccessSelf, "System.AI.Behavior Trees.Composite node: deep search sequence with force success self")
|
|
|
|
struct FAITest_BTSearchParentNotAffectedByForceSuccessChild : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSearchParentNotAffectedByForceSuccessChild()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& MiddleSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MiddleSequence);
|
|
{
|
|
FBTBuilder::AddTask(InnerSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(InnerSequence);
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(InnerSequence);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MiddleSequence, Task2Execute, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(MiddleSequence);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(MiddleSequence, Task3Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task4Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSearchParentNotAffectedByForceSuccessChild, "System.AI.Behavior Trees.Composite node: search in parent node not affected by force success child")
|
|
|
|
struct FAITest_BTDecoratorBlueprint : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorBlueprint()
|
|
{
|
|
enum
|
|
{
|
|
DecoratorBlueprintCalculate = 1,
|
|
DecoratorBlueprintBecomeRelevant,
|
|
DecoratorBlueprintCeaseRelevant,
|
|
Task1Execute,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
};
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode1 = FBTBuilder::AddSequence(CompNode);
|
|
FBTBuilder::WithDecoratorBlueprint(CompNode, EBTFlowAbortMode::Both, EBPConditionType::TrueCondition, DecoratorBlueprintBecomeRelevant, DecoratorBlueprintCeaseRelevant, DecoratorBlueprintCalculate);
|
|
{
|
|
// Task1
|
|
FBTBuilder::AddTask(CompNode1, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(CompNode1, Task2Execute, EBTNodeResult::Succeeded, /*ExecutionTicks*/1);
|
|
}
|
|
// Task3
|
|
FBTBuilder::AddTask(CompNode, Task3Execute, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(DecoratorBlueprintCalculate/*1*/);
|
|
ExpectedResult.Add(DecoratorBlueprintBecomeRelevant/*2*/);
|
|
ExpectedResult.Add(DecoratorBlueprintCalculate/*1*/);
|
|
ExpectedResult.Add(Task1Execute/*4*/);
|
|
ExpectedResult.Add(DecoratorBlueprintCalculate/*1*/);
|
|
ExpectedResult.Add(Task2Execute/*5*/);
|
|
ExpectedResult.Add(DecoratorBlueprintCalculate/*1*/);
|
|
ExpectedResult.Add(DecoratorBlueprintCalculate/*1*/);
|
|
ExpectedResult.Add(DecoratorBlueprintCeaseRelevant/*3*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorBlueprint, "System.AI.Behavior Trees.Decorator: blueprint")
|
|
|
|
struct FAITest_BTDecoratorBlueprintNoConditionImpl : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorBlueprintNoConditionImpl()
|
|
{
|
|
enum
|
|
{
|
|
DecoratorBlueprintCalculate = 1,
|
|
DecoratorBlueprintBecomeRelevant,
|
|
DecoratorBlueprintCeaseRelevant,
|
|
Task1Execute,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
};
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
// Task1
|
|
FBTBuilder::AddTask(CompNode, Task1Execute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlueprint(CompNode, EBTFlowAbortMode::LowerPriority, EBPConditionType::NoCondition, DecoratorBlueprintBecomeRelevant, DecoratorBlueprintCeaseRelevant, DecoratorBlueprintCalculate, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTaskFlagChange(CompNode, true, EBTNodeResult::Succeeded, TEXT("Bool1"));
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
|
|
// Task3
|
|
FBTBuilder::AddTask(CompNode, Task3Execute, EBTNodeResult::Succeeded, /*ExecutionTicks*/1);
|
|
}
|
|
|
|
ExpectedResult.Add(DecoratorBlueprintCalculate/*1*/);
|
|
ExpectedResult.Add(DecoratorBlueprintBecomeRelevant/*2*/);
|
|
ExpectedResult.Add(Task3Execute/*6*/);
|
|
ExpectedResult.Add(DecoratorBlueprintCeaseRelevant/*3*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorBlueprintNoConditionImpl, "System.AI.Behavior Trees.Decorator: blueprint no condition impl")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessTaskFailed : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessTaskFailed()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
FBTBuilder::AddTask(InnerSequence, Task2Execute, EBTNodeResult::Failed);
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(InnerSequence);
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task3Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
ExpectedResult.Add(Task3Execute);
|
|
ExpectedResult.Add(Task4Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessTaskFailed, "System.AI.Behavior Trees.Decorator: force success task failed self")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessTaskFailedParentComposite : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessTaskFailedParentComposite()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(MainSequence, EArithmeticKeyOperation::NotEqual, /*IntValue*/1, EBTFlowAbortMode::Self, EBTBlackboardRestart::ResultChange);
|
|
|
|
FBTBuilder::AddTaskValuesChangedWithLogs(InnerSequence, Task2Execute, EBTNodeResult::Succeeded, /*IntValue1*/1, /*IntValue2*/INDEX_NONE);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(InnerSequence);
|
|
}
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task3Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessTaskFailedParentComposite, "System.AI.Behavior Trees.Decorator: force success task failed parent composite")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessCompositeFailed : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessCompositeFailed()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute=1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(MainSequence);
|
|
FBTBuilder::WithDecoratorBlackboard(MainSequence, EArithmeticKeyOperation::NotEqual, /*IntValue*/1, EBTFlowAbortMode::Self, EBTBlackboardRestart::ResultChange);
|
|
|
|
FBTBuilder::AddTaskValuesChangedWithLogs(InnerSequence, Task2Execute, EBTNodeResult::Succeeded, /*IntValue1*/1, /*IntValue2*/INDEX_NONE);
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task3Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
ExpectedResult.Add(Task4Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessCompositeFailed, "System.AI.Behavior Trees.Decorator: force success composite failed self")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessCompositeFailedFromLastChild : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessCompositeFailedFromLastChild()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute=1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(MainSequence);
|
|
FBTBuilder::WithDecoratorBlackboard(MainSequence, EArithmeticKeyOperation::NotEqual, /*IntValue*/1, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange);
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task2Execute, EBTNodeResult::Succeeded);
|
|
|
|
FBTBuilder::AddTaskValuesChangedWithLogs(InnerSequence, Task3Execute, EBTNodeResult::Succeeded, /*IntValue1*/1, /*IntValue2*/INDEX_NONE);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
ExpectedResult.Add(Task3Execute);
|
|
ExpectedResult.Add(Task4Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessCompositeFailedFromLastChild, "System.AI.Behavior Trees.Decorator: force success composite failed self from last child")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessCompositeFailedChild : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessCompositeFailedChild()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(MainSequence);
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task2Execute, EBTNodeResult::Failed);
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task3Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
ExpectedResult.Add(Task4Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessCompositeFailedChild, "System.AI.Behavior Trees.Decorator: force success composite failed child task")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessCompositeFailedChildFromSubTree : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessCompositeFailedChildFromSubTree()
|
|
{
|
|
enum
|
|
{
|
|
ChildTask1Execute = 1,
|
|
ChildTask2Execute,
|
|
Task1Execute,
|
|
Task2Execute,
|
|
};
|
|
|
|
// Subtree that will trigger the abort condition (i.e, Bool1 set) of the composite node in the parent tree
|
|
UBehaviorTree* ChildAsset1 = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset1)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset1);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*ChildAsset1);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, ChildTask1Execute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode, true, EBTNodeResult::InProgress, TEXT("Bool1"));
|
|
FBTBuilder::AddTask(CompNode, ChildTask2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
// Main tree with a composite that aborts on key change but should succeed with ForceSuccess decorator
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskSubtree(MainSequence, ChildAsset1);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(MainSequence, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(MainSequence);
|
|
}
|
|
FBTBuilder::AddTask(MainSequence, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(ChildTask1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessCompositeFailedChildFromSubTree, "System.AI.Behavior Trees.Decorator: force success composite failed from subtree task")
|
|
|
|
struct FAITest_BTDecoratorForceSuccessTaskFailedSibling : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDecoratorForceSuccessTaskFailedSibling()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task2Execute,
|
|
Task3Execute,
|
|
Task4Execute,
|
|
};
|
|
|
|
UBTCompositeNode& MainSequence = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(MainSequence, Task1Execute, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& InnerSequence = FBTBuilder::AddSequence(MainSequence);
|
|
{
|
|
FBTBuilder::AddTask(InnerSequence, Task2Execute, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(InnerSequence);
|
|
}
|
|
|
|
FBTBuilder::AddTask(InnerSequence, Task3Execute, EBTNodeResult::Failed);
|
|
}
|
|
|
|
FBTBuilder::AddTask(MainSequence, Task4Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task2Execute);
|
|
ExpectedResult.Add(Task3Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDecoratorForceSuccessTaskFailedSibling, "System.AI.Behavior Trees.Decorator: force success task failed sibling task")
|
|
|
|
struct FAITest_BTBasicParallelWait : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTBasicParallelWait()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddParallel(CompNode, EBTParallelMode::WaitForBackground);
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(CompNode2, 0, 10, EBTNodeResult::Succeeded, 6);
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 1, 11, EBTNodeResult::Succeeded, 3);
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 2, 12, EBTNodeResult::Succeeded, 3);
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 3, 13, EBTNodeResult::Succeeded, 3);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(11);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(10);
|
|
ExpectedResult.Add(12);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(13);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTBasicParallelWait, "System.AI.Behavior Trees.Composite node: parallel (wait)")
|
|
|
|
struct FAITest_BTBasicParallelAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTBasicParallelAbort()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddParallel(CompNode, EBTParallelMode::AbortBackground);
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(CompNode2, 0, 10, EBTNodeResult::Succeeded, 6);
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 1, 11, EBTNodeResult::Succeeded, 4);
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 2, 12, EBTNodeResult::Succeeded, 4);
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 3, 13, EBTNodeResult::Succeeded, 4);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(11);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(10);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTBasicParallelAbort, "System.AI.Behavior Trees.Composite node: parallel (abort)")
|
|
|
|
struct FAITest_BTCompositeDecorator : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCompositeDecorator()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
|
|
FBTBuilder::AddTask(CompNode, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::None, TEXT("Bool1"));
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::None, TEXT("Bool2"));
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::None, TEXT("Bool3"));
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::None, TEXT("Bool4"));
|
|
|
|
TArray<FBTDecoratorLogic>& CompositeOps = CompNode.Children.Last().DecoratorOps;
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Or, 3));
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Test, 0));
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Not, 1));
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::And, 2));
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Test, 1));
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Test, 2));
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Test, 3));
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCompositeDecorator, "System.AI.Behavior Trees.Composite decorator")
|
|
|
|
struct FAITest_BTCompositeChildrenDecoratorsNotUnregistered : public FAITest_SimpleBT
|
|
{
|
|
/**
|
|
* +-------+
|
|
* |root |
|
|
* +---+---+
|
|
* |
|
|
* +--------+--------+
|
|
* |Sequence (0)|
|
|
* +--------+--------+
|
|
* |
|
|
* +--------------------+--------------------+
|
|
* | |
|
|
* +--------+--------+ +--------+--------+
|
|
* |Set Int=1 (1)| |Selector (2)|
|
|
* +-----------------+ +--------+--------+
|
|
* |
|
|
* +-------------------+--------------------+--------------------+
|
|
* | | |
|
|
* +--------+--------+ +--------+--------+ +--------+--------+
|
|
* |Selector (3)| |BBDec: Int==2(10)| |Set Int=2 (12)|
|
|
* +--------+--------+ +-----------------+ +-----------------+
|
|
* | |Task 3 (11)|
|
|
* +-----------------------------------------+ +-----------------+
|
|
* | | |
|
|
* +--------+--------+ +--------+--------+ +--------+--------+
|
|
* |BBDec:Int==11 (4)| |BBDec:Int==12 (6)| |BBDec: Int==1 (8)|
|
|
* +-----------------+ +-----------------+ +-----------------+
|
|
* |Task1 (5)| |Task2 (7)| | Set Int=0 (9)|
|
|
* +-----------------+ +-----------------+ +-----------------+
|
|
*
|
|
*/
|
|
FAITest_BTCompositeChildrenDecoratorsNotUnregistered()
|
|
{
|
|
UBTCompositeNode& CompNode0 = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTaskValueChange(CompNode0, 1, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(CompNode0);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EArithmeticKeyOperation::Equal, 11, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 110 /*LogIndexBecomeRelevant*/, 119 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EArithmeticKeyOperation::Equal, 12, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 120 /*LogIndexBecomeRelevant*/, 129 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
FBTBuilder::AddTaskValueChange(CompNode2, 0, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EArithmeticKeyOperation::Equal, 1, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 130 /*LogIndexBecomeRelevant*/, 139 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::Equal, 2, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 200 /*LogIndexBecomeRelevant*/, 299 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
FBTBuilder::AddTaskValueChange(CompNode, 2, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(110);
|
|
ExpectedResult.Add(120);
|
|
ExpectedResult.Add(130);
|
|
ExpectedResult.Add(200);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(119);
|
|
ExpectedResult.Add(129);
|
|
ExpectedResult.Add(139);
|
|
ExpectedResult.Add(299);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCompositeChildrenDecoratorsNotUnregistered, "System.AI.Behavior Trees.Composite children decorators not unregistered")
|
|
|
|
struct FAITest_BTCompositeFailedDecoratorUnregistersChildren : public FAITest_SimpleBT
|
|
{
|
|
/**
|
|
* +-------+
|
|
* |root |
|
|
* +---+---+
|
|
* |
|
|
* +--------+--------+
|
|
* |Sequence (0)|
|
|
* +--------+--------+
|
|
* |
|
|
* +--------------------+--------------------+
|
|
* | |
|
|
* +--------+--------+ +--------+--------+
|
|
* |Set Int=1 (1)| |Selector (2)|
|
|
* +-----------------+ +--------+--------+
|
|
* |
|
|
* +-------------------+--------------------+--------------------+
|
|
* | | |
|
|
* +--------+--------+ +--------+--------+ +--------+--------+
|
|
* |BBDec: Int==1 (3)| |BBDec: Int==2(10)| |Set Int=2 (12)|
|
|
* +-----------------+ +-----------------+ +-----------------+
|
|
* |Selector (4)| |Task 3 (11)|
|
|
* +--------+--------+ +-----------------+
|
|
* |
|
|
* +-----------------------------------------+
|
|
* | | |
|
|
* +--------+--------+ +--------+--------+ +--------+--------+
|
|
* |BBDec:Int==11 (5)| |BBDec:Int==12 (7)| | Set Int=0 (9)|
|
|
* +-----------------+ +-----------------+ +-----------------+
|
|
* |Task1 (6)| |Task2 (8)|
|
|
* +-----------------+ +-----------------+
|
|
*
|
|
*
|
|
*/
|
|
FAITest_BTCompositeFailedDecoratorUnregistersChildren()
|
|
{
|
|
UBTCompositeNode& CompNode0 = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTaskValueChange(CompNode0, 1, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(CompNode0);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::Equal, 1, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 100 /*LogIndexBecomeRelevant*/, 199 /*LogIndexCeaseRelevant*/);
|
|
|
|
FBTBuilder::AddTask(CompNode2, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EArithmeticKeyOperation::Equal, 11, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 110 /*LogIndexBecomeRelevant*/, 119 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EArithmeticKeyOperation::Equal, 12, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange,
|
|
TEXT("Int"), 120 /*LogIndexBecomeRelevant*/, 129 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
FBTBuilder::AddTaskValueChange(CompNode2, 0, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::Equal, 2, EBTFlowAbortMode::Both, EBTBlackboardRestart::ResultChange, TEXT("Int"), 200 /*LogIndexBecomeRelevant*/, 299 /*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
FBTBuilder::AddTaskValueChange(CompNode, 2, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(100);
|
|
ExpectedResult.Add(110);
|
|
ExpectedResult.Add(120);
|
|
ExpectedResult.Add(119);
|
|
ExpectedResult.Add(129);
|
|
ExpectedResult.Add(200);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(199);
|
|
ExpectedResult.Add(299);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCompositeFailedDecoratorUnregistersChildren, "System.AI.Behavior Trees.Composite failed decorator unregisters child nodes")
|
|
|
|
struct FAITest_BTTimeLimitDecorator : FAITest_SimpleBT
|
|
{
|
|
FAITest_BTTimeLimitDecorator()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task1Tick,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, Task1Execute, EBTNodeResult::Succeeded, /*ExecutionTicks*/ 5, Task1Tick);
|
|
{
|
|
constexpr float NumTicks = 2.5f;
|
|
FBTBuilder::WithDecorator<UBTDecorator_TimeLimit>(CompNode).TimeLimit = NumTicks * FAITestHelpers::TickInterval;
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task1Tick);
|
|
ExpectedResult.Add(Task1Tick);
|
|
ExpectedResult.Add(Task2Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTTimeLimitDecorator, "System.AI.Behavior Trees.TimeLimit decorator")
|
|
|
|
struct FAITest_BTTimeLimitInCompositeDecorator : FAITest_SimpleBT
|
|
{
|
|
FAITest_BTTimeLimitInCompositeDecorator()
|
|
{
|
|
enum
|
|
{
|
|
Task1Execute = 1,
|
|
Task1Tick,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, Task1Execute, EBTNodeResult::Succeeded, /*ExecutionTicks*/ 5, Task1Tick);
|
|
{
|
|
constexpr float NumTicks = 2.5f;
|
|
FBTBuilder::WithDecorator<UBTDecorator_TimeLimit>(CompNode).TimeLimit = NumTicks * FAITestHelpers::TickInterval;
|
|
|
|
TArray<FBTDecoratorLogic>& CompositeOps = CompNode.Children.Last().DecoratorOps;
|
|
CompositeOps.Add(FBTDecoratorLogic(EBTDecoratorLogic::Test, 0));
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(Task1Execute);
|
|
ExpectedResult.Add(Task1Tick);
|
|
ExpectedResult.Add(Task1Tick);
|
|
ExpectedResult.Add(Task2Execute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTTimeLimitInCompositeDecorator, "System.AI.Behavior Trees.TimeLimit in Composite decorator")
|
|
|
|
/* All BTAbortingDuringService/BTAbortingDuringTaskService come from UDN case 00317509*/
|
|
struct FAITest_BTAbortingDuringServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringServiceTick()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithServiceLog(CompNode2, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/, 222/*LogTickIndex*/);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(222);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringServiceTick, "System.AI.Behavior Trees.Abort: during service tick")
|
|
|
|
struct FAITest_BTRestartingTheAbortedBranch : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRestartingTheAbortedBranch()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 2/*NumOfToggles*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRestartingTheAbortedBranch, "System.AI.Behavior Trees.Toggle: restart the aborted branch")
|
|
|
|
struct FAITest_BTAbortingTheRestarted : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingTheRestarted()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 3/*NumOfToggles*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/);
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingTheRestarted, "System.AI.Behavior Trees.Toggle: reabort the restarted branch")
|
|
|
|
struct FAITest_BTRestartingTheReaborted : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRestartingTheReaborted()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 4/*NumOfToggles*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRestartingTheReaborted, "System.AI.Behavior Trees.Toggle: restart the reaborted branch")
|
|
|
|
struct FAITest_BTRestartingTheAbortedBranchDuringServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRestartingTheAbortedBranchDuringServiceTick()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 4, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, -1 /*ActivationIndex*/, -1 /*DeactivationIndex*/, -1 /*TickIndex*/, TEXT("Bool1") /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, NAME_None /*CeaseRelevantBoolKeyName*/, true /*bToggleValues*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, -1 /*ActivationIndex*/, -1 /*DeactivationIndex*/, -1 /*TickIndex*/, TEXT("Bool1") /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, NAME_None /*CeaseRelevantBoolKeyName*/, true /*bToggleValues*/);
|
|
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRestartingTheAbortedBranchDuringServiceTick, "System.AI.Behavior Trees.Toggle: restart the aborted branch during service tick")
|
|
|
|
struct FAITest_BTRestartTheAbortedBranchDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRestartTheAbortedBranchDuringServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 1/*NumOfToggles*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, -1 /*ActivationIndex*/, -1 /*DeactivationIndex*/, -1 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool1") /*CeaseRelevantBoolKeyName*/, true /*bToggleValues*/);
|
|
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRestartTheAbortedBranchDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Toggle: restart the aborted branch during service cease relevant")
|
|
|
|
struct FAITest_BTRestartTheReabortedBranchDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRestartTheReabortedBranchDuringServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 1/*NumOfToggles*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, -1 /*ActivationIndex*/, -1 /*DeactivationIndex*/, -1 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool1") /*CeaseRelevantBoolKeyName*/, true /*bToggleValues*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, -1 /*ActivationIndex*/, -1 /*DeactivationIndex*/, -1 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool1") /*CeaseRelevantBoolKeyName*/, true /*bToggleValues*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, -1 /*ActivationIndex*/, -1 /*DeactivationIndex*/, -1 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool1") /*CeaseRelevantBoolKeyName*/, true /*bToggleValues*/);
|
|
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRestartTheReabortedBranchDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Toggle: restart the reaborted branch during service cease relevant")
|
|
|
|
struct FAITest_BTStartBranchDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStartBranchDuringServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 5, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 1/*NumOfToggles*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStartBranchDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Toggle: start new branch during service cease relevant")
|
|
|
|
struct FAITest_BTStartBranchDuringServiceCeaseRelevant2 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStartBranchDuringServiceCeaseRelevant2()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 6/*LogIndex*/, EBTNodeResult::Succeeded, 2/* ExecutionTicks*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 5/*LogIndex*/, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
|
|
FBTBuilder::AddTaskToggleFlag(CompNode3, EBTNodeResult::InProgress, TEXT("Bool1"), 1/*NumOfToggles*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1 /*ActivationIndex*/, 2 /*DeactivationIndex*/, 3 /*TickIndex*/, NAME_None /*TickBoolKeyName*/, false /*bCallTickOnSearchStart*/,
|
|
NAME_None /*BecomeRelevantBoolKeyeyName*/, TEXT("Bool2") /*CeaseRelevantBoolKeyName*/);
|
|
}
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 7/*LogIndex*/, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStartBranchDuringServiceCeaseRelevant2, "System.AI.Behavior Trees.Toggle: start new branch during service cease relevant (low prio)")
|
|
|
|
struct FAITest_BTAbortingDuringServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringServiceBecomeRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithServiceLog(CompNode2, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringServiceBecomeRelevant, "System.AI.Behavior Trees.Abort: during service becomes relevant")
|
|
|
|
struct FAITest_BTAbortingDuringServiceBecomeRelevantTaskTicking : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringServiceBecomeRelevantTaskTicking()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithServiceLog(CompNode2, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/, 222/*LogTickIndex*/);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(222);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringServiceBecomeRelevantTaskTicking, "System.AI.Behavior Trees.Abort: during service becomes relevant when task continue to tick for a longer time")
|
|
|
|
struct FAITest_BTAbortingDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithServiceLog(CompNode3, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, NAME_None, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode3, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode2, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(7);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Abort: during service ceases relevant")
|
|
|
|
struct FAITest_BTAbortingDuringTaskServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringTaskServiceTick()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/, 222/*LogTickIndex*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(222);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringTaskServiceTick, "System.AI.Behavior Trees.Abort: during task service tick")
|
|
|
|
struct FAITest_BTAbortingDuringTaskServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringTaskServiceBecomeRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringTaskServiceBecomeRelevant, "System.AI.Behavior Trees.Abort: during task service becomes relevant")
|
|
|
|
struct FAITest_BTAbortingDuringTaskServiceBecomeRelevantTaskTicking : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringTaskServiceBecomeRelevantTaskTicking()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/, 222/*LogTickIndex*/);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(222);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringTaskServiceBecomeRelevantTaskTicking, "System.AI.Behavior Trees.Abort: during task service becomes relevant when task continue to tick for a longer time")
|
|
|
|
struct FAITest_BTAbortingDuringTaskServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortingDuringTaskServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceLog(CompNode2, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, NAME_None, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(7);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortingDuringTaskServiceCeaseRelevant, "System.AI.Behavior Trees.Abort: during task service ceases relevant")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringServiceTick()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode3, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode3, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringServiceTick, "System.AI.Behavior Trees.Switch: higher priority during service tick")
|
|
|
|
struct FAITest_BTRequestExecutionOnLatentAbortFinished : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRequestExecutionOnLatentAbortFinished()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset); // 0
|
|
{
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 3
|
|
1 /* ExecHalfNumTicks */, FName() /* ExecKeyName */, 100 /* ExecLogStart */, 199 /* ExecLogFinish */,
|
|
1 /* AbortHalfNumTicks */, FName() /* AbortKeyName */, 200 /* AbortLogStart */, 299 /* AbortLogFinish */);
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(CompNode); // 1
|
|
FBTBuilder::WithDecoratorDelayedAbort(CompNode, 1, false /* bOnlyOnce */); // 2
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded); // 4
|
|
FBTBuilder::AddTask(CompNode, 5, EBTNodeResult::Succeeded); // 5
|
|
}
|
|
|
|
ExpectedResult.Add(100);
|
|
ExpectedResult.Add(200);
|
|
ExpectedResult.Add(299);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRequestExecutionOnLatentAbortFinished, "System.AI.Behavior Trees.Abort: request on latent task finished")
|
|
|
|
struct FAITest_BTRequestExecutionOnTimerBasedLatentAbortFinished : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTRequestExecutionOnTimerBasedLatentAbortFinished()
|
|
{
|
|
enum
|
|
{
|
|
FirstTaskStartExecute = 1,
|
|
FirstTaskStartAbort,
|
|
FirstTaskFinishAbort,
|
|
FirstTaskFinished,
|
|
SecondTaskExecute
|
|
};
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& SelectorNode = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
constexpr float NumTicksBeforeAbortingTask = 3;
|
|
|
|
// Add this decorator to prevent the test from running indefinitely if there is a regression on the behavior
|
|
// this unit test is meant to validate
|
|
constexpr float NumTicksBeforeAbortingSelector = NumTicksBeforeAbortingTask + 10;
|
|
FBTBuilder::WithDecorator<UBTDecorator_TimeLimit>(CompNode).TimeLimit = NumTicksBeforeAbortingSelector * FAITestHelpers::TickInterval;
|
|
|
|
UTestBTTask_TimerBasedLatent& Task = FBTBuilder::AddTask<UTestBTTask_TimerBasedLatent>(SelectorNode);
|
|
Task.LogIndexExecuteStart = FirstTaskStartExecute;
|
|
Task.LogIndexAbortStart = FirstTaskStartAbort;
|
|
Task.LogIndexAbortFinish = FirstTaskFinishAbort;
|
|
Task.NumTicksAborting = 2;
|
|
// Make sure to execute long enough to be aborted
|
|
Task.NumTicksExecuting = 2 * NumTicksBeforeAbortingTask;
|
|
{
|
|
FBTBuilder::WithDecorator<UBTDecorator_TimeLimit>(SelectorNode).TimeLimit = NumTicksBeforeAbortingTask * FAITestHelpers::TickInterval;
|
|
}
|
|
|
|
FBTBuilder::AddTask(SelectorNode, SecondTaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(FirstTaskStartExecute);
|
|
ExpectedResult.Add(FirstTaskStartAbort);
|
|
ExpectedResult.Add(FirstTaskFinishAbort);
|
|
ExpectedResult.Add(SecondTaskExecute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTRequestExecutionOnTimerBasedLatentAbortFinished, "System.AI.Behavior Trees.Abort: request on latent timer based task finished")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringServiceBecomeRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode3, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode3, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringServiceBecomeRelevant, "System.AI.Behavior Trees.Switch: higher priority during service becomes relevant")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringServiceBecomeRelevantWithTickingTask : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringServiceBecomeRelevantWithTickingTask()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode3, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode3, 6, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/, 222/*LogTickIndex*/);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(222);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringServiceBecomeRelevantWithTickingTask, "System.AI.Behavior Trees.Switch: higher priority during service becomes relevant with ticking task")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
UBTCompositeNode& CompNode4 = FBTBuilder::AddSelector(CompNode3);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode4, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, NAME_None, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode4, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode3, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(7);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Switch: higher priority during service ceases relevant")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringTaskServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringTaskServiceTick()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, TEXT("Bool1"));
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringTaskServiceTick, "System.AI.Behavior Trees.Switch: higher priority during task service tick")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringTaskServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringTaskServiceBecomeRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringTaskServiceBecomeRelevant, "System.AI.Behavior Trees.Switch: higher priority during task service becomes relevant")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringTaskServiceBecomeRelevantWithTickingTask : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringTaskServiceBecomeRelevantWithTickingTask()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/, 222/*LogTickIndex*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, TEXT("Bool1"));
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(222);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringTaskServiceBecomeRelevantWithTickingTask, "System.AI.Behavior Trees.Switch: higher priority during task service becomes relevant with ticking task")
|
|
|
|
struct FAITest_BTSwitchingHigherPrioDuringTaskServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSwitchingHigherPrioDuringTaskServiceCeaseRelevant()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 6, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 3/*TickIndex*/, NAME_None, false, NAME_None, TEXT("Bool1"));
|
|
FBTBuilder::AddTask(CompNode3, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(3); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(7);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSwitchingHigherPrioDuringTaskServiceCeaseRelevant, "System.AI.Behavior Trees.Switch: higher priority during task service ceases relevant")
|
|
|
|
struct FAITest_BTAbortSelfFail : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortSelfFail()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self);
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortSelfFail, "System.AI.Behavior Trees.Abort: self failure")
|
|
|
|
struct FAITest_BTAbortSelfSuccess : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortSelfSuccess()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self);
|
|
FBTBuilder::WithDecorator<UBTDecorator_ForceSuccess>(CompNode);
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortSelfSuccess, "System.AI.Behavior Trees.Abort: self success")
|
|
|
|
struct FAITest_BTAbortLowerPri : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortLowerPri()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Failed);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(0);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortLowerPri, "System.AI.Behavior Trees.Abort: lower priority")
|
|
|
|
struct FAITest_BTAbortMerge1 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortMerge1()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode);
|
|
}
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self);
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortMerge1, "System.AI.Behavior Trees.Abort: merge ranges 1")
|
|
|
|
struct FAITest_BTAbortMerge2 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortMerge2()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Failed);
|
|
|
|
FBTBuilder::AddTask(CompNode, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 2, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Failed);
|
|
FBTBuilder::AddTaskFlagChange(CompNode, true, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortMerge2, "System.AI.Behavior Trees.Abort: merge ranges 2")
|
|
|
|
struct FAITest_BTAbortMerge3 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortMerge3()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode2);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode2);
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 2, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
FBTBuilder::AddTaskFlagChange(CompNode3, true, EBTNodeResult::Failed);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortMerge3, "System.AI.Behavior Trees.Abort: merge ranges 3")
|
|
|
|
struct FAITest_BTAbortParallelInternal : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortParallelInternal()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddParallel(CompNode, EBTParallelMode::WaitForBackground);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 0, EBTNodeResult::Succeeded, 5);
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 1, EBTNodeResult::Succeeded, 1);
|
|
|
|
UBTCompositeNode& CompNode4 = FBTBuilder::AddSelector(CompNode3);
|
|
{
|
|
FBTBuilder::AddTask(CompNode4, 2, EBTNodeResult::Succeeded, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode4, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode4, 3, EBTNodeResult::Succeeded, 1);
|
|
}
|
|
|
|
FBTBuilder::AddTaskFlagChange(CompNode3, true, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortParallelInternal, "System.AI.Behavior Trees.Abort: parallel internal")
|
|
|
|
struct FAITest_BTAbortParallelOut : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortParallelOut()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddParallel(CompNode, EBTParallelMode::WaitForBackground);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Failed, 5);
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 2, EBTNodeResult::Succeeded, 1);
|
|
FBTBuilder::AddTaskFlagChange(CompNode3, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode3, 3, EBTNodeResult::Succeeded, 1);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(0);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortParallelOut, "System.AI.Behavior Trees.Abort: parallel out")
|
|
|
|
struct FAITest_BTAbortParallelOutAndBack : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortParallelOutAndBack()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
FBTBuilder::WithDecorator<UTestBTDecorator_CantExecute>(CompNode);
|
|
}
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddParallel(CompNode, EBTParallelMode::WaitForBackground);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Failed, 5);
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 2, EBTNodeResult::Succeeded, 2);
|
|
FBTBuilder::AddTaskFlagChange(CompNode3, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode3, 3, EBTNodeResult::Succeeded, 3);
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortParallelOutAndBack, "System.AI.Behavior Trees.Abort: parallel out & back")
|
|
|
|
struct FAITest_BTAbortMultipleDelayed : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortMultipleDelayed()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Failed);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorDelayedAbort(CompNode, 2, false);
|
|
|
|
FBTBuilder::AddTaskLogFinish(CompNode2, 1, 11, EBTNodeResult::Succeeded, 4);
|
|
FBTBuilder::AddTaskLogFinish(CompNode2, 2, 12, EBTNodeResult::Succeeded, 4);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortMultipleDelayed, "System.AI.Behavior Trees.Abort: multiple delayed requests")
|
|
|
|
struct FAITest_BTAbortToInactiveParallel : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortToInactiveParallel()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddParallel(CompNode, EBTParallelMode::WaitForBackground);
|
|
{
|
|
FBTBuilder::WithDecoratorDelayedAbort(CompNode, 5);
|
|
|
|
FBTBuilder::AddTaskLogFinish(CompNode2, 1, 11, EBTNodeResult::Succeeded, 10);
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 2, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode3, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
FBTBuilder::AddTaskLogFinish(CompNode3, 3, 13, EBTNodeResult::Succeeded, 8);
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode4 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode4, 4, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode4, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode4, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(5);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortToInactiveParallel, "System.AI.Behavior Trees.Abort: observer in inactive parallel")
|
|
|
|
struct FAITest_BTAbortDuringLatentAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringLatentAbort()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::Set, EBTFlowAbortMode::None, TEXT("Bool3"));
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& Comp2Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTaskLatentFlags(Comp2Node, EBTNodeResult::Succeeded,
|
|
1, TEXT("Bool2"), 2, 3,
|
|
1, TEXT("Bool1"), 4, 5);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp2Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool2"));
|
|
}
|
|
|
|
FBTBuilder::AddTask(Comp2Node, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(5);
|
|
ExpectedResult.Add(7);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringLatentAbort, "System.AI.Behavior Trees.Abort: during latent task abort (lower pri)")
|
|
|
|
struct FAITest_BTAbortDuringLatentAbort2 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringLatentAbort2()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTaskLatentFlags(Comp1Node, EBTNodeResult::Succeeded,
|
|
1, TEXT("Bool1"), 0, 1,
|
|
1, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
}
|
|
|
|
FBTBuilder::AddTask(Comp1Node, 4, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool3"));
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringLatentAbort2, "System.AI.Behavior Trees.Abort: during latent task abort (self)")
|
|
|
|
struct FAITest_BTAbortDuringLatentAbort3 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringLatentAbort3()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool1")); // 1
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 4
|
|
1, TEXT("Bool1"), 0, 1,
|
|
1, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2")); // 3
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 5, EBTNodeResult::Succeeded); // 5
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringLatentAbort3, "System.AI.Behavior Trees.Abort: during latent task abort (high pri)")
|
|
|
|
struct FAITest_BTAbortDuringLatentAbort4 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringLatentAbort4()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2")); // 1
|
|
FBTBuilder::AddTask(Comp1Node, 8, EBTNodeResult::Succeeded); // 4
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool3")); // 3
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 6
|
|
1, TEXT("Bool1"), 0, 1,
|
|
1, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1")); // 5
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 8
|
|
1, TEXT("Bool3"), 4, 5,
|
|
0, NAME_None, 6, 7);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool4")); // 7
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(7);
|
|
ExpectedResult.Add(8);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringLatentAbort4, "System.AI.Behavior Trees.Abort: during latent task abort (high pri 2)")
|
|
|
|
struct FAITest_BTResumingDuringLatentAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTResumingDuringLatentAbort()
|
|
{
|
|
enum
|
|
{
|
|
LatentTaskStart = 0,
|
|
LatentTaskFinish,
|
|
LatentTaskAbortStart,
|
|
LatentTaskAbortFinish,
|
|
Task1Log,
|
|
Task2Log,
|
|
};
|
|
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
FBTBuilder::AddTask(CompNode, Task1Log, EBTNodeResult::Succeeded); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool1")); // 1
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, Task2Log, EBTNodeResult::Succeeded); // 4
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::None, TEXT("Bool2")); // 3
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 5
|
|
/*ExecuteHalfTicks*/2, TEXT("Bool1"), LatentTaskStart, LatentTaskFinish,
|
|
/*AbortHalfTicks*/3, TEXT("Bool1"), LatentTaskAbortStart, LatentTaskAbortFinish, EBTTestChangeFlagBehavior::Toggle);
|
|
{
|
|
FBTBuilder::WithTaskServiceLog(CompNode, /*ActivationIndex*/-1, /*DeactivationIndex*/-1, /*TickIndex*/-1, /*TickBoolKeyName*/TEXT("Bool2")); // 6
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(LatentTaskStart/*0*/);
|
|
ExpectedResult.Add(LatentTaskAbortStart/*2*/);
|
|
ExpectedResult.Add(LatentTaskAbortFinish/*3*/);
|
|
ExpectedResult.Add(Task2Log/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTResumingDuringLatentAbort, "System.AI.Behavior Trees.Resume: during latent task abort")
|
|
|
|
struct FAITest_BTAbortDuringInstantAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringInstantAbort()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, 1, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::Set, EBTFlowAbortMode::None, TEXT("Bool3"));
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& Comp2Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTaskLatentFlags(Comp2Node, EBTNodeResult::Succeeded,
|
|
1, TEXT("Bool2"), 2, 3,
|
|
0, TEXT("Bool1"), 4, 5);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp2Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool2"));
|
|
}
|
|
|
|
FBTBuilder::AddTask(Comp2Node, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(5);
|
|
ExpectedResult.Add(7);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringInstantAbort, "System.AI.Behavior Trees.Abort: during instant task abort (lower pri)")
|
|
|
|
struct FAITest_BTAbortDuringInstantAbort2 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringInstantAbort2()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTaskLatentFlags(Comp1Node, EBTNodeResult::Succeeded,
|
|
1, TEXT("Bool1"), 0, 1,
|
|
0, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1"));
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2"));
|
|
}
|
|
|
|
FBTBuilder::AddTask(Comp1Node, 4, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool3"));
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 5, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringInstantAbort2, "System.AI.Behavior Trees.Abort: during instant task abort (self)")
|
|
|
|
struct FAITest_BTAbortDuringInstantAbort3 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringInstantAbort3()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 4, EBTNodeResult::Succeeded); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool1")); // 1
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 4
|
|
1, TEXT("Bool1"), 0, 1,
|
|
0, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool2")); // 3
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 5, EBTNodeResult::Succeeded); // 5
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringInstantAbort3, "System.AI.Behavior Trees.Abort: during instant task abort (high pri)")
|
|
|
|
struct FAITest_BTAbortDuringInstantAbort4 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortDuringInstantAbort4()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2")); // 1
|
|
FBTBuilder::AddTask(Comp1Node, 8, EBTNodeResult::Succeeded); // 4
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool3")); // 3
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 6
|
|
1, TEXT("Bool1"), 0, 1,
|
|
0, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1")); // 5
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 8
|
|
1, TEXT("Bool3"), 4, 5,
|
|
0, NAME_None, 6, 7);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool4")); // 7
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(7);
|
|
ExpectedResult.Add(8);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortDuringInstantAbort4, "System.AI.Behavior Trees.Abort: during instant task abort (high pri 2)")
|
|
|
|
struct FAITest_BTAbortOnValueChangePass : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortOnValueChangePass()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Failed);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::NotEqual, 10, EBTFlowAbortMode::Self, EBTBlackboardRestart::ValueChange, TEXT("Int"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskValueChange(CompNode2, 1, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortOnValueChangePass, "System.AI.Behavior Trees.Abort: value change (pass)")
|
|
|
|
struct FAITest_BTAbortOnValueChangeFail : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortOnValueChangeFail()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Failed);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::NotEqual, 10, EBTFlowAbortMode::Self, EBTBlackboardRestart::ValueChange, TEXT("Int"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskValueChange(CompNode2, 10, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortOnValueChangeFail, "System.AI.Behavior Trees.Abort: value change (fail)")
|
|
|
|
struct FAITest_BTAbortOnValueChangeFailOther : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTAbortOnValueChangeFailOther()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Failed);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::NotEqual, 10, EBTFlowAbortMode::Self, EBTBlackboardRestart::ValueChange, TEXT("Int"));
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::None, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded, TEXT("Bool1"));
|
|
FBTBuilder::AddTaskValueChange(CompNode2, 1, EBTNodeResult::Succeeded, TEXT("Int"));
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Failed);
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTAbortOnValueChangeFailOther, "System.AI.Behavior Trees.Abort: value change (other failed)")
|
|
|
|
struct FAITest_BTLowPriObserverInLoop : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTLowPriObserverInLoop()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 1, EBTNodeResult::Failed);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorLoop(CompNode);
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode2, EBTNodeResult::Succeeded, 1, TEXT("Bool2"), 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::Set, EBTFlowAbortMode::None, TEXT("Bool1"));
|
|
}
|
|
|
|
UBTCompositeNode& CompNode4 = FBTBuilder::AddSequence(CompNode2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode4, 4, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode4, true, EBTNodeResult::Failed, TEXT("Bool1"));
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode2, 5, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool2"));
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTLowPriObserverInLoop, "System.AI.Behavior Trees.Other: low priority observer in looped branch")
|
|
|
|
struct FAITest_BTLoopUntilSuccess : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTLoopUntilSuccess()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
// We first set the bool key to false so task number 2 doesn't execute during the first loop
|
|
FBTBuilder::AddTaskFlagChange(CompNode, false, EBTNodeResult::Failed);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// Loop the selector until it succeeds
|
|
FBTBuilder::WithDecoratorLoopUntil(CompNode, EBTNodeResult::Succeeded);
|
|
|
|
// Execute a failed task in the selector so we continue and can verify the looping
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Failed);
|
|
|
|
// Conditionally execute a succeeding task
|
|
FBTBuilder::AddTask(CompNode2, 2, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::Set, EBTFlowAbortMode::None, TEXT("Bool1"));
|
|
}
|
|
|
|
// Set the bool key to true so task number 2 will now execute and make the selector succeed
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Failed);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTLoopUntilSuccess, "System.AI.Behavior Trees.LoopUntil: Loop until success")
|
|
|
|
struct FAITest_BTSubtreeSimple : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSubtreeSimple()
|
|
{
|
|
UBehaviorTree* ChildAsset1 = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset1)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset1);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*ChildAsset1);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 10, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode, 11, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
UBehaviorTree* ChildAsset2 = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset2)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset2);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*ChildAsset2);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 20, EBTNodeResult::Failed);
|
|
FBTBuilder::AddTask(CompNode, 21, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 0, EBTNodeResult::Failed);
|
|
FBTBuilder::AddTaskSubtree(CompNode2, ChildAsset2);
|
|
FBTBuilder::AddTask(CompNode2, 1, EBTNodeResult::Failed);
|
|
}
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode3, 2, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskSubtree(CompNode3, ChildAsset1);
|
|
FBTBuilder::AddTask(CompNode3, 3, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(20);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(10);
|
|
ExpectedResult.Add(11);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSubtreeSimple, "System.AI.Behavior Trees.Subtree: simple")
|
|
|
|
struct FAITest_BTSubtreeRequestInDeactivatedBranch : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSubtreeRequestInDeactivatedBranch()
|
|
{
|
|
UBehaviorTree* ChildAsset1 = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset1)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset1);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*ChildAsset1);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 10, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool2"));
|
|
}
|
|
FBTBuilder::AddTaskFlagChange(CompNode, true, EBTNodeResult::InProgress, TEXT("Bool1"), TEXT("Bool2"), true);
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::AddTask(CompNode2, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode2, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
}
|
|
FBTBuilder::AddTaskSubtree(CompNode2, ChildAsset1);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSubtreeRequestInDeactivatedBranch, "System.AI.Behavior Trees.Subtree: deactivated branch")
|
|
|
|
struct FAITest_BTSubtreeAbortOut : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSubtreeAbortOut()
|
|
{
|
|
UBehaviorTree* ChildAsset = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*ChildAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 10, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTaskFlagChange(CompNode, true, EBTNodeResult::Succeeded);
|
|
FBTBuilder::AddTask(CompNode, 11, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority);
|
|
}
|
|
|
|
FBTBuilder::AddTaskSubtree(CompNode, ChildAsset);
|
|
}
|
|
|
|
ExpectedResult.Add(10);
|
|
ExpectedResult.Add(0);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSubtreeAbortOut, "System.AI.Behavior Trees.Subtree: abort out")
|
|
|
|
/* This unittest come from UDN case 00320135 */
|
|
struct FAITest_BTSubtreeAbortOutToLowerPrio : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSubtreeAbortOutToLowerPrio()
|
|
{
|
|
UBehaviorTree* ChildAsset = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*ChildAsset);
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2"), 3/*LogIndexBecomeRelevant*/, 4/*LogIndexCeaseRelevant*/);
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded, TEXT("Bool3"));
|
|
}
|
|
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool3"), 5/*LogIndexBecomeRelevant*/, 6/*LogIndexCeaseRelevant*/);
|
|
FBTBuilder::AddTask(CompNode3, 12, EBTNodeResult::Succeeded, 10/*ExecutionTicks*/);
|
|
FBTBuilder::WithTaskServiceLog(CompNode3, 13/*ActivationIndex*/, 14/*DeactivationIndex*/, 15/*TickIndex*/, TEXT("Bool1"));
|
|
}
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTaskFlagChange(CompNode, true, EBTNodeResult::Failed, TEXT("Bool3"));
|
|
FBTBuilder::AddTaskSubtree(CompNode, ChildAsset);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"), 1/*LogIndexBecomeRelevant*/, 2/*LogIndexCeaseRelevant*/);
|
|
}
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, false, EBTNodeResult::Succeeded, TEXT("Bool3"));
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, true, EBTNodeResult::Succeeded, TEXT("Bool2"));
|
|
FBTBuilder::AddTaskFlagChange(CompNode2, false, EBTNodeResult::Succeeded, TEXT("Bool1"));
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(13);
|
|
ExpectedResult.Add(15);
|
|
ExpectedResult.Add(12);
|
|
ExpectedResult.Add(15); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(14);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(2);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSubtreeAbortOutToLowerPrio, "System.AI.Behavior Trees.Subtree: abort out lower prio")
|
|
|
|
/* This unittest come from UDN case 00484061 */
|
|
struct FAITest_BTSubtreeAbortOutToLowerPrio2 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTSubtreeAbortOutToLowerPrio2()
|
|
{
|
|
enum
|
|
{
|
|
SubtreeTaskExecute = 1,
|
|
SubtreeTaskTick,
|
|
BBDecoratorBecomeRelevant,
|
|
BBDecoratorCeaseRelevant,
|
|
MainTaskExecute,
|
|
MainTaskTick
|
|
};
|
|
|
|
// SubTree
|
|
UBehaviorTree* ChildAsset = &FBTBuilder::CreateBehaviorTree(*BTAsset);
|
|
if (ChildAsset)
|
|
{
|
|
AddAutoDestroyObject(*ChildAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*ChildAsset);
|
|
{
|
|
// SubtreeTask
|
|
FBTBuilder::AddTask(CompNode, SubtreeTaskExecute, EBTNodeResult::Failed, 1, SubtreeTaskTick);
|
|
}
|
|
}
|
|
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
// SubTreeTask
|
|
FBTBuilder::AddTaskSubtree(CompNode, ChildAsset);
|
|
|
|
// BBDecorator
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"), BBDecoratorBecomeRelevant, BBDecoratorCeaseRelevant);
|
|
|
|
// MainTask
|
|
FBTBuilder::AddTask(CompNode, MainTaskExecute, EBTNodeResult::Succeeded, 1, MainTaskTick);
|
|
}
|
|
|
|
ExpectedResult.Add(SubtreeTaskExecute/*1*/);
|
|
ExpectedResult.Add(SubtreeTaskTick/*2*/);
|
|
ExpectedResult.Add(SubtreeTaskTick/*2*/);
|
|
ExpectedResult.Add(BBDecoratorBecomeRelevant/*3*/);
|
|
ExpectedResult.Add(MainTaskExecute/*5*/);
|
|
ExpectedResult.Add(MainTaskTick/*6*/);
|
|
ExpectedResult.Add(MainTaskTick/*6*/);
|
|
ExpectedResult.Add(BBDecoratorCeaseRelevant/*4*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTSubtreeAbortOutToLowerPrio2, "System.AI.Behavior Trees.Subtree: abort out lower prio 2")
|
|
|
|
struct FAITest_BTServiceInstantTask : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTServiceInstantTask()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 4/*TickIndex*/);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(4); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTServiceInstantTask, "System.AI.Behavior Trees.Service: instant task")
|
|
|
|
struct FAITest_BTServiceLatentTask : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTServiceLatentTask()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded, 2);
|
|
{
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 1/*ActivationIndex*/, 2/*DeactivationIndex*/, 4/*TickIndex*/);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 3, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(4);// Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(2);
|
|
ExpectedResult.Add(3);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTServiceLatentTask, "System.AI.Behavior Trees.Service: latent task")
|
|
|
|
struct FAITest_BTServiceAbortingTask : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTServiceAbortingTask()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset);
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 0, EBTNodeResult::Succeeded);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::LowerPriority, TEXT("Bool1"));
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, 1, TEXT("Bool1"), 1, 2, 0, NAME_None, 3, 4);
|
|
{
|
|
FBTBuilder::WithTaskServiceLog(CompNode, 5/*ActivationIndex*/, 6/*DeactivationIndex*/, 8/*TickIndex*/);
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 7, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(5);
|
|
ExpectedResult.Add(8);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(8);
|
|
ExpectedResult.Add(8); // Extra service tick because aux nodes are always ticked before any pending requests are processed
|
|
ExpectedResult.Add(3);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(6);
|
|
ExpectedResult.Add(0);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTServiceAbortingTask, "System.AI.Behavior Trees.Service: abort task")
|
|
|
|
struct FAITest_BTPostponeDuringSearch : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTPostponeDuringSearch()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
FBTBuilder::AddTask(CompNode, 6, EBTNodeResult::Succeeded); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2")); // 1
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 4
|
|
1, TEXT("Bool1"), 0, 1,
|
|
0, NAME_None, 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1")); // 3
|
|
}
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode); // 7
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool3")); // 5
|
|
FBTBuilder::WithServiceLog(Comp1Node, INDEX_NONE, INDEX_NONE, 4, TEXT("Bool2"), true); // 6
|
|
FBTBuilder::AddTask(Comp1Node, 5, EBTNodeResult::Succeeded); // 8
|
|
}
|
|
|
|
FBTBuilder::AddTask(CompNode, 7, EBTNodeResult::Succeeded); // 9
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(6);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTPostponeDuringSearch, "System.AI.Behavior Trees.Service: Postpone during search (high pri)")
|
|
|
|
struct FAITest_BTPostponeDuringSearch2 : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTPostponeDuringSearch2()
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(*BTAsset); // 0
|
|
{
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode); // 2
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool2")); // 1
|
|
FBTBuilder::AddTask(Comp1Node, 9, EBTNodeResult::Succeeded); // 4
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::Set, EBTFlowAbortMode::Both, TEXT("Bool3")); // 3
|
|
}
|
|
}
|
|
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 6
|
|
1, TEXT("Bool1"), 0, 1,
|
|
0, NAME_None, 2, 3);
|
|
{
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Self, TEXT("Bool1")); // 5
|
|
}
|
|
|
|
UBTCompositeNode& Comp2Node = FBTBuilder::AddSelector(CompNode); // 8
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp2Node, INDEX_NONE, INDEX_NONE, 4, TEXT("Bool2"), true); // 7
|
|
FBTBuilder::AddTaskLatentFlags(CompNode, EBTNodeResult::Succeeded, // 9
|
|
1, TEXT("Bool3"), 5, 6,
|
|
0, NAME_None, 7, 8);
|
|
}
|
|
|
|
}
|
|
|
|
ExpectedResult.Add(0);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(1);
|
|
ExpectedResult.Add(4);
|
|
ExpectedResult.Add(5);
|
|
ExpectedResult.Add(7);
|
|
ExpectedResult.Add(8);
|
|
ExpectedResult.Add(9);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTPostponeDuringSearch2, "System.AI.Behavior Trees.Service: Postpone during search (lower pri)")
|
|
|
|
// This test is temporarily turned off until we enable CVarApplyAuxNodesFromFailedSearches again
|
|
//struct FAITest_BTTestOberserverAbortLowerPriorityTwoDeep: public FAITest_SimpleBT
|
|
//{
|
|
// FAITest_BTTestOberserverAbortLowerPriorityTwoDeep()
|
|
// {
|
|
// enum
|
|
// {
|
|
// MainTaskExecute = 1,
|
|
// InteruptingTaskExecute,
|
|
// };
|
|
//
|
|
// UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
// UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
//
|
|
// {
|
|
// UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
// FBTBuilder::WithDecoratorBlackboard(CompNode, EArithmeticKeyOperation::Equal, 1, EBTFlowAbortMode::LowerPriority, EBTBlackboardRestart::ValueChange, TEXT("Int"));
|
|
//
|
|
// UBTCompositeNode& Comp2Node = FBTBuilder::AddSelector(Comp1Node);
|
|
// FBTBuilder::WithDecoratorBlackboard(Comp1Node, EArithmeticKeyOperation::Equal, 1, EBTFlowAbortMode::LowerPriority, EBTBlackboardRestart::ValueChange, TEXT("Int2"));
|
|
//
|
|
// FBTBuilder::AddTask(Comp2Node, InteruptingTaskExecute, EBTNodeResult::Succeeded);
|
|
// }
|
|
//
|
|
// {
|
|
// FBTBuilder::AddTaskValuesChangedWithLogs(/*ParentNode*/ CompNode, /*LogIndex*/ MainTaskExecute, /*NodeResult*/ EBTNodeResult::Succeeded, /*Value1*/1, /*Value2*/ 1, /*IntKeyName2*/ TEXT("Int"), /* IntKeyName2 */ TEXT("Int2"), /*ExecutionTicks1*/ 5, /*ExecutionTicks2*/ 5);
|
|
// }
|
|
//
|
|
// ExpectedResult.Add(MainTaskExecute);
|
|
// ExpectedResult.Add(InteruptingTaskExecute);
|
|
// }
|
|
//};
|
|
//IMPLEMENT_AI_LATENT_TEST(FAITest_BTTestOberserverAbortLowerPriorityTwoDeep, "System.AI.Behavior Trees.OberserverAbortLowerPriorityTwoDeep: Two nodes in same branch with observer aborts lower priority")
|
|
|
|
struct FAITest_BTTestTickAuxNodesDeactivateNodes : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTTestTickAuxNodesDeactivateNodes()
|
|
{
|
|
enum
|
|
{
|
|
MainTaskExecute = 1,
|
|
StartAbortMainTask,
|
|
SecondaryTask,
|
|
IncorrectTaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
FBTBuilder::WithServiceLog(/*ParentNode*/ RootNode, /*ActivationIndex*/ INDEX_NONE, /*DeactivationIndex*/ INDEX_NONE, /*TickIndex*/ INDEX_NONE, /*TickBoolKeyName*/ TEXT("Bool1"), /*bCallTickOnSearchStart*/ false, /*BecomeRelevantBoolKeyName*/ NAME_None, /*BecomeRelevantBoolKeyName*/ NAME_None, /*bToggleValue*/ false, /*TicksDelaySetKeyNameTick*/ 4);
|
|
FBTBuilder::WithServiceLog(/*ParentNode*/ RootNode, /*ActivationIndex*/ INDEX_NONE, /*DeactivationIndex*/ INDEX_NONE, /*TickIndex*/ INDEX_NONE, /*TickBoolKeyName*/ TEXT("Bool3"), /*bCallTickOnSearchStart*/ false, /*BecomeRelevantBoolKeyName*/ NAME_None, /*BecomeRelevantBoolKeyName*/ NAME_None, /*bToggleValue*/ false, /*TicksDelaySetKeyNameTick*/ 2);
|
|
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
FBTBuilder::WithDecoratorBlackboard(/*ParentNode*/ RootNode, /*Condition*/ EBasicKeyOperation::NotSet, /*Observer*/ EBTFlowAbortMode::LowerPriority, /*BoolKeyName*/ TEXT("Bool1"));
|
|
{
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSelector(CompNode);
|
|
FBTBuilder::WithDecoratorBlackboard(/*ParentNode*/ RootNode, /*Condition*/ EBasicKeyOperation::Set, /*Observer*/ EBTFlowAbortMode::LowerPriority, /*BoolKeyName*/ TEXT("Bool2"));
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(/*ParentNode*/ CompNode2, /*LogIndex*/ IncorrectTaskExecute, /*FinishIndex*/ INDEX_NONE, EBTNodeResult::Succeeded, /*ExecutionTick*/ 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
UBTCompositeNode& CompNode3 = FBTBuilder::AddSelector(RootNode);
|
|
FBTBuilder::WithDecoratorBlackboard(/*ParentNode*/ RootNode, /*Condition*/ EBasicKeyOperation::Set, /*Observer*/ EBTFlowAbortMode::LowerPriority, /*BoolKeyName*/ TEXT("Bool3"));
|
|
|
|
FBTBuilder::AddTaskLogFinish(/*ParentNode*/ CompNode3, /*LogIndex*/ SecondaryTask, /*FinishIndex*/ INDEX_NONE, EBTNodeResult::Succeeded, /*ExecutionTick*/ 4);
|
|
}
|
|
|
|
{
|
|
FBTBuilder::AddTaskLatentFlags(RootNode, EBTNodeResult::Succeeded, 3, FName(), MainTaskExecute, INDEX_NONE, 3, NAME_None, 2, INDEX_NONE);
|
|
}
|
|
|
|
ExpectedResult.Add(MainTaskExecute);
|
|
ExpectedResult.Add(StartAbortMainTask);
|
|
ExpectedResult.Add(SecondaryTask);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTTestTickAuxNodesDeactivateNodes, "System.AI.Behavior Trees.Ticking aux nodes deactivates nodes")
|
|
|
|
struct FAITest_BTTestAbortNestedSimpleParallel : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTTestAbortNestedSimpleParallel()
|
|
{
|
|
enum
|
|
{
|
|
ChildFirstTaskExecute = 1,
|
|
ChildSecondTaskExecute,
|
|
ChildThirdTaskExecute
|
|
};
|
|
|
|
UBehaviorTree* ChildBTAsset = &FBTBuilder::CreateBehaviorTree();
|
|
AddAutoDestroyObject(*ChildBTAsset);
|
|
|
|
// Setup subtree
|
|
{
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSequence(*ChildBTAsset);
|
|
{
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddParallel(RootNode, EBTParallelMode::AbortBackground);
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(/*ParentNode*/ CompNode, /*LogIndex*/ ChildFirstTaskExecute, /*FinishIndex*/ INDEX_NONE, EBTNodeResult::Succeeded, /*ExecutionTick*/ 500);
|
|
FBTBuilder::WithDecorator<UBTDecorator_Cooldown>(CompNode);
|
|
|
|
UBTCompositeNode& CompNode2 = FBTBuilder::AddSequence(CompNode);
|
|
{
|
|
FBTBuilder::AddTaskLogFinish(/*ParentNode*/ CompNode2, /*LogIndex*/ ChildSecondTaskExecute, /*FinishIndex*/ INDEX_NONE, EBTNodeResult::Succeeded, /*ExecutionTick*/ 5);
|
|
FBTBuilder::WithDecorator<UBTDecorator_Cooldown>(CompNode2);
|
|
|
|
FBTBuilder::AddTaskLogFinish(/*ParentNode*/ CompNode2, /*LogIndex*/ ChildThirdTaskExecute, /*FinishIndex*/ INDEX_NONE, EBTNodeResult::Succeeded, /*ExecutionTick*/ 5);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Setup main tree
|
|
{
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSequence(*BTAsset);
|
|
{
|
|
constexpr float NumTicks = 4.f;
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
FBTBuilder::WithDecorator<UBTDecorator_TimeLimit>(RootNode).TimeLimit = NumTicks * FAITestHelpers::TickInterval;
|
|
{
|
|
FBTBuilder::AddTask<UTestBTTask_RunBehavior>(CompNode).SetSubtreeAsset(ChildBTAsset);
|
|
}
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ChildFirstTaskExecute);
|
|
ExpectedResult.Add(ChildSecondTaskExecute);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTTestAbortNestedSimpleParallel, "System.AI.Behavior Trees.Abort: nested simple parallel")
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Stop tree tests
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
struct FAITest_BTStopDuringTaskExecute : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskExecute()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
UninitTaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskExecute, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringExecute, EBTTestStopAction::StopTree);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(UninitTaskExecute/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskExecute, "System.AI.Behavior Trees.Stop: during task execute")
|
|
|
|
struct FAITest_BTStopDuringTaskTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
UninitTaskTick,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskTick, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringTick, EBTTestStopAction::StopTree);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(UninitTaskTick/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskTick, "System.AI.Behavior Trees.Stop: during task tick")
|
|
|
|
struct FAITest_BTStopDuringTaskAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskAbort()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskAborting,
|
|
TaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskAborting, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringAbort, EBTTestStopAction::StopTree);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*5*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskAborting/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskAbort, "System.AI.Behavior Trees.Stop: during task abort")
|
|
|
|
struct FAITest_BTStopDuringTaskFinished : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskFinished()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskFinished,
|
|
TaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskFinished, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringFinish, EBTTestStopAction::StopTree);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskFinished/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskFinished, "System.AI.Behavior Trees.Stop: during task finished")
|
|
|
|
struct FAITest_BTStopDuringServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringServiceTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceTick,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Servier
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitServiceTick
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceTick, EBTTestServiceStopTiming::DuringTick, EBTTestStopAction::StopTree);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitServiceTick/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringServiceTick, "System.AI.Behavior Trees.Stop: during service tick")
|
|
|
|
struct FAITest_BTStopDuringServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringServiceBecomeRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceBecomeRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitService
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceBecomeRelevant, EBTTestServiceStopTiming::DuringBecomeRelevant, EBTTestStopAction::StopTree);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(UninitServiceBecomeRelevant/*7*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringServiceBecomeRelevant, "System.AI.Behavior Trees.Stop: during service become relevant")
|
|
|
|
struct FAITest_BTStopDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringServiceCeaseRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceCeaseRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitService
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceCeaseRelevant, EBTTestServiceStopTiming::DuringCeaseRelevant, EBTTestStopAction::StopTree);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
}
|
|
// Task2
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
ExpectedResult.Add(UninitServiceCeaseRelevant/*7*/);
|
|
ExpectedResult.Add(Task2Execute/*9*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Stop: during service cease relevant")
|
|
|
|
struct FAITest_BTStopDuringTaskServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskServiceTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceTick,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceTick, EBTTestServiceStopTiming::DuringTick, EBTTestStopAction::StopTree);
|
|
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceTick/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskServiceTick, "System.AI.Behavior Trees.Stop: during task service tick")
|
|
|
|
struct FAITest_BTStopDuringTaskServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskServiceBecomeRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceBecomeRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceBecomeRelevant, EBTTestServiceStopTiming::DuringBecomeRelevant, EBTTestStopAction::StopTree);
|
|
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceBecomeRelevant/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskServiceBecomeRelevant, "System.AI.Behavior Trees.Stop: during task service become relevant")
|
|
|
|
struct FAITest_BTStopDuringTaskServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTStopDuringTaskServiceCeaseRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceCeaseRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceCeaseRelevant, EBTTestServiceStopTiming::DuringCeaseRelevant, EBTTestStopAction::StopTree);
|
|
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceCeaseRelevant/*7*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
ExpectedResult.Add(Task2Execute/*9*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTStopDuringTaskServiceCeaseRelevant, "System.AI.Behavior Trees.Stop: during task service cease relevant")
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Uninitialize tests
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
struct FAITest_BTUninitializeDuringTaskExecute : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringTaskExecute()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
UninitTaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskExecute, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringExecute, EBTTestStopAction::UnInitialize);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(UninitTaskExecute/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskExecute, "System.AI.Behavior Trees.Uninitialize: during task execute")
|
|
|
|
struct FAITest_BTUninitializeDuringTaskTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringTaskTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
UninitTaskTick,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskTick, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringTick, EBTTestStopAction::UnInitialize);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(UninitTaskTick/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskTick, "System.AI.Behavior Trees.Uninitialize: during task tick")
|
|
|
|
struct FAITest_BTUninitializeDuringTaskAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringTaskAbort()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskAborting,
|
|
TaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskAborting, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringAbort, EBTTestStopAction::UnInitialize);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*5*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskAborting/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskAbort, "System.AI.Behavior Trees.Uninitialize: during task abort")
|
|
|
|
struct FAITest_BTUninitializeDuringTaskFinished : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringTaskFinished()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskFinished,
|
|
TaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskFinished, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringFinish, EBTTestStopAction::UnInitialize);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskFinished/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskFinished, "System.AI.Behavior Trees.Uninitialize: during task finished")
|
|
|
|
struct FAITest_BTUninitializeDuringServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringServiceTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceTick,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Servier
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitServiceTick
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceTick, EBTTestServiceStopTiming::DuringTick, EBTTestStopAction::UnInitialize);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitServiceTick/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringServiceTick, "System.AI.Behavior Trees.Uninitialize: during service tick")
|
|
|
|
struct FAITest_BTUninitializeDuringServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringServiceBecomeRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceBecomeRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitService
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceBecomeRelevant, EBTTestServiceStopTiming::DuringBecomeRelevant, EBTTestStopAction::UnInitialize);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(UninitServiceBecomeRelevant/*7*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringServiceBecomeRelevant, "System.AI.Behavior Trees.Uninitialize: during service become relevant")
|
|
|
|
struct FAITest_BTUninitializeDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringServiceCeaseRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceCeaseRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitService
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceCeaseRelevant, EBTTestServiceStopTiming::DuringCeaseRelevant, EBTTestStopAction::UnInitialize);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
}
|
|
// Task2
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
ExpectedResult.Add(UninitServiceCeaseRelevant/*7*/);
|
|
ExpectedResult.Add(Task2Execute/*9*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Uninitialize: during service cease relevant")
|
|
|
|
struct FAITest_BTUninitializeDuringTaskServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringTaskServiceTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceTick,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceTick, EBTTestServiceStopTiming::DuringTick, EBTTestStopAction::UnInitialize);
|
|
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceTick/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskServiceTick, "System.AI.Behavior Trees.Uninitialize: during task service tick")
|
|
|
|
struct FAITest_BTUninitializeDuringTaskServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTUninitializeDuringTaskServiceBecomeRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceBecomeRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceBecomeRelevant, EBTTestServiceStopTiming::DuringBecomeRelevant, EBTTestStopAction::UnInitialize);
|
|
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceBecomeRelevant/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskServiceBecomeRelevant, "System.AI.Behavior Trees.Uninitialize: during task service become relevant")
|
|
|
|
struct FAITest_BTUninitializeDuringTaskServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{ FAITest_BTUninitializeDuringTaskServiceCeaseRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceCeaseRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceCeaseRelevant, EBTTestServiceStopTiming::DuringCeaseRelevant, EBTTestStopAction::UnInitialize);
|
|
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceCeaseRelevant/*7*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
ExpectedResult.Add(Task2Execute/*9*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTUninitializeDuringTaskServiceCeaseRelevant, "System.AI.Behavior Trees.Uninitialize: during task service cease relevant")
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Cleanup tests
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
struct FAITest_BTCleanupDuringTaskExecute : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskExecute()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
UninitTaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskExecute, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringExecute, EBTTestStopAction::Cleanup);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(UninitTaskExecute/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskExecute, "System.AI.Behavior Trees.Cleanup: during task execute")
|
|
|
|
struct FAITest_BTCleanupDuringTaskTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
UninitTaskTick,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskTick, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringTick, EBTTestStopAction::Cleanup);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(UninitTaskTick/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskTick, "System.AI.Behavior Trees.Cleanup: during task tick")
|
|
|
|
struct FAITest_BTCleanupDuringTaskAbort : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskAbort()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskAborting,
|
|
TaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskAborting, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringAbort, EBTTestStopAction::Cleanup);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*5*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskAborting/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskAbort, "System.AI.Behavior Trees.Cleanup: during task abort")
|
|
|
|
struct FAITest_BTCleanupDuringTaskFinished : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskFinished()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskFinished,
|
|
TaskExecute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
// UninitTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, UninitTaskFinished, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringFinish, EBTTestStopAction::Cleanup);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskFinished/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskFinished, "System.AI.Behavior Trees.Cleanup: during task finished")
|
|
|
|
struct FAITest_BTCleanupDuringServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringServiceTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceTick,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Servier
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitServiceTick
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceTick, EBTTestServiceStopTiming::DuringTick, EBTTestStopAction::Cleanup);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitServiceTick/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringServiceTick, "System.AI.Behavior Trees.Cleanup: during service tick")
|
|
|
|
struct FAITest_BTCleanupDuringServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringServiceBecomeRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceBecomeRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitService
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceBecomeRelevant, EBTTestServiceStopTiming::DuringBecomeRelevant, EBTTestStopAction::Cleanup);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
|
|
// Task2
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(UninitServiceBecomeRelevant/*7*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringServiceBecomeRelevant, "System.AI.Behavior Trees.Cleanup: during service become relevant")
|
|
|
|
struct FAITest_BTCleanupDuringServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringServiceCeaseRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitServiceCeaseRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
// SubService
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
// UninitService
|
|
FBTBuilder::WithServiceBTStopAction(Comp1Node, UninitServiceCeaseRelevant, EBTTestServiceStopTiming::DuringCeaseRelevant, EBTTestStopAction::Cleanup);
|
|
|
|
// Task
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
}
|
|
// Task2
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
ExpectedResult.Add(UninitServiceCeaseRelevant/*7*/);
|
|
ExpectedResult.Add(Task2Execute/*9*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringServiceCeaseRelevant, "System.AI.Behavior Trees.Cleanup: during service cease relevant")
|
|
|
|
struct FAITest_BTCleanupDuringTaskServiceTick : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskServiceTick()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceTick,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceTick, EBTTestServiceStopTiming::DuringTick, EBTTestStopAction::Cleanup);
|
|
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceTick/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskServiceTick, "System.AI.Behavior Trees.Cleanup: during task service tick")
|
|
|
|
struct FAITest_BTCleanupDuringTaskServiceBecomeRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskServiceBecomeRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceBecomeRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceBecomeRelevant, EBTTestServiceStopTiming::DuringBecomeRelevant, EBTTestStopAction::Cleanup);
|
|
|
|
FBTBuilder::AddTask(Comp1Node, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceBecomeRelevant/*7*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskServiceBecomeRelevant, "System.AI.Behavior Trees.Cleanup: during task service become relevant")
|
|
|
|
struct FAITest_BTCleanupDuringTaskServiceCeaseRelevant : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCleanupDuringTaskServiceCeaseRelevant()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
SubServiceActivate,
|
|
SubServiceDeactivate,
|
|
SubServiceTick,
|
|
UninitTaskServiceCeaseRelevant,
|
|
TaskExecute,
|
|
Task2Execute,
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, SubServiceActivate, SubServiceDeactivate, SubServiceTick, TEXT("Bool1"));
|
|
|
|
FBTBuilder::AddTask(Comp1Node, TaskExecute, EBTNodeResult::Succeeded);
|
|
FBTBuilder::WithDecoratorBlackboard(Comp1Node, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
FBTBuilder::WithTaskServiceBTStopAction(Comp1Node, UninitTaskServiceCeaseRelevant, EBTTestServiceStopTiming::DuringCeaseRelevant, EBTTestStopAction::Cleanup);
|
|
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(SubServiceActivate/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(TaskExecute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(SubServiceTick/*6*/);
|
|
ExpectedResult.Add(UninitTaskServiceCeaseRelevant/*7*/);
|
|
ExpectedResult.Add(SubServiceDeactivate/*5*/);
|
|
ExpectedResult.Add(Task2Execute/*9*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCleanupDuringTaskServiceCeaseRelevant, "System.AI.Behavior Trees.Cleanup: during task service cease relevant")
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Restart tests
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
struct FAITest_BTDefaultRestartDuringTaskExecute : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTDefaultRestartDuringTaskExecute()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
RestartTaskTaskExecute,
|
|
ServiceActivate2,
|
|
ServiceDeactivate2,
|
|
ServiceTick2,
|
|
Task2Execute
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, ServiceActivate2, ServiceDeactivate2, ServiceTick2, /*TickBoolKeyName*/NAME_None, /*bCallOnTickSearch*/false, /*BecomeRelevantBoolKeyName*/TEXT("Bool1"));
|
|
|
|
// RestartTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, RestartTaskTaskExecute, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringExecute, EBTTestStopAction::Restart_ForceReevaluateRootNode);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceActivate2/*5*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(ServiceTick2/*7*/);
|
|
ExpectedResult.Add(RestartTaskTaskExecute/*4*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(ServiceTick2/*7*/);
|
|
ExpectedResult.Add(ServiceDeactivate2/*6*/);
|
|
ExpectedResult.Add(Task2Execute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTDefaultRestartDuringTaskExecute, "System.AI.Behavior Trees.Restart: default during task execute")
|
|
|
|
struct FAITest_BTCompleteRestartDuringTaskExecute : public FAITest_SimpleBT
|
|
{
|
|
FAITest_BTCompleteRestartDuringTaskExecute()
|
|
{
|
|
enum
|
|
{
|
|
ServiceActivate = 1,
|
|
ServiceDeactivate,
|
|
ServiceTick,
|
|
RestartTaskTaskExecute,
|
|
ServiceActivate2,
|
|
ServiceDeactivate2,
|
|
ServiceTick2,
|
|
Task2Execute
|
|
};
|
|
|
|
UBTCompositeNode& RootNode = FBTBuilder::AddSelector(*BTAsset);
|
|
UBTCompositeNode& CompNode = FBTBuilder::AddSelector(RootNode);
|
|
{
|
|
// Service
|
|
FBTBuilder::WithServiceLog(CompNode, ServiceActivate, ServiceDeactivate, ServiceTick);
|
|
|
|
UBTCompositeNode& Comp1Node = FBTBuilder::AddSelector(CompNode);
|
|
FBTBuilder::WithDecoratorBlackboard(CompNode, EBasicKeyOperation::NotSet, EBTFlowAbortMode::Both, TEXT("Bool1"));
|
|
{
|
|
FBTBuilder::WithServiceLog(Comp1Node, ServiceActivate2, ServiceDeactivate2, ServiceTick2, /*TickBoolKeyName*/NAME_None, /*bCallOnTickSearch*/false, /*BecomeRelevantBoolKeyName*/TEXT("Bool1"));
|
|
|
|
// RestartTask
|
|
FBTBuilder::AddTaskBTStopAction(Comp1Node, RestartTaskTaskExecute, EBTNodeResult::Succeeded, EBTTestTaskStopTiming::DuringExecute, EBTTestStopAction::Restart_Complete);
|
|
}
|
|
FBTBuilder::AddTask(CompNode, Task2Execute, EBTNodeResult::Succeeded);
|
|
}
|
|
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceActivate2/*5*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(ServiceTick2/*7*/);
|
|
ExpectedResult.Add(RestartTaskTaskExecute/*4*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
ExpectedResult.Add(ServiceDeactivate2/*6*/);
|
|
ExpectedResult.Add(ServiceActivate/*1*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(Task2Execute/*8*/);
|
|
ExpectedResult.Add(ServiceTick/*3*/);
|
|
ExpectedResult.Add(ServiceDeactivate/*2*/);
|
|
}
|
|
};
|
|
IMPLEMENT_AI_LATENT_TEST(FAITest_BTCompleteRestartDuringTaskExecute, "System.AI.Behavior Trees.Restart: complete during task execute")
|
|
|
|
#undef LOCTEXT_NAMESPACE |