跳至主要內容

8. 状态机与行为树

EVOCOSMOS2026/4/14大约 11 分钟

状态机与行为树

你有没有注意到，游戏里的敌人不是像无头苍蝇一样乱跑的？守卫会在固定路线上巡逻，发现你之后追过来，打不过就跑回去求援，你躲起来之后又会回到巡逻状态。

这些"聪明"的行为，背后就是 AI 决策架构 在控制。最常见的两种架构是有限状态机（FSM）和行为树（Behavior Tree）。本章从零开始教你理解和实现它们。

为什么需要 AI 决策架构

想象一下，如果不用任何架构，直接用 if-else 来写敌人 AI：

// 反面教材：用一堆 if-else 写 AI，越写越乱
void Update()
{
    if (看到玩家 && 距离 < 5)
    {
        攻击();
    }
    else if (看到玩家 && 血量 < 30)
    {
        逃跑();
    }
    else if (看到玩家)
    {
        追逐();
    }
    else if (血量 < 50 && 巡逻到回血点)
    {
        回血();
    }
    else if (巡逻时间到了)
    {
        换巡逻点();
    }
    else
    {
        巡逻();
    }
}

这段代码现在看起来还能看懂，但如果再加 10 种行为、20 种条件呢？你会得到几百个 if-else 嵌套在一起——谁也看不懂、谁也不敢改。

AI 决策架构的作用就是把复杂的行为逻辑整理成清晰的结构，让代码好写、好读、好改。

有限状态机（FSM）——最经典的 AI 架构

什么是状态机

有限状态机（Finite State Machine，简称 FSM）的核心思想非常简单：一个实体在任意时刻只能处于一种状态，不同状态之间可以切换。

打个比方：你的一天可以分成几个"状态"：

[睡觉] --闹钟响了--> [起床洗漱] --出门--> [上班/上学]
[上班] --到饭点了--> [吃饭] --吃完--> [继续上班]
[上班] --下班了--> [回家] --到点了--> [睡觉]

你在任意时刻只处于一个状态（不可能同时在睡觉和上班），而且状态之间有明确的切换条件。这就是状态机。

状态机的三个要素

要素说明举例
状态（State）实体当前在做什么巡逻、追逐、攻击、逃跑
转移（Transition）从一个状态切换到另一个状态发现玩家：巡逻 -> 追逐
条件（Condition）什么情况下可以转移距离玩家 < 10 且看到玩家

画一个状态图

敌人的 AI 可以用这样的状态图表示：

        ┌────────── 发现玩家 ──────────┐
        │                              │
        ▼                              │
    ┌───────┐    玩家跑远了    ┌───────┐
    │ 巡逻   │ ◄──────────── │ 追逐   │
    └───────┘                └───────┘
        │                      │
        │ 血量低                │ 到攻击范围
        ▼                      ▼
    ┌───────┐    血量恢复    ┌───────┐
    │ 回血   │ ──────────► │ 攻击   │
    └───────┘              └───────┘
        ▲                      │
        │ 血量低                │ 玩家跑远
        └──────────────────────┘

用代码实现状态机

下面我们用 Godot 实现一个完整的敌人 AI 状态机。

C
using Godot;
using System.Collections.Generic;

// ========== 状态基类 ==========
// 所有具体状态都继承这个基类
public abstract class EnemyState
{
    // 状态名字，方便调试
    public abstract string Name { get; }

    // 进入状态时调用（初始化）
    public abstract void Enter(EnemyController enemy);

    // 每帧调用（更新逻辑）
    public abstract void Update(EnemyController enemy, double delta);

    // 离开状态时调用（清理）
    public abstract void Exit(EnemyController enemy);
}

// ========== 巡逻状态 ==========
public class PatrolState : EnemyState
{
    public override string Name => "巡逻";

    private int _currentWaypointIndex = 0;

    public override void Enter(EnemyController enemy)
    {
        GD.Print($"{enemy.Name} 开始巡逻");
        _currentWaypointIndex = 0;
    }

    public override void Update(EnemyController enemy, double delta)
    {
        // 如果没有巡逻点，就站在原地
        if (enemy.Waypoints.Count == 0) return;

        // 朝当前巡逻点移动
        var target = enemy.Waypoints[_currentWaypointIndex];
        enemy.MoveToward(target, enemy.PatrolSpeed, delta);

        // 到达巡逻点后，切换到下一个
        if (enemy.GlobalPosition.DistanceTo(target) < 10)
        {
            _currentWaypointIndex = (_currentWaypointIndex + 1) % enemy.Waypoints.Count;
        }

        // 检测玩家：如果看到玩家且在追逐范围内，切换到追逐状态
        if (enemy.CanSeePlayer() && enemy.DistanceToPlayer() < enemy.ChaseRange)
        {
            enemy.ChangeState(new ChaseState());
        }
    }

    public override void Exit(EnemyController enemy)
    {
        // 巡逻结束，可以播放停止动画
        enemy.StopMovement();
    }
}

