——从“木头人”到“战术大师”，揭秘游戏AI的“大脑”是如何炼成的

---

NPC的“觉醒时刻”

你有没有玩过游戏，遇到一个敌人会绕后偷袭、一个商人会根据你的装备调整价格？这些“活生生”的NPC背后，是一套精密的决策系统在驱动。而C#凭借其面向对象特性、跨平台能力（Unity/Unreal插件支持）和高性能（.NET 7+的AOT编译），正成为游戏AI开发的“瑞士军刀”。

但如何让NPC从“按脚本行动”进化为“自主思考”？答案就是决策系统——它能让NPC在不同场景中做出“合理”选择，比如：

• RPG游戏：巡逻→发现玩家→追击→战斗→撤退
• RTS游戏：采集资源→建造基地→侦查敌情→发起攻击
• 恐怖游戏：随机游荡→感知脚步声→锁定位置→潜行接近

本文将通过真实项目级代码，带你从零构建一个可扩展的AI决策系统，甚至能让你的NPC学会“作弊”（比如预判玩家路径）。

---

从“状态机”到“行为树”，AI的进化之路

1. 基础架构：状态机（State Machine）——AI的“交通信号灯”

状态机是AI决策的起点，它让NPC在不同“行为状态”之间切换，比如：

// 状态机核心：定义所有可能的状态
public enum AIState {
    Idle,       // 空闲
    Patrol,     // 巡逻
    Chase,      // 追击
    Attack,     // 攻击
    Flee        // 逃跑
}

// 状态基类：所有状态的抽象接口
public abstract class AIStateHandler {
    public abstract void OnEnter(AIController ai);    // 进入状态
    public abstract void OnUpdate(AIController ai);   // 每帧更新
    public abstract void OnExit(AIController ai);     // 退出状态
}

// 具体状态：巡逻状态
public class PatrolState : AIStateHandler {
    private float _patrolTimer = 0f;
    private const float PATROL_DURATION = 5f;

    public override void OnEnter(AIController ai) {
        Console.WriteLine("进入巡逻状态");
        _patrolTimer = 0f;
    }

    public override void OnUpdate(AIController ai) {
        _patrolTimer += Time.DeltaTime;
        if (_patrolTimer >= PATROL_DURATION) {
            ai.ChangeState(AIState.Idle); // 自动切换到空闲
        }
        // 实现巡逻逻辑：沿着预设路径移动
        ai.MoveToNextWaypoint();
    }

    public override void OnExit(AIController ai) {
        Console.WriteLine("离开巡逻状态");
    }
}

// AI控制器：管理状态切换
public class AIController {
    public AIState CurrentState { get; private set; }
    private Dictionary<AIState, AIStateHandler> _stateHandlers = new();

    public AIController() {
        _stateHandlers[AIState.Idle] = new IdleState();
        _stateHandlers[AIState.Patrol] = new PatrolState();
        // 初始化状态
        ChangeState(AIState.Idle);
    }

    public void ChangeState(AIState newState) {
        // 退出当前状态
        _stateHandlers[CurrentState]?.OnExit(this);
        // 进入新状态
        CurrentState = newState;
        _stateHandlers[CurrentState].OnEnter(this);
    }

    public void Update() {
        _stateHandlers[CurrentState].OnUpdate(this);
    }

    // 示例方法：移动到下一个路点
    public void MoveToNextWaypoint() {
        Console.WriteLine("向下一个路点移动...");
    }
}

代码亮点解析

• 解耦设计：状态逻辑与控制器分离，新增状态只需添加类，无需修改控制器。
• 热切换机制：通过ChangeState()实现实时状态切换（比如发现玩家时从Patrol跳转到Chase）。
• 可扩展性：通过继承AIStateHandler，可快速实现复杂状态（如CombatState带技能释放）。

---

2. 进阶玩法：行为树（Behavior Tree）——AI的“树状大脑”

行为树是更复杂的决策系统，适合需要条件分支和优先级控制的场景（如Boss战）。

核心概念

• 节点类型：
  • Sequence（序列）：子节点全部成功才返回成功。
  • Selector（选择）：子节点任一成功即返回成功。
  • Action（动作）：执行具体操作（如攻击、移动）。
  • Condition（条件）：判断是否满足条件。

代码实现：Boss的战斗逻辑

// 节点基类
public abstract class BehaviorNode {
    public abstract NodeState Evaluate(); // 返回状态
}

public enum NodeState {
    Success,
    Failure,
    Running
}

// 序列节点：所有子节点必须成功
public class SequenceNode : BehaviorNode {
    private List<BehaviorNode> _children = new();

    public void AddChild(BehaviorNode child) => _children.Add(child);

    public override NodeState Evaluate() {
        foreach (var child in _children) {
            var state = child.Evaluate();
            if (state != NodeState.Success) return state; // 失败则停止
        }
        return NodeState.Success;
    }
}

// 条件节点：检查血量是否低于30%
public class LowHealthCondition : BehaviorNode {
    private readonly AIController _ai;

    public LowHealthCondition(AIController ai) => _ai = ai;

    public override NodeState Evaluate() {
        if (_ai.Health <= 30f) {
            Console.WriteLine("血量低于30%，触发逃跑！");
            return NodeState.Success;
        }
        return NodeState.Failure;
    }
}

// 动作节点：逃跑行为
public class FleeAction : BehaviorNode {
    private readonly AIController _ai;

    public FleeAction(AIController ai) => _ai = ai;

