游戏 AI / 系统课时

创建根节点与组合节点

创建根节点与组合节点

这一课搭出一棵最小可运行行为树:由 Root 提供统一执行入口,Selector 负责候选回退,Sequence 负责顺序约束,再通过日志验证节点的进入、执行和退出顺序是否与树结构一致。

学习目标

  • 理解 Root、Selector、Sequence 在运行时各自承担的职责
  • 用完整代码组装并执行一棵最小行为树
  • 根据日志验证组合节点的进入、退出与状态传播顺序

Root 只提供稳定入口

Root 最适合保持简单:它只持有一个真正的业务子树,每次 Tick 都把执行权交给这个子节点,再把结果原样向上返回。以后即使把内部业务树全部替换,外部运行器仍然只需要调用同一个根节点。

Selector 和 Sequence 才承担组合策略。前者从左到右寻找第一个可执行方案,后者要求一组步骤依次成立。把入口与组合策略分开之后,后续增加整树暂停、调试、重置或性能统计时不需要侵入具体 NPC 行为。

Root Selector Sequence最小行为树结构与状态传播

用最小 Java 实现跑通组合节点

下面的代码只保留行为树执行模型所需的部分。BaseNode 统一记录进入与退出;节点返回 RUNNING 时保持活动,只有返回 SUCCESS 或 FAILURE 才打印退出日志。为了先验证组合关系,本例叶子节点直接返回预设状态。

java
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);
    }
}

预期输出:

text
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 行为才容易定位问题。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

创建根节点与组合节点

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通