// ========== 追逐状态 ==========
public class ChaseState : EnemyState
{
    public override string Name => "追逐";

    public override void Enter(EnemyController enemy)
    {
        GD.Print($"{enemy.Name} 发现了玩家！开始追逐！");
    }

    public override void Update(EnemyController enemy, double delta)
    {
        // 血量太低，逃跑
        if (enemy.Hp < enemy.MaxHp * 0.2f)
        {
            enemy.ChangeState(new FleeState());
            return;
        }

        // 玩家跑远了，回到巡逻
        if (enemy.DistanceToPlayer() > enemy.ChaseRange * 1.5f)
        {
            enemy.ChangeState(new PatrolState());
            return;
        }

        // 到了攻击范围，开始攻击
        if (enemy.DistanceToPlayer() < enemy.AttackRange)
        {
            enemy.ChangeState(new AttackState());
            return;
        }

        // 追逐玩家
        enemy.MoveToward(enemy.PlayerPosition, enemy.ChaseSpeed, delta);
    }

    public override void Exit(EnemyController enemy) { }
}

// ========== 攻击状态 ==========
public class AttackState : EnemyState
{
    public override string Name => "攻击";

    private double _attackTimer = 0;

    public override void Enter(EnemyController enemy)
    {
        GD.Print($"{enemy.Name} 进入攻击状态！");
        _attackTimer = 0;
    }

    public override void Update(EnemyController enemy, double delta)
    {
        // 血量太低，逃跑
        if (enemy.Hp < enemy.MaxHp * 0.2f)
        {
            enemy.ChangeState(new FleeState());
            return;
        }

        // 玩家跑出攻击范围，继续追逐
        if (enemy.DistanceToPlayer() > enemy.AttackRange * 1.2f)
        {
            enemy.ChangeState(new ChaseState());
            return;
        }

        // 面向玩家
        enemy.LookAt(enemy.PlayerPosition);

        // 攻击冷却
        _attackTimer += delta;
        if (_attackTimer >= enemy.AttackCooldown)
        {
            _attackTimer = 0;
            enemy.PerformAttack();
        }
    }

    public override void Exit(EnemyController enemy) { }
}

// ========== 逃跑状态 ==========
public class FleeState : EnemyState
{
    public override string Name => "逃跑";

    public override void Enter(EnemyController enemy)
    {
        GD.Print($"{enemy.Name} 血量太低了，开始逃跑！");
    }

    public override void Update(EnemyController enemy, double delta)
    {
        // 血量恢复到安全水平，回到巡逻
        if (enemy.Hp > enemy.MaxHp * 0.5f)
        {
            enemy.ChangeState(new PatrolState());
            return;
        }

        // 往远离玩家的方向跑
        var awayDirection = (enemy.GlobalPosition - enemy.PlayerPosition).Normalized();
        var fleeTarget = enemy.GlobalPosition + awayDirection * 100;
        enemy.MoveToward(fleeTarget, enemy.ChaseSpeed * 1.2f, delta);
    }

    public override void Exit(EnemyController enemy) { }
}

状态机控制器

有了各个状态类，还需要一个"控制器"来管理当前处于哪个状态，以及状态之间的切换：

C
using Godot;

public partial class EnemyController : CharacterBody2D
{
    // 属性
    [Export] public float PatrolSpeed { get; set; } = 100f;
    [Export] public float ChaseSpeed { get; set; } = 200f;
    [Export] public float ChaseRange { get; set; } = 200f;
    [Export] public float AttackRange { get; set; } = 50f;
    [Export] public float AttackCooldown { get; set; } = 1.0f;
    [Export] public float Hp { get; set; } = 100f;
    [Export] public float MaxHp { get; set; } = 100f;
    [Export] public float DetectionRange { get; set; } = 300f;

    // 巡逻点
    public Godot.Collections.Array<Vector2> Waypoints { get; set; } = new();

    // 状态机
    private EnemyState _currentState;
    public string CurrentStateName => _currentState?.Name ?? "无";

    // 玩家引用
    private CharacterBody2D _player;

    public override void _Ready()
    {
        // 设置初始状态为巡逻
        ChangeState(new PatrolState());
    }

    public override void _PhysicsProcess(double delta)
    {
        // 更新玩家引用
        _player = GetTree().GetFirstNodeInGroup("player") as CharacterBody2D;

        // 更新当前状态
        _currentState?.Update(this, delta);
    }

    // 切换状态
    public void ChangeState(EnemyState newState)
    {
        if (_currentState != null)
        {
            GD.Print($"{Name} 状态切换：{_currentState.Name} -> {newState.Name}");
            _currentState.Exit(this);
        }

        _currentState = newState;
        _currentState.Enter(this);
    }

    // 辅助方法
    public bool CanSeePlayer()
    {
        if (_player == null) return false;
        return DistanceToPlayer() <= DetectionRange;
    }

