4.10 AI 编程 (人工智能)

文档摘要

4.10 AI 编程 (人工智能) 4.10 AI 编程 (人工智能) 在游戏开发领域，人工智能 (AI) 不仅仅是锦上添花，而是构建沉浸式、挑战性和引人入胜体验的核心要素。一个优秀的 AI 系统能够赋予游戏角色生命，使其行为更具真实感、策略性和不可预测性，从而极大地提升游戏的可玩性和玩家的沉浸感。在 Unity3D 引擎中，我们拥有丰富的工具和技术来实现各种复杂的 AI 行为。本章节将深入探讨 Unity3D 中的 AI 编程，涵盖基础概念、常用技术以及实战案例，助你掌握为游戏注入智能的强大能力。 4.10.1 AI 编程基础概念在深入代码实践之前，我们首先需要理解游戏 AI 编程的一些核心概念。游戏 AI 与传统意义上的人工智能研究有所不同，它更侧重于模拟智能，而非追求通用人工智能。

4.10 AI 编程 (人工智能)

在游戏开发领域，人工智能 (AI) 不仅仅是锦上添花，而是构建沉浸式、挑战性和引人入胜体验的核心要素。一个优秀的 AI 系统能够赋予游戏角色生命，使其行为更具真实感、策略性和不可预测性，从而极大地提升游戏的可玩性和玩家的沉浸感。在 Unity3D 引擎中，我们拥有丰富的工具和技术来实现各种复杂的 AI 行为。本章节将深入探讨 Unity3D 中的 AI 编程，涵盖基础概念、常用技术以及实战案例，助你掌握为游戏注入智能的强大能力。

4.10.1 AI 编程基础概念

在深入代码实践之前，我们首先需要理解游戏 AI 编程的一些核心概念。游戏 AI 与传统意义上的人工智能研究有所不同，它更侧重于模拟智能，而非追求通用人工智能。我们的目标是创建能够为玩家提供有趣和具有挑战性游戏体验的角色和系统，而非构建能够进行复杂推理和学习的通用智能体。

以下是一些游戏 AI 编程中常用的核心概念：

状态机 (Finite State Machine, FSM)：状态机是一种行为模型，将 AI 角色的行为划分为不同的状态，并在不同状态之间进行切换。每个状态代表角色的一种特定行为模式，例如巡逻、追逐、攻击、逃跑等。状态机简单直观，易于实现，是游戏 AI 中最基础也是最常用的技术之一。
行为树 (Behavior Tree, BT)：行为树是一种更高级的行为模型，它以树状结构组织 AI 角色的行为。行为树具有模块化、可重用、易于扩展和调试的优点，能够构建比状态机更复杂、更灵活的 AI 系统。行为树在现代游戏 AI 开发中越来越受欢迎。
导航网格 (Navigation Mesh, NavMesh)：导航网格是一种用于寻路的网格数据结构。它预先计算并存储了游戏场景中可行走区域的信息，AI 角色可以利用导航网格快速高效地找到到达目标点的路径，而无需进行实时的路径规划计算。Unity3D 内置了强大的 NavMesh 系统。
路径规划算法 (Pathfinding Algorithm)：路径规划算法是 AI 角色在导航网格上寻找最优路径的核心算法。常用的路径规划算法包括 A* 算法、Dijkstra 算法等。A* 算法是游戏开发中最常用的路径规划算法，它在效率和准确性之间取得了良好的平衡。
感知系统 (Perception System)：感知系统负责让 AI 角色“感知”周围的环境。这通常包括视觉、听觉、触觉等模拟。在游戏中，感知系统通常通过射线检测 (Raycast)、碰撞检测 (Collider Detection)、视野模拟 (Field of View, FOV) 等技术实现。
决策系统 (Decision Making System)：决策系统负责根据 AI 角色的感知信息、当前状态和目标，选择合适的行为。决策系统可以是简单的规则引擎、也可以是更复杂的算法，例如模糊逻辑、神经网络等。
运动控制 (Movement Control)：运动控制负责控制 AI 角色的实际运动。这包括移动、转向、动画控制等。Unity3D 提供了 CharacterController、Rigidbody 等组件以及动画系统来方便地实现角色运动控制。

