关于游戏开发:UE5新功能StateTree源码解析

StateTree 是一种UE5中新增的通用分层状态机，其组合了行为树中的选择器（Selectors）与状态机中的状态（States）和过渡（Transitions）。用户能够创立十分高效、放弃灵便且颠三倒四的逻辑。
StateTree蕴含以树结构布局的状态。状态抉择能够在树中的任意地位触发。相比行为树，其组织形式更为自在，灵便，能够在任意两个状态之间过渡。相比状态机，其树状的分层构造更加清晰和高效。
这样一个非常好用乏味的新货色天然未免让人想进入源码一探到底。
次要文件的组织
StateTree的次要逻辑在UE5源码中大抵分为如下几个文件：
StateTree.h 次要蕴含UStateTree类，作为StateTree的定义
StateTreeComponent.h 次要蕴含UStateTreeComponent 类作为在Actor上运行指定StateTree的组件
StateTreeExecutionContext.h 次要蕴含 FStateTreeExecutionContext 作为更新和拜访 StateTree的helper类StateTree的更新，状态切换和转换逻辑根本都在这个外面
其余的还有诸如StateTree中条件，工作，评估器的基类，用于编辑器资源创立的类等，在此不多加叙述

执行流程
开始
进入游戏后，对于启用了UStateTreeComponent组件的Actor，在组件的BeginPlay()期间，执行FStateTreeExecutionContext的Start()函数。开启StateTree的执行，该函数次要执行初始化和状态抉择，一开始的状态抉择从根部开始，后续会具体讲到状态抉择的逻辑。以下为Start()函数增加了具体的正文，能够帮忙各位了解。
// 开始状态树的执行，返回状态执行的状态
EStateTreeRunStatus FStateTreeExecutionContext::Start()
{

// 记录函数执行工夫CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_Start);// 如果上下文没有被正确初始化，则返回失败并记录日志if (!IsValid()){    STATETREE_LOG(Warning, TEXT("%s: StateTree context is not initialized properly ('%s' using StateTree '%s')"),        ANSI_TO_TCHAR(__FUNCTION__), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    return EStateTreeRunStatus::Failed;}// 如果实例数据有效，则初始化if (!InstanceData.IsValid()){    const FStateTreeActiveStates Empty;    UpdateInstanceData(Empty, Empty);    if (!InstanceData.IsValid())    {        STATETREE_LOG(Warning, TEXT("%s: Failed to initialize instance data on '%s' using StateTree '%s'. Try to recompile the StateTree asset."),            ANSI_TO_TCHAR(__FUNCTION__), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));        return EStateTreeRunStatus::Failed;    }}// 获取共享实例数据const TSharedPtr<FStateTreeInstanceData> SharedInstanceData = StateTree.GetSharedInstanceData();check(SharedInstanceData.IsValid());// 获取执行状态，并记录为指针以便稍后从新获取FStateTreeExecutionState* Exec = &GetExecState(); // Using pointer as we will need to reacquire the exec later.// 如果之前有状态正在运行，则进行if (Exec->TreeRunStatus == EStateTreeRunStatus::Running){    Stop();}// 调用所有评估器的TreeStart办法StartEvaluators();// 第一次调用TickEvaluatorsTickEvaluators(0.0f);// 初始化为未设置状态Exec->TreeRunStatus = EStateTreeRunStatus::Running;Exec->ActiveStates.Reset();Exec->LastTickStatus = EStateTreeRunStatus::Unset;static const FStateTreeStateHandle RootState = FStateTreeStateHandle(0);// 抉择状态,从RootState开始FStateTreeActiveStates NextActiveStates;if (SelectState(*SharedInstanceData.Get(), RootState, NextActiveStates)){    if (NextActiveStates.Last() == FStateTreeStateHandle::Succeeded || NextActiveStates.Last() == FStateTreeStateHandle::Failed)    {        // 如果抉择的是终止状态，阐明状态执行实现        // 记录日志并更改状态        STATETREE_LOG(Warning, TEXT("%s: Tree %s at StateTree start on '%s' using StateTree '%s'."),            ANSI_TO_TCHAR(__FUNCTION__), NextActiveStates.Last() == FStateTreeStateHandle::Succeeded ? TEXT("succeeded") : TEXT("failed"), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));        Exec->TreeRunStatus = NextActiveStates.Last() == FStateTreeStateHandle::Succeeded ? EStateTreeRunStatus::Succeeded : EStateTreeRunStatus::Failed;    }    else    {        // 如果不是终止状态，进入抉择的状态        // Enter state能够失败或胜利，并且与Tick中的矗立雷同        FStateTreeTransitionResult Transition;        Transition.TargetState = RootState;        Transition.CurrentActiveStates = Exec->ActiveStates;        Transition.CurrentRunStatus = Exec->LastTickStatus;        Transition.NextActiveStates = NextActiveStates;         // EnterState将更新Exec.ActiveStates        const EStateTreeRunStatus LastTickStatus = EnterState(Transition);        // 须要从新获取执行状态，因为EnterState可能会更改调配        Exec = &GetExecState();        Exec->LastTickStatus = LastTickStatus;        // 如果状态已实现，则在此时报告        if (Exec->LastTickStatus != EStateTreeRunStatus::Running)        {            StateCompleted();          }    }}// 如果没有沉闷状态，则返回失败，这应该不会产生if (Exec->ActiveStates.IsEmpty()){    STATETREE_LOG(Error, TEXT("%s: Failed to select initial state on '%s' using StateTree '%s'. This should not happen, check that the StateTree logic can always select a state at start."),        ANSI_TO_TCHAR(__FUNCTION__), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    Exec->TreeRunStatus = EStateTreeRunStatus::Failed;}// 返回状态执行的状态return Exec->TreeRunStatus;

}
更新
StateTree的更新逻辑次要在FStateTreeExecutionContext 的Tick()函数里进行。该函数次要负责更新评估期和tick事件，依据条件触发状态转换等，以下为代码增加了正文帮忙了解。
EStateTreeRunStatus FStateTreeExecutionContext::Tick(const float DeltaTime)
{

CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_Tick); // 统计性能// 判断状态树是否非法if (!IsValid()){       // 输入正告信息    STATETREE_LOG(Warning, TEXT("%s: StateTree context is not initialized properly ('%s' using StateTree '%s')"),        ANSI_TO_TCHAR(__FUNCTION__), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    return EStateTreeRunStatus::Failed; // 返回运行失败状态}// 判断实例数据是否非法if (!InstanceData.IsValid()){       // 输入错误信息    STATETREE_LOG(Error, TEXT("%s: Tick called on %s using StateTree %s with invalid instance data. Start() must be called before Tick()."),        ANSI_TO_TCHAR(__FUNCTION__), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    return EStateTreeRunStatus::Failed; // 返回运行失败状态}// 获取共享实例数据const TSharedPtr<FStateTreeInstanceData> SharedInstanceData = StateTree.GetSharedInstanceData();check(SharedInstanceData.IsValid()); // 断言共享实例数据是否无效// 获取执行状态FStateTreeExecutionState* Exec = &GetExecState();// 将在工夫距离内增加的事件增加到 EventsToProcess 中以进行后续解决EventsToProcess = InstanceData.GetEvents();InstanceData.GetEvents().Reset();// 如果状态已进行或未在运行，则间接返回其状态if (Exec->TreeRunStatus != EStateTreeRunStatus::Running){    return Exec->TreeRunStatus;}// 更新阀门转换工夫if (Exec->GatedTransitionIndex.IsValid()){    Exec->GatedTransitionTime -= DeltaTime;}// 执行全局预计器TickEvaluators(DeltaTime);// 如果上次的状态是运行中，则对活动状态进行工作解决，并告诉状态曾经实现if (Exec->LastTickStatus == EStateTreeRunStatus::Running){    // 对活动状态的工作进行解决    Exec->LastTickStatus = TickTasks(DeltaTime);    // 如果该状态实现后不再运行，告诉状态曾经实现    if (Exec->LastTickStatus != EStateTreeRunStatus::Running)    {        StateCompleted();    }}// 将 EventsToProcess 中的事件增加到实例数据的事件列表中以供后续解决EventsToProcess.Append(InstanceData.GetEvents());// 在肯定的迭代次数内触发条件转换或状态实现/失败转换，并处理事件static constexpr int32 MaxIterations = 5;for (int32 Iter = 0; Iter < MaxIterations; Iter++){    // 触发条件转换或状态实现/失败转换，并获取转换后果    FStateTreeTransitionResult Transition;    if (TriggerTransitions(*SharedInstanceData.Get(), Transition))    {        // 确认状态转换后，重置事件列表，并开始状态退出操作        InstanceData.GetEvents().Reset();        ExitState(Transition);        // 如果要转换到的状态为终止状态，设置运行状态为胜利或失败，并返回该状态        if (Transition.NextActiveStates.Last() == FStateTreeStateHandle::Succeeded || Transition.NextActiveStates.Last() == FStateTreeStateHandle::Failed)        {            Exec->TreeRunStatus = Transition.NextActiveStates.Last() == FStateTreeStateHandle::Succeeded ? EStateTreeRunStatus::Succeeded : EStateTreeRunStatus::Failed;            Exec->ActiveStates.Reset();            return Exec->TreeRunStatus;        }        // 将状态退出期间积攒的事件增加到 EventsToProcess 中以进行后续解决        EventsToProcess.Append(InstanceData.GetEvents());        InstanceData.GetEvents().Reset();        // 进入新状态并解决其工作        const EStateTreeRunStatus LastTickStatus = EnterState(Transition);        Exec = &GetExecState();        Exec->LastTickStatus = LastTickStatus;        // 如果该状态实现后不再运行，告诉状态曾经实现        if (Exec->LastTickStatus != EStateTreeRunStatus::Running)        {            StateCompleted();        }    }    // 如果曾经找到了运行状态，则间接退出    if (Exec->LastTickStatus == EStateTreeRunStatus::Running)    {        break;    }}// 如果活动状态为空，返回运行失败状态if (Exec->ActiveStates.IsEmpty()){    STATETREE_LOG(Error, TEXT("%s: Failed to select state on '%s' using StateTree '%s'. This should not happen, state completion transition is likely missing."),        ANSI_TO_TCHAR(__FUNCTION__), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    Exec->TreeRunStatus = EStateTreeRunStatus::Failed;    return Exec->TreeRunStatus;}// 重置事件列表并返回以后状态EventsToProcess.Reset();return Exec->TreeRunStatus;

}
状态抉择
状态抉择的次要逻辑在FStateTreeExecutionContext的SelectState()里。在抉择过程中，将对每个状态的进入条件（Enter Conditions）求值。如果通过，抉择将后退到该状态的子状态（如果可用）。如果没有子状态可用，将激活以后状态。抉择状态将激活从根到叶状态的所有状态。抉择某个状态时，所选状态及其所有父状态都将激活。为所有活动状态执行所有工作，执行形式为从根开始，直至所选的状态。以下为SelectState函数增加了正文。
/**

抉择要转换到的下一个状态，并更新激活状态汇合以反映新状态。
@param SharedInstanceData 共享实例数据。
@param NextState 要抉择的下一个状态。
@param OutNewActiveState 输入的新激活状态汇合。
@return 如果胜利抉择并转移了状态，则返回true，否则返回false。
*/