    public float DistanceToPlayer()
    {
        return _player == null ? float.MaxValue : GlobalPosition.DistanceTo(_player.GlobalPosition);
    }

    public Vector2 PlayerPosition => _player?.GlobalPosition ?? GlobalPosition;

    public void PerformAttack()
    {
        GD.Print($"{Name} 发动攻击！");
        // 这里添加实际攻击逻辑
    }

    public void MoveToward(Vector2 target, float speed, double delta)
    {
        var direction = (target - GlobalPosition).Normalized();
        Velocity = direction * speed;
        MoveAndSlide();
    }

    public void StopMovement()
    {
        Velocity = Vector2.Zero;
    }
}

状态机的优缺点

优点

优点说明
简单直观状态图一目了然，容易理解和讨论
容易调试打印当前状态就能知道 AI 在做什么
性能好每帧只执行一个状态的逻辑，开销很小
适合简单 AI巡逻、追逐、攻击这种简单的行为模式非常合适

缺点

缺点说明
状态爆炸行为多了之后，状态数量会急剧增长，状态图变得像一团乱麻
难以复用"追着玩家打"这个行为，追逐状态和攻击状态可能都要写一遍
缺乏层次不能表达"先做 A，如果 A 失败就做 B，否则做 C"这种复杂逻辑
扩展困难加一个新状态可能要修改很多现有状态的转移条件

行为树（Behavior Tree）——更强大的 AI 架构

当 AI 行为变得复杂（比如 RTS 游戏里的士兵，需要同时考虑资源采集、战斗、建造、逃跑等多种因素），状态机就不够用了。这时候就需要行为树。

行为树的核心概念

行为树就像一棵倒挂的树，从上往下执行。树的每个节点代表一个"任务"或"判断"。

打个比方：行为树就像你每天早上的决策流程：

起床了
├── 今天是工作日吗？
│   ├── 是 → 准备上班
│   │   ├── 天气好吗？
│   │   │   ├── 是 → 骑自行车去
│   │   │   └── 否 → 打车去
│   │   └── 到公司
│   └── 否 → 今天是休息日
│       ├── 想出去玩吗？
│       │   ├── 是 → 出门逛街
│       │   └── 否 → 在家打游戏
│       └── ...

行为树的节点类型

行为树有四种基本节点类型：

节点类型作用返回值举例
Sequence（顺序）依次执行子节点，一个失败就全部失败子节点全部成功才成功先走到门边，再开门，再走出去
Selector（选择）依次尝试子节点，一个成功就全部成功子节点有一个成功就成功优先攻击，不行就逃跑，再不行就待着
Condition（条件）判断某个条件是否成立成功或失败玩家在视野内？血量低于30%？
Action（动作）执行具体的行为成功或失败移动、攻击、播放动画

行为树 vs 状态机怎么选

对比维度状态机（FSM）行为树（BT）
复杂度简单中等
适合行为数3-8 个状态10+ 个行为
调试难度容易（打印当前状态）中等（需要追踪执行路径）
复用性低高（子树可以复用）
学习曲线平缓较陡
典型应用平台跳跃敌人、射击游戏小怪RTS 单位、RPG NPC、复杂 Boss

选择建议

  • 初学者和简单 AI：用状态机，够用且好懂
  • 复杂 AI（需要同时考虑多个因素）：用行为树
  • 大型项目：两者结合——行为树做高层决策，状态机做底层行为执行

实战案例：用 FSM 做敌人 AI

上面的代码已经是一个完整的 FSM 敌人 AI 实现了。让我们来看看如何在实际场景中使用它。

场景设置

  1. 创建一个 EnemyController 场景（CharacterBody2D）
  2. 添加 Sprite2D、CollisionShape2D 等子节点
  3. 设置 Waypoints（巡逻点）——可以在编辑器中手动放置几个 Marker2D 节点
  4. 把玩家节点加入 "player" 组

运行效果

敌人会自动：

  1. 在巡逻点之间来回走动
  2. 发现玩家后追过去
  3. 到了攻击范围就停下来攻击
  4. 血量低了就逃跑
  5. 玩家跑远后回到巡逻

扩展思路

你可以在上面基础上继续扩展：

  • 添加搜索状态：玩家消失后去最后看到的位置搜索
  • 添加警戒状态：听到声音但没看到人，提高警惕
  • 添加呼叫支援状态：发现玩家后通知附近的同伴
  • 添加动画混合：不同状态播放不同动画
  • 添加音效：发现玩家时播放警报声

最终建议

  1. 从状态机开始学，它是 AI 编程的基础
  2. 把每个状态写得小而清晰，一个状态只做一件事
  3. 状态切换时要有明确的进入/退出逻辑（比如切换动画）
  4. 用日志打印状态切换信息，方便调试
  5. 等你发现状态机不够用了，再学行为树
最近更新:
贡献者: zefeng.peng
EVOCOSMOS
Copyright © 2026 EVOCOSMOS