4.10.2 状态机 (Finite State Machine) 的实践与详解

状态机 (FSM) 是最简单且应用广泛的 AI 行为建模方法。它将角色的行为分解为有限数量的状态，并在状态之间定义转换条件。

状态机原理图 (Mermaid Graph):

代码实践 (C# - Unity):


using UnityEngine;
public enum EnemyState
{
    Idle,
    Patrol,
    Chase,
    Attack
}
public class EnemyFSM : MonoBehaviour
{
    public EnemyState currentState = EnemyState.Idle;
    public float patrolSpeed = 2f;
    public float chaseSpeed = 5f;
    public float attackRange = 2f;
    public float patrolWaitTime = 3f;
    public Transform playerTransform;
    private float patrolTimer = 0f;
    void Update()
    {
        switch (currentState)
        {
            case EnemyState.Idle:
                UpdateIdleState();
                break;
            case EnemyState.Patrol:
                UpdatePatrolState();
                break;
            case EnemyState.Chase:
                UpdateChaseState();
                break;
            case EnemyState.Attack:
                UpdateAttackState();
                break;
            default:
                break;
        }
    }
    void UpdateIdleState()
    {
        patrolTimer += Time.deltaTime;
        if (patrolTimer >= patrolWaitTime)
        {
            currentState = EnemyState.Patrol;
            patrolTimer = 0f;
            Debug.Log("Enemy State: Idle -> Patrol");
        }
    }
    void UpdatePatrolState()
    {
        // 简单的巡逻逻辑：来回移动
        transform.Translate(Vector3.forward * patrolSpeed * Time.deltaTime);
        // 检测是否到达巡逻点（这里简化为距离判断，实际应用中可以使用更复杂的巡逻点系统）
        if (Vector3.Distance(transform.position, Vector3.zero) > 10f)
        {
            transform.rotation = Quaternion.LookRotation(-transform.position.normalized); // 反向
        }
        // 检测玩家是否进入追逐范围
        if (playerTransform != null && Vector3.Distance(transform.position, playerTransform.position) < 10f)
        {
            currentState = EnemyState.Chase;
            Debug.Log("Enemy State: Patrol -> Chase");
        }
    }
    void UpdateChaseState()
    {
        if (playerTransform == null)
        {
            currentState = EnemyState.Patrol; // 玩家丢失，返回巡逻
            Debug.Log("Enemy State: Chase -> Patrol (Player Lost)");
            return;
        }
        // 朝向玩家并移动
        transform.rotation = Quaternion.LookRotation(playerTransform.position - transform.position);
        transform.Translate(Vector3.forward * chaseSpeed * Time.deltaTime);
        // 检测是否进入攻击范围
        if (Vector3.Distance(transform.position, playerTransform.position) <= attackRange)
        {
            currentState = EnemyState.Attack;
            Debug.Log("Enemy State: Chase -> Attack");
        }
        // 检测玩家是否超出追逐范围，返回巡逻
        if (Vector3.Distance(transform.position, playerTransform.position) > 15f)
        {
            currentState = EnemyState.Patrol;
            Debug.Log("Enemy State: Chase -> Patrol (Player Out of Range)");
        }
    }
    void UpdateAttackState()
    {
        if (playerTransform == null)
        {
            currentState = EnemyState.Patrol; // 玩家丢失，返回巡逻
            Debug.Log("Enemy State: Attack -> Patrol (Player Lost)");
            return;
        }
        // 保持朝向玩家
        transform.rotation = Quaternion.LookRotation(playerTransform.position - transform.position);
        // 执行攻击动作 (这里简化为打印日志)
        Debug.Log("Enemy Attacking Player!");
        // 检测玩家是否超出攻击范围，返回追逐状态
        if (Vector3.Distance(transform.position, playerTransform.position) > attackRange)
        {
            currentState = EnemyState.Chase;
            Debug.Log("Enemy State: Attack -> Chase");
        }
    }
}

代码详解:

EnemyState 枚举: 定义了敌人的几种状态：Idle (空闲)、Patrol (巡逻)、Chase (追逐)、Attack (攻击)。
currentState 变量: 存储敌人当前的状态，初始状态设置为 Idle。
速度和范围参数: patrolSpeed, chaseSpeed, attackRange 等变量控制敌人在不同状态下的行为参数。
playerTransform 变量: 用于追踪玩家的位置，需要手动在 Unity 编辑器中将玩家的 Transform 组件拖拽到这个变量上。
Update() 函数: 每帧执行，根据 currentState 的值调用不同的状态更新函数。
状态更新函数 (UpdateIdleState, UpdatePatrolState, UpdateChaseState, UpdateAttackState):
- UpdateIdleState: 敌人处于空闲状态，等待一段时间后切换到 Patrol 状态。
- UpdatePatrolState: 敌人进行简单的巡逻移动，并在巡逻过程中检测玩家是否进入追逐范围，如果进入则切换到 Chase 状态。
- UpdateChaseState: 敌人追逐玩家，并检测是否进入攻击范围，如果进入则切换到 Attack 状态。同时检测玩家是否超出追逐范围，如果超出则返回 Patrol 状态。
- UpdateAttackState: 敌人攻击玩家，并检测玩家是否超出攻击范围，如果超出则返回 Chase 状态。
状态切换逻辑: 在每个状态更新函数中，都包含了状态切换的逻辑，基于条件判断 (例如距离、时间) 来改变 currentState 的值，从而实现状态的转换。

使用方法:

在 Unity 中创建一个新的 C# 脚本，命名为 EnemyFSM。
将上述代码复制粘贴到脚本中。
创建一个 3D 物体作为敌人，例如 Cube 或 Capsule。
将 EnemyFSM 脚本添加到敌人物体上。
创建一个 3D 物体作为玩家，例如 Capsule。
将玩家物体的 Transform 组件拖拽到敌人物体 EnemyFSM 组件的 Player Transform 属性上。
运行游戏，观察敌人的行为。

状态机的优势与局限性:

优势:
- 简单易懂: 状态机概念直观，易于理解和实现。
- 高效: 状态机执行效率高，适合资源有限的游戏环境。
- 易于调试: 状态机的状态转换逻辑清晰，方便调试和维护。
局限性:
- 状态爆炸: 当 AI 行为变得复杂时，状态数量会急剧增加，导致状态机变得难以管理和维护。
- 缺乏灵活性: 状态机状态之间的转换是预先定义好的，难以应对复杂多变的游戏环境和玩家行为。
- 不适合复杂行为: 对于需要复杂决策和规划的 AI 行为，状态机显得力不从心。

4.10.3 行为树 (Behavior Tree) 的实践与详解

行为树 (BT) 是一种更高级、更灵活的行为建模方法，可以克服状态机的局限性，构建更复杂的 AI 系统。行为树以树状结构组织 AI 行为，每个节点代表一个行为或条件判断。

行为树原理图 (Mermaid Graph):

行为树节点类型:

根节点 (Root Node): 行为树的入口，通常是一个复合节点。
复合节点 (Composite Nodes): 控制子节点的执行流程。
- Sequence (序列节点): 按顺序执行子节点，如果所有子节点都成功，则序列节点返回成功；如果任何子节点失败，则序列节点立即返回失败。
- Selector (选择节点): 按顺序执行子节点，如果任何子节点成功，则选择节点立即返回成功；如果所有子节点都失败，则选择节点返回失败。
- Parallel (并行节点): 并行执行子节点，根据具体实现方式决定返回结果。
行为节点 (Action Nodes): 执行具体的行为，例如移动、攻击、巡逻等。
条件节点 (Condition Nodes): 判断条件是否满足，返回成功或失败。
装饰节点 (Decorator Nodes): 修饰子节点的行为，例如重复执行、条件判断等。

代码实践 (C# - Unity - 简化示例，实际应用中通常会使用行为树库):


using UnityEngine;
using System.Collections.Generic;
// 行为树节点基类
public abstract class BTNode
{
    public abstract BTNodeResult Execute();
}
// 行为树节点执行结果
public enum BTNodeResult
{
    Success,
    Failure,
    Running
}
// 序列节点
public class BTSequence : BTNode
{
    protected List<BTNode> children = new List<BTNode>();
    public BTSequence(List<BTNode> children)
    {
        this.children = children;
    }
    public override BTNodeResult Execute()
    {
        foreach (var node in children)
        {
            BTNodeResult result = node.Execute();
            if (result == BTNodeResult.Failure)
            {
                return BTNodeResult.Failure; // 序列中任何节点失败，则序列失败
            }
            if (result == BTNodeResult.Running)
            {
                return BTNodeResult.Running; // 如果有节点正在运行，则序列也正在运行
            }
        }
        return BTNodeResult.Success; // 所有节点都成功，则序列成功
    }
}
// 选择节点
public class BTSelector : BTNode
{
    protected List<BTNode> children = new List<BTNode>();
    public BTSelector(List<BTNode> children)
    {
        this.children = children;
    }
    public override BTNodeResult Execute()
    {
        foreach (var node in children)
        {
            BTNodeResult result = node.Execute();
            if (result == BTNodeResult.Success)
            {
                return BTNodeResult.Success; // 任何节点成功，则选择成功
            }
            if (result == BTNodeResult.Running)
            {
                return BTNodeResult.Running; // 如果有节点正在运行，则选择也正在运行
            }
        }
        return BTNodeResult.Failure; // 所有节点都失败，则选择失败
    }
}
// 行为节点 - 巡逻
public class BTActionPatrol : BTNode
{
    private Transform transform;
    private float speed;
    public BTActionPatrol(Transform transform, float speed)
    {
        this.transform = transform;
        this.speed = speed;
    }
    public override BTNodeResult Execute()
    {
        // 简单的巡逻逻辑 (与状态机示例类似)
        transform.Translate(Vector3.forward * speed * Time.deltaTime);
        if (Vector3.Distance(transform.position, Vector3.zero) > 10f)
        {
            transform.rotation = Quaternion.LookRotation(-transform.position.normalized);
        }
        return BTNodeResult.Success; // 巡逻行为总是成功 (简化示例)
    }
}
// 条件节点 - 检测玩家是否可见 (简化示例)
public class BTConditionCheckPlayerVisible : BTNode
{
    private Transform transform;
    private Transform playerTransform;
    private float viewRange;
    public BTConditionCheckPlayerVisible(Transform transform, Transform playerTransform, float viewRange)
    {
        this.transform = transform;
        this.playerTransform = playerTransform;
        this.viewRange = viewRange;
    }
    public override BTNodeResult Execute()
    {
        if (playerTransform != null && Vector3.Distance(transform.position, playerTransform.position) < viewRange)
        {
            Debug.Log("Player Visible!");
            return BTNodeResult.Success; // 玩家可见
        }
        return BTNodeResult.Failure; // 玩家不可见
    }
}
public class EnemyBTController : MonoBehaviour
{
    private BTNode rootNode;
    public Transform playerTransform;
    public float patrolSpeed = 2f;
    public float viewRange = 10f;
    void Start()
    {
        // 构建行为树
        rootNode = new BTSelector(new List<BTNode>()
        {
            new BTSequence(new List<BTNode>()
            {
                new BTConditionCheckPlayerVisible(transform, playerTransform, viewRange), // 条件: 检测玩家是否可见
                new BTActionPatrol(transform, patrolSpeed) // 行为: 巡逻 (如果玩家不可见)
            }),
            new BTActionPatrol(transform, patrolSpeed) // 行为: 巡逻 (如果玩家不可见)
        });
    }
    void Update()
    {
        rootNode.Execute(); // 每帧执行行为树
    }
}

代码详解:

BTNode 抽象基类: 定义了所有行为树节点的基类，包含一个抽象方法 Execute()，用于执行节点逻辑并返回 BTNodeResult。
BTNodeResult 枚举: 定义了节点执行结果：Success (成功)、Failure (失败)、Running (正在运行)。
BTSequence 序列节点: 继承自 BTNode，包含一个子节点列表 children。Execute() 方法按顺序执行子节点，并根据子节点的执行结果决定序列节点的返回结果。
BTSelector 选择节点: 继承自 BTNode，也包含一个子节点列表 children。Execute() 方法按顺序执行子节点，并根据子节点的执行结果决定选择节点的返回结果。
BTActionPatrol 行为节点: 继承自 BTNode，实现巡逻行为。
BTConditionCheckPlayerVisible 条件节点: 继承自 BTNode，检测玩家是否在视野范围内。
EnemyBTController: MonoBehaviour 组件，负责创建和执行行为树。
- rootNode 变量: 存储行为树的根节点。
- Start() 函数: 在游戏开始时构建行为树。
- Update() 函数: 每帧调用 rootNode.Execute() 执行行为树。

行为树构建示例 (Start() 函数中):


rootNode = new BTSelector(new List<BTNode>()
{
    new BTSequence(new List<BTNode>()
    {
        new BTConditionCheckPlayerVisible(transform, playerTransform, viewRange), // 条件: 检测玩家是否可见
        new BTActionPatrol(transform, patrolSpeed) // 行为: 巡逻 (如果玩家不可见)
    }),
    new BTActionPatrol(transform, patrolSpeed) // 行为: 巡逻 (如果玩家不可见)
});

这段代码构建了一个简单的行为树，根节点是一个 Selector 选择节点。选择节点包含两个子节点：

第一个子节点: 是一个 Sequence 序列节点，序列节点包含两个子节点：
- BTConditionCheckPlayerVisible: 条件节点，检测玩家是否可见。
- BTActionPatrol: 行为节点，执行巡逻行为。
第二个子节点: BTActionPatrol: 行为节点，执行巡逻行为。

行为树的执行逻辑:

根节点 Selector 执行: 选择节点按顺序执行子节点。
执行第一个子节点 Sequence: 序列节点按顺序执行子节点。
执行 BTConditionCheckPlayerVisible: 检测玩家是否可见，如果可见，返回 Success；否则返回 Failure。
如果 BTConditionCheckPlayerVisible 返回 Success: 序列节点继续执行下一个子节点 BTActionPatrol。
如果 BTConditionCheckPlayerVisible 返回 Failure: 序列节点立即返回 Failure，选择节点 Selector 继续执行下一个子节点 BTActionPatrol。
执行 BTActionPatrol: 执行巡逻行为，并返回 Success (简化示例)。
选择节点 Selector 根据子节点的执行结果决定自身的返回结果: 如果任何子节点返回 Success，则选择节点返回 Success；如果所有子节点都返回 Failure，则选择节点返回 Failure。

行为树的优势与局限性:

优势:
- 模块化: 行为树节点可以独立开发和测试，易于重用和组合。
- 可读性: 行为树结构清晰直观，易于理解和维护。
- 灵活性: 行为树可以轻松扩展和修改，适应复杂多变的游戏环境和玩家行为。
- 可重用性: 行为树节点可以跨多个 AI 角色重用，提高开发效率。
局限性:
- 复杂性: 对于非常复杂的 AI 行为，行为树可能会变得庞大复杂，管理难度增加。
- 学习曲线: 相比状态机，行为树的学习曲线稍高。
- 性能开销: 相比状态机，行为树的执行可能会有一定的性能开销，尤其是在节点数量庞大且逻辑复杂的情况下。 (但通常在现代硬件上可以忽略不计)

实际应用中行为树库:

在实际 Unity 项目中，通常会使用现成的行为树库，例如：

Behavior Designer: Unity Asset Store 上流行的行为树插件，提供可视化编辑器和丰富的节点库。
Node Canvas: 另一个流行的可视化脚本工具，也包含行为树功能。
开源行为树库: 例如 BTSharp 等。

使用行为树库可以极大地简化行为树的创建、编辑和管理，提高开发效率。

4.10.4 导航网格 (NavMesh) 的实践与详解

导航网格 (NavMesh) 是 Unity3D 内置的强大的寻路系统，用于实现 AI 角色的智能寻路。NavMesh 预先计算并存储了场景中可行走区域的信息，AI 角色可以利用 NavMesh 快速高效地找到到达目标点的路径。

NavMesh 工作流程:

烘焙 (Baking) 导航网格: 使用 Unity 编辑器中的 Navigation 窗口，根据场景中的静态物体 (例如地面、墙壁、建筑) 生成导航网格数据。
NavMesh Agent 组件: 为 AI 角色添加 NavMeshAgent 组件，该组件负责控制角色在导航网格上的移动。
路径规划: 使用 NavMeshAgent.SetDestination() 方法设置目标点，NavMeshAgent 会自动计算从当前位置到目标点的路径。
运动控制: NavMeshAgent 组件会自动控制角色的移动和转向，使其沿着计算出的路径移动到目标点。

代码实践 (C# - Unity):


using UnityEngine;
using UnityEngine.AI;
public class NavMeshAgentController : MonoBehaviour
{
    public Transform targetTransform;
    private NavMeshAgent navMeshAgent;
    void Start()
    {
        navMeshAgent = GetComponent<NavMeshAgent>();
        if (navMeshAgent == null)
        {
            Debug.LogError("NavMeshAgent component not found on this GameObject!");
            enabled = false; // 禁用脚本
            return;
        }
        if (targetTransform == null)
        {
            Debug.LogError("Target Transform is not assigned!");
            enabled = false; // 禁用脚本
            return;
        }
    }
    void Update()
    {
        // 设置导航目标为目标物体的 Transform
        navMeshAgent.SetDestination(targetTransform.position);
    }
}

代码详解:

NavMeshAgentController: MonoBehaviour 组件，用于控制 NavMeshAgent。
targetTransform 变量: 目标物体的 Transform 组件，需要手动在 Unity 编辑器中拖拽赋值。
navMeshAgent 变量: 存储当前物体的 NavMeshAgent 组件。
Start() 函数:
- 获取当前物体的 NavMeshAgent 组件。
- 检查 NavMeshAgent 组件和 targetTransform 是否成功获取，如果失败则禁用脚本并输出错误日志。
Update() 函数: 每帧调用 navMeshAgent.SetDestination(targetTransform.position)，设置导航目标为目标物体的位置。NavMeshAgent 组件会自动计算路径并控制角色移动。

使用方法:

烘焙 NavMesh:
- 打开 Navigation 窗口 (Window -> AI -> Navigation)。
- 在 Scene 视图中，选择所有静态物体 (例如地面、墙壁、建筑)。
- 在 Navigation 窗口的 Object 标签页，将这些物体设置为 Navigation Static。
- 在 Navigation 窗口的 Bake 标签页，点击 Bake 按钮，生成导航网格。
创建一个 3D 物体作为 AI 角色，例如 Capsule。
为 AI 角色添加 NavMeshAgent 组件 (Component -> Navigation -> NavMesh Agent)。
创建一个 3D 物体作为目标点，例如 Sphere。
创建一个新的 C# 脚本，命名为 NavMeshAgentController。
将上述代码复制粘贴到脚本中。
将 NavMeshAgentController 脚本添加到 AI 角色物体上。
将目标点物体的 Transform 组件拖拽到 AI 角色物体 NavMeshAgentController 组件的 Target Transform 属性上。
运行游戏，观察 AI 角色是否能够自动寻路到目标点。

NavMesh 的优势与局限性:

优势:
- 高效: NavMesh 寻路效率高，适合复杂场景和大量 AI 角色。
- 易用: Unity NavMesh 系统易于使用，集成度高。
- 自动寻路: NavMeshAgent 组件自动处理路径规划和运动控制，开发者只需设置目标点即可。
- 支持动态障碍物: NavMesh 可以与 NavMesh Obstacle 组件配合使用，处理动态障碍物。
局限性:
- 静态环境: NavMesh 通常适用于静态场景，对于动态变化剧烈的场景，需要动态更新 NavMesh 或使用其他寻路技术。
- 内存占用: NavMesh 数据会占用一定的内存，尤其是在大型复杂场景中。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/221-unity3d%E6%B8%B8%E6%88%8F%E5%BC%80%E5%8F%91%E5%AE%9E%E6%88%98%E6%95%99%E7%A8%8B

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流