第9章 AI系统

考点： AI Controller生命周期、Possess机制、Controller与Pawn的关系、AI架构设计

参考答案：

1. AAIController 继承自 AController，负责"思考"和"决策"，Pawn 负责"物理存在"。
2. 完整控制流程：
   • GameMode::SpawnDefaultPawnAtTransform() 生成 Pawn；
   • GameMode::SpawnDefaultControllerFor() 生成 AIController（由 Pawn 的 AIControllerClass 决定）；
   • AIController::Possess(Pawn) 建立绑定，触发 OnPossess()；
   • OnPossess() 中 UseBlackboard() + RunBehaviorTree() 启动行为树；
   • 每帧 Tick → 行为树求值 → 执行 Task → 更新黑板。
3. 关键代码：

void AMyAIController::OnPossess(APawn* InPawn)
{
    Super::OnPossess(InPawn);
    if (UseBlackboard(BlackboardAsset, BlackboardComp))
    {
        BlackboardComp->SetValueAsVector(TEXT("HomeLocation"), InPawn->GetActorLocation());
        BlackboardComp->SetValueAsObject(TEXT("SelfActor"), InPawn);
    }
    if (BehaviorTreeAsset)
    {
        RunBehaviorTree(BehaviorTreeAsset);
    }
}

void AMyAIController::OnUnPossess()
{
    Super::OnUnPossess();
    if (UBrainComponent* BrainComp = GetBrainComponent())
    {
        BrainComp->StopLogic("Unpossessed"); // 暂停行为树
    }
}

4. 与 PlayerController 对比：

5. 易错点/进阶：理解 BrainComponent 抽象（行为树/Logic树等多实现）；运行时可用 RunBehaviorTree(NewTree) 动态切换；感知组件通常挂在 AIController 而非 Pawn 上。

考点： 行为树架构、节点类型、执行流、组合逻辑

参考答案：

1. 行为树由组合节点（Composite）、装饰器（Decorator）、服务（Service）、任务（Task） 四类节点组成。
2. 各类节点逻辑：
   • Selector：OR 逻辑，从左到右执行，遇第一个成功即返回成功，全部失败才失败（优先级决策）。
   • Sequence：AND 逻辑，从左到右执行，遇第一个失败即返回失败，全部成功才成功（步骤流程）。
   • Decorator：附加在组合/任务节点上控制子树执行条件，常见类型有 Blackboard、Loop、Cooldown、Force Success/Failure，关键属性 Observer Aborts。
   • Service：挂载在组合节点上，按频率后台 Tick（更新黑板、监控环境），不返回成功/失败。
   • Task：叶子节点执行具体行为，返回 Succeeded/Failed/InProgress。
3. Observer Aborts 四种模式：

None           - 不中止任何正在执行的节点
Self           - 条件变为false时，中止自身所在分支
Lower Priority - 条件变为true时，中止右侧（低优先级）分支
Both           - 同时启用Self和Lower Priority

4. 典型 AI 战斗行为树结构：Selector[战斗/巡逻/待机] → 战斗用 Sequence（Blackboard 条件 + Service 更新目标信息 + 攻击策略 Selector + MoveTo）。

5. 自定义 Task 示例：

EBTNodeResult::Type UBTTask_FindRandomLocation::ExecuteTask(
    UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory)
{
    AAIController* Controller = OwnerComp.GetAIOwner();
    if (!Controller || !Controller->GetPawn()) return EBTNodeResult::Failed;

    FVector Origin = Controller->GetPawn()->GetActorLocation();
    FNavLocation ResultLocation;
    UNavigationSystemV1* NavSys = UNavigationSystemV1::GetCurrent(GetWorld());
    if (NavSys && NavSys->GetRandomReachablePointInRadius(Origin, SearchRadius, ResultLocation))
    {
        OwnerComp.GetBlackboardComponent()->SetValueAsVector(
            LocationKey.SelectedKeyName, ResultLocation.Location);
        return EBTNodeResult::Succeeded;
    }
    return EBTNodeResult::Failed;
}

6. 易错点：行为树是事件驱动而非每帧遍历全树；UBTTaskNode::AbortTask() 用于被中止时清理；支持 SubTree 节点模块化复用。

考点： Selector执行流、优先级设计、行为树组合逻辑

参考答案：

1. Selector 核心逻辑：按优先级从左到右尝试子节点，遇到第一个成功的即返回成功，全部失败则返回失败。
2. 执行流程：

1. 激活第一个子节点
2. 子节点返回Success → Selector立即返回Success（不再执行后续）
3. 子节点返回Failure → 激活下一个子节点
4. 全部Failure → Selector返回Failure
5. 子节点返回InProgress → Selector返回InProgress，等待完成

3. 与 Sequence 的本质区别：Selector 是 OR（"做什么"选择最佳行为）；Sequence 是 AND（"怎么做"按步骤执行）。

4. 优先级决策示例：Selector[战斗 > 逃跑 > 求援 > 巡逻 > 待机]，每个分支用 Decorator（BB 条件）控制是否可进入，左侧优先级最高。

5. 动态优先级可自定义 Decorator 实现：

