游戏 AI / 系统课时
给树接入追击和攻击动作
给树接入追击和攻击动作
这一节把单一巡逻扩展成完整的敌人决策入口:有攻击机会时攻击,能看到目标但距离较远时追击,否则继续巡逻。核心是用 Selector 表达优先级,让高优先级分支成立时自然阻止低优先级行为执行。
学习目标
- 能用 Selector 组织攻击、追击、巡逻三条互斥分支。
- 理解条件节点与动作节点如何组合成可读的决策结构。
- 能验证同一 Tick 中只执行优先级最高且可用的行为。
用 Selector 表达行为优先级
Selector 会从前到后尝试子节点。某个子节点返回 Failure 时继续尝试下一个;遇到 Success 或 Running 时立即停止。因此,把攻击分支放在追击前面、追击放在巡逻前面,就能直接表达“攻击优先于追击,追击优先于巡逻”。
一棵常见的敌人行为树可以组织为:
- Attack Sequence:目标可见且进入攻击距离后执行攻击。
- Chase Sequence:目标可见但当前无法攻击时执行追击。
- Patrol:前两条分支都不可用时作为兜底行为。

这种结构比在一个 Update 方法里连续写多层 if 更容易扩展,因为每个分支的进入条件和动作边界都是显式的。
条件节点只回答能不能执行
条件节点最好只做判断,不直接产生移动、攻击等副作用。例如 TargetVisible 只读取感知数据,InAttackRange 只比较距离。动作节点再负责执行追击或攻击。
这样做有两个好处:一是条件可以被多个分支复用;二是调试时可以明确看到到底是“条件不成立”还是“动作执行失败”。
实现一个可验证的优先级树
下面的纯 C# 示例使用“响应式 Selector”:每次 Tick 都从最高优先级分支重新检查。这样 NPC 在追击过程中一旦进入攻击距离,下一次 Tick 就会先命中攻击分支,而不会被旧的追击状态锁住。
using System;
using System.Collections.Generic;
enum NodeStatus
{
Success,
Failure,
Running
}
interface INode
{
NodeStatus Tick();
}
sealed class Blackboard
{
public bool TargetVisible { get; set; }
public float TargetDistance { get; set; }
}
sealed class Condition : INode
{
private readonly Func<bool> _predicate;
public Condition(Func<bool> predicate)
{
_predicate = predicate;
}
public NodeStatus Tick()
{
return _predicate() ? NodeStatus.Success : NodeStatus.Failure;
}
}
sealed class ActionNode : INode
{
private readonly string _name;
public ActionNode(string name)
{
_name = name;
}
public NodeStatus Tick()
{
Console.WriteLine(_name);
return NodeStatus.Running;
}
}
sealed class Sequence : INode
{
private readonly List<INode> _children;
public Sequence(params INode[] children)
{
_children = new List<INode>(children);
}
public NodeStatus Tick()
{
foreach (var child in _children)
{
var status = child.Tick();
if (status != NodeStatus.Success)
{
return status;
}
}
return NodeStatus.Success;
}
}
sealed class Selector : INode
{
private readonly List<INode> _children;
public Selector(params INode[] children)
{
_children = new List<INode>(children);
}
public NodeStatus Tick()
{
foreach (var child in _children)
{
var status = child.Tick();
if (status != NodeStatus.Failure)
{
return status;
}
}
return NodeStatus.Failure;
}
}
static class Program
{
static void Main()
{
var blackboard = new Blackboard();
var attack = new Sequence(
new Condition(() => blackboard.TargetVisible),
new Condition(() => blackboard.TargetDistance <= 2.0f),
new ActionNode("ATTACK")
);
var chase = new Sequence(
new Condition(() => blackboard.TargetVisible),
new ActionNode("CHASE")
);
var patrol = new ActionNode("PATROL");
var root = new Selector(attack, chase, patrol);
var frames = new[]
{
(visible: false, distance: 8.0f),
(visible: true, distance: 6.0f),
(visible: true, distance: 1.5f),
(visible: true, distance: 4.0f)
};
for (var i = 0; i < frames.Length; i++)
{
blackboard.TargetVisible = frames[i].visible;
blackboard.TargetDistance = frames[i].distance;
var status = root.Tick();
Console.WriteLine($"tick {i + 1}: {status}");
}
}
}预期输出:
PATROL
tick 1: Running
CHASE
tick 2: Running
ATTACK
tick 3: Running
CHASE
tick 4: Running第 1 个 Tick 中,攻击和追击分支都因目标不可见而失败,所以执行巡逻。第 2 个 Tick 目标可见但不在攻击范围内,攻击分支失败,追击分支返回 Running。第 3 个 Tick 条件变为可攻击后,Selector 从头检查并直接选择攻击。
为什么要每次从高优先级重新检查
如果 Selector 记住上一次正在运行的子节点,并在下个 Tick 直接继续追击,那么目标已经进入攻击距离时,攻击分支也可能得不到检查。对于“攻击应随时抢占追击”这类需求,响应式 Selector 更符合语义。
但响应式检查也意味着高优先级条件每个 Tick 都会重新执行。如果条件本身非常昂贵,例如大范围寻路或复杂感知查询,应把昂贵计算放到独立感知系统中缓存,行为树只读取结果,不要把重计算直接塞进条件节点。
避免优先级写反和条件重叠
分支顺序就是策略。如果把追击放在攻击前面,只要目标可见,追击就返回 Running,攻击分支永远不会执行。另一个常见问题是条件过于宽泛,例如攻击分支只判断 TargetVisible,同样会长期吞掉后面的追击分支。
实际项目中可以给攻击分支继续补充冷却、朝向、弹药等条件,但原则不变:高优先级分支必须先证明“现在真的能执行”,否则应返回 Failure 让 Selector 继续向后选择。
当攻击、追击、巡逻都通过同一个 Selector 汇合后,敌人的行为优先级就不再隐藏在代码分支里,而是直接体现在树的结构顺序中;后续新增逃跑、受击或寻找掩体时,也可以沿用同样的组织方式。