2318 lines
105 KiB
C++
2318 lines
105 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "StateTreeTest.h"
|
|
#include "StateTreeTestBase.h"
|
|
#include "StateTreeTestTypes.h"
|
|
|
|
#include "StateTreeCompilerLog.h"
|
|
#include "StateTreeEditorData.h"
|
|
#include "StateTreeCompiler.h"
|
|
#include "Conditions/StateTreeCommonConditions.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "AITestSuite_StateTreeTest"
|
|
|
|
UE_DISABLE_OPTIMIZATION_SHIP
|
|
|
|
namespace UE::StateTree::Tests
|
|
{
|
|
|
|
struct FStateTreeTest_TransitionPriority : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
/*
|
|
- Root
|
|
- State1 : Task1 -> Succeeded
|
|
- State1A : Task1A -> Next
|
|
- State1B : Task1B -> Next
|
|
- State1C : Task1C
|
|
|
|
Task1A completed first, transitioning to State1B.
|
|
Task1, Task1B, and Task1C complete at the same time, we should take the transition on the first completed state (State1).
|
|
*/
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& State1 = Root.AddChildState(FName(TEXT("State1")));
|
|
UStateTreeState& State1A = State1.AddChildState(FName(TEXT("State1A")));
|
|
UStateTreeState& State1B = State1.AddChildState(FName(TEXT("State1B")));
|
|
UStateTreeState& State1C = State1.AddChildState(FName(TEXT("State1C")));
|
|
|
|
auto& Task1 = State1.AddTask<FTestTask_Stand>(FName(TEXT("Task1")));
|
|
Task1.GetNode().TicksToCompletion = 2;
|
|
State1.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::Succeeded);
|
|
|
|
auto& Task1A = State1A.AddTask<FTestTask_Stand>(FName(TEXT("Task1A")));
|
|
Task1A.GetNode().TicksToCompletion = 1;
|
|
State1A.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::NextState);
|
|
|
|
auto& Task1B = State1B.AddTask<FTestTask_Stand>(FName(TEXT("Task1B")));
|
|
Task1B.GetNode().TicksToCompletion = 2;
|
|
State1B.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::NextState);
|
|
|
|
auto& Task1C = State1C.AddTask<FTestTask_Stand>(FName(TEXT("Task1C")));
|
|
Task1C.GetNode().TicksToCompletion = 2;
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
const TCHAR* TickStr(TEXT("Tick"));
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
const TCHAR* StateCompletedStr(TEXT("StateCompleted"));
|
|
|
|
// Start and enter state
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task1 should enter state"), Exec.Expect(Task1.GetName(), EnterStateStr));
|
|
AITEST_TRUE(TEXT("StateTree Task1A should enter state"), Exec.Expect(Task1A.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Transition from Task1A to Task1B
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task1A should complete"), Exec.Expect(Task1A.GetName(), StateCompletedStr));
|
|
AITEST_TRUE(TEXT("StateTree Task1B should enter state"), Exec.Expect(Task1B.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Task1 completes, and we should take State1 transition.
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE("StateTree Task1 should complete", Exec.Expect(Task1.GetName(), StateCompletedStr));
|
|
AITEST_EQUAL(TEXT("Tree execution should stop on success"), Status, EStateTreeRunStatus::Succeeded);
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionPriority, "System.StateTree.Transition.Priority");
|
|
|
|
struct FStateTreeTest_TransitionPriorityEnterState : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& State0 = Root.AddChildState(FName(TEXT("State0")));
|
|
UStateTreeState& State1 = Root.AddChildState(FName(TEXT("State1")));
|
|
UStateTreeState& State1A = State1.AddChildState(FName(TEXT("State1A")));
|
|
UStateTreeState& State2 = Root.AddChildState(FName(TEXT("State2")));
|
|
UStateTreeState& State3 = Root.AddChildState(FName(TEXT("State3")));
|
|
|
|
auto& Task0 = State0.AddTask<FTestTask_Stand>(FName(TEXT("Task0")));
|
|
State0.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &State1);
|
|
|
|
auto& Task1 = State1.AddTask<FTestTask_Stand>(FName(TEXT("Task1")));
|
|
Task1.GetNode().EnterStateResult = EStateTreeRunStatus::Failed;
|
|
State1.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &State2);
|
|
|
|
auto& Task1A = State1A.AddTask<FTestTask_Stand>(FName(TEXT("Task1A")));
|
|
State1A.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &State3);
|
|
|
|
auto& Task2 = State2.AddTask<FTestTask_Stand>(FName(TEXT("Task2")));
|
|
State2.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::Succeeded);
|
|
|
|
auto& Task3 = State3.AddTask<FTestTask_Stand>(FName(TEXT("Task3")));
|
|
State3.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::Succeeded);
|
|
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
const TCHAR* TickStr(TEXT("Tick"));
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
const TCHAR* StateCompletedStr(TEXT("StateCompleted"));
|
|
|
|
// Start and enter state
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state"), Exec.Expect(Task0.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Transition from State0 to State1, it should fail (Task1), and the transition on State1->State2 (and not State1A->State3)
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should complete"), Exec.Expect(Task0.GetName(), StateCompletedStr));
|
|
AITEST_TRUE(TEXT("StateTree Task2 should enter state"), Exec.Expect(Task2.GetName(), EnterStateStr));
|
|
AITEST_FALSE(TEXT("StateTree Task3 should not enter state"), Exec.Expect(Task3.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionPriorityEnterState, "System.StateTree.Transition.PriorityEnterState");
|
|
|
|
struct FStateTreeTest_TransitionNextSelectableState : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
// Root
|
|
// State0: OnCompleted->Nextselectable
|
|
// State1: EnterCondition fails
|
|
// State2: EnterCondition fails
|
|
// State3: EnterCondition successed. OnCompleted->Succeeded
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& State0 = Root.AddChildState(FName(TEXT("State0")));
|
|
UStateTreeState& State1 = Root.AddChildState(FName(TEXT("State1")));
|
|
UStateTreeState& State2 = Root.AddChildState(FName(TEXT("State2")));
|
|
UStateTreeState& State3 = Root.AddChildState(FName(TEXT("State3")));
|
|
|
|
auto& EvalA = EditorData.AddEvaluator<FTestEval_A>();
|
|
EvalA.GetInstanceData().bBoolA = true;
|
|
|
|
auto& Task0 = State0.AddTask<FTestTask_Stand>(FName(TEXT("Task0")));
|
|
State0.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::NextSelectableState);
|
|
|
|
// Add Task 1 with Condition that will always fail
|
|
auto& Task1 = State1.AddTask<FTestTask_Stand>(FName(TEXT("Task1")));
|
|
auto& BoolCond1 = State1.AddEnterCondition<FStateTreeCompareBoolCondition>();
|
|
|
|
EditorData.AddPropertyBinding(EvalA, TEXT("bBoolA"), BoolCond1, TEXT("bLeft"));
|
|
BoolCond1.GetInstanceData().bRight = !EvalA.GetInstanceData().bBoolA;
|
|
|
|
// Add Task 2 with Condition that will always fail
|
|
auto& Task2 = State2.AddTask<FTestTask_Stand>(FName(TEXT("Task2")));
|
|
auto& BoolCond2 = State2.AddEnterCondition<FStateTreeCompareBoolCondition>();
|
|
|
|
EditorData.AddPropertyBinding(EvalA, TEXT("bBoolA"), BoolCond2, TEXT("bLeft"));
|
|
BoolCond2.GetInstanceData().bRight = !EvalA.GetInstanceData().bBoolA;
|
|
|
|
// Add Task 3 with Condition that will always succeed
|
|
auto& Task3 = State3.AddTask<FTestTask_Stand>(FName(TEXT("Task3")));
|
|
auto& BoolCond3 = State3.AddEnterCondition<FStateTreeCompareBoolCondition>();
|
|
State3.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::Succeeded);
|
|
|
|
EditorData.AddPropertyBinding(EvalA, TEXT("bBoolA"), BoolCond3, TEXT("bLeft"));
|
|
BoolCond3.GetInstanceData().bRight = EvalA.GetInstanceData().bBoolA;
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* TickStr = TEXT("Tick");
|
|
const TCHAR* EnterStateStr = TEXT("EnterState");
|
|
const TCHAR* ExitStateStr = TEXT("ExitState");
|
|
const TCHAR* StateCompletedStr = TEXT("StateCompleted");
|
|
|
|
// Start and enter state
|
|
Exec.Start();
|
|
AITEST_TRUE(TEXT("Should be in active state"), Exec.ExpectInActiveStates("Root", "State0"));
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state"), Exec.Expect(Task0.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Transition from State0 and tries to select State1. It should fail (Task1 and Tasks2) and because transition is set to "Next Selectable", it should now select Task 3 and Enter State
|
|
Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("Should be in active state"), Exec.ExpectInActiveStates("Root", "State3"));
|
|
AITEST_TRUE(TEXT("StateTree Task0 should complete"), Exec.Expect(Task0.GetName(), StateCompletedStr));
|
|
AITEST_FALSE(TEXT("StateTree Task1 should not enter state"), Exec.Expect(Task1.GetName(), EnterStateStr));
|
|
AITEST_FALSE(TEXT("StateTree Task2 should not enter state"), Exec.Expect(Task2.GetName(), EnterStateStr));
|
|
AITEST_TRUE(TEXT("StateTree Task3 should enter state"), Exec.Expect(Task3.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Complete Task3
|
|
EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should succeed"), Status, EStateTreeRunStatus::Succeeded);
|
|
AITEST_TRUE(TEXT("Should be in active state"), Exec.GetActiveStateNames().Num() == 0);
|
|
AITEST_TRUE(TEXT("StateTree Task3 should complete"), Exec.Expect(Task3.GetName(), StateCompletedStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionNextSelectableState, "System.StateTree.Transition.NextSelectableState");
|
|
|
|
struct FStateTreeTest_TransitionNextWithParentData : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& State0 = Root.AddChildState(FName(TEXT("State0")));
|
|
UStateTreeState& State1 = Root.AddChildState(FName(TEXT("State1")));
|
|
UStateTreeState& State1A = State1.AddChildState(FName(TEXT("State1A")));
|
|
|
|
auto& RootTask = Root.AddTask<FTestTask_B>(FName(TEXT("RootTask")));
|
|
RootTask.GetInstanceData().bBoolB = true;
|
|
|
|
auto& Task0 = State0.AddTask<FTestTask_Stand>(FName(TEXT("Task0")));
|
|
State0.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::NextState);
|
|
|
|
auto& Task1A = State1A.AddTask<FTestTask_Stand>(FName(TEXT("Task1A")));
|
|
auto& BoolCond1 = State1A.AddEnterCondition<FStateTreeCompareBoolCondition>();
|
|
|
|
EditorData.AddPropertyBinding(RootTask, TEXT("bBoolB"), BoolCond1, TEXT("bLeft"));
|
|
BoolCond1.GetInstanceData().bRight = true;
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
const TCHAR* TickStr(TEXT("Tick"));
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
const TCHAR* StateCompletedStr(TEXT("StateCompleted"));
|
|
|
|
// Start and enter state
|
|
Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state"), Exec.Expect(Task0.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Transition from State0 and tries to select State1.
|
|
// This tests that data from current shared active states (Root) is available during state selection.
|
|
Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should complete"), Exec.Expect(Task0.GetName(), StateCompletedStr));
|
|
AITEST_TRUE(TEXT("StateTree Task1A should enter state"), Exec.Expect(Task1A.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionNextWithParentData, "System.StateTree.Transition.NextWithParentData");
|
|
|
|
struct FStateTreeTest_TransitionGlobalDataView : FStateTreeTestBase
|
|
{
|
|
// Tests that the global eval and task dataviews are kept up to date when transitioning from
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& StateA = Root.AddChildState(FName(TEXT("A")));
|
|
UStateTreeState& StateB = Root.AddChildState(FName(TEXT("B")));
|
|
|
|
auto& EvalA = EditorData.AddEvaluator<FTestEval_A>(FName(TEXT("Eval")));
|
|
EvalA.GetInstanceData().IntA = 42;
|
|
auto& GlobalTask = EditorData.AddGlobalTask<FTestTask_PrintValue>(FName(TEXT("Global")));
|
|
GlobalTask.GetInstanceData().Value = 123;
|
|
|
|
// State A
|
|
auto& Task0 = StateA.AddTask<FTestTask_Stand>(FName(TEXT("Task0")));
|
|
StateA.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &StateB);
|
|
|
|
// State B
|
|
auto& Task1 = StateB.AddTask<FTestTask_PrintValue>(FName(TEXT("Task1")));
|
|
EditorData.AddPropertyBinding(EvalA, TEXT("IntA"), Task1, TEXT("Value"));
|
|
auto& Task2 = StateB.AddTask<FTestTask_PrintValue>(FName(TEXT("Task2")));
|
|
EditorData.AddPropertyBinding(GlobalTask, TEXT("Value"), Task2, TEXT("Value"));
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* EnterState42Str(TEXT("EnterState42"));
|
|
const TCHAR* EnterState123Str(TEXT("EnterState123"));
|
|
|
|
// Start and enter state
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state"), Exec.Expect(Task0.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Transition from StateA to StateB, Task0 should enter state with evaluator value copied.
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state with value 42"), Exec.Expect(Task1.GetName(), EnterState42Str));
|
|
AITEST_TRUE(TEXT("StateTree Task1 should enter state with value 123"), Exec.Expect(Task2.GetName(), EnterState123Str));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionGlobalDataView, "System.StateTree.Transition.GlobalDataView");
|
|
|
|
struct FStateTreeTest_TransitionDelay : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
const FGameplayTag Tag = GetTestTag1();
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& StateA = Root.AddChildState(FName(TEXT("A")));
|
|
UStateTreeState& StateB = Root.AddChildState(FName(TEXT("B")));
|
|
|
|
// State A
|
|
auto& Task0 = StateA.AddTask<FTestTask_Stand>(FName(TEXT("Task0")));
|
|
Task0.GetNode().TicksToCompletion = 100;
|
|
|
|
FStateTreeTransition& Transition = StateA.AddTransition(EStateTreeTransitionTrigger::OnEvent, EStateTreeTransitionType::GotoState, &StateB);
|
|
Transition.bDelayTransition = true;
|
|
Transition.DelayDuration = 0.15f;
|
|
Transition.DelayRandomVariance = 0.0f;
|
|
Transition.RequiredEvent.Tag = Tag;
|
|
|
|
// State B
|
|
auto& Task1 = StateB.AddTask<FTestTask_Stand>(FName(TEXT("Task1")));
|
|
Task1.GetNode().TicksToCompletion = 100;
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* TickStr(TEXT("Tick"));
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
const TCHAR* StateCompletedStr(TEXT("StateCompleted"));
|
|
|
|
// Start and enter state
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state"), Exec.Expect(Task0.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// This should cause delayed transition.
|
|
Exec.SendEvent(Tag);
|
|
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should tick"), Exec.Expect(Task0.GetName(), TickStr));
|
|
Exec.LogClear();
|
|
|
|
// Should have execution frames
|
|
AITEST_TRUE(TEXT("Should have active frames"), InstanceData.GetExecutionState()->ActiveFrames.Num() > 0);
|
|
|
|
// Should have delayed transitions
|
|
const int32 NumDelayedTransitions0 = InstanceData.GetExecutionState()->DelayedTransitions.Num();
|
|
AITEST_EQUAL(TEXT("Should have a delayed transition"), NumDelayedTransitions0, 1);
|
|
|
|
// Tick and expect a delayed transition.
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should tick"), Exec.Expect(Task0.GetName(), TickStr));
|
|
Exec.LogClear();
|
|
|
|
const int32 NumDelayedTransitions1 = InstanceData.GetExecutionState()->DelayedTransitions.Num();
|
|
AITEST_EQUAL(TEXT("Should have a delayed transition"), NumDelayedTransitions1, 1);
|
|
|
|
// Should complete delayed transition.
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should exit state"), Exec.Expect(Task0.GetName(), ExitStateStr));
|
|
AITEST_TRUE(TEXT("StateTree Task1 should enter state"), Exec.Expect(Task1.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionDelay, "System.StateTree.Transition.Delay");
|
|
|
|
struct FStateTreeTest_TransitionDelayZero : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
const FGameplayTag Tag = GetTestTag1();
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& StateA = Root.AddChildState(FName(TEXT("A")));
|
|
UStateTreeState& StateB = Root.AddChildState(FName(TEXT("B")));
|
|
|
|
// State A
|
|
auto& Task0 = StateA.AddTask<FTestTask_Stand>(FName(TEXT("Task0")));
|
|
Task0.GetNode().TicksToCompletion = 100;
|
|
|
|
FStateTreeTransition& Transition = StateA.AddTransition(EStateTreeTransitionTrigger::OnEvent, EStateTreeTransitionType::GotoState, &StateB);
|
|
Transition.bDelayTransition = true;
|
|
Transition.DelayDuration = 0.0f;
|
|
Transition.DelayRandomVariance = 0.0f;
|
|
Transition.RequiredEvent.Tag = Tag;
|
|
|
|
// State B
|
|
auto& Task1 = StateB.AddTask<FTestTask_Stand>(FName(TEXT("Task1")));
|
|
Task1.GetNode().TicksToCompletion = 100;
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* TickStr(TEXT("Tick"));
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
const TCHAR* StateCompletedStr(TEXT("StateCompleted"));
|
|
|
|
// Start and enter state
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task0 should enter state"), Exec.Expect(Task0.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// This should cause delayed transition. Because the time is 0, it should happen immediately.
|
|
Exec.SendEvent(Tag);
|
|
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("StateTree Task0 should exit state"), Exec.Expect(Task0.GetName(), ExitStateStr));
|
|
AITEST_TRUE(TEXT("StateTree Task1 should enter state"), Exec.Expect(Task1.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionDelayZero, "System.StateTree.Transition.DelayZero");
|
|
|
|
struct FStateTreeTest_PassingTransitionEventToStateSelection : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
|
|
FPropertyBindingPath PathToPayloadMember;
|
|
{
|
|
const bool bParseResult = PathToPayloadMember.FromString(TEXT("Payload.A"));
|
|
|
|
AITEST_TRUE(TEXT("Parsing path should succeeed"), bParseResult);
|
|
|
|
FStateTreeEvent EventWithPayload;
|
|
EventWithPayload.Payload = FInstancedStruct::Make<FStateTreeTest_PropertyStructA>();
|
|
const bool bUpdateSegments = PathToPayloadMember.UpdateSegmentsFromValue(FStateTreeDataView(FStructView::Make(EventWithPayload)));
|
|
AITEST_TRUE(TEXT("Updating segments should succeeed"), bUpdateSegments);
|
|
}
|
|
|
|
// This state shouldn't be selected, because transition's condition and state's enter condition exlude each other.
|
|
UStateTreeState& StateA = Root.AddChildState(FName(TEXT("A")));
|
|
StateA.bHasRequiredEventToEnter = true;
|
|
StateA.RequiredEventToEnter.PayloadStruct = FStateTreeTest_PropertyStructA::StaticStruct();
|
|
auto& TaskA = StateA.AddTask<FTestTask_Stand>(FName(TEXT("TaskA")));
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& AIntCond = StateA.AddEnterCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
AIntCond.GetInstanceData().Right = 0;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(StateA.GetEventID(), PathToPayloadMember.GetSegments()),
|
|
FPropertyBindingPath(AIntCond.ID, TEXT("Left")));
|
|
|
|
// This state should be selected as the sent event fullfils both transition's condition and state's enter condition.
|
|
UStateTreeState& StateB = Root.AddChildState(FName(TEXT("B")));
|
|
StateB.bHasRequiredEventToEnter = true;
|
|
StateB.RequiredEventToEnter.PayloadStruct = FStateTreeTest_PropertyStructA::StaticStruct();
|
|
auto& TaskB = StateB.AddTask<FTestTask_PrintValue>(FName(TEXT("TaskB")));
|
|
// Test copying data from the state event. The condition properties are copied from temp instance data during selection, this gets copied from active instance data.
|
|
TaskB.GetInstanceData().Value = -1; // Initially -1, expected to be overridden by property binding below.
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(StateB.GetEventID(), PathToPayloadMember.GetSegments()),
|
|
FPropertyBindingPath(TaskB.ID, TEXT("Value")));
|
|
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& BIntCond = StateB.AddEnterCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
BIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(StateB.GetEventID(), PathToPayloadMember.GetSegments()),
|
|
FPropertyBindingPath(BIntCond.ID, TEXT("Left")));
|
|
|
|
// This state should be selected only initially when there's not event in the queue.
|
|
UStateTreeState& StateInitial = Root.AddChildState(FName(TEXT("Initial")));
|
|
auto& TaskInitial = StateInitial.AddTask<FTestTask_Stand>(FName(TEXT("TaskInitial")));
|
|
// Transition from Initial -> StateA
|
|
FStateTreeTransition& TransA = StateInitial.AddTransition(EStateTreeTransitionTrigger::OnEvent, FGameplayTag(), EStateTreeTransitionType::GotoState, &StateA);
|
|
TransA.RequiredEvent.PayloadStruct = FStateTreeTest_PropertyStructA::StaticStruct();
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransAIntCond = TransA.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransAIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(TransA.GetEventID(), PathToPayloadMember.GetSegments()),
|
|
FPropertyBindingPath(TransAIntCond.ID, TEXT("Left")));
|
|
// Transition from Initial -> StateB
|
|
FStateTreeTransition& TransB = StateInitial.AddTransition(EStateTreeTransitionTrigger::OnEvent, FGameplayTag(), EStateTreeTransitionType::GotoState, &StateB);
|
|
TransB.RequiredEvent.PayloadStruct = FStateTreeTest_PropertyStructA::StaticStruct();
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransBIntCond = TransB.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransBIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(TransB.GetEventID(), PathToPayloadMember.GetSegments()),
|
|
FPropertyBindingPath(TransBIntCond.ID, TEXT("Left")));
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree TaskInitial should enter state"), Exec.Expect(TaskInitial.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// The conditions test for payload Value=1, the first event should not trigger transition.
|
|
Exec.SendEvent(GetTestTag1(), FConstStructView::Make(FStateTreeTest_PropertyStructA{0}));
|
|
Exec.SendEvent(GetTestTag1(), FConstStructView::Make(FStateTreeTest_PropertyStructA{1}));
|
|
Status = Exec.Tick(0.1f);
|
|
|
|
AITEST_FALSE(TEXT("StateTree TaskA should not enter state"), Exec.Expect(TaskA.GetName(), EnterStateStr));
|
|
AITEST_TRUE(TEXT("StateTree TaskB should enter state"), Exec.Expect(TaskB.GetName(), TEXT("EnterState1"))); // TaskB decorates "EnterState" with value from the payload.
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_PassingTransitionEventToStateSelection, "System.StateTree.Transition.PassingTransitionEventToStateSelection");
|
|
|
|
struct FStateTreeTest_FollowTransitions : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
//Root
|
|
// Trans
|
|
// A
|
|
// B
|
|
// C
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
FInstancedPropertyBag& RootPropertyBag = GetRootPropertyBag(EditorData);
|
|
RootPropertyBag.AddProperty(FName(TEXT("Int")), EPropertyBagPropertyType::Int32);
|
|
RootPropertyBag.SetValueInt32(FName(TEXT("Int")), 1);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& StateTrans = Root.AddChildState(FName(TEXT("Trans")));
|
|
UStateTreeState& StateA = Root.AddChildState(FName(TEXT("A")));
|
|
UStateTreeState& StateB = Root.AddChildState(FName(TEXT("B")));
|
|
UStateTreeState& StateC = Root.AddChildState(FName(TEXT("C")));
|
|
|
|
// Root
|
|
|
|
// Trans
|
|
{
|
|
StateTrans.SelectionBehavior = EStateTreeStateSelectionBehavior::TryFollowTransitions;
|
|
|
|
{
|
|
// This transition should be skipped due to the condition
|
|
FStateTreeTransition& TransA = StateTrans.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &StateA);
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransIntCond = TransA.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransIntCond.GetInstanceData().Right = 0;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Int")),
|
|
FPropertyBindingPath(TransIntCond.ID, TEXT("Left")));
|
|
}
|
|
|
|
{
|
|
// This transition leads to selection, but will be overridden.
|
|
FStateTreeTransition& TransB = StateTrans.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &StateB);
|
|
TransB.Priority = EStateTreeTransitionPriority::Normal;
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransIntCond = TransB.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Int")),
|
|
FPropertyBindingPath(TransIntCond.ID, TEXT("Left")));
|
|
}
|
|
|
|
{
|
|
// This transition is selected, should override previous one due to priority.
|
|
FStateTreeTransition& TransC = StateTrans.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &StateC);
|
|
TransC.Priority = EStateTreeTransitionPriority::High;
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransIntCond = TransC.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Int")),
|
|
FPropertyBindingPath(TransIntCond.ID, TEXT("Left")));
|
|
}
|
|
}
|
|
|
|
auto& TaskA = StateA.AddTask<FTestTask_Stand>(FName(TEXT("TaskA")));
|
|
auto& TaskB = StateB.AddTask<FTestTask_Stand>(FName(TEXT("TaskB")));
|
|
auto& TaskC = StateC.AddTask<FTestTask_Stand>(FName(TEXT("TaskC")));
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* TickStr = TEXT("Tick");
|
|
const TCHAR* EnterStateStr = TEXT("EnterState");
|
|
const TCHAR* ExitStateStr = TEXT("ExitState");
|
|
|
|
Status = Exec.Start();
|
|
AITEST_FALSE(TEXT("StateTree TaskA should not enter state"), Exec.Expect(TaskA.GetName(), EnterStateStr));
|
|
AITEST_FALSE(TEXT("StateTree TaskB should not enter state"), Exec.Expect(TaskB.GetName(), EnterStateStr));
|
|
AITEST_TRUE(TEXT("StateTree TaskC should enter state"), Exec.Expect(TaskC.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_FollowTransitions, "System.StateTree.Transition.FollowTransitions");
|
|
|
|
struct FStateTreeTest_InfiniteLoop : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
FInstancedPropertyBag& RootPropertyBag = GetRootPropertyBag(EditorData);
|
|
RootPropertyBag.AddProperty(FName(TEXT("Int")), EPropertyBagPropertyType::Int32);
|
|
RootPropertyBag.SetValueInt32(FName(TEXT("Int")), 1);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& StateA = Root.AddChildState(FName(TEXT("A")));
|
|
UStateTreeState& StateB = StateA.AddChildState(FName(TEXT("B")));
|
|
|
|
// Root
|
|
|
|
// State A
|
|
{
|
|
StateA.SelectionBehavior = EStateTreeStateSelectionBehavior::TryFollowTransitions;
|
|
{
|
|
// A -> B
|
|
FStateTreeTransition& Trans = StateA.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &StateB);
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransIntCond = Trans.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Int")),
|
|
FPropertyBindingPath(TransIntCond.ID, TEXT("Left")));
|
|
}
|
|
}
|
|
|
|
// State B
|
|
{
|
|
StateB.SelectionBehavior = EStateTreeStateSelectionBehavior::TryFollowTransitions;
|
|
{
|
|
// B -> A
|
|
FStateTreeTransition& Trans = StateB.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &StateA);
|
|
TStateTreeEditorNode<FStateTreeCompareIntCondition>& TransIntCond = Trans.AddCondition<FStateTreeCompareIntCondition>(EGenericAICheck::Equal);
|
|
TransIntCond.GetInstanceData().Right = 1;
|
|
EditorData.AddPropertyBinding(
|
|
FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Int")),
|
|
FPropertyBindingPath(TransIntCond.ID, TEXT("Left")));
|
|
}
|
|
}
|
|
|
|
auto& TaskA = StateA.AddTask<FTestTask_Stand>(FName(TEXT("TaskA")));
|
|
auto& TaskB = StateB.AddTask<FTestTask_Stand>(FName(TEXT("TaskB")));
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
const TCHAR* TickStr = TEXT("Tick");
|
|
const TCHAR* EnterStateStr = TEXT("EnterState");
|
|
const TCHAR* ExitStateStr = TEXT("ExitState");
|
|
|
|
GetTestRunner().AddExpectedMessage(TEXT("Loop detected when trying to select state"), ELogVerbosity::Warning, EAutomationExpectedErrorFlags::Contains, 1);
|
|
GetTestRunner().AddExpectedError(TEXT("Failed to select initial state"), EAutomationExpectedErrorFlags::Contains, 1);
|
|
|
|
Status = Exec.Start();
|
|
AITEST_EQUAL(TEXT("Start should fail"), Status, EStateTreeRunStatus::Failed);
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_AI_INSTANT_TEST(FStateTreeTest_InfiniteLoop, "System.StateTree.Transition.InfiniteLoop");
|
|
|
|
struct FStateTreeTest_RegularTransitions : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
//Tree 1
|
|
// Global task and parameter
|
|
// RootA
|
|
// StateB -> Next
|
|
// StateC -> Next
|
|
// StateD -> Next
|
|
// StateE -> Next
|
|
// StateF -> Next
|
|
// StateG -> Succeeded
|
|
|
|
FStateTreeCompilerLog Log;
|
|
|
|
// Main asset
|
|
UStateTree& StateTree = NewStateTree();
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
FGuid RootParameter_ValueID;
|
|
{
|
|
// Parameters
|
|
FInstancedPropertyBag& RootPropertyBag = GetRootPropertyBag(EditorData);
|
|
RootPropertyBag.AddProperty("Value", EPropertyBagPropertyType::Int32);
|
|
RootPropertyBag.SetValueInt32("Value", -111);
|
|
RootParameter_ValueID = RootPropertyBag.FindPropertyDescByName("Value")->ID;
|
|
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& GlobalTask = EditorData.AddGlobalTask<FTestTask_PrintValue>("GlobalTask");
|
|
GlobalTask.GetInstanceData().Value = -1;
|
|
EditorData.AddPropertyBinding(FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Value")), FPropertyBindingPath(GlobalTask.ID, TEXT("Value")));
|
|
}
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree("RootA");
|
|
{
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& Task = Root.AddTask<FTestTask_PrintValue>("TaskA");
|
|
Task.GetInstanceData().Value = -1;
|
|
EditorData.AddPropertyBinding(FPropertyBindingPath(EditorData.GetRootParametersGuid(), TEXT("Value")), FPropertyBindingPath(Task.ID, TEXT("Value")));
|
|
}
|
|
{
|
|
UStateTreeState& StateB = Root.AddChildState("StateB", EStateTreeStateType::State);
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& Task = StateB.AddTask<FTestTask_PrintValue>("TaskB");
|
|
Task.GetInstanceData().Value = 1;
|
|
FStateTreeTransition& Transition = StateB.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::NextState);
|
|
Transition.bDelayTransition = true;
|
|
Transition.DelayDuration = 1.0;
|
|
}
|
|
{
|
|
UStateTreeState& StateB = Root.AddChildState("StateC", EStateTreeStateType::State);
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& Task = StateB.AddTask<FTestTask_PrintValue>("TaskC");
|
|
Task.GetInstanceData().Value = 2;
|
|
FStateTreeTransition& Transition = StateB.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::NextState);
|
|
Transition.bDelayTransition = true;
|
|
Transition.DelayDuration = 1.0;
|
|
}
|
|
{
|
|
UStateTreeState& StateD = Root.AddChildState("StateD", EStateTreeStateType::State);
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& Task = StateD.AddTask<FTestTask_PrintValue>("TaskD");
|
|
Task.GetInstanceData().Value = 3;
|
|
FStateTreeTransition& Transition = StateD.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &Root);
|
|
Transition.bDelayTransition = true;
|
|
Transition.DelayDuration = 1.0;
|
|
}
|
|
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE(TEXT("StateTree should get compiled"), bResult);
|
|
}
|
|
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
|
|
{
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE(TEXT("StateTree should init"), bInitSucceeded);
|
|
|
|
FInstancedPropertyBag Parameters;
|
|
Parameters.MigrateToNewBagInstance(StateTree.GetDefaultParameters());
|
|
Parameters.SetValueInt32("Value", 111);
|
|
|
|
Status = Exec.Start(&Parameters);
|
|
AITEST_EQUAL(TEXT("Start should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should enter Global tasks"), Exec.Expect("GlobalTask", TEXT("EnterState111")));
|
|
AITEST_TRUE(TEXT("Start should enter StateA"), Exec.Expect("TaskA", TEXT("EnterState111")));
|
|
AITEST_TRUE(TEXT("Start should enter StateB"), Exec.Expect("TaskB", TEXT("EnterState1")));
|
|
Exec.LogClear();
|
|
|
|
Status = Exec.Tick(1.5f); // over tick, should trigger
|
|
AITEST_EQUAL(TEXT("1st Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("1st Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("1st Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("1st Tick should tick StateB"), Exec.Expect("TaskB", TEXT("Tick1")));
|
|
Exec.LogClear();
|
|
|
|
// B go to C
|
|
Status = Exec.Tick(1.0f);
|
|
AITEST_EQUAL(TEXT("2nd Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("2nd Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("2nd Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("2nd Tick should tick the StateB"), Exec.Expect("TaskB", TEXT("Tick1")));
|
|
AITEST_TRUE(TEXT("2nd Tick should exit the StateB"), Exec.Expect("TaskB", TEXT("ExitState1")));
|
|
AITEST_TRUE(TEXT("2nd Tick should enter the StateC"), Exec.Expect("TaskC", TEXT("EnterState2")));
|
|
AITEST_FALSE(TEXT("2nd Tick should not exit the StateA"), Exec.Expect("TaskA", TEXT("ExitState111")));
|
|
AITEST_FALSE(TEXT("2nd Tick should not exit the Global tasks"), Exec.Expect("GlobalTask", TEXT("ExitState111")));
|
|
Exec.LogClear();
|
|
|
|
Status = Exec.Tick(1.0f);
|
|
AITEST_EQUAL(TEXT("3rd Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("3rd Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("3rd Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("3rd Tick should tick StateC"), Exec.Expect("TaskC", TEXT("Tick2")));
|
|
AITEST_FALSE(TEXT("3th Tick should not exit StateC"), Exec.Expect("TaskD", TEXT("ExitState2")));
|
|
Exec.LogClear();
|
|
|
|
// C go to D
|
|
Status = Exec.Tick(1.0f);
|
|
AITEST_EQUAL(TEXT("4th Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("4th Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("4th Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("4th Tick should tick the StateC"), Exec.Expect("TaskC", TEXT("Tick2")));
|
|
AITEST_TRUE(TEXT("4th Tick should exit the StateC"), Exec.Expect("TaskC", TEXT("ExitState2")));
|
|
AITEST_TRUE(TEXT("4th Tick should enter the StateD"), Exec.Expect("TaskD", TEXT("EnterState3")));
|
|
AITEST_FALSE(TEXT("4th Tick should not exit the StateA"), Exec.Expect("TaskA", TEXT("ExitState111")));
|
|
AITEST_FALSE(TEXT("4th Tick should not exit the Global tasks"), Exec.Expect("GlobalTask", TEXT("ExitState111")));
|
|
Exec.LogClear();
|
|
|
|
Status = Exec.Tick(0.001f);
|
|
AITEST_EQUAL(TEXT("5th Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("5th Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("5th Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("5th Tick should tick StateD"), Exec.Expect("TaskD", TEXT("Tick3")));
|
|
AITEST_FALSE(TEXT("5th Tick should not exit StateD"), Exec.Expect("TaskD", TEXT("ExitState3")));
|
|
Exec.LogClear();
|
|
|
|
// D go to root
|
|
Status = Exec.Tick(1.0f);
|
|
AITEST_EQUAL(TEXT("6th Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("6th Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("6th Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("6th Tick should tick StateD"), Exec.Expect("TaskD", TEXT("Tick3")));
|
|
AITEST_TRUE(TEXT("6th Tick should exit the StateD"), Exec.Expect("TaskD", TEXT("ExitState3")));
|
|
AITEST_FALSE(TEXT("6th Tick should not exit the Global tasks"), Exec.Expect("GlobalTask", TEXT("ExitState111")));
|
|
AITEST_FALSE(TEXT("6th Tick should not enter the Global tasks"), Exec.Expect("GlobalTask", TEXT("EnterState111")));
|
|
AITEST_TRUE(TEXT("6th Tick should exit the StateA"), Exec.Expect("TaskA", TEXT("ExitState=Sustained")));
|
|
AITEST_TRUE(TEXT("6th Tick should enter the StateA"), Exec.Expect("TaskA", TEXT("EnterState=Sustained")));
|
|
AITEST_TRUE(TEXT("6th Tick should enter the StateB"), Exec.Expect("TaskB", TEXT("EnterState1")));
|
|
AITEST_TRUE(TEXT("6th Tick should enter the StateB"), Exec.Expect("TaskB", TEXT("EnterState=Changed")));
|
|
Exec.LogClear();
|
|
|
|
Status = Exec.Tick(1.0f);
|
|
AITEST_EQUAL(TEXT("7th Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("7th Tick should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("7th Tick should tick StateA"), Exec.Expect("TaskA", TEXT("Tick111")));
|
|
AITEST_TRUE(TEXT("7th Tick should tick StateB"), Exec.Expect("TaskB", TEXT("Tick1")));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
AITEST_TRUE(TEXT("Stop Tick should exit the StateB"), Exec.Expect("TaskB", TEXT("ExitState1")));
|
|
AITEST_TRUE(TEXT("Stop Tick should exit the StateA"), Exec.Expect("TaskA", TEXT("ExitState111")));
|
|
AITEST_TRUE(TEXT("Stop should tick Global tasks"), Exec.Expect("GlobalTask", TEXT("ExitState111")));
|
|
Exec.LogClear();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_RegularTransitions, "System.StateTree.Transition.RegularTransitions");
|
|
|
|
|
|
struct FStateTreeTest_RequestTransition : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
//Tree 1
|
|
//RootA
|
|
// StateB
|
|
// StateC
|
|
// StateD
|
|
// StateE
|
|
// StateF
|
|
// StateI
|
|
// StateJ
|
|
// StateX
|
|
// StateY
|
|
//RootO
|
|
// StateP
|
|
|
|
FStateTreeCompilerLog Log;
|
|
|
|
enum class ECustomFunctionToRun
|
|
{
|
|
None,
|
|
TransitionD_To_E,
|
|
TransitionB_To_I,
|
|
TransitionB_To_C,
|
|
TransitionC_To_B,
|
|
TransitionB_To_X,
|
|
TransitionB_To_B,
|
|
TransitionB_To_P,
|
|
} TransitionToExecute = ECustomFunctionToRun::None;
|
|
struct FStateHandle
|
|
{
|
|
FStateTreeStateHandle B;
|
|
FStateTreeStateHandle C;
|
|
FStateTreeStateHandle E;
|
|
FStateTreeStateHandle I;
|
|
FStateTreeStateHandle X;
|
|
FStateTreeStateHandle P;
|
|
FGuid B_ID;
|
|
FGuid C_ID;
|
|
FGuid E_ID;
|
|
FGuid I_ID;
|
|
FGuid X_ID;
|
|
FGuid P_ID;
|
|
bool bFinishTasksB = false;
|
|
bool bFinishTasksC = false;
|
|
bool bFinishTasksD = false;
|
|
} AllStateHandle;
|
|
|
|
// Main asset
|
|
UStateTree& StateTree = NewStateTree();
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
UStateTreeState& StateA = EditorData.AddSubTree("StateA");
|
|
StateA.AddTask<FTestTask_PrintValue>("StateATask");
|
|
|
|
UStateTreeState& StateB = StateA.AddChildState("StateB", EStateTreeStateType::State);
|
|
FTestTask_PrintValue& TaskB = StateB.AddTask<FTestTask_PrintValue>("StateBTask").GetNode();
|
|
AllStateHandle.B_ID = StateB.ID;
|
|
|
|
UStateTreeState& StateC = StateB.AddChildState("StateC", EStateTreeStateType::State);
|
|
FTestTask_PrintValue& TaskC = StateC.AddTask<FTestTask_PrintValue>("StateCTask").GetNode();
|
|
AllStateHandle.C_ID = StateC.ID;
|
|
|
|
UStateTreeState& StateD = StateC.AddChildState("StateD", EStateTreeStateType::State);
|
|
FTestTask_PrintValue& TaskD = StateD.AddTask<FTestTask_PrintValue>("StateDTask").GetNode();
|
|
StateD.SelectionBehavior = EStateTreeStateSelectionBehavior::TryEnterState;
|
|
|
|
UStateTreeState& StateE = StateD.AddChildState("StateE", EStateTreeStateType::State);
|
|
StateE.AddTask<FTestTask_PrintValue>("StateETask");
|
|
AllStateHandle.E_ID = StateE.ID;
|
|
|
|
UStateTreeState& StateF = StateE.AddChildState("StateF", EStateTreeStateType::State);
|
|
StateF.AddTask<FTestTask_PrintValue>("StateFTask");
|
|
|
|
UStateTreeState& StateI = StateB.AddChildState("StateI", EStateTreeStateType::State);
|
|
StateI.AddTask<FTestTask_PrintValue>("StateITask");
|
|
AllStateHandle.I_ID = StateI.ID;
|
|
|
|
UStateTreeState& StateJ = StateI.AddChildState("StateJ", EStateTreeStateType::State);
|
|
StateJ.AddTask<FTestTask_PrintValue>("StateJTask");
|
|
|
|
UStateTreeState& StateX = StateA.AddChildState("StateX", EStateTreeStateType::State);
|
|
StateX.AddTask<FTestTask_PrintValue>("StateXTask");
|
|
AllStateHandle.X_ID = StateX.ID;
|
|
|
|
UStateTreeState& StateY = StateX.AddChildState("StateY", EStateTreeStateType::State);
|
|
StateY.AddTask<FTestTask_PrintValue>("StateYTask");
|
|
|
|
UStateTreeState& StateO = EditorData.AddSubTree("StateO");
|
|
StateO.AddTask<FTestTask_PrintValue>("StateOTask");
|
|
|
|
UStateTreeState& StateP = StateO.AddChildState("StateP", EStateTreeStateType::State);
|
|
StateP.AddTask<FTestTask_PrintValue>("StatePTask");
|
|
AllStateHandle.P_ID = StateP.ID;
|
|
|
|
TaskB.CustomTickFunc = [&TransitionToExecute, &AllStateHandle]
|
|
(FStateTreeExecutionContext& Context, const FTestTask_PrintValue* Task)
|
|
{
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionB_To_I)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.I);
|
|
}
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionB_To_C)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.C);
|
|
}
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionB_To_X)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.X);
|
|
}
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionB_To_B)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.B);
|
|
}
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionB_To_P)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.P);
|
|
}
|
|
if (AllStateHandle.bFinishTasksB)
|
|
{
|
|
Context.FinishTask(*Task, EStateTreeFinishTaskType::Succeeded);
|
|
}
|
|
};
|
|
|
|
TaskC.CustomTickFunc = [&TransitionToExecute, &AllStateHandle]
|
|
(FStateTreeExecutionContext& Context, const FTestTask_PrintValue* Task)
|
|
{
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionC_To_B)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.B);
|
|
}
|
|
if (AllStateHandle.bFinishTasksC)
|
|
{
|
|
Context.FinishTask(*Task, EStateTreeFinishTaskType::Succeeded);
|
|
}
|
|
};
|
|
|
|
TaskD.CustomTickFunc = [&TransitionToExecute, &AllStateHandle]
|
|
(FStateTreeExecutionContext& Context, const FTestTask_PrintValue* Task)
|
|
{
|
|
if (TransitionToExecute == ECustomFunctionToRun::TransitionD_To_E)
|
|
{
|
|
Context.RequestTransition(AllStateHandle.E);
|
|
}
|
|
|
|
if (AllStateHandle.bFinishTasksD)
|
|
{
|
|
Context.FinishTask(*Task, EStateTreeFinishTaskType::Succeeded);
|
|
}
|
|
};
|
|
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
|
|
AllStateHandle.B = StateTree.GetStateHandleFromId(AllStateHandle.B_ID);
|
|
AllStateHandle.C = StateTree.GetStateHandleFromId(AllStateHandle.C_ID);
|
|
AllStateHandle.E = StateTree.GetStateHandleFromId(AllStateHandle.E_ID);
|
|
AllStateHandle.I = StateTree.GetStateHandleFromId(AllStateHandle.I_ID);
|
|
AllStateHandle.X = StateTree.GetStateHandleFromId(AllStateHandle.X_ID);
|
|
AllStateHandle.P = StateTree.GetStateHandleFromId(AllStateHandle.P_ID);
|
|
}
|
|
|
|
FStateTreeInstanceData InstanceData;
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
}
|
|
|
|
constexpr int32 MaxRules = 4;
|
|
auto MakeStateSelectionRule = [](int32 Index)
|
|
{
|
|
EStateTreeStateSelectionRules Rule = EStateTreeStateSelectionRules::None;
|
|
if ((Index % 2) == 1)
|
|
{
|
|
Rule |= EStateTreeStateSelectionRules::CompletedTransitionStatesCreateNewStates;
|
|
Rule |= EStateTreeStateSelectionRules::CompletedStateBeforeTransitionSourceFailsTransition;
|
|
}
|
|
if (Index >= 2)
|
|
{
|
|
Rule |= EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates;
|
|
}
|
|
return Rule;
|
|
};
|
|
|
|
auto ResetInstanceData = [this, &StateTree, &InstanceData]()
|
|
{
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
EStateTreeRunStatus Status = Exec.Stop();
|
|
AITEST_EQUAL(TEXT("Should stop"), Status, EStateTreeRunStatus::Stopped);
|
|
}
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_EQUAL(TEXT("State should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
}
|
|
return true;
|
|
};
|
|
|
|
const TCHAR* EnterStateChangedStr = TEXT("EnterState=Changed");
|
|
const TCHAR* EnterStateSustainedStr = TEXT("EnterState=Sustained");
|
|
const TCHAR* ExitStateChangedStr = TEXT("ExitState=Changed");;
|
|
const TCHAR* ExitStateSustainedStr = TEXT("ExitState=Sustained");
|
|
|
|
for (int32 Index = 0; Index < MaxRules; ++Index)
|
|
{
|
|
const EStateTreeStateSelectionRules StateSelectionRules = MakeStateSelectionRule(Index);
|
|
InstanceData = FStateTreeInstanceData();
|
|
if (StateTree.GetStateSelectionRules() != StateSelectionRules)
|
|
{
|
|
StateTree.ResetCompiled();
|
|
UStateTreeEditorData* EditorData = CastChecked<UStateTreeEditorData>(StateTree.EditorData);
|
|
UStateTreeTestSchema* Schema = CastChecked<UStateTreeTestSchema>(EditorData->Schema);
|
|
Schema->SetStateSelectionRules(StateSelectionRules);
|
|
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
|
|
// Normal Start and tick. Make sure we are in ABCD before testing the transitions
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_EQUAL("Start should complete with Running", Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE("Start should enter Global tasks", Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Start StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Start StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Start StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Start StateD"), LogOrder);
|
|
AITEST_FALSE(TEXT("Tick StateA"), Exec.Expect("StateATask", TEXT("Tick0")));
|
|
AITEST_FALSE(TEXT("Tick StateB"), Exec.Expect("StateBTask", TEXT("Tick0")));
|
|
AITEST_FALSE(TEXT("Tick StateC"), Exec.Expect("StateCTask", TEXT("Tick0")));
|
|
AITEST_FALSE(TEXT("Tick StateD"), Exec.Expect("StateDTask", TEXT("Tick0")));
|
|
AITEST_FALSE(TEXT("Start StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Start StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Start StateC"), Exec.Expect("StateCTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Start StateD"), Exec.Expect("StateDTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
}
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL("1st Tick should complete with Running", Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE("1st Tick no transition", Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateC"), Exec.Expect("StateCTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateD"), Exec.Expect("StateDTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateC"), Exec.Expect("StateCTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateD"), Exec.Expect("StateDTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
}
|
|
// Select new child
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionD_To_E;
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("2nd Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("2nd tick should be in new state"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD", "StateE", "StateF"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateETask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateE"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateFTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateF"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateC"), Exec.Expect("StateCTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateD"), Exec.Expect("StateDTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateC"), Exec.Expect("StateCTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateD"), Exec.Expect("StateDTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
|
|
// Select a new child but with a completed D
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionD_To_E;
|
|
AllStateHandle.bFinishTasksD = true;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool bUseCompletedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::CompletedTransitionStatesCreateNewStates);
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD", "StateE", "StateF"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
if (bUseCompletedRule)
|
|
{
|
|
LogOrder = LogOrder.Then("StateDTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
}
|
|
LogOrder = LogOrder.Then("StateETask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateE"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateFTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateF"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateC"), Exec.Expect("StateCTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateC"), Exec.Expect("StateCTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
AllStateHandle.bFinishTasksD = false;
|
|
}
|
|
// Select a new child but B is completed (before the source/target)
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionD_To_E;
|
|
AllStateHandle.bFinishTasksB = true;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool bUseCompletedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::CompletedStateBeforeTransitionSourceFailsTransition);
|
|
const bool bUseReselectedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
if (bUseCompletedRule)
|
|
{
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
}
|
|
else
|
|
{
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD", "StateE", "StateF"));
|
|
}
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
if (bUseCompletedRule)
|
|
{
|
|
const TCHAR* SchemaEnterStateStr = bUseReselectedRule ? EnterStateChangedStr : EnterStateSustainedStr;
|
|
const TCHAR* SchemaExitStateStr = bUseReselectedRule ? ExitStateChangedStr : ExitStateSustainedStr;
|
|
|
|
LogOrder = LogOrder.Then("StateDTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateATask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateATask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
|
|
// Only one transition
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("EnterState0"));
|
|
AITEST_FALSE(TEXT("Enter StateD"), LogOrder);
|
|
|
|
AITEST_FALSE(TEXT("Enter StateE"), Exec.Expect("StateETask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateF"), Exec.Expect("StateFTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateE"), Exec.Expect("StateETask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateF"), Exec.Expect("StateFTask", TEXT("ExitState0")));
|
|
}
|
|
else
|
|
{
|
|
LogOrder = LogOrder.Then("StateETask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateE"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateFTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateF"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateC"), Exec.Expect("StateCTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateC"), Exec.Expect("StateCTask", TEXT("ExitState0")));
|
|
}
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
AllStateHandle.bFinishTasksB = false;
|
|
}
|
|
// Select a sibling
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionB_To_I;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateI", "StateJ"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateITask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateI"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateJTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateJ"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
// No state completed. Reselect child.
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionB_To_C;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool bUseReselectedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
const TCHAR* SchemaEnterStateStr = bUseReselectedRule ? EnterStateChangedStr : EnterStateSustainedStr;
|
|
const TCHAR* SchemaExitStateStr = bUseReselectedRule ? ExitStateChangedStr : ExitStateSustainedStr;
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
// State completed. Reselect child.
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionB_To_C;
|
|
AllStateHandle.bFinishTasksC = true;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool bUseCompletedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::CompletedTransitionStatesCreateNewStates);
|
|
const bool bUseReselectedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
const TCHAR* SchemaEnterStateStr = bUseCompletedRule || bUseReselectedRule ? EnterStateChangedStr : EnterStateSustainedStr;
|
|
const TCHAR* SchemaExitStateStr = bUseCompletedRule || bUseReselectedRule ? ExitStateChangedStr : ExitStateSustainedStr;
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Enter StateB"), Exec.Expect("StateBTask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
AITEST_FALSE(TEXT("Exit StateB"), Exec.Expect("StateBTask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
AllStateHandle.bFinishTasksC = false;
|
|
}
|
|
// No state completed. Reselect parent.
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionC_To_B;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool bUseReselectedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
const TCHAR* SchemaEnterStateStr = bUseReselectedRule ? EnterStateChangedStr : EnterStateSustainedStr;
|
|
const TCHAR* SchemaExitStateStr = bUseReselectedRule ? ExitStateChangedStr : ExitStateSustainedStr;
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
// State completed. Reselect parent.
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionC_To_B;
|
|
AllStateHandle.bFinishTasksC = true;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const bool bUseCompletedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::CompletedTransitionStatesCreateNewStates);
|
|
const bool bUseReselectedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
const TCHAR* SchemaEnterStateStr = bUseCompletedRule || bUseReselectedRule ? EnterStateChangedStr : EnterStateSustainedStr;
|
|
const TCHAR* SchemaExitStateStr = bUseCompletedRule || bUseReselectedRule ? ExitStateChangedStr : ExitStateSustainedStr;
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaExitStateStr);
|
|
if (bUseReselectedRule)
|
|
{
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", EnterStateChangedStr);
|
|
}
|
|
else
|
|
{
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", ExitStateSustainedStr);
|
|
AITEST_TRUE(TEXT("Exit StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", EnterStateSustainedStr);
|
|
}
|
|
AITEST_TRUE(TEXT("Enter StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
|
|
Exec.LogClear();
|
|
AllStateHandle.bFinishTasksC = false;
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
// linked state
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionB_To_X;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateX", "StateY"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateXTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateX"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateYTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateY"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
// Reselection same state
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionB_To_B;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
const bool bUseReselectedRule = EnumHasAllFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
const TCHAR* SchemaEnterStateStr = bUseReselectedRule ? EnterStateChangedStr : EnterStateSustainedStr;
|
|
const TCHAR* SchemaExitStateStr = bUseReselectedRule ? ExitStateChangedStr : ExitStateSustainedStr;
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateA", "StateB", "StateC", "StateD"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", SchemaExitStateStr);
|
|
AITEST_TRUE(TEXT("Exit StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", SchemaEnterStateStr);
|
|
AITEST_TRUE(TEXT("Enter StateD"), LogOrder);
|
|
AITEST_FALSE(TEXT("Enter StateA"), Exec.Expect("StateATask", TEXT("EnterState0")));
|
|
AITEST_FALSE(TEXT("Exit StateA"), Exec.Expect("StateATask", TEXT("ExitState0")));
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
// Select another root.
|
|
{
|
|
TransitionToExecute = ECustomFunctionToRun::TransitionB_To_P;
|
|
if (!ResetInstanceData())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const EStateTreeRunStatus Status = Exec.Tick(0.1f);
|
|
AITEST_EQUAL(TEXT("Tick should complete with Running"), Status, EStateTreeRunStatus::Running);
|
|
AITEST_TRUE(TEXT("Start should"), Exec.ExpectInActiveStates("StateO", "StateP"));
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("StateATask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", TEXT("Tick0"));
|
|
AITEST_TRUE(TEXT("Tick StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateDTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateD"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateCTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateC"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateBTask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateB"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateATask", ExitStateChangedStr);
|
|
AITEST_TRUE(TEXT("Exit StateA"), LogOrder);
|
|
LogOrder = LogOrder.Then("StateOTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateO"), LogOrder);
|
|
LogOrder = LogOrder.Then("StatePTask", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Enter StateP"), LogOrder);
|
|
Exec.LogClear();
|
|
TransitionToExecute = ECustomFunctionToRun::None;
|
|
}
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
EStateTreeRunStatus Status = Exec.Stop();
|
|
AITEST_EQUAL(TEXT("Should stop"), Status, EStateTreeRunStatus::Stopped);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_AI_INSTANT_TEST(FStateTreeTest_RequestTransition, "System.StateTree.Transition.RequestTransition");
|
|
|
|
struct FStateTreeTest_TransitionToNone : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
const FGameplayTag Tag = GetTestTag1();
|
|
|
|
UStateTree& StateTree = NewStateTree();
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& State1 = Root.AddChildState(FName(TEXT("State1")));
|
|
UStateTreeState& State2 = Root.AddChildState(FName(TEXT("State2")));
|
|
|
|
FStateTreeTransition& TransitionRoot = Root.AddTransition(EStateTreeTransitionTrigger::OnEvent, EStateTreeTransitionType::GotoState);
|
|
TransitionRoot.State = State1.GetLinkToState();
|
|
TransitionRoot.RequiredEvent.Tag = Tag;
|
|
|
|
TStateTreeEditorNode<FTestTask_StandNoTick>& Task1 = State1.AddTask<FTestTask_StandNoTick>(FName(TEXT("Task1")));
|
|
FStateTreeTransition& TransitionState1 = State1.AddTransition(EStateTreeTransitionTrigger::OnEvent, EStateTreeTransitionType::None);
|
|
TransitionState1.RequiredEvent.Tag = Tag;
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
|
|
EStateTreeRunStatus Status = EStateTreeRunStatus::Unset;
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
|
|
// Start and enter state
|
|
Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("StateTree Task1 should enter state"), Exec.Expect(Task1.GetName(), EnterStateStr));
|
|
Exec.LogClear();
|
|
|
|
// Send event with Tag
|
|
Exec.SendEvent(Tag);
|
|
|
|
// Transition from Root to State2 should not be triggered
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State1"));
|
|
AITEST_FALSE(TEXT("StateTree Task1 should not exit state"), Exec.Expect(Task1.GetName(), ExitStateStr));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionToNone, "System.StateTree.Transition.ToNone");
|
|
|
|
struct FStateTreeTest_TransitionTwoEvents : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
UStateTree& StateTree = NewStateTree();
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree.EditorData);
|
|
|
|
UStateTreeState& Root = EditorData.AddSubTree(FName(TEXT("Root")));
|
|
UStateTreeState& State1 = Root.AddChildState(FName(TEXT("State1")));
|
|
UStateTreeState& State2 = Root.AddChildState(FName(TEXT("State2")));
|
|
UStateTreeState& State3 = State2.AddChildState(FName(TEXT("State3")));
|
|
UStateTreeState& State4 = State2.AddChildState(FName(TEXT("State4")));
|
|
|
|
State2.bHasRequiredEventToEnter = true;
|
|
State2.RequiredEventToEnter.Tag = GetTestTag1();
|
|
|
|
State3.bHasRequiredEventToEnter = true;
|
|
State3.RequiredEventToEnter.Tag = GetTestTag2();
|
|
|
|
FStateTreeTransition& TransitionA = State1.AddTransition(EStateTreeTransitionTrigger::OnEvent, EStateTreeTransitionType::GotoState);
|
|
TransitionA.State = State2.GetLinkToState();
|
|
TransitionA.RequiredEvent.Tag = GetTestTag1();
|
|
|
|
TStateTreeEditorNode<FTestTask_StandNoTick>& State3Task1 = State3.AddTask<FTestTask_StandNoTick>(FName(TEXT("State3Task1")));
|
|
}
|
|
{
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
|
|
const TCHAR* EnterStateStr(TEXT("EnterState"));
|
|
const TCHAR* ExitStateStr(TEXT("ExitState"));
|
|
|
|
FStateTreeInstanceData InstanceData;
|
|
TArray<FRecordedStateTreeTransitionResult> RecordedTransitions;
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData, {}, EStateTreeRecordTransitions::Yes);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
// Start and enter state
|
|
EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State1"));
|
|
Exec.LogClear();
|
|
|
|
// Transition from State1 to State2. State3 fails (missing event), enter State4.
|
|
Exec.SendEvent(GetTestTag1());
|
|
Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State2", "State4"));
|
|
Exec.LogClear();
|
|
|
|
Exec.Stop();
|
|
Exec.Start();
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State1"));
|
|
|
|
// Transition from State1 to State2 failed.
|
|
Exec.SendEvent(GetTestTag2());
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State1"));
|
|
Exec.LogClear();
|
|
|
|
// Transition from State1 to State2. State3 succeed.
|
|
Exec.SendEvent(GetTestTag2());
|
|
Exec.SendEvent(GetTestTag1());
|
|
Status = Exec.Tick(0.1f);
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State2", "State3"));
|
|
Exec.LogClear();
|
|
|
|
RecordedTransitions = Exec.GetRecordedTransitions();
|
|
Exec.Stop();
|
|
}
|
|
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree, StateTree, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
// Start and enter state
|
|
EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State1"));
|
|
Exec.LogClear();
|
|
|
|
AITEST_TRUE(TEXT("Wrong number of transitions"), RecordedTransitions.Num() == 5);
|
|
|
|
Exec.ForceTransition(RecordedTransitions[0]); // start
|
|
AITEST_TRUE(TEXT("Start."), Exec.ExpectInActiveStates("Root", "State1"));
|
|
|
|
Exec.ForceTransition(RecordedTransitions[1]); // state 3 doesn't have the event
|
|
AITEST_TRUE(TEXT("State3 failed."), Exec.ExpectInActiveStates("Root", "State2", "State4"));
|
|
|
|
Exec.ForceTransition(RecordedTransitions[2]); // start
|
|
AITEST_TRUE(TEXT("Start and failed transition."), Exec.ExpectInActiveStates("Root", "State1"));
|
|
|
|
Exec.ForceTransition(RecordedTransitions[3]); // failed
|
|
AITEST_TRUE(TEXT("Start and failed transition."), Exec.ExpectInActiveStates("Root", "State1"));
|
|
|
|
Exec.ForceTransition(RecordedTransitions[4]); // succeed
|
|
AITEST_TRUE(TEXT("State3 succeed."), Exec.ExpectInActiveStates("Root", "State2", "State3"));
|
|
|
|
Exec.Stop();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionTwoEvents, "System.StateTree.Transition.TwoEvents");
|
|
|
|
struct FStateTreeTest_TransitionLinkedAssetFromCompletedParent : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
/*
|
|
- Tree1
|
|
- Root1
|
|
- State1: TryEnter, Task w/ 1 frame to complete
|
|
- State2 : LinkedAsset (On Complete -> State 3)
|
|
- State3
|
|
- Tree2
|
|
- Root1
|
|
- State1: Task w/ 2 frames to complete
|
|
*/
|
|
|
|
UStateTree& StateTree1 = NewStateTree();
|
|
UStateTree& StateTree2 = NewStateTree();
|
|
|
|
// Setup linked asset
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree2.EditorData);
|
|
UStateTreeState& Root1 = EditorData.AddSubTree(FName("Tree2_Root1"));
|
|
UStateTreeState& State1 = Root1.AddChildState(FName("Tree2_State1"));
|
|
|
|
State1.AddTask<FTestTask_PrintValue>("Tree2_State1_TaskPrint")
|
|
.GetInstanceData().Value = 21;
|
|
State1.AddTask<FTestTask_Stand>(FName("Tree2_State1_TaskStand"))
|
|
.GetNode().TicksToCompletion = 2;
|
|
State1.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &Root1);
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree2);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
|
|
// Setup main asset
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree1.EditorData);
|
|
UStateTreeState& Root1 = EditorData.AddSubTree(FName("Tree1_Root1"));
|
|
UStateTreeState& State1 = Root1.AddChildState(FName("Tree1_State1"));
|
|
|
|
UStateTreeState& State2 = State1.AddChildState(FName("Tree1_State2"), EStateTreeStateType::LinkedAsset);
|
|
UStateTreeState& State3 = Root1.AddChildState(FName("Tree1_State3"));
|
|
|
|
{
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& PrintTask = State1.AddTask<FTestTask_PrintValue>("Tree1_State1_TaskPrint");
|
|
PrintTask.GetInstanceData().Value = 11;
|
|
TStateTreeEditorNode<FTestTask_Stand>& StandTask = State1.AddTask<FTestTask_Stand>(FName("Tree1_State1_TaskStand"));
|
|
StandTask.GetNode().TicksToCompletion = 1;
|
|
StandTask.GetInstanceData().Value = 11;
|
|
State1.SelectionBehavior = EStateTreeStateSelectionBehavior::TryEnterState;
|
|
State1.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &State2);
|
|
}
|
|
|
|
{
|
|
State2.SetLinkedStateAsset(&StateTree2);
|
|
TStateTreeEditorNode<FTestTask_PrintValue>& PrintTask = State2.AddTask<FTestTask_PrintValue>("Tree1_State2_TaskPrint");
|
|
PrintTask.GetInstanceData().Value = 12;
|
|
}
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree1);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
|
|
FStateTreeInstanceData InstanceData;
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
}
|
|
|
|
constexpr int32 MaxRules = 4;
|
|
auto MakeStateSelectionRule = [](int32 Index)
|
|
{
|
|
EStateTreeStateSelectionRules Rule = EStateTreeStateSelectionRules::None;
|
|
if ((Index % 2) == 1)
|
|
{
|
|
Rule |= EStateTreeStateSelectionRules::CompletedTransitionStatesCreateNewStates;
|
|
Rule |= EStateTreeStateSelectionRules::CompletedStateBeforeTransitionSourceFailsTransition;
|
|
}
|
|
if (Index >= 2)
|
|
{
|
|
Rule |= EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates;
|
|
}
|
|
return Rule;
|
|
};
|
|
|
|
const TCHAR* EnterStateChangedStr = TEXT("EnterState=Changed");
|
|
const TCHAR* EnterStateSustainedStr = TEXT("EnterState=Sustained");
|
|
const TCHAR* ExitStateChangedStr = TEXT("ExitState=Changed");
|
|
const TCHAR* ExitStateSustainedStr = TEXT("ExitState=Sustained");
|
|
|
|
for (int32 Index = 0; Index < MaxRules; ++Index)
|
|
{
|
|
const EStateTreeStateSelectionRules StateSelectionRules = MakeStateSelectionRule(Index);
|
|
InstanceData = FStateTreeInstanceData();
|
|
if (StateTree1.GetStateSelectionRules() != StateSelectionRules)
|
|
{
|
|
StateTree1.ResetCompiled();
|
|
UStateTreeEditorData* EditorData = CastChecked<UStateTreeEditorData>(StateTree1.EditorData);
|
|
UStateTreeTestSchema* Schema = CastChecked<UStateTreeTestSchema>(EditorData->Schema);
|
|
Schema->SetStateSelectionRules(StateSelectionRules);
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree1);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
// Start and enter state
|
|
EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("Valid states"), Exec.ExpectInActiveStates("Tree1_Root1", "Tree1_State1"));
|
|
AITEST_TRUE(TEXT("Expected amount of frames."), InstanceData.GetExecutionState()->ActiveFrames.Num() == 1);
|
|
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("Tree1_State1_TaskPrint", TEXT("EnterState11"));
|
|
AITEST_TRUE(TEXT("Start enters in the correct order Tree1_State1_TaskPrint"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskPrint", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Start enters in the correct order Tree1_State1_TaskPrint"), LogOrder);
|
|
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", TEXT("EnterState"));
|
|
AITEST_TRUE(TEXT("Start enters in the correct order Tree1_State1_TaskStand"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Start enters in the correct order Tree1_State1_TaskStand"), LogOrder);
|
|
Exec.LogClear();
|
|
}
|
|
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
EStateTreeRunStatus Status = Exec.Tick(0.f);
|
|
AITEST_TRUE(TEXT("Active states should now include linked asset states"), Exec.ExpectInActiveStates("Tree1_Root1", "Tree1_State1", "Tree1_State2", "Tree2_Root1", "Tree2_State1"));
|
|
AITEST_TRUE(TEXT("Expected amount of frames."), InstanceData.GetExecutionState()->ActiveFrames.Num() == 2);
|
|
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("Tree1_State1_TaskPrint", TEXT("Tick11"));
|
|
AITEST_TRUE(TEXT("Tree1_State1_TaskPrint ticked"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", TEXT("Tick"));
|
|
AITEST_TRUE(TEXT("Tree1_State1_TaskStand ticked"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", TEXT("StateCompleted"));
|
|
AITEST_TRUE(TEXT("Completed State1 in Tree1"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State2_TaskPrint", TEXT("EnterState12"));
|
|
AITEST_TRUE(TEXT("Entered State2 in Tree1"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State2_TaskPrint", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Entered State2 in Tree1"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskPrint", TEXT("EnterState21"));
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree2"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskStand", TEXT("EnterState"));
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree2"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskStand", EnterStateChangedStr);
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree2"), LogOrder);
|
|
Exec.LogClear();
|
|
}
|
|
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
EStateTreeRunStatus Status = Exec.Tick(0.f);
|
|
AITEST_TRUE(TEXT("Active states should stay the same after Tree1_State1 completion"), Exec.ExpectInActiveStates("Tree1_Root1", "Tree1_State1", "Tree1_State2", "Tree2_Root1", "Tree2_State1"));
|
|
AITEST_TRUE(TEXT("Expected amount of frames."), InstanceData.GetExecutionState()->ActiveFrames.Num() == 2);
|
|
|
|
const bool bCompletedStatedCreateNewStates = EnumHasAnyFlags(StateSelectionRules, EStateTreeStateSelectionRules::CompletedTransitionStatesCreateNewStates);
|
|
const bool bReselectCreateNewStates = EnumHasAnyFlags(StateSelectionRules, EStateTreeStateSelectionRules::ReselectedStateCreatesNewStates);
|
|
const TCHAR* EnterStateStr = (bCompletedStatedCreateNewStates || bReselectCreateNewStates) ? EnterStateChangedStr: EnterStateSustainedStr;
|
|
const TCHAR* ExitStateStr = (bCompletedStatedCreateNewStates || bReselectCreateNewStates) ? ExitStateChangedStr: ExitStateSustainedStr;
|
|
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = Exec.Expect("Tree1_State1_TaskPrint", TEXT("Tick11"));
|
|
AITEST_TRUE(TEXT("Tree1_State1_TaskPrint ticked"), LogOrder);
|
|
|
|
if (bCompletedStatedCreateNewStates)
|
|
{
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", TEXT("Tick"));
|
|
AITEST_TRUE(TEXT("Tree1_State1_TaskStand ticked"), LogOrder);
|
|
}
|
|
|
|
LogOrder = LogOrder.Then("Tree1_State2_TaskPrint", TEXT("Tick12"));
|
|
AITEST_TRUE(TEXT("Tree1_State2_TaskPrint ticked"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskPrint", TEXT("Tick21"));
|
|
AITEST_TRUE(TEXT("Tree2_State1_TaskPrint ticked"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskStand", TEXT("Tick"));
|
|
AITEST_TRUE(TEXT("Tree2_State1_TaskStand ticked"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskStand", TEXT("StateCompleted"));
|
|
AITEST_TRUE(TEXT("Completed State1 in Tree2"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", TEXT("StateCompleted"));
|
|
AITEST_TRUE(TEXT("Completed State1 in Tree1"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskStand", ExitStateStr);
|
|
AITEST_TRUE(TEXT("Exited State1 in Tree2"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree2_State1_TaskPrint", TEXT("ExitState21"));
|
|
AITEST_TRUE(TEXT("Exited State1 in Tree2"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree2_State1_TaskPrint", ExitStateStr);
|
|
AITEST_TRUE(TEXT("Exited State1 in Tree2"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree1_State2_TaskPrint", TEXT("ExitState12"));
|
|
AITEST_TRUE(TEXT("Exited State2 in Tree1"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree1_State2_TaskPrint", ExitStateStr);
|
|
AITEST_TRUE(TEXT("Exited State2 in Tree1"), LogOrder);
|
|
|
|
if (bCompletedStatedCreateNewStates)
|
|
{
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", ExitStateStr);
|
|
AITEST_TRUE(TEXT("Exited State1 in Tree1"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree1_State1_TaskPrint", TEXT("ExitState11"));
|
|
AITEST_TRUE(TEXT("Exited State1 in Tree1"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree1_State1_TaskPrint", ExitStateStr);
|
|
AITEST_TRUE(TEXT("Exited State1 in Tree1"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree1_State1_TaskPrint", TEXT("EnterState11"));
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree1"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State1_TaskStand", EnterStateStr);
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree1"), LogOrder);
|
|
}
|
|
|
|
LogOrder = Exec.Expect("Tree1_State2_TaskPrint", TEXT("EnterState12"));
|
|
AITEST_TRUE(TEXT("Entered State2 in Tree1"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree1_State2_TaskPrint", EnterStateStr);
|
|
AITEST_TRUE(TEXT("Entered State2 in Tree1"), LogOrder);
|
|
LogOrder = Exec.Expect("Tree2_State1_TaskPrint", TEXT("EnterState21"));
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree2"), LogOrder);
|
|
LogOrder = LogOrder.Then("Tree2_State1_TaskStand", EnterStateStr);
|
|
AITEST_TRUE(TEXT("Entered State1 in Tree2"), LogOrder);
|
|
Exec.LogClear();
|
|
}
|
|
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
Exec.Stop();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionLinkedAssetFromCompletedParent, "System.StateTree.Transition.LinkedAssetFromCompletedParent");
|
|
|
|
struct FStateTreeTest_TransitionLinkedAssetWith2Root : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
/*
|
|
- Tree1
|
|
- Root1
|
|
- State1 : LinkedAsset
|
|
- Tree2
|
|
- Root1
|
|
- State1: Transition To Root3
|
|
- Root2
|
|
- State2
|
|
*/
|
|
|
|
UStateTree& StateTree1 = NewStateTree();
|
|
UStateTree& StateTree2 = NewStateTree();
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree2.EditorData);
|
|
UStateTreeState& Root1 = EditorData.AddSubTree(FName("Root1"));
|
|
UStateTreeState& State1 = Root1.AddChildState(FName("State1"));
|
|
UStateTreeState& Root2 = EditorData.AddSubTree(FName("Root2"));
|
|
UStateTreeState& State2 = Root2.AddChildState(FName("State2"));
|
|
|
|
auto& Task1 = State1.AddTask<FTestTask_Stand>(FName("Tree2State1Task1"));
|
|
Task1.GetNode().TicksToCompletion = 1;
|
|
State1.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::GotoState, &State2);
|
|
|
|
auto& Task2 = State2.AddTask<FTestTask_Stand>(FName(TEXT("Task1A")));
|
|
Task2.GetNode().TicksToCompletion = 1;
|
|
State2.AddTransition(EStateTreeTransitionTrigger::OnStateCompleted, EStateTreeTransitionType::Succeeded);
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree2);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
{
|
|
UStateTreeEditorData& EditorData = *Cast<UStateTreeEditorData>(StateTree1.EditorData);
|
|
UStateTreeState& Root1 = EditorData.AddSubTree(FName("Root"));
|
|
UStateTreeState& State1 = Root1.AddChildState(FName("State1"), EStateTreeStateType::LinkedAsset);
|
|
|
|
State1.SetLinkedStateAsset(&StateTree2);
|
|
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree1);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
|
|
FStateTreeInstanceData InstanceData;
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
// Start and enter state
|
|
EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("Valid states"), Exec.ExpectInActiveStates("Root", "State1", "Root1", "State1"));
|
|
AITEST_TRUE(TEXT("Expected amount of frames."), InstanceData.GetExecutionState()->ActiveFrames.Num() == 2);
|
|
Exec.LogClear();
|
|
}
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
EStateTreeRunStatus Status = Exec.Tick(0.f);
|
|
AITEST_TRUE(TEXT("Active states should stay the same"), Exec.ExpectInActiveStates("Root", "State1", "Root2", "State2"));
|
|
AITEST_TRUE(TEXT("Expected amount of frames."), InstanceData.GetExecutionState()->ActiveFrames.Num() == 2);
|
|
Exec.LogClear();
|
|
}
|
|
{
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
Exec.Stop();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_TransitionLinkedAssetWith2Root, "System.StateTree.Transition.LinkedAssetWith2Root");
|
|
|
|
struct FStateTreeTest_MultipleTransition_TemporaryFrame_GlobalTask : FStateTreeTestBase
|
|
{
|
|
virtual bool InstantTest() override
|
|
{
|
|
/*
|
|
- Tree1
|
|
- Root
|
|
- State1 Transition1 -> Goto State2; Transition2 -> Goto State3
|
|
- State2 : Tree2
|
|
- State3
|
|
|
|
- Tree2 : Global Tasks
|
|
- Root : Tree3
|
|
|
|
- Tree3 : Global Tasks
|
|
*/
|
|
|
|
UStateTree& StateTree1 = NewStateTree();
|
|
UStateTree& StateTree2 = NewStateTree();
|
|
UStateTree& StateTree3 = NewStateTree();
|
|
|
|
{
|
|
UStateTreeEditorData& Tree1EditorData = *Cast<UStateTreeEditorData>(StateTree1.EditorData);
|
|
UStateTreeState& Root = Tree1EditorData.AddSubTree(FName("Tree1Root"));
|
|
UStateTreeState& State1 = Root.AddChildState(FName("Tree1State1"));
|
|
UStateTreeState& State2 = Root.AddChildState(FName("Tree1State2"));
|
|
UStateTreeState& State3 = Root.AddChildState(FName("Tree1State3"));
|
|
|
|
FStateTreeTransition& LowPriorityTrans = State1.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &State2);
|
|
LowPriorityTrans.Priority = EStateTreeTransitionPriority::Low;
|
|
FStateTreeTransition& HighPriorityTrans = State1.AddTransition(EStateTreeTransitionTrigger::OnTick, EStateTreeTransitionType::GotoState, &State3);
|
|
HighPriorityTrans.Priority = EStateTreeTransitionPriority::High;
|
|
|
|
State2.Type = EStateTreeStateType::LinkedAsset;
|
|
State2.SetLinkedStateAsset(&StateTree2);
|
|
}
|
|
|
|
{
|
|
UStateTreeEditorData& Tree2EditorData = *Cast<UStateTreeEditorData>(StateTree2.EditorData);
|
|
TStateTreeEditorNode<FTestTask_StandNoTick>& TaskEditorNode = Tree2EditorData.AddGlobalTask<FTestTask_StandNoTick>(FName("Tree2Stand"));
|
|
UStateTreeState& Root = Tree2EditorData.AddSubTree(FName("Tree2Root"));
|
|
Root.Type = EStateTreeStateType::LinkedAsset;
|
|
Root.SetLinkedStateAsset(&StateTree3);
|
|
}
|
|
|
|
{
|
|
UStateTreeEditorData& Tree3EditorData = *Cast<UStateTreeEditorData>(StateTree3.EditorData);
|
|
Tree3EditorData.AddGlobalTask<FTestTask_StandNoTick>(FName("Tree3Stand"));
|
|
|
|
UStateTreeState& Root = Tree3EditorData.AddSubTree(FName("Tree3Root"));
|
|
}
|
|
|
|
{
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree3);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
{
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree2);
|
|
AITEST_TRUE("StateTree should get compiled", bResult);
|
|
}
|
|
{
|
|
FStateTreeCompilerLog Log;
|
|
FStateTreeCompiler Compiler(Log);
|
|
const bool bResult = Compiler.Compile(StateTree1);
|
|
AITEST_TRUE("StateTree should get compiled", bResult)
|
|
}
|
|
|
|
{
|
|
FStateTreeInstanceData InstanceData;
|
|
FTestStateTreeExecutionContext Exec(StateTree1, StateTree1, InstanceData);
|
|
const bool bInitSucceeded = Exec.IsValid();
|
|
AITEST_TRUE("StateTree should init", bInitSucceeded);
|
|
|
|
EStateTreeRunStatus Status = Exec.Start();
|
|
AITEST_TRUE(TEXT("Valid states"), Exec.ExpectInActiveStates("Tree1Root", "Tree1State1"));
|
|
Exec.LogClear();
|
|
|
|
Exec.Tick(0.1f);
|
|
|
|
FTestStateTreeExecutionContext::FLogOrder LogOrder = FTestStateTreeExecutionContext::FLogOrder(Exec, 0);
|
|
LogOrder = LogOrder.Then("Tree2Stand", TEXT("EnterState=Changed")).Then("Tree3Stand", TEXT("EnterState=Changed"));
|
|
AITEST_TRUE(TEXT("Enter Global tasks on temporary frames correctly"), LogOrder);
|
|
|
|
LogOrder = LogOrder.Then("Tree3Stand", TEXT("ExitStopped"))
|
|
.Then("Tree3Stand", TEXT("ExitState=Changed"))
|
|
.Then("Tree2Stand", TEXT("ExitStopped"))
|
|
.Then("Tree2Stand", TEXT("ExitState=Changed"));
|
|
|
|
AITEST_TRUE(TEXT("Exit Global tasks on temporary frames correctly"), LogOrder);
|
|
|
|
AITEST_TRUE(TEXT("Valid states"), Exec.ExpectInActiveStates("Tree1Root", "Tree1State3"));
|
|
|
|
Exec.Stop();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
IMPLEMENT_STATE_TREE_INSTANT_TEST(FStateTreeTest_MultipleTransition_TemporaryFrame_GlobalTask, "System.StateTree.Transition.MultipleTransition.TemporaryFrame.GlobalTask");
|
|
|
|
} // namespace UE::StateTree::Tests
|
|
|
|
UE_ENABLE_OPTIMIZATION_SHIP
|
|
|
|
#undef LOCTEXT_NAMESPACE
|