class UBTDecorator_DynamicPriority : public UBTDecorator
{
public:
    virtual bool CalculateRawConditionValue(
        UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const override
    {
        UBlackboardComponent* BB = OwnerComp.GetBlackboardComponent();
        if (!BB) return false;
        float ThreatLevel = BB->GetValueAsFloat(ThreatLevelKey.SelectedKeyName);
        return ThreatLevel > BasePriority; // 威胁越高，此分支越优先
    }
};

6. 易错点：Selector 左侧节点被频繁评估有性能开销，可结合 Observer Aborts 优化不必要的分支执行。

考点： Sequence执行流、InProgress处理、错误恢复设计

参考答案：

1. Sequence 核心逻辑：按顺序执行所有子节点，所有成功才成功，遇第一个失败即失败。
2. 执行状态机：

1. 从第一个子节点开始执行
2. Success → 记忆进度，激活下一个子节点
3. Failure → Sequence立即返回Failure
4. InProgress → Sequence返回InProgress，下一Tick从该子节点继续（不会重新开始）
5. 全部Success → 返回Success

3. 关键：Sequence 会记忆执行进度，InProgress 的子节点不会导致从头执行；进度存储在 NodeMemory 中。
4. 多步骤示例：Sequence[搜索→接近→攻击]，其中 MoveTo 返回 InProgress 直到到达。
5. 优雅降级：自定义 Task 内做多级回退：

EBTNodeResult::Type UBTTask_SearchWithFallback::ExecuteTask(...)
{
    // 优先搜索小范围
    if (NavSys->GetRandomReachablePointInRadius(Origin, PrimarySearchRadius, Result))
    { /* 写入黑板，返回Succeeded */ }
    // 降级：扩大搜索范围
    if (NavSys->GetRandomReachablePointInRadius(Origin, FallbackSearchRadius, Result))
    { /* 写入黑板，返回Succeeded */ }
    return EBTNodeResult::Failed; // 最终失败
}

6. Abort 清理：AbortTask() 中停止移动并清理黑板临时数据，返回 EBTNodeResult::Aborted。ForceSuccess 装饰器可将 Failure 转 Success 实现可选步骤。

考点： Observer Aborts、行为树事件驱动、优先级打断

参考答案：

1. Observer Aborts 使行为树从"轮询式"变为"事件驱动式"，提升响应效率。
2. 四种模式行为：

None（默认）        - 不观察变化，条件变false当前分支也继续执行
Self               - 条件从true变false时，中止当前Decorator所在分支
Lower Priority     - 条件从false变true时，中止右侧（低优先级）分支
Both               - 同时启用Self和Lower Priority（最灵活也最消耗性能）

3. 典型场景：巡逻中检测到敌人 → BB[HasEnemy] false→true → Lower Priority 中止巡逻分支 → 立即进入战斗分支。
4. 紧急打断示例（检测爆炸物立即逃跑）：

UBTDecorator_HasExplosiveNearby::UBTDecorator_HasExplosiveNearby()
{
    // 关键：检测到爆炸物时打断所有低优先级行为
    FlowAbortMode = EBTFlowAbortMode::LowerPriority;
    bNotifyBecomeRelevant = true;
    bNotifyTick = true;
}

bool UBTDecorator_HasExplosiveNearby::CalculateRawConditionValue(
    UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) const
{
    // OverlapMultiByChannel 检测附近的 AExplosiveActor
    // 命中且已激活 → 写入黑板 ExplosiveLocationKey → 返回 true
    return true; // 找到爆炸物
}

Root
└── Selector
    ├── Sequence [紧急逃跑] ← 最高优先级（Decorator: HasExplosiveNearby, Lower Priority）
    ├── Sequence [战斗]（Decorator: HasEnemy, Both）
    ├── Sequence [巡逻]
    └── Task: Idle

5. 性能注意：每个设了 Observer Aborts 的 Decorator 都会注册黑板 Key 观察者；避免在高频变化的 Key 上设置；复杂条件放 Service，Decorator 只做简单黑板检查。

考点： Service机制、Tick频率控制、性能优化

参考答案：

1. Service 是挂载在组合节点上的后台执行节点，组合节点活动期间按频率执行，用于更新黑板数据、监控环境。
2. 执行时机：
   • 组合节点激活 → OnBecomeRelevant()；
   • 活动期间 → 按 TickInterval 调 TickNode()；
   • 去激活 → OnCeaseRelevant()。
3. 与 Actor Tick 对比：

4. 自定义 Service：

UBTService_UpdateCombatInfo::UBTService_UpdateCombatInfo()
{
    Interval = 0.5f;          // 默认0.5秒更新一次
    RandomDeviation = 0.1f;   // 随机偏移，避免所有AI同帧更新（帧峰值）
}

void UBTService_UpdateCombatInfo::TickNode(...)
{
    // 读取 TargetActor → 计算 Distance 写入黑板
    // 综合距离/血量/敌方数量计算 ThreatLevel 写入黑板
    // 判断 ShouldFlee 条件
}

5. Tick 频率选择：
   • 高频（0.1-0.3s）：战斗目标追踪、精确距离判断、少量AI；
   • 中频（0.5-1.0s）：环境感知更新、威胁评估（默认选择）；
   • 低频（1.0-3.0s）：巡逻路线检查、非关键信息更新。
6. 易错点：RandomDeviation 用于打散更新帧，防止大规模 AI 同帧产生帧峰值。

考点： 行为树蓝图集成、蓝图Task/Decorator/Service、跨系统通信

参考答案：

1. 蓝图创建自定义 Task：新建蓝图父类选 BTTaskNode，实现 ExecuteTask（返回 Succeeded/Failed/InProgress），Latent 执行返回 InProgress 并绑定完成回调后调 FinishLatentTask；实现 AbortTask 处理中止。
2. 蓝图创建自定义 Decorator：父类选 BTDecorator，实现 CalculateRawConditionValue（返回 true/false），设置 FlowAbortMode。
3. 蓝图创建自定义 Service：父类选 BTService，实现 TickNode，设置 Interval/RandomDeviation。
4. 在 C++ Task 中调用蓝图逻辑：

UCLASS()
class UBTTask_CallBlueprintFunction : public UBTTaskNode
{
    GENERATED_BODY()
public:
    // 蓝图可实现的接口
    UFUNCTION(BlueprintImplementableEvent, Category = "AI")
    EBTNodeResult::Type ExecuteBlueprintTask(AAIController* Controller, UBlackboardComponent* Blackboard);

    virtual EBTNodeResult::Type ExecuteTask(
        UBehaviorTreeComponent& OwnerComp, uint8* NodeMemory) override
    {
        return ExecuteBlueprintTask(OwnerComp.GetAIOwner(),
            OwnerComp.GetBlackboardComponent());
    }
};

5. 使用 Blueprint Interface（BlueprintNativeEvent）在 Task 中通过 Cast<IAIBehaviorInterface>(Pawn) + Execute_ShouldAttack(Pawn) 调用蓝图实现。
6. 蓝图与黑板交互：通过 AIController/BTComponent 的 GetBlackboardComponent() 读写黑板；用 Register Observer 监听黑板变化。
7. 易错点：区分 BlueprintImplementableEvent（仅蓝图实现）与 BlueprintNativeEvent（C++ 默认实现 + 蓝图可覆盖）；SubTree 节点可跨资产引用实现模块化。

考点： 黑板架构、数据类型、KeySelector、运行时数据管理

参考答案：

1. 黑板是行为树的共享数据存储（Key-Value Store），行为树负责"决策逻辑"，黑板负责"决策依据"；每个 AIController 拥有独立黑板实例。
2. 支持的数据类型：Bool、Int、Float、String、Name、Vector、Rotator、Enum、Class、Object、Struct。
3. C++ 读写：

UBlackboardComponent* BB = AIController->GetBlackboardComponent();
// 写入
BB->SetValueAsBool(TEXT("HasTarget"), true);
BB->SetValueAsObject(TEXT("TargetActor"), EnemyActor);
BB->SetValueAsVector(TEXT("LastKnownLocation"), TargetLocation);
// 用 KeyID 写入性能更优（跳过名称查找）
FBlackboard::FKey KeyID = BB->GetKeyID(TEXT("HasTarget"));
BB->SetValue<bool>(KeyID, true);
// 读取
bool bHasTarget = BB->GetValueAsBool(TEXT("HasTarget"));
AActor* Target = Cast<AActor>(BB->GetValueAsObject(TEXT("TargetActor")));
// 观察变化
BB->RegisterObserver(BB->GetKeyID(TEXT("HasTarget")), this,
    FOnBlackboardChangeNotification::CreateUObject(this, &AMyAIController::OnBlackboardValueChanged));

4. FBlackboardKeySelector 提供类型安全的 Key 引用，构造函数中用 AddObjectFilter/AddVectorFilter 过滤可选类型。
5. 关系：Decorator 读黑板做条件判断；Service 写黑板更新数据；Task 读写黑板执行行为。
6. 易错点：黑板数据默认不复制到客户端；UBlackboardData 可设 Parent 实现继承；大量 AI 实例时关注黑板内存占用。

考点： KeySelector、类型安全、黑板观察者模式

参考答案：

1. FBlackboardKeySelector 是用于在编辑器中选择黑板 Key 的结构体，提供类型过滤、运行时解析和类型安全访问。
2. 类型过滤：

UBTTask_MyTask::UBTTask_MyTask()
{
    TargetKey.AddObjectFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MyTask, TargetKey), AActor::StaticClass());
    TargetKey.AddVectorFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MyTask, TargetKey));
    TargetKey.AddEnumFilter(this, GET_MEMBER_NAME_CHECKED(UBTTask_MyTask, TargetKey), StaticEnum<EMyAIState>());
}

3. 运行时类型安全访问：

FVector Location = BB->GetValueAsVector(TargetKey.SelectedKeyName);
UObject* Object = BB->GetValueAsObject(TargetKey.SelectedKeyName);
BB->SetValueAsVector(TargetKey.SelectedKeyName, NewLocation);

// 底层：FBlackboard::FKey 直接访问，避免字符串查找
FBlackboard::FKey KeyID = BB->GetKeyID(TargetKey.SelectedKeyName);
if (KeyID != FBlackboard::InvalidKey)
{
    float Value = BB->GetValue<UBlackboardKeyType_Float>(KeyID);
}

4. 监听黑板值变化：

FBlackboard::FKey TargetKeyID = BB->GetKeyID(TEXT("TargetActor"));
BB->RegisterObserver(TargetKeyID, this,
    FOnBlackboardChangeNotification::CreateUObject(this, &AMyAIController::OnTargetChanged));

