游戏 AI / 系统课时
创建根节点与组合节点
创建根节点与组合节点
这一课搭出一棵最小可运行行为树:由 Root 提供统一执行入口,Selector 负责候选回退,Sequence 负责顺序约束,再通过日志验证节点的进入、执行和退出顺序是否与树结构一致。
学习目标
- 理解 Root、Selector、Sequence 在运行时各自承担的职责
- 用完整代码组装并执行一棵最小行为树
- 根据日志验证组合节点的进入、退出与状态传播顺序
Root 只提供稳定入口
Root 最适合保持简单:它只持有一个真正的业务子树,每次 Tick 都把执行权交给这个子节点,再把结果原样向上返回。以后即使把内部业务树全部替换,外部运行器仍然只需要调用同一个根节点。
Selector 和 Sequence 才承担组合策略。前者从左到右寻找第一个可执行方案,后者要求一组步骤依次成立。把入口与组合策略分开之后,后续增加整树暂停、调试、重置或性能统计时不需要侵入具体 NPC 行为。

用最小 Java 实现跑通组合节点
下面的代码只保留行为树执行模型所需的部分。BaseNode 统一记录进入与退出;节点返回 RUNNING 时保持活动,只有返回 SUCCESS 或 FAILURE 才打印退出日志。为了先验证组合关系,本例叶子节点直接返回预设状态。
public class BehaviorTreeDemo {
enum Status {
SUCCESS, FAILURE, RUNNING
}
interface Node {
Status tick();
}
static abstract class BaseNode implements Node {
private final String name;
BaseNode(String name) {
this.name = name;
}
@Override
public final Status tick() {
System.out.println("ENTER " + name);
Status status = execute();
if (status != Status.RUNNING) {
System.out.println("EXIT " + name + " -> " + status);
}
return status;
}
protected abstract Status execute();
}
static final class Leaf extends BaseNode {
private final Status result;
Leaf(String name, Status result) {
super(name);
this.result = result;
}
@Override
protected Status execute() {
return result;
}
}
static final class Sequence extends BaseNode {
private final Node[] children;
Sequence(String name, Node... children) {
super(name);
this.children = children;
}
@Override
protected Status execute() {
for (Node child : children) {
Status status = child.tick();
if (status != Status.SUCCESS) {
return status;
}
}
return Status.SUCCESS;
}
}
static final class Selector extends BaseNode {
private final Node[] children;
Selector(String name, Node... children) {
super(name);
this.children = children;
}
@Override
protected Status execute() {
for (Node child : children) {
Status status = child.tick();
if (status != Status.FAILURE) {
return status;
}
}
return Status.FAILURE;
}
}
static final class Root extends BaseNode {
private final Node child;
Root(String name, Node child) {
super(name);
this.child = child;
}
@Override
protected Status execute() {
return child.tick();
}
}
public static void main(String[] args) {
Node combat = new Sequence(
"CombatSequence",
new Leaf("HasTarget", Status.SUCCESS),
new Leaf("Attack", Status.SUCCESS)
);
Node tree = new Root(
"Root",
new Selector(
"MainSelector",
combat,
new Leaf("Patrol", Status.SUCCESS)
)
);
Status result = tree.tick();
System.out.println("FINAL " + result);
}
}预期输出:
ENTER Root
ENTER MainSelector
ENTER CombatSequence
ENTER HasTarget
EXIT HasTarget -> SUCCESS
ENTER Attack
EXIT Attack -> SUCCESS
EXIT CombatSequence -> SUCCESS
EXIT MainSelector -> SUCCESS
EXIT Root -> SUCCESS
FINAL SUCCESS输出展示了一个完整的向下执行、向上返回过程。因为 CombatSequence 最终成功,MainSelector 在收到 SUCCESS 后立即停止,所以后面的 Patrol 根本不会进入。
从日志验证组合规则
验证行为树时,不要只看最后的 FINAL SUCCESS。更重要的是确认哪些节点实际被访问、哪些节点因短路没有被访问,以及状态在哪一层改变了父节点的控制流。
把示例中 HasTarget 的结果从 Status.SUCCESS 改成 Status.FAILURE 后再次运行,CombatSequence 会立即失败,因此 Attack 不应该出现进入日志;MainSelector 则会继续执行后面的 Patrol。如果此时日志中仍出现 Attack,说明 Sequence 没有正确实现失败短路。
RUNNING 需要明确记忆策略
当前示例没有保存正在运行的子节点索引,因为目标只是跑通 Root、Selector 和 Sequence 的基本传播规则。真正加入移动、攻击蓄力或动画等待后,叶子节点通常会连续多个 Tick 返回 RUNNING。
如果组合节点希望下一帧从正在运行的子节点继续,就需要保存当前位置,这通常属于 Memory Sequence 或 Memory Selector;如果希望每一帧重新检查前面的高优先级条件,则可以采用 Reactive 语义。两种方式都合理,关键是实现时必须明确选择,不能一部分逻辑记忆位置、另一部分又默认从头重新检查。
节点退出要跟最终状态一致
本例约定节点返回 SUCCESS 或 FAILURE 后退出,返回 RUNNING 时继续保持活动。这比“每个 Tick 都退出再重新进入”更适合游戏 AI,因为移动、攻击前摇、等待动画结束等行为通常需要跨越多个游戏帧。
以后把叶子节点扩展成真正的 enter、update、exit 生命周期时,也应该保持同一条状态传播原则:父节点先获得子节点的结果,再决定继续下一个步骤、回退到其他候选还是结束自身。Root、Selector、Sequence 的执行模型先跑正确,后续增加条件节点和具体 NPC 行为才容易定位问题。