    public override NodeState Evaluate() {
        _ai.ChangeState(AIState.Flee);
        return NodeState.Success;
    }
}

// 构建行为树
public class BossBehaviorTree {
    public BehaviorNode Root { get; private set; }

    public BossBehaviorTree(AIController ai) {
        // 构建树结构：如果血量低则逃跑，否则继续攻击
        var root = new SequenceNode();
        var selector = new SelectorNode(); // 选择器
        selector.AddChild(new LowHealthCondition(ai));
        selector.AddChild(new AttackAction(ai));
        root.AddChild(selector);
        root.AddChild(new FleeAction(ai)); // 逃跑动作（仅当选择器失败时执行）

        Root = root;
    }
}

代码亮点解析

• 动态决策：通过条件节点动态调整行为（比如Boss血量低时切换逃跑）。
• 优先级控制：选择器节点允许“应急行为”优先执行（如Boss被击倒时立即死亡动画）。
• 可复用性：节点可组合成任意复杂度的逻辑（如Boss的“蓄力技能→普通攻击→闪避”链式行为）。

---

3. 决策树（Decision Tree）——AI的“经验库”

决策树适合处理复杂条件组合的场景，比如NPC的对话选择或交易策略。

代码示例：NPC商人定价策略

// 决策树节点
public class DecisionTreeNode {
    public Func<bool> Condition { get; set; }  // 条件判断
    public Action Action { get; set; }          // 执行动作
    public DecisionTreeNode TrueBranch { get; set; } // 条件成立后的分支
    public DecisionTreeNode FalseBranch { get; set; } // 条件不成立后的分支

    public void Evaluate() {
        if (Condition()) {
            Action?.Invoke();
            TrueBranch?.Evaluate();
        } else {
            FalseBranch?.Evaluate();
        }
    }
}

// 商人定价逻辑
public class TraderAI {
    private int _playerReputation = 50; // 玩家声望
    private float _basePrice = 100f;

    public void DeterminePrice() {
        var root = new DecisionTreeNode {
            Condition = () => _playerReputation > 80,
            Action = () => _basePrice *= 0.8f, // 声望高则打折
            TrueBranch = new DecisionTreeNode {
                Condition = () => _playerReputation > 95,
                Action = () => _basePrice *= 0.5f // 超高声望半价
            },
            FalseBranch = new DecisionTreeNode {
                Condition = () => _playerReputation < 30,
                Action = () => _basePrice *= 1.5f // 声望低则涨价
            }
        };

        root.Evaluate();
        Console.WriteLine($"最终价格：{_basePrice:C}");
    }
}

代码亮点解析

• 条件嵌套：通过树状结构处理多层条件（如“声望高→打折→再看是否超高→再打折”）。
• 动态定价：NPC商人能根据玩家行为调整策略，增加游戏真实感。
• 可扩展性：新增条件只需修改树结构，无需重构代码。

---

4. 混合架构：状态机 + 行为树 + 决策树的“三叉戟”

在复杂游戏中，单一决策系统往往不够。我们可以将它们组合使用：

• 状态机管理大范围行为（如巡逻、战斗、逃跑）。
• 行为树细化当前状态下的具体动作（如Boss的技能释放顺序）。
• 决策树处理复杂条件判断（如NPC的对话选项）。

代码示例：RPG游戏Boss战逻辑

public class BossAI : MonoBehaviour {
    private AIController _stateMachine; // 状态机
    private BehaviorTree _behaviorTree; // 行为树
    private DecisionTree _decisionTree; // 决策树

    void Start() {
        _stateMachine = new AIController();
        _behaviorTree = new BossBehaviorTree(_stateMachine);
        _decisionTree = new TraderDecisionTree(); // 假设Boss也卖东西

        // 状态机绑定行为树
        _stateMachine.OnEnterCombat += () => _behaviorTree.Start();
    }

    void Update() {
        _stateMachine.Update();
        if (_stateMachine.CurrentState == AIState.Combat) {
            _behaviorTree.Tick();
        }
        _decisionTree.Evaluate(); // 例如动态调整商店价格
    }
}

---

让AI“活起来”的终极秘籍

1. C#的优势

• 性能与灵活性兼顾：.NET 7的AOT编译让C#在Unity中接近C++性能，同时保留开发效率。
• 生态丰富：Unity、Unreal的C#插件支持，以及ML-Agents等AI框架无缝集成。
• 面向对象设计：天然适合构建模块化、可扩展的AI系统。

2. 未来趋势

• 机器学习辅助决策：通过C#调用Python训练的模型，让AI学会“学习”玩家习惯。
• 异步处理：利用async/await优化AI逻辑，避免卡顿。
• 云AI协作：将复杂决策逻辑部署到云端，降低本地计算压力。

---

代码彩蛋与冷知识

彩蛋1：用LINQ优化条件判断

// 使用LINQ简化条件组合
var conditions = new List<Func<bool>> {
    () => playerInSight,
    () => health < 50
};

if (conditions.All(c => c())) {
    ChangeState(AIState.Flee);
}

冷知识：行为树的“冷却时间”机制

// 在节点中添加冷却时间
public class CooldownNode : BehaviorNode {
    private float _cooldownTime = 5f;
    private float _lastExecutionTime;

    public override NodeState Evaluate() {
        if (Time.Elapsed - _lastExecutionTime < _cooldownTime) return NodeState.Failure;
        _lastExecutionTime = Time.Elapsed;
        return base.Evaluate();
    }
}