EBlackboardNotificationResult OnTargetChanged(
    const UBlackboardComponent& BB, FBlackboard::FKey ChangedKeyID)
{
    UObject* NewTarget = BB.GetValue<UBlackboardKeyType_Object>(ChangedKeyID);
    // 处理目标变化/丢失
    return EBlackboardNotificationResult::ContinueObserving; // 或 RemoveObserver
}

5. 易错点：EndPlay 中 UnregisterObserversFrom(this) 清理观察者；Key 的 InstanceSynced 控制是否多 AI 实例同步；可运行时 RegisterKey() 动态添加 Key。

考点： EQS架构、Generator/Test/Context、评分机制、AI决策辅助

参考答案：

1. EQS 是空间决策系统：通过生成候选点/对象，经多项测试评分筛选，选出最优解。
2. 核心概念：
   • Generator（生成器）：生成候选点，内置 Points: Grid/Ring/Donut/On NavMesh、Actors Of Class 等；
   • Test（测试）：对候选 Item 评分或过滤，内置 Distance、Trace、PathFinding、Dot、GameplayTag；模式分 Filter（过滤）与 Score（打分）；
   • Context（上下文）：测试的参考点，如 Querier、EnvQueryContext_Item；
   • Query（查询）：组合 Generator + 多个 Test，执行流程为 生成→过滤→评分→返回最高分 Item。
3. 寻找最佳掩体位置的示例配置：Generator（Points Grid 投影到 NavMesh）+ Trace Filter（可达性/射击线）+ Trace Filter（敌人看不到我）+ Distance Score（钟形曲线适中距离）+ PathFinding Score（路径越短分越高）。
4. C++ 执行查询：

FEnvQueryRequest Request(FindCoverQuery, this);
Request.Execute(EEnvQueryRunMode::SingleResult,
    FQueryFinishedSignature::CreateUObject(this, &AMyAIController::OnCoverQueryFinished));

void AMyAIController::OnCoverQueryFinished(
    UEnvQueryInstanceBlueprintWrapper* QueryInstance, EEnvQueryStatus::Type QueryStatus)
{
    if (QueryStatus != EEnvQueryStatus::Success) return;
    TArray<FVector> Results;
    QueryInstance->GetAllAsLocations(Results);
    if (Results.Num() > 0)
    {
        GetBlackboardComponent()->SetValueAsVector(TEXT("CoverLocation"), Results[0]);
    }
}

5. 自定义 Test 继承 UEnvQueryTest，重写 RunTest，用 FEnvQueryInstance::ItemIterator 遍历并调用 It.FinishTest / It.SetScore。
6. 易错点：Trace 类 Test 的 Cost 较高；可用 EQS Testing Pawn 可视化调试；行为树 Task 中通过 RunEQSQuery 节点调用。

考点： EQS Generator、点生成策略、空间查询

参考答案：

1. Generator 是 EQS 的数据源，负责生成一组待评估的位置或 Actor，输出被 Test 评估筛选。
2. 内置类型：Points Along Line、Points in Circle、Points in Grid、Points on Path、Simple Grid、Donut、Actors of Class、On NavMesh。
3. Generator 可生成两种数据：FVector（位置点，用 AddItemData<FVector>）或 UObject*（Actor，用 AddItemData<AActor*>）。
4. 自定义螺旋点 Generator：

UCLASS()
class UEQSGenerator_SpiralPoints : public UEnvQueryGenerator
{
    GENERATED_BODY()
public:
    virtual void GenerateItems(FEnvQueryInstance& QueryInstance) const override;
    // 参数：FAIDataProviderFloatValue SpiralRadius; FAIDataProviderIntValue SpiralTurns; PointsPerTurn; HeightOffset;
};

void UEQSGenerator_SpiralPoints::GenerateItems(FEnvQueryInstance& QueryInstance) const
{
    AActor* QuerierActor = Cast<AActor>(QueryInstance.Owner.Get());
    if (!QuerierActor) return;

    FVector Origin = QuerierActor->GetActorLocation();
    float Radius = SpiralRadius.GetValue();
    int32 Turns = SpiralTurns.GetValue();
    int32 PPT = PointsPerTurn.GetValue();

    int32 TotalPoints = Turns * PPT;
    TArray<FVector> GeneratedPoints;
    GeneratedPoints.Reserve(TotalPoints);

    for (int32 i = 0; i < TotalPoints; ++i)
    {
        float Progress = static_cast<float>(i) / TotalPoints;
        float Angle = Progress * Turns * 2.0f * PI;
        float CurrentRadius = Progress * Radius;

        FVector Point;
        Point.X = Origin.X + FMath::Cos(Angle) * CurrentRadius;
        Point.Y = Origin.Y + FMath::Sin(Angle) * CurrentRadius;
        Point.Z = Origin.Z + FMath::FRandRange(-HeightOffset.GetValue(), HeightOffset.GetValue());
        GeneratedPoints.Add(Point);
    }
    QueryInstance.AddItemData<FVector>(MoveTemp(GeneratedPoints));
}

5. 易错点：ShouldUseProjection() 控制是否投影到导航网格；多个 Generator 输出可合并或取交集；大量点生成时用异步查询避免卡顿。

考点： EQS Test、评分机制、多Test组合、掩体评估

参考答案：

1. Test 是 EQS 的评估层，对 Generator 生成的每个 Item 进行筛选或评分，最终选出最优结果。
2. 两种模式区别：
   • Filter：排除不满足条件的 Item，结果为布尔（通过/不通过），通常先于 Score 执行减少评分数；
   • Score：为通过筛选的 Item 打分（浮点数），多个 Score 按权重加权组合。
3. 评估流程：生成 N 个 → Filter 排除 → 剩余 M 个 → 各 Score Test 加权求和 → 选择最高分（或前 N 个）。
4. 寻找最佳掩体位置设计：

Generator: Points in Circle (半径1500, 间距100)
Tests:
  [Filter] NavMesh Path Distance < 2000
  [Filter] Trace to Enemy (Line of Sight) == blocked
  [Score]  Distance to Self (Inverse, Weight: 0.3)
  [Score]  Distance to Enemy (Weight: 0.2)
  [Score]  Distance to Nearest Wall (Weight: 0.3)
  [Score]  Dot: Forward to Enemy (Weight: 0.2)

5. 自定义 Test：

void UEQSTest_CoverQuality::RunTest(FEnvQueryInstance& QueryInstance) const
{
    for (FEnvQueryInstance::ItemIterator It(this, QueryInstance); It; ++It)
    {
        FVector ItemLocation = GetItemLocation(QueryInstance, It.GetIndex());
        float CoverScore = 0.0f;
        int32 BlockedDirections = 0;
        // 向 N 个方向做短射线检测，统计被阻挡方向比例作为掩体质量
        // 被阻挡方向越多，掩体质量越高
        if (TestMode == EEnvTestCoverQuality::Filter)
        {
            It.SetScore(TestPurpose, FilterContext, CoverScore > 0.3f ? 1.0f : 0.0f);
        }
        else
        {
            It.SetScore(TestPurpose, FilterContext, CoverScore);
        }
    }
}

6. 易错点：RunMode 决定返回 SingleBest / Top5Percent / AllMatching；FloatValueMin/Max 用于归一化评分；EEnvTestPurpose 的 Filter 与 Score 可在同一 Test 中同时启用。

考点： NavMesh生成、NavMeshBoundsVolume、Nav Modifier、动态障碍物、路径跟随

参考答案：

1. 导航基于 Recast & Detour 库。生成流程：NavMeshBoundsVolume 定义范围 → 体素化 → 高度场分析 → 区域标记 → 轮廓提取 → 多边形网格化 → Detour A* 寻路。
2. 关键组件：UNavigationSystemV1（单例）、ANavMeshBoundsVolume（烘焙范围）、ARecastNavMesh（数据与配置）。
3. Nav Modifier Volume 修改局部导航属性（无需重新烘焙）：NavArea_Null 不可行走、NavArea_LowHeight 低矮区域；自定义 NavArea 可设 DefaultCost 影响 AI 偏好：

