游戏 AI / 系统课时

给树接入追击和攻击动作

给树接入追击和攻击动作

这一节把单一巡逻扩展成完整的敌人决策入口:有攻击机会时攻击,能看到目标但距离较远时追击,否则继续巡逻。核心是用 Selector 表达优先级,让高优先级分支成立时自然阻止低优先级行为执行。

学习目标

  • 能用 Selector 组织攻击、追击、巡逻三条互斥分支。
  • 理解条件节点与动作节点如何组合成可读的决策结构。
  • 能验证同一 Tick 中只执行优先级最高且可用的行为。

用 Selector 表达行为优先级

Selector 会从前到后尝试子节点。某个子节点返回 Failure 时继续尝试下一个;遇到 Success 或 Running 时立即停止。因此,把攻击分支放在追击前面、追击放在巡逻前面,就能直接表达“攻击优先于追击,追击优先于巡逻”。

一棵常见的敌人行为树可以组织为:

  • Attack Sequence:目标可见且进入攻击距离后执行攻击。
  • Chase Sequence:目标可见但当前无法攻击时执行追击。
  • Patrol:前两条分支都不可用时作为兜底行为。

攻击追击巡逻的 Selector 优先级结构

这种结构比在一个 Update 方法里连续写多层 if 更容易扩展,因为每个分支的进入条件和动作边界都是显式的。

条件节点只回答能不能执行

条件节点最好只做判断,不直接产生移动、攻击等副作用。例如 TargetVisible 只读取感知数据,InAttackRange 只比较距离。动作节点再负责执行追击或攻击。

这样做有两个好处:一是条件可以被多个分支复用;二是调试时可以明确看到到底是“条件不成立”还是“动作执行失败”。

实现一个可验证的优先级树

下面的纯 C# 示例使用“响应式 Selector”:每次 Tick 都从最高优先级分支重新检查。这样 NPC 在追击过程中一旦进入攻击距离,下一次 Tick 就会先命中攻击分支,而不会被旧的追击状态锁住。

csharp
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}");
        }
    }
}

预期输出:

text
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 汇合后,敌人的行为优先级就不再隐藏在代码分支里,而是直接体现在树的结构顺序中;后续新增逃跑、受击或寻找掩体时,也可以沿用同样的组织方式。

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

目录与阅读设置

阅读设置

17

记录一个想法

给树接入追击和攻击动作

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

登录哪都通