bool FStateTreeExecutionContext::SelectState(

FStateTreeInstanceData& SharedInstanceData,            // 共享实例数据const FStateTreeStateHandle NextState,                 // 要抉择的下一个状态FStateTreeActiveStates& OutNewActiveState)              // 输入的新激活状态汇合

{

const FStateTreeExecutionState& Exec = GetExecState(); // 获取以后的执行状态// 如果要抉择的下一个状态有效，则返回失败if (!NextState.IsValid()){    return false;}OutNewActiveState = Exec.ActiveStates;                 // 将以后激活状态汇合复制到输入汇合中TStaticArray<FStateTreeStateHandle, FStateTreeActiveStates::MaxStates> InBetweenStates;  // 存储中间状态的数组int32 NumInBetweenStates = 0;                           // 中间状态数量int32 CommonActiveAncestorIndex = INDEX_NONE;           // 下一个状态与以后激活状态的公共先人在 OutNewActiveState 中的索引FStateTreeStateHandle CurrState = NextState;            // 从待抉择状态开始向上查找公共先人while (CurrState.IsValid())                            {    InBetweenStates[NumInBetweenStates++] = CurrState;  // 将以后状态增加到中间状态数组中    CommonActiveAncestorIndex = OutNewActiveState.IndexOfReverse(CurrState);  // 查找该状态在以后激活状态中的地位    if (CommonActiveAncestorIndex != INDEX_NONE)       // 找到公共先人，退出循环    {        break;    }    if (NumInBetweenStates == InBetweenStates.Num())   // 中间状态数量超过限度，返回失败    {        STATETREE_LOG(Error, TEXT("%s: Too many parent states when selecting state '%s' from '%s'.  '%s' using StateTree '%s'."),            ANSI_TO_TCHAR(__FUNCTION__), *GetSafeStateName(NextState), *GetStateStatusString(Exec), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));        return false;    }    CurrState = StateTree.States[CurrState.Index].Parent; // 迭代查找父状态}OutNewActiveState.SetNum(FMath::Max(0, CommonActiveAncestorIndex)); // 移除公共先人以下的所有状态// 将中间状态（从下标 NumInBetweenStates-1 到 1，以反向程序）增加到新的激活状态汇合中bool bActiveStatesOverflow = false;  // 激活状态汇合是否已满标记for (int32 Index = NumInBetweenStates - 1; Index > 0; Index--){    bActiveStatesOverflow |= !OutNewActiveState.Push(InBetweenStates[Index]);  // 增加中间状态到输入激活状态汇合中，如果汇合已满则标记为true}if (bActiveStatesOverflow)  // 如果增加中间状态时呈现汇合溢出，则返回失败{    STATETREE_LOG(Error, TEXT("%s: Reached max execution depth when trying to select state %s from '%s'.  '%s' using StateTree '%s'."),        ANSI_TO_TCHAR(__FUNCTION__), *GetSafeStateName(NextState), *GetStateStatusString(Exec), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    return false;}// 执行状态转移return SelectStateInternal(SharedInstanceData, NextState, OutNewActiveState);

}
以下是SelcetStateInternal的代码
bool FStateTreeExecutionContext::SelectStateInternal(FStateTreeInstanceData& SharedInstanceData, const FStateTreeStateHandle NextState, FStateTreeActiveStates& OutNewActiveState)
{

// 记录运行工夫的统计量。CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_SelectState);const FStateTreeExecutionState& Exec = GetExecState();// 如果要抉择的状态有效，则输入错误信息并返回false。if (!NextState.IsValid()){    STATETREE_LOG(Error, TEXT("%s: Trying to select invalid state from '%s'.  '%s' using StateTree '%s'."),        ANSI_TO_TCHAR(__FUNCTION__), *GetStateStatusString(Exec), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));    return false;}// 获取要抉择的状态。const FCompactStateTreeState& State = StateTree.States[NextState.Index];// 查看该状态是否能够进入。if (TestAllConditions(SharedInstanceData, State.EnterConditionsBegin, State.EnterConditionsNum)){    // 将要抉择的状态增加到输入激活状态汇合中，如果增加失败则输入错误信息并返回false。    if (!OutNewActiveState.Push(NextState))    {        STATETREE_LOG(Error, TEXT("%s: Reached max execution depth when trying to select state %s from '%s'.  '%s' using StateTree '%s'."),            ANSI_TO_TCHAR(__FUNCTION__), *GetSafeStateName(NextState), *GetStateStatusString(Exec), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));        return false;    }        // 如果该状态有链接状态，则尝试转换到链接状态。    if (State.LinkedState.IsValid())    {        if (SelectStateInternal(SharedInstanceData, State.LinkedState, OutNewActiveState))        {            // 如果胜利，则返回true。            return true;        }    }    // 如果没有链接状态，并且该状态有子状态，则尝试抉择一个子状态。    else if (State.HasChildren())    {        for (uint16 ChildState = State.ChildrenBegin; ChildState < State.ChildrenEnd; ChildState = StateTree.States[ChildState].GetNextSibling())        {            if (SelectStateInternal(SharedInstanceData, FStateTreeStateHandle(ChildState), OutNewActiveState))            {                // 如果胜利，则返回true。                return true;            }        }    }    // 如果没有链接状态并且没有子状态，则将该状态作为以后状态进行抉择。    else    {        // Select this state.        return true;    }        // 弹出增加到输入激活状态汇合中的状态。    OutNewActiveState.Pop();}// 如果没有抉择任何状态，则返回false。return false;

}
状态切换
StateTree的状态切换逻辑次要在 FStateTreeExecutionContext::TriggerTransitions里，该函数将从以后状态开始自底向上查问自根节点的所有可能的转换，同时对于带有提早的转换进行非凡解决，以下是增加了正文的代码
/**

该函数用于触发状态树的转换。
@param SharedInstanceData 状态树实例的数据。
@param OutTransition 存储状态树转换后果的变量。
@return 如果胜利触发了状态转换，则返回true；否则返回false并持续更新以后状态节点。
*/

bool FStateTreeExecutionContext::TriggerTransitions(FStateTreeInstanceData& SharedInstanceData, FStateTreeTransitionResult& OutTransition)
{

// 应用计时器统计函数运行工夫CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_TriggerTransition);FStateTreeExecutionState& Exec = GetExecState();// 依据上一次执行的后果，确定该采取什么类型的触发条件EStateTreeTransitionTrigger CompletionTrigger = EStateTreeTransitionTrigger::None;if (Exec.LastTickStatus == EStateTreeRunStatus::Succeeded){    CompletionTrigger = EStateTreeTransitionTrigger::OnStateSucceeded;}else if (Exec.LastTickStatus == EStateTreeRunStatus::Failed){    CompletionTrigger = EStateTreeTransitionTrigger::OnStateFailed;}// 定义一个lambda表达式，用于查看是否存在给定的事件类型auto HasEvent = [this](const FGameplayTag QueriedTag){    if (EventsToProcess.IsEmpty())    {        return false;    }        // 判断是否存在对应事件类型的事件对象    return EventsToProcess.ContainsByPredicate([QueriedTag](const FStateTreeEvent& Event)    {        return Event.Tag == QueriedTag;    });};// 从以后状态向根节点遍历，查看所有可能产生的转移条件for (int32 StateIndex = Exec.ActiveStates.Num() - 1; StateIndex >= 0; StateIndex--){    // 获取以后状态节点    const FCompactStateTreeState& State = StateTree.States[Exec.ActiveStates[StateIndex].Index];        // 遍历以后状态中的每个转移条件    for (uint8 i = 0; i < State.TransitionsNum; i++)    {        // 获取以后转移条件对象        const int16 TransitionIndex = State.TransitionsBegin + i;        const FCompactStateTransition& Transition = StateTree.Transitions[TransitionIndex];        // 判断是否须要查看以后条件        const bool bShouldCheck = EnumHasAnyFlags(Transition.Trigger, CompletionTrigger) // 确认实现触发器是否与以后触发条件匹配                                || Transition.Trigger == EStateTreeTransitionTrigger::OnTick // 是否为每次状态树运行都应该查看的转移条件                                || (Transition.Trigger == EStateTreeTransitionTrigger::OnEvent && HasEvent(Transition.EventTag)); // 是否与事件相干        // 如果须要查看以后条件，并且满足所有条件，则进行转移        if (bShouldCheck && TestAllConditions(SharedInstanceData, Transition.ConditionsBegin, Transition.ConditionsNum))        {            // 如果这是一个门控转移，则执行非凡解决逻辑            if (Transition.GateDelay > 0)            {                // 如果以后转移条件被门控且还在限度工夫内，则期待                if ((int32)Exec.GatedTransitionIndex.Get() != TransitionIndex)                {                    // 设置属性并开始转移解决                    Exec.GatedTransitionIndex = FStateTreeIndex16(TransitionIndex);                    Exec.GatedTransitionTime = FMath::RandRange(0.0f, Transition.GateDelay * 0.1f); // TODO: we need variance too.                    BeginGatedTransition(Exec);                    STATETREE_LOG(Verbose, TEXT("Gated transition triggered from '%s' (%s) -> '%s' %.1fs"), *GetSafeStateName(Exec.ActiveStates.Last()), *State.Name.ToString(), *GetSafeStateName(Transition.State), Exec.GatedTransitionTime);                }                // 持续放弃状态更新，直到咱们尝试触发转换                if (Exec.GatedTransitionTime > 0.0f)                {                    return false;                }                STATETREE_LOG(Verbose, TEXT("Passed gated transition from '%s' (%s) -> '%s'"), *GetSafeStateName(Exec.ActiveStates.Last()), *State.Name.ToString(), *GetSafeStateName(Transition.State));            }            // 依据不同的转移类型做对应解决            if (Transition.Type == EStateTreeTransitionType::GotoState || Transition.Type == EStateTreeTransitionType::NextState)            {                // 更新转换后果的以后活动状态列表与指标状态                OutTransition.CurrentActiveStates = Exec.ActiveStates;                OutTransition.TargetState = Transition.State;                OutTransition.NextActiveStates.Reset();                // 尝试抉择下一个活动状态                if (SelectState(SharedInstanceData, Transition.State, OutTransition.NextActiveStates))                {                    STATETREE_LOG(Verbose, TEXT("Transition on state '%s' (%s) -[%s]-> state '%s'"), *GetSafeStateName(Exec.ActiveStates.Last()), *State.Name.ToString(), *GetSafeStateName(Transition.State), *GetSafeStateName(OutTransition.NextActiveStates.Last()));                    return true;                }            }            else if (Transition.Type == EStateTreeTransitionType::NotSet)            {                // 对于不设置转移类型，间接更新以后状态并持续运行                // （能够应用该类型的条件屏蔽父级状态节点中的某些转移条件）                return false;            }            else if (Transition.Type == EStateTreeTransitionType::Succeeded)            {                // 如果触发了胜利转移，则将以后状态设置为胜利状态，并进行状态树的执行                STATETREE_LOG(Verbose, TEXT("Stop tree execution from state '%s' (%s): Succeeded"), *GetSafeStateName(Exec.ActiveStates.Last()), *State.Name.ToString());                OutTransition.CurrentActiveStates = Exec.ActiveStates;                OutTransition.TargetState = FStateTreeStateHandle::Succeeded;                OutTransition.NextActiveStates = FStateTreeActiveStates(FStateTreeStateHandle::Succeeded);                return true;            }            else            {                // 如果触发了失败转移，则将以后状态设置为失败状态，并进行状态树的执行                STATETREE_LOG(Verbose, TEXT("Stop tree execution from state '%s' (%s): Failed"), *GetSafeStateName(Exec.ActiveStates.Last()), *State.Name.ToString());                OutTransition.CurrentActiveStates = Exec.ActiveStates;                OutTransition.TargetState = FStateTreeStateHandle::Failed;                OutTransition.NextActiveStates = FStateTreeActiveStates(FStateTreeStateHandle::Failed);                return true;            }        }        else if ((int32)Exec.GatedTransitionIndex.Get() == TransitionIndex)        {            // 如果以后转移被提早，然而查看失败，则重置限度条件            Exec.GatedTransitionIndex = FStateTreeIndex16::Invalid;            Exec.GatedTransitionTime = 0.0f;        }    }}// 如果上一次状态树运行的后果不为“正在运行”，则返回到根节点并从新开始状态树的实例化if (Exec.LastTickStatus != EStateTreeRunStatus::Running){    static const FStateTreeStateHandle RootState = FStateTreeStateHandle(0);    OutTransition.CurrentActiveStates = Exec.ActiveStates;    OutTransition.TargetState = RootState;    OutTransition.NextActiveStates.Reset();    SelectState(SharedInstanceData, RootState, OutTransition.NextActiveStates);    STATETREE_LOG(Verbose, TEXT("Restart tree execution from state '%s'"), *GetSafeStateName(RootState));    return true;}// 如果没有转移条件满足，则持续更新以后状态节点return false;

}
EnterState
接下来是负责进入状态逻辑的FStateTreeExecutionContext::EnterState函数，其代码如下:
EStateTreeRunStatus FStateTreeExecutionContext::EnterState(const FStateTreeTransitionResult& Transition)
{

// 记录进入状态的工夫CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_EnterState);// 如果下一个激活状态为空，间接返回运行失败if (Transition.NextActiveStates.IsEmpty()){    return EStateTreeRunStatus::Failed;}// 调配新工作，即依据以后和下一个激活状态更新实例数据UpdateInstanceData(Transition.CurrentActiveStates, Transition.NextActiveStates);// 获取执行状态并对其进行更新FStateTreeExecutionState& Exec = GetExecState();Exec.StateChangeCount++;// "在指标分支上"示意该状态是以后转移的指标状态或其子状态。    //之前处于活动状态且仍放弃活动状态但不在指标分支上的状态不会被调用EnterState。也就是说，一个转移被视为“从此状态从新打算”。bool bOnTargetBranch = false;// 将转移后果复制一份FStateTreeTransitionResult CurrentTransition = Transition;// 设置状态树运行状态为运行中EStateTreeRunStatus Result = EStateTreeRunStatus::Running;// 重置EnterState失败工作索引和激活状态列表Exec.EnterStateFailedTaskIndex = FStateTreeIndex16::Invalid; // This will make all tasks to be accepted.Exec.ActiveStates.Reset();// 依据Transition.NextActiveStates遍历所有下一个激活状态for (int32 Index = 0; Index < Transition.NextActiveStates.Num() && Result != EStateTreeRunStatus::Failed; Index++){    // 获取以后激活状态的句柄与前一个激活状态的句柄    const FStateTreeStateHandle CurrentHandle = Transition.NextActiveStates[Index];    const FStateTreeStateHandle PreviousHandle = Transition.CurrentActiveStates.GetStateSafe(Index);    // 获取以后状态的压缩存储构造    const FCompactStateTreeState& State = StateTree.States[CurrentHandle.Index];    // 将以后状态的句柄增加到激活状态列表中    if (!Exec.ActiveStates.Push(CurrentHandle))    {        // 如果无奈增加，示意达到了最大执行深度，记录错误信息并退出遍历        STATETREE_LOG(Error, TEXT("%s: Reached max execution depth when trying to enter state '%s'.  '%s' using StateTree '%s'."),            ANSI_TO_TCHAR(__FUNCTION__), *GetStateStatusString(Exec), *GetNameSafe(&Owner), *GetFullNameSafe(&StateTree));        break;    }    // 如果状态是链接类型，则更新其属性    if (State.Type == EStateTreeStateType::Linked)    {        UpdateLinkedStateParameters(State, InstanceStructIndex);        InstanceStructIndex++;    }    // 如果状态是子树类型，则更新其参数    else if (State.Type == EStateTreeStateType::Subtree)    {        UpdateSubtreeStateParameters(State);    }    // 记录以后状态是否在指标分支上，并确定以后状态是否须要进入状态    bOnTargetBranch = bOnTargetBranch || CurrentHandle == Transition.TargetState;    const bool bWasActive = PreviousHandle == CurrentHandle;    const bool bIsEnteringState = !bWasActive || bOnTargetBranch;    // 更新转移后果的以后状态和状态扭转类型    CurrentTransition.CurrentState = CurrentHandle;    CurrentTransition.ChangeType = bWasActive ? EStateTreeStateChangeType::Sustained : EStateTreeStateChangeType::Changed;    // 打印进入状态日志    STATETREE_CLOG(bIsEnteringState, Log, TEXT("%*sEnter state '%s' %s"), Index*UE::StateTree::DebugIndentSize, TEXT(""), *DebugGetStatePath(Transition.NextActiveStates, Index), *UEnum::GetValueAsString(CurrentTransition.ChangeType));        // 激活以后状态中的工作    for (int32 TaskIndex = State.TasksBegin; TaskIndex < (State.TasksBegin + State.TasksNum); TaskIndex++)    {        // 获取当前任务并与其状态中的数据关联        const FStateTreeTaskBase& Task = StateTree.Nodes[TaskIndex].Get<FStateTreeTaskBase>();        SetNodeDataView(Task, InstanceStructIndex, InstanceObjectIndex);        // 复制绑定属性        if (Task.BindingsBatch.IsValid())        {            StateTree.PropertyBindings.CopyTo(DataViews, Task.BindingsBatch, DataViews[Task.DataViewIndex.Get()]);        }        // 判断是否须要调用EnterState函数        const bool bShouldCallStateChange = CurrentTransition.ChangeType == EStateTreeStateChangeType::Changed                                            || (CurrentTransition.ChangeType == EStateTreeStateChangeType::Sustained && Task.bShouldStateChangeOnReselect);        if (bIsEnteringState && bShouldCallStateChange)        {            // 打印工作进入状态日志            STATETREE_LOG(Verbose, TEXT("%*s  Notify Task '%s'"), Index*UE::StateTree::DebugIndentSize, TEXT(""), *Task.Name.ToString());            // 调用工作的EnterState函数并记录返回后果            QUICK_SCOPE_CYCLE_COUNTER(StateTree_Task_EnterState);            CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_Task_EnterState);            const EStateTreeRunStatus Status = Task.EnterState(*this, CurrentTransition);                        // 如果工作进入状态失败，则记录失败索引，并进行遍历            if (Status == EStateTreeRunStatus::Failed)            {                Exec.EnterStateFailedTaskIndex = FStateTreeIndex16(TaskIndex);                Result = Status;                break;            }        }    }}return Result;

}
ExitState
有了EnterState天然也要有ExitState：
void FStateTreeExecutionContext::ExitState(const FStateTreeTransitionResult& Transition)
{

// 记录函数运行工夫的计时器CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_ExitState);// 查看以后须要退出的状态是否为空，若为空则间接返回if (Transition.CurrentActiveStates.IsEmpty()){    return;}// 重置转换提早计时器FStateTreeExecutionState& Exec = GetExecState();Exec.GatedTransitionIndex = FStateTreeIndex16::Invalid;Exec.GatedTransitionTime = 0.0f;// 标记以后状态是否在指标分支上bool bOnTargetBranch = false;// 存储须要退出的状态以及须要调用ExitState()函数的工作相干数据FStateTreeStateHandle ExitedStates[FStateTreeActiveStates::MaxStates];EStateTreeStateChangeType ExitedStateChangeType[FStateTreeActiveStates::MaxStates];int32 ExitedStateActiveIndex[FStateTreeActiveStates::MaxStates];int32 NumExitedStates = 0;// 在待退出的所有状态上执行ExitState()操作，并标记是否在指标状态分支上check(Exec.FirstTaskStructIndex.IsValid() && Exec.FirstTaskObjectIndex.IsValid());int32 InstanceStructIndex = Exec.FirstTaskStructIndex.Get();int32 InstanceObjectIndex = Exec.FirstTaskObjectIndex.Get();for (int32 Index = 0; Index < Transition.CurrentActiveStates.Num(); Index++){    // 获取以后状态和指标状态    const FStateTreeStateHandle CurrentHandle = Transition.CurrentActiveStates[Index];    const FStateTreeStateHandle NextHandle = Transition.NextActiveStates.GetStateSafe(Index);    const FCompactStateTreeState& State = StateTree.States[CurrentHandle.Index];    // 更新Linked类型的状态参数    if (State.Type == EStateTreeStateType::Linked)    {        UpdateLinkedStateParameters(State, InstanceStructIndex);        InstanceStructIndex++;    }    // 更新Subtree类型的状态参数    else if (State.Type == EStateTreeStateType::Subtree)    {        UpdateSubtreeStateParameters(State);    }    // 判断以后状态是否在指标分支上    const bool bRemainsActive = NextHandle == CurrentHandle;    bOnTargetBranch = bOnTargetBranch || NextHandle == Transition.TargetState;    const EStateTreeStateChangeType ChangeType = bRemainsActive ? EStateTreeStateChangeType::Sustained : EStateTreeStateChangeType::Changed;    // 如果以后状态不在指标分支上，设置须要退出的状态及相干数据    if (!bRemainsActive || bOnTargetBranch)    {        check(NumExitedStates < FStateTreeActiveStates::MaxStates);        ExitedStates[NumExitedStates] = CurrentHandle;        ExitedStateChangeType[NumExitedStates] = ChangeType;        ExitedStateActiveIndex[NumExitedStates] = Index;        NumExitedStates++;    }    // 执行以后状态的工作，包含拷贝属性和执行工作实现回调    for (int32 TaskIndex = State.TasksBegin; TaskIndex < (State.TasksBegin + State.TasksNum); TaskIndex++)    {        const FStateTreeTaskBase& Task = StateTree.Nodes[TaskIndex].Get<FStateTreeTaskBase>();        SetNodeDataView(Task, InstanceStructIndex, InstanceObjectIndex);        // 拷贝绑定属性        if (Task.BindingsBatch.IsValid())        {            StateTree.PropertyBindings.CopyTo(DataViews, Task.BindingsBatch, DataViews[Task.DataViewIndex.Get()]);        }    }}// 反向执行须要退出的状态及工作回调FStateTreeTransitionResult CurrentTransition = Transition;for (int32 Index = NumExitedStates - 1; Index >= 0; Index--){    const FStateTreeStateHandle CurrentHandle = ExitedStates[Index];    const FCompactStateTreeState& State = StateTree.States[CurrentHandle.Index];    // 设置以后Transition的状态、状态变动类型等参数，并打印信息    CurrentTransition.CurrentState = CurrentHandle;    CurrentTransition.ChangeType = ExitedStateChangeType[Index];    STATETREE_LOG(Log, TEXT("%*sExit state '%s' %s"), Index*UE::StateTree::DebugIndentSize, TEXT(""), *DebugGetStatePath(Transition.CurrentActiveStates, ExitedStateActiveIndex[Index]), *UEnum::GetValueAsString(CurrentTransition.ChangeType));    // 执行该状态下的所有工作    for (int32 TaskIndex = (State.TasksBegin + State.TasksNum) - 1; TaskIndex >= State.TasksBegin; TaskIndex--)    {        // 如果EnterState()被调用，则执行工作实现回调函数        if (TaskIndex <= Exec.EnterStateFailedTaskIndex.Get())        {            const FStateTreeTaskBase& Task = StateTree.Nodes[TaskIndex].Get<FStateTreeTaskBase>();            // 在状态变动时应该调用工作实现回调函数，须要满足两个条件：以后状态产生了更改，或者以后状态与上一个状态雷同（示意从新进入该状态），且该工作的bShouldStateChangeOnReselect参数为true            const bool bShouldCallStateChange = CurrentTransition.ChangeType == EStateTreeStateChangeType::Changed                        || (CurrentTransition.ChangeType == EStateTreeStateChangeType::Sustained && Task.bShouldStateChangeOnReselect);            if (bShouldCallStateChange)            {                STATETREE_LOG(Verbose, TEXT("%*s  Notify Task '%s'"), Index*UE::StateTree::DebugIndentSize, TEXT(""), *Task.Name.ToString());                                // 调用工作实现回调函数                {                    QUICK_SCOPE_CYCLE_COUNTER(StateTree_Task_ExitState);                    CSV_SCOPED_TIMING_STAT_EXCLUSIVE(StateTree_Task_ExitState);                    Task.ExitState(*this, CurrentTransition);                }            }        }    }}

}
最初当然还有Stop函数，不过都是一些重置和终止的操作，在此就不做过多介绍了。
总结
作为UE5新引入的AI架构，StateTree无疑会为AI开发带来新的生机和组织形式，理解其工作原理可能帮忙咱们更好的使用，也能触类旁通汲取成为本人的常识。