UCLASS()
class UNavArea_Water : public UNavArea
{
    GENERATED_BODY()
public:
    UNavArea_Water()
    {
        DefaultCost = 2.0f; // 代价越高，AI 越不倾向走这里
        DrawColor = FColor::Blue;
    }
};

4. 动态障碍物：UNavModifierComponent 附加到移动 Actor 上，通过 SetAreaClass(UNavArea_Null::StaticClass()) 动态开关阻挡。
5. 运行时修改导航：NavModifierComponent（推荐，自动更新）；UNavigationInvokerComponent（玩家驱动动态生成）；NavSys->Build() 强制重建；ProjectPointToNavigation() 查找最近可行走点。
6. 路径跟随（MoveTo）：

void AMyAIController::MoveToTarget(FVector TargetLocation)
{
    FAIMoveRequest MoveRequest;
    MoveRequest.SetGoalLocation(TargetLocation);
    MoveRequest.SetAcceptanceRadius(50.0f);
    MoveRequest.SetUsePathfinding(true);
    MoveRequest.SetAllowPartialPath(true);
    MoveRequest.SetCanStrafe(true);
    MoveTo(MoveRequest);
}

7. 易错点：OnMoveCompleted 中通过 Result.IsSuccess()/IsInterrupted() 区分结果；UE5 支持多种 Agent 配置（不同大小 AI 用不同 NavData）。

考点： NavMesh生成、导航配置、动态修改、Navigation Modifier

参考答案：

1. NavMesh 生成流程（Recast 算法）：体素化 → 区域标记 → 轮廓提取 → 多边形网格生成 → 细节网格生成（高度信息）。
2. Agent 配置（Project Settings 中 +Agents）：每个 Agent 类型（Name/Radius/Height/bCanCrouch 等）生成独立 NavMesh；FNavAgentProperties 定义 Agent 的 Radius/Height。
3. 区域标记：通过自定义 Area 类型（Default/Water/Lava/Restricted）并设置行走代价（Cost=1.0 正常、10.0 极力避免），结合 NavModifierVolume 标记区域。
4. 运行时动态修改方式：
   • NavModifierVolume（常用，编辑器放置或运行时 SpawnActor）；
   • UNavMeshObstacleComponent 动态障碍物（CarvingMode: All/DynamicOnly/StaticOnly）；
   • Tile 局部更新：NavSys->OnNavigationBoundsUpdated(UpdateBounds) 触发局部重建（性能优于全局 Build）。
5. NavMesh 与 Nav Modifier 关系：Nav Modifier（Volume/Component）在 NavMesh 基础上覆盖/修改局部区域的行走代价或可行性，无需重新完整烘焙。
6. 性能优化：合理 Tile 大小（默认200）；控制 Agent 类型数量；用局部更新代替全局重建；小物体聚合；异步查询。
7. 易错点：修改 NavModifier 的 AreaClass 后 NavMesh 下一帧自动更新；NavMesh 与 EQS 联动（Generator 只在 NavMesh 上生成点）。

考点： AI移动系统、MoveTo打断、路径跟随、速度控制

参考答案：

1. 移动方式分层：
   • AAIController::MoveToActor()/MoveToLocation()：高层移动，返回 FAIRequestID；
   • UBTTask_MoveTo：行为树内置任务，返回 InProgress 直到到达/失败；
   • UPathFollowingComponent：底层路径跟随（转向、速度、路径点切换）；
   • AddMovementInput()：最底层，需自行实现避障与路径跟随。
2. 正确打断移动：

Controller->StopMovement();   // 直接停止
// 或
UPathFollowingComponent* PathComp = Controller->GetPathFollowingComponent();
PathComp->AbortMove(*Controller, FPathFollowingResultFlags::MovementStop);
// 或
Controller->CancelMoveRequest();

3. 行为树 Task 中正确处理 Abort：ExecuteTask 发起移动请求并注册 OnRequestFinished 回调返回 InProgress；AbortTask 中 StopMovement() 并 RemoveAll(this) 清理回调，返回 EBTNodeResult::Aborted。
4. 路径点跟随：Task 内读取当前索引对应的路径点发起 MoveTo，到达后 FinishLatentTask 并推进索引，全部完成归零索引。
5. 速度控制：

void ControlAISpeed(AAIController* Controller, float DesiredSpeed)
{
    ACharacter* Character = Cast<ACharacter>(Controller->GetPawn());
    if (!Character) return;
    UCharacterMovementComponent* CMC = Character->GetCharacterMovement();
    if (CMC) CMC->MaxWalkSpeed = DesiredSpeed;
}

6. 易错点：SetAllowPartialPath(true) 允许部分路径（目标不可达时移动到最近点）；SetCanStrafe(true) 允许斜向移动；FPathFollowingResult 含详细失败原因。

考点： 寻路优化、路径平滑算法、NavMesh路径质量

参考答案：

1. NavMesh 路径是折线路径（多边形中心点连接），直接跟随会产生锯齿形、多余转向、不贴墙等不自然轨迹。
2. 常用算法：
   • String Pulling / Funnel Algorithm（漏斗算法）：拉直线遇障在切点转折，生成最短可行路径（UE 内置默认）；
   • Bezier 曲线：平滑但可能穿入障碍；
   • Catmull-Rom 样条：经过所有控制点，适合赛车 AI 路径；
   • Line of Sight Smoothing（视线平滑）：检查点间直接视线，有则跳过中间点，实现简单效果好。
3. 自定义视线平滑：

static TArray<FVector> LineOfSightSmooth(const TArray<FVector>& RawPath,
    UWorld* World, ECollisionChannel TraceChannel = ECC_WorldStatic)
{
    if (RawPath.Num() < 3) return RawPath;
    TArray<FVector> SmoothedPath;
    SmoothedPath.Add(RawPath[0]);
    int32 CurrentIndex = 0;
    while (CurrentIndex < RawPath.Num() - 1)
    {
        int32 FarthestVisible = CurrentIndex + 1;
        for (int32 i = CurrentIndex + 2; i < RawPath.Num(); ++i)
        {
            FHitResult Hit;
            if (!World->LineTraceSingleByChannel(Hit, RawPath[CurrentIndex], RawPath[i], TraceChannel))
            {
                FarthestVisible = i; // 直接可见，可跳过中间点
            }
            else break;
        }
        SmoothedPath.Add(RawPath[FarthestVisible]);
        CurrentIndex = FarthestVisible;
    }
    return SmoothedPath;
}

4. 综合方案：先视线平滑去冗余点，再 Catmull-Rom 样条插值平滑转折（FullSmooth）。
5. 在行为树中使用：FindPathSync 取原始路径 → UPathSmoother::FullSmooth 平滑 → 按平滑路径移动。
6. 易错点：平滑后路径需再次验证与 NavMesh 一致（避免穿墙）；大量 Agent 用异步寻路 + 路径缓存优化性能。

考点： AI Perception组件、感知配置、团队系统、事件响应

参考答案：

1. 架构：UAIPerceptionSystem（全局单例）→ UAIPerceptionComponent（挂 AIController，内含 UAISenseConfig_Sight/Hearing/Damage）→ 被感知方挂 UAIPerceptionStimuliSourceComponent 注册刺激源。
2. Sight 配置：

PerceptionComp = CreateDefaultSubobject<UAIPerceptionComponent>(TEXT("PerceptionComp"));
SetPerceptionComponent(*PerceptionComp);

SightConfig = CreateDefaultSubobject<UAISenseConfig_Sight>(TEXT("SightConfig"));
SightConfig->SightRadius = 3000.0f;                    // 视野半径
SightConfig->LoseSightRadius = 3500.0f;                // 丢失视野半径（滞后）
SightConfig->PeripheralVisionAngleDegrees = 45.0f;     // 半视野角度（总90°）
SightConfig->SetMaxAge(5.0f);
SightConfig->DetectionByAffiliation.bDetectEnemies = true;
PerceptionComp->ConfigureSense(*SightConfig);
PerceptionComp->SetDominantSense(UAISense_Sight::StaticClass());
PerceptionComp->OnTargetPerceptionUpdated.AddDynamic(this, &AMyAIController::OnPerceptionUpdated);

3. Hearing：HearingRange + SetMaxAge；声源通过 UAISense_Hearing::ReportNoiseEvent 报告噪声事件。
4. Damage：UAISense_Damage::ReportDamageEvent(World, 受伤者, 伤害来源, 伤害量, 伤害位置, 命中位置)。
5. 事件处理：OnPerceptionUpdated(Actor, Stimulus) 中判断 Stimulus.Type 与 WasSuccessfullySensed()，更新黑板（TargetActor/LastKnownLocation/NoiseLocation 等）。
6. 团队系统：实现 IGenericTeamAgentInterface（GetGenericTeamId、GetTeamAttitudeTowards），TeamId 255 表示中立。
7. 自定义感知类型：继承 UAISense 重写 Update()，配套继承 UAISenseConfig 重写 GetSenseImplementation()。
8. 易错点：MaxAge 控制刺激持久化；GetCurrentlyPerceivedActors() 获取当前感知到的 Actor；UE5 感知支持多线程更新。

考点： AI感知系统、感知配置、感知事件、团队判断

参考答案：

1. 架构：UAIPerceptionSystem 单例 → UAIPerceptionComponent（含三种 SenseConfig）→ 被感知 Actor 挂 UAIPerceptionStimuliSourceComponent。
2. Sight 视觉锥体关键参数：SightRadius（视野半径）、LoseSightRadius（须大于 SightRadius，丢失视野的滞后半径）、PeripheralVisionAngleDegrees（半角角度）、AutoSuccessRangeFromLastSeenLocation（最后看到位置附近自动成功）。
3. Hearing：HearingRange + MaxAge；声源调用：

UAISense_Hearing::ReportNoiseEvent(GetWorld(),
    FAINoiseEvent(NoiseLocation, Loudness, InstigatorActor, MaxRange));

4. Damage：SetMaxAge(5.0f)；伤害方调用 UAISense_Damage::ReportDamageEvent。
5. 感知更新与丢失处理：

void AMyAIController::OnPerceptionUpdated(AActor* Actor, FAIStimulus Stimulus)
{
    if (Stimulus.Type == UAISense::GetSenseID<UAISense_Sight>())
    {
        if (Stimulus.WasSuccessfullySensed())
        {
            // 更新 TargetActor / LastSeenLocation
        }
        else
        {
            // 丢失视野：清空 TargetActor，保留最后已知位置用于搜索
        }
    }
    else if (Stimulus.Type == UAISense::GetSenseID<UAISense_Hearing>())
    {
        if (Stimulus.WasSuccessfullySensed())
        {
            // 记录 SuspiciousLocation / HeardNoise
        }
    }
}

6. 感知源组件：被感知 Actor 挂 UAIPerceptionStimuliSourceComponent，BeginPlay 中 RegisterForSense(UAISense_Sight::StaticClass()) 等。
7. 易错点：DetectionByAffiliation 控制检测敌方/中立/友方；批量感知更新可用 Native 版本（传入 TArray<AActor*>）。

考点： 群集算法、RVO避障、Crowd Manager、性能优化

参考答案：

1. Flock（Boids）三规则：Separation（分离）、Alignment（对齐）、Cohesion（聚合），各有权重，可自定义组件计算合力：

FVector UFlockBehaviorComponent::CalculateFlockForce(const TArray<AActor*>& Neighbors)
{
    // 对每个邻居：
    // 分离：距离越近排斥力越大（(MyLocation - NeighborLocation).GetSafeNormal() / Distance）
    // 对齐：累加邻居速度方向（NeighborVelocity.GetSafeNormal()）
    // 聚合：累加邻居位置，最终指向中心（(CenterOfMass - MyLocation).GetSafeNormal()）
    // 三力分别除计数后乘各自权重求和
    return TotalForce;
}

2. UE 内置避障（RVO）：CharacterMovementComponent->SetAvoidanceEnabled(true)，配置 AvoidanceConsiderationRadius、AvoidanceWeight、SetGroupsToAvoid/SetGroupsToIgnore。
3. Crowd Manager（UCrowdManager）管理大规模 AI 移动避障，可在 DefaultEngine.ini 配置 MaxAgents/MaxAgentRadius/NavmeshCheckInterval 等。
4. 性能优化：按距离分档 Tick（PrimaryActorTick.TickInterval）；USignificanceManager 按重要性分配资源；网格/四叉树空间划分避免 O(n²) 邻居搜索。
5. 队形系统：按领导者位置/朝向计算成员偏移（如 V 字形），成员各自 MoveTo 目标偏移点。
6. 易错点：Flock 邻居搜索要避免 O(n²)；远距离 AI 降低 Tick 频率；Mass Entity 是 UE5 大规模 AI 的新方案。

考点： 群体避障、RVO/ORCA算法、Crowd Manager、性能优化

参考答案：

1. 原理：
   • RVO：每个 Agent 不仅承担自己的避障责任，还假设其他 Agent 承担一半；用"速度障碍物"（其他 Agent 位置+速度定义的禁止速度区）选择新速度。
   • ORCA：RVO 的改进，用**半平面（Half-Plane）**代替锥体；每个 Agent 定义其他 Agent 应保持的 ORCA 半平面，最终速度取所有半平面交集中的最优解。
   • 步骤：邻居检测 → 计算 ORCA 半平面 → 求交集 → 选最接近期望速度的解。
2. UE 实现：UCrowdManager 内部使用 Detour Crowd（Recast/Detour 库，RVO2/ORCA）。
3. 配置方式：

UCharacterMovementComponent* CMC = GetCharacterMovement();
CMC->SetCrowdAvoidanceQuality(ECrowdAvoidanceQuality::High);
CMC->CrowdAvoidanceRadius = 50.0f;
CMC->CrowdAvoidanceHeight = 200.0f;
CMC->CrowdAvoidanceGroup = 1;          // 我方阵营
CMC->CrowdAvoidanceMask = 0xFFFFFFFF;  // 避开所有组

4. 避障组：同组 Agent 不互相避障（编队移动）；掩码按位标记需要避开的组。
5. Crowd 参数：VelocityBias、AdaptiveDivisions/Rings/Depth、SeparationWeight、PathOptimizationRange。
6. 性能优化：
   • 限制参与避障的 Agent 数量，远距离禁用 Crowd Avoidance；
   • 分层避障：近距离精确避障、中距离简单速度调整、远距离不避障；
   • 减小 CollisionQueryRange、用低质量 Avoidance Quality。
7. 易错点：避障后的速度会投影回 NavMesh；CrowdManager->GetCrowdAgentData() 可获取调试信息。

考点： 调试工具使用、可视化调试、性能分析

参考答案：

1. Gameplay Debugger（最常用）：' 单引号打开，显示行为树节点状态、黑板值、EQS 查询、感知范围等；项目设置启用 bEnableGameplayDebugger=true。
2. 自定义 Gameplay Debugger 类别：继承 FGameplayDebuggerCategory，CollectData 收集数据 + DrawData 绘制 Canvas 文本，用 SetDataPackReplicate 支持网络复制。
3. Visual Logger（AI Debugger）：代码中用 UE_VLOG、UE_VLOG_LOCATION、UE_VLOG_SEGMENT 记录时间线日志与可视化信息。
4. 常用控制台命令：

ai.debug.bt           # 行为树状态
ai.debug.navmesh      # 显示NavMesh
ai.debug.perception   # 感知范围
ai.debug.sight        # 视觉锥体
ai.debug.hearing      # 听觉范围
show Navigation       # 显示/隐藏NavMesh
ai.debug.eqs          # EQS查询结果
stat AI               # AI性能统计
stat BehaviorTree     # 行为树性能
stat Perception       # 感知系统性能
ai.disable / ai.enable # 禁用/启用所有AI

5. 排查清单：AI 不移动→查 NavMesh/AI Possess/行为树运行/接受半径；不感知目标→查团队ID/DetectionByAffiliation/范围/阻挡；行为树不切分支→查 Observer Aborts/黑板值/条件过滤；性能问题→stat AI 定位各系统耗时。
6. 易错点：行为树编辑器"模拟"模式可在编辑器中测试；UE5 Insights 深入分析 CPU/GPU 性能。

考点： Gameplay Debugger、AI调试、可视化调试

参考答案：

1. 快捷键：' 开/关；数字键切换类别；WASD 移动调试摄像机；Tab 切换目标 Actor。
2. 默认类别：AI（行为树节点/EQS/感知列表/黑板值）、Movement（路径/速度/碰撞）、Perception（感知范围/已感知丢失的 Actor）。
3. 自定义类别：

UCLASS()
class UGameplayDebuggerCategory_AICombat : public UGameplayDebuggerCategory
{
public:
    virtual void CollectData(APlayerController* OwnerPC, AActor* DebugActor) override;
    virtual void DrawData(APlayerController* OwnerPC,
        FGameplayDebuggerCanvasContext& CanvasContext) override;
    static TSharedRef<UGameplayDebuggerCategory> MakeInstance();
    // FDebugData 存 CurrentState/HealthPercent/ThreatLevel/TargetName 等
};

void UGameplayDebuggerCategory_AICombat::DrawData(...)
{
    CanvasContext.Printf(TEXT("{yellow}State: {white}%s"), *Data.CurrentState);
    CanvasContext.Printf(TEXT("{green}Health: {white}%.1f%%"), Data.HealthPercent * 100.0f);
    // 可在世界坐标 DrawWireSphere 绘制位置信息
}

// 注册类别（模块启动时）
IGameplayDebugger& Debugger = IGameplayDebugger::Get();
Debugger.RegisterCategory("AICombat",
    IGameplayDebugger::FOnGetCategory::CreateStatic(&UGameplayDebuggerCategory_AICombat::MakeInstance),
    EGameplayDebuggerCategoryState::EnabledInGameAndSimulate);

4. 行为树调试：行为树编辑器运行时打开资产可看实时执行流程（绿色执行/灰色未执行/红色中止），可手动设置黑板值。
5. 感知调试：显示视觉锥体（绿扇）、听觉范围（蓝圆）；被感知绿色标记、最后已知位置黄色、丢失红色；Log LogAIPerception Verbose 查看事件日志。
6. 易错点：EGameplayDebuggerCategoryState 控制类别可见性；可通过 GameplayDebugger.ini 配置默认启用类别。

考点： AI与动画集成、AnimNotify、Root Motion、状态机

参考答案：

1. 行为树 Task 播放蒙太奇并等待完成：

EBTNodeResult::Type UBTTask_PlayAttackMontage::ExecuteTask(...)
{
    // 播放 Montage_Play，返回 InProgress
    // 绑定 OnMontageEnded → FinishLatentTask(Succeeded/Failed)
    return EBTNodeResult::InProgress;
}

void UBTTask_PlayAttackMontage::AbortTask(...)
{
    // 被中止时 Montage_Stop(0.2f) 停止动画
    Super::AbortTask(OwnerComp, NodeMemory);
}

2. AnimNotify 与 AI 交互：
   • UAnimNotify（一次性）：在动画特定帧执行逻辑（如 SweepMultiByChannel 做攻击判定并 ApplyDamage）；
   • UAnimNotifyState（持续性）：NotifyBegin/NotifyEnd 控制攻击碰撞窗口开关。
3. 根运动处理：Root Motion 期间暂停路径跟随（PathComp->PauseMove()），播放含根运动的蒙太奇，结束后恢复；用 Motion Warping 可在根运动中动态调整目标位置。
4. 动画蓝图集成：UAnimInstance 的 NativeUpdateAnimation 每帧读取 Pawn 速度与黑板值（Speed/HasTarget/IsAttacking），驱动动画状态机切换。
5. 易错点：蒙太奇被中断（bInterrupted）应返回 Failed；动画预算分配器（Animation Budget Allocator）优化大量 AI 动画性能；UE5 Chooser 系统可替代传统 AnimNotify 做更灵活动画选择。

考点： AI网络架构、服务器权威、客户端预测、延迟补偿

参考答案：

1. 职责划分：
   • 服务端（权威）：AI Controller 逻辑、行为树执行、决策（感知/寻路/攻击）、黑板更新、伤害计算；
   • 客户端（表现）：动画、特效、声音、UI。
2. 实现：AI Controller bReplicates=false（仅服务端运行），OnPossess/Tick 中 HasAuthority() 判断；AI Character bReplicates=true，用 UPROPERTY(ReplicatedUsing=OnRep_AIState) 复制状态，OnRep 切换客户端动画。
3. 状态同步策略：服务端按间隔同步关键状态（CurrentAIState、TargetActor）；即时事件用 NetMulticast, Unreliable 的 RPC（如 Multicast_OnAIAttack）。
4. 预测与回滚：AI 一般不做客户端预测（不同于玩家），由服务端权威保证一致性；UE5 网络预测插件可能改变 AI 同步方式。
5. 易错点：大量 AI 用"感兴趣集合"（NetCullDistance/Relevancy）优化网络流量；寻路可在客户端本地计算但结果由服务端验证；bAlwaysRelevant=true 需谨慎（大范围复制）。

考点： AI网络同步、服务端权威、状态复制、带宽优化

参考答案：

1. 三种方案：纯服务端 AI（推荐，简单防作弊一致性，延迟高）；客户端预测 AI（响应快需回滚复杂度高）；混合方案（服务端核心逻辑 + 客户端表现逻辑）。
2. 服务端 AI 实现：

void AMyAIController::OnPossess(APawn* InPawn)
{
    Super::OnPossess(InPawn);
    if (HasAuthority())
    {
        if (UseBlackboard(BlackboardAsset, BlackboardComp))
        {
            RunBehaviorTree(BehaviorTreeAsset);
        }
    }
}

UPROPERTY(ReplicatedUsing = OnRep_AIState)
EAIState CurrentAIState;

3. 状态复制方式：
   • 复制关键黑板值（OnRep_HasTarget 等回调里写回客户端黑板）；
   • 复制行为状态枚举（客户端按状态播动画）；
   • DOREPLIFETIME_CONDITION 条件复制（COND_InitialOrOwner/COND_SimulatedOnly）。
4. 带宽优化：只复制影响表现的状态；降低 AI 的 NetUpdateFrequency（如 10Hz，玩家 30-60Hz）+ MinNetUpdateFrequency；设置 NetCullDistanceSquared 距离剔除；用位域打包多个状态到 1-2 字节；关键事件用 RPC 而非属性复制。
5. 客户端预测与回滚：客户端先移动（StartSmoothMove），服务端 ServerConfirmMove 校验，合法则 ClientAcknowledgeMove，否则 ClientRollbackMove 回滚。
6. 易错点：AGameModeBase 只在服务端存在适合管理 AI；AReplicationGraph 优化大量 Actor 复制；Dedicated Server 优先于 Listen Server；客户端用插值平滑 AI 移动。

考点： 性能分析、系统优化、大规模AI管理

参考答案：

1. 行为树优化：
   • 按距离分档设 Tick 间隔（SetTickInterval(0.5/0.1/0.0)）；
   • 远离玩家时 Brain->StopLogic() 暂停，靠近 RestartLogic()；
   • Service 设合理 Interval + RandomDeviation 打散更新帧。
2. 感知系统优化：
   • 远距离禁用昂贵感知（SetSenseEnabled(Sight, false) 只留 Hearing）；
   • 调小感知更新间隔（PerceptionSystemUpdateRate）；
   • DetectionByAffiliation 只检测必要团队。
3. 寻路优化：异步寻路避免阻塞；路径缓存（哈希+时间过期）；限制寻路频率（节流）。
4. 整体架构优化：
   • AI Manager 统一管理，按优先级分配 Tick 预算（每帧限定 AI 总耗时如 2ms）；
   • 集成 USignificanceManager 分 High/Medium/Low 优先级；
   • 昂贵的 EQS 计算放后台线程（StartBackgroundTask）。
5. 性能监控：

DECLARE_STATS_GROUP(TEXT("MyAI"), STATGROUP_MyAI, STATCAT_Advanced);
DECLARE_CYCLE_STAT(TEXT("AI Tick"), STAT_AITick, STATGROUP_MyAI);
void AMyAIController::Tick(float DeltaTime)
{
    SCOPE_CYCLE_COUNTER(STAT_AITick);
    Super::Tick(DeltaTime);
}

6. 易错点：stat AI/BehaviorTree/Perception/NavMesh 定位瓶颈；UE5 Mass Entity 提供 ECS 方案；用 LOD 思想管理 AI 复杂度。

考点： AI性能优化、性能分析、大规模AI管理

参考答案：

1. 行为树优化：Service 控制更新频率（0.5s + 随机偏差）；用 Observer Aborts 替代轮询；行为树 LOD（远处用简化行为树）；复杂计算放 Service 或异步 Task。
2. 感知优化：控制 MaxAge 与感知范围；团队过滤（不检测友方）；分层感知（远处禁用/中距离缩小范围/近处完整）。
3. 寻路优化：路径缓存（TMap + 有效性检查）；FindPathAsync 异步寻路；限制同时寻路的 AI 数量（MaxConcurrentPathfinds）。
4. 大规模 AI 管理：
   • 分帧更新：每帧只更新一部分 AI（CurrentUpdateIndex 轮转）；
   • 距离分档更新频率（SetActorTickInterval）；
   • Object Pool 复用 AIController（隐藏 + 停 Tick + 回收复用）。
5. 性能分析工具：
   • Unreal Insights（-trace=cpu,game）查看 AI Tick 时间、识别高耗 AI；
   • stat game / stat ai / stat navigation 查看统计；
   • Profiler（Session Frontend）查看函数调用栈；
   • 自定义计数器追踪活跃 AI 数、行为树节点执行次数、寻路请求次数。
6. 易错点：BrainComponent->StopLogic() 可完全停止 AI 决策；用简化碰撞体（Capsule）做感知检测而非完整 Mesh。

考点： 系统设计能力、行为树架构、多系统协作、工程实践

参考答案：

1. 架构总览：AIController 组合 Perception Component + Behavior Tree Component + Path Following Component，三者读写共享的 Blackboard Component（Key：TargetActor/TargetLocation/AIState/PatrolPoint/HomeLocation/LastKnownLocation/HasTarget/ShouldSearch/AmmoCount）。
2. 行为树结构：

Root
└── Selector [主决策]
    ├── Sequence [战斗]   Decorator: HasTarget (Lower Priority) + Service: CombatService
    │     ├── Selector [近战(Distance<200+Cooldown) / 远程(弹药+EQS找掩体+攻击) / 换弹近战]
    │     └── Task: MoveTo (TargetActor) [追击]
    ├── Sequence [搜索]   Decorator: ShouldSearch (Lower Priority)
    │     └── 最后已知位置搜索 / 随机搜索
    └── Sequence [巡逻]   Service: PatrolService → GetNextPatrolPoint → MoveTo → Wait

3. 关键 Service（CombatService，Interval=0.5s）：更新距离、LineOfSightTo 检查视线；失去视线累计超 3s → 保存 LastKnownLocation、置 ShouldSearch、清空 TargetActor；有视线则更新 LastKnownLocation 并清零计时。
4. 状态流转：巡逻 →（发现敌人）→ 战斗 →（击杀）→ 巡逻；战斗 →（失去视线超时）→ 搜索 →（超时/无线索）→ 巡逻；搜索 →（重新发现）→ 战斗。
5. GameMode 管理 AI 生成：BeginPlay 延迟 1s 等待 NavMesh 烘焙完成后再 SpawnAIWave。
6. 实现要点：用 Observer Aborts: Lower Priority 实现高优先级打断低优先级；状态切换通过黑板值驱动而非硬编码；考虑性能（多 AI 时 Service 频率与感知开销）。
7. 易错点：进阶可用 UAIMessageSubsystem 实现 AI 间通信；考虑 AI"记忆"（多目标位置）与"个性"参数（不同 AI 不同行为参数）。

考点： AI设计模式、FSM实现、行为树与状态机的混合使用

参考答案：

1. 对比：

2. FSM 核心实现（状态基类 + 状态机管理器）：

UCLASS(Abstract)
class UAIBaseState : public UObject
{
    GENERATED_BODY()
public:
    virtual void Enter(AAIController* Controller) {}
    virtual void Update(AAIController* Controller, float DeltaTime) {}
    virtual void Exit(AAIController* Controller) {}
    virtual UAIBaseState* CheckTransitions(AAIController* Controller) { return nullptr; }
    virtual FString GetStateName() const { return TEXT("Base"); }
};

UCLASS()
class UAIFiniteStateMachine : public UObject
{
    // RegisterState / SetInitialState(调用Enter) /
    // Update：CheckTransitions → 需要则 TransitionTo；再 Update 当前状态
    // TransitionTo：Exit旧状态 → 记录PreviousState → Enter新状态
};

3. 具体状态（如 UAIPatrolState）：Enter 设置巡逻路径；Update 移向下一点；CheckTransitions 中读黑板 HasEnemy 为真时切到 Combat。
4. 混合式架构：状态机管理宏观状态（Patrol/Combat/Flee），每个状态内 RunBehaviorTree(对应行为树) 处理微观决策；AIController BeginPlay 注册状态、Tick 驱动 StateMachine->Update(DeltaTime)。
5. 易错点：层次状态机（HFSM）解决状态爆炸；行为树 Selector+Decorator 本质是隐式状态机；动画状态机（AnimGraph StateMachine）就是 FSM 典型应用；可用 Gameplay Tags 映射 FSM 状态配合 GAS。

考点： ECS核心概念、数据导向设计（DOD）、与Actor-Component的对比

参考答案：

1. ECS 三要素：
   • Entity：唯一标识符（ID），无数据无行为；
   • Component：纯数据容器，同类组件连续内存存储（关键）；
   • System：纯行为/逻辑，处理拥有特定组件组合的实体。
2. UE 传统 Actor-Component：组件"智能"（数据+行为一体），每个 Actor 独立堆分配，面向对象设计。
3. 本质区别：

4. 为什么更快——缓存局部性：Actor 遍历 1000 个 Health 每次跳跃访问易缓存未命中；ECS 的 Health[0..999] 连续存储，CPU 预取 + SIMD 批量处理，性能差距可达 10x-100x。
5. UE 传统方式性能问题：每个 Actor 是 UObject 有 GC 开销；Tick 虚函数调用无法内联；内存碎片导致缓存未命中。
6. 易错点：能说出具体内存布局差异而非泛泛说"ECS 更快"；关键概念 SoA（Struct of Arrays）vs AoS（Array of Structs）。

考点： Mass Entity架构设计、Fragment/Processor/Chunk概念、内存管理

参考答案：

1. 核心概念：Entity（FEntityHandle = ID + Generation）；Fragment（纯数据，继承 FMassFragment）；Tag（无数据标记，继承 FMassTag）；Chunk（存储 Fragment 数据的内存块）；Archetype（Fragment 组合的类型签名）；Processor（逻辑执行单元，对应 System）。
2. Fragment 定义：

USTRUCT()
struct FTransformFragment : public FMassFragment
{
    GENERATED_BODY()
    FTransform Transform;
};

USTRUCT()
struct FEnemyTag : public FMassTag { GENERATED_BODY() }; // 仅标记

3. Archetype 与 Chunk：同一 Fragment 组合的实体共享同一 Archetype 并连续存储；Chunk 内 Fragment 按类型 SoA 连续排布（如 FTransformFragment[128]、FVelocityFragment[128]）；典型 Chunk 大小 16KB，可存实体数 = Chunk大小/各Fragment大小和。
4. Processor：

UCLASS()
class UMovementProcessor : public UMassProcessor
{
    GENERATED_BODY()
public:
    virtual void ConfigureQueries() override
    {
        MovementQuery.AddRequirement<FTransformFragment>(EMassFragmentAccess::ReadWrite);
        MovementQuery.AddRequirement<FVelocityFragment>(EMassFragmentAccess::ReadOnly);
        MovementQuery.AddExcludeRequirement<FDeadTag>(); // 排除已死亡
    }

    virtual void Execute(FMassEntityManager& EntityManager, FMassExecutionContext& Context) override
    {
        MovementQuery.ForEachEntityChunk(EntityManager, Context,
            [&](FMassExecutionContext& Context)
            {
                auto Transforms = Context.GetMutableFragmentView<FTransformFragment>();
                auto Velocities = Context.GetFragmentView<FVelocityFragment>();
                const int32 NumEntities = Context.GetNumEntities();
                const float DeltaTime = Context.GetDeltaTimeSeconds();
                for (int32 i = 0; i < NumEntities; ++i)  // 连续内存批量处理，SIMD友好
                {
                    Transforms[i].Transform.AddToTranslation(Velocities[i].Velocity * DeltaTime);
                }
            });
    }
};

5. 数据流：MassEntitySubsystem 遍历已注册 Processor → 按查询条件匹配 Chunk → 批量执行（原地修改无拷贝）；执行顺序由依赖与优先级分 Phase（PrePhysics/Physics/PostPhysics/Async）。
6. Entity 生命周期：CreateEntity(Archetype)/BatchCreateEntities（批量更高效）/DestroyEntity；添加或移除 Fragment 会触发 Archetype 变更，实体被移动到新 Chunk（有开销）。
7. 易错点：不要与 ActorComponent 混为一谈；mass.ChunkSize 可配置 Chunk 大小；Shared Fragment 支持 Chunk 级共享数据。

考点： Mass Entity实战应用、大规模实体管理、性能优化实践

参考答案：

1. 适合场景（大量同质实体）：城市交通（数千车）、人群模拟（数万 NPC）、RTS 单位、子弹/弹幕、碎片掉落、大规模 AI agent、生态系统模拟。
2. 不适合场景：需要复杂渲染/物理交互的主角（用 Actor+SkeletalMesh/Chaos）、网络复制要求高的实体、需要蓝图可视化编辑的少量对象。
3. 实现思路：为实体定义 Fragment（如 FVehicleFragment/FVehiclePathFragment），写 Processor 批量更新（转向插值、速度插值、移动、推进路径点）。
4. 人群模拟避障：先用空间网格（Spatial Hash）构建邻居，再对每个实体按个人空间半径计算排斥力：

// 查询附近实体（空间网格 O(1)）
TArray<FNeighborInfo> Neighbors;
QuerySpatialGrid(MyPos, CrowdAgents[i].PersonalRadius * 3.0f, Neighbors);
// 计算排斥力 = 距离越近力越大（Overlap = PersonalRadius*2 - Distance）

5. 性能对比：10000 个移动 Agent，Actor+AIController 约 15ms/~500MB；Mass Entity 约 1.5ms/~20MB；Mass + LOD 约 0.8ms。关键：批量处理 Chunk、缓存连续、SIMD 友好、无 UObject/GC 开销。
6. Mass Perception：用空间查询 FindEntitiesInRadius + Tag 过滤替代独立 AIPerceptionComponent，O(1) 查询。
7. 易错点：Mass 不是万能药——复杂 AI（行为树+动画+物理）仍需 Actor；可用 Zone Graph 配合大规模导航、State Tree 提供高层决策。

考点： 架构设计决策、Mass Entity与Actor的桥接、数据迁移策略

参考答案：

1. 混合依据：10000 个路人 NPC → Mass Entity；10 个剧情 NPC / 玩家 → Actor；两者各有优势（Mass 高吞吐内存高效，Actor 完整生态与交互）。
2. 架构：GameMode 管理两侧生命周期，中间用 Bridge Layer 做 Mass ↔ Actor 数据同步。
3. 升级（Mass → Actor，如玩家靠近触发对话）：读 Fragment 数据 → SpawnActor → 迁移 Transform/Velocity/初始化数据 → DestroyEntity → 记录映射。
4. 降级（Actor → Mass，如玩家离开恢复"背景行人"）：读 Actor 状态 → CreateEntity → 写 Fragment → Actor->Destroy() → 更新映射。
5. 触发策略：基于距离（Distance < 500 升级）；基于游戏事件（剧情需要）；基于性能（实体过多时降级最远的非关键 Actor）。
6. 注意事项：
   • 转换开销大，避免频繁转换，用缓冲区/滞后区域防抖动（进入 500 升级、离开 700 才降级）；
   • 数据一致性：迁移所有必要数据，处理中间状态；
   • 渲染：Mass 用 ISM，Actor 用 Skeletal Mesh，切换可能有视觉跳变；
   • 网络：需要同步的实体用 Actor；调试：用 mass.debug 命令与 Mass Entity Debugger。
7. 易错点：stat MassEntity 查看各 Processor 耗时；Mass 与导航集成用简化 Zone Graph，Actor 用完整 NavMesh。

考点： Mass Entity、ECS架构、大规模AI、性能优化

参考答案：

1. Mass Entity 是 UE5 的 ECS 框架，核心概念：Entity（轻量标识符，非 Actor、无 GC）、Fragment（纯数据连续存储）、Chunk（同 Fragment 组合连续内存块）、Processor（按查询批量处理、可并行）、Archetype（Fragment 组合签名）。
2. 与传统 Actor-based AI 对比：

3. 用 Mass 实现大量 NPC：定义 AI 相关 Fragment（FAIBehaviorFragment 存状态/目标位置/移动速度、FHealthFragment 存血量），再写 UMassAIBehaviorProcessor：

UCLASS()
class UMassAIBehaviorProcessor : public UMassProcessor
{
    virtual void ConfigureQueries() override
    {
        EntityQuery.AddRequirement<FTransformFragment>(EMassFragmentAccess::ReadWrite);
        EntityQuery.AddRequirement<FMassMovementFragment>(EMassFragmentAccess::ReadWrite);
        EntityQuery.AddRequirement<FAIBehaviorFragment>(EMassFragmentAccess::ReadWrite);
    }
    virtual void Execute(FMassEntityManager& EntityManager, FMassExecutionContext& Context) override
    {
        EntityQuery.ForEachEntityChunk(EntityManager, Context,
            [this](FMassExecutionContext& Context)
            {
                // 批量取 Fragment 视图，遍历按状态机处理：
                // Idle → 随机选巡逻点；Patrol → 朝目标移动（速度写入 Movement.Velocity）；
                // Combat → 战斗逻辑；死亡实体跳过
            });
    }
};

4. 混合使用：重要 AI（Boss、关键 NPC）用传统 Actor，大量普通 AI（市民、士兵）用 Mass Entity；可用 FMassEntityConfig 定义原型并 BatchCreateEntities 批量生成上万个实体。
5. 易错点：ExecutionFlags/ExecutionOrder 控制 Processor 执行时机；FMassEntityQuery 支持过滤子集；MassDebugger 命令与 LOD（远实体降更新频率）用于调试与优化。