跳至主要內容

16. 敌人创建与战斗AI

EVOCOSMOS2026/4/14大约 15 分钟

敌人创建与战斗AI

敌人角色的场景结构

创建一个有智能行为的敌人，就像给游戏角色装上一个"大脑"。敌人需要知道：自己在哪、玩家在哪、什么时候追、什么时候打。

各节点的作用说明：

节点作用比喻
CharacterBody3D敌人物理主体敌人的身体
CollisionShape3D敌人的碰撞形状敌人的"边界"
MeshInstance3D敌人的外观模型敌人的"长相"
NavigationAgent3DAI 寻路组件敌人的"地图导航"
Area3D（检测范围）感知玩家进入范围敌人的"眼睛和耳朵"
Area3D（攻击范围）判断能否攻击敌人的"手臂长度"
RayCast3D检查视线是否被遮挡敌人的"凝视"
Node（AI控制器）控制行为状态切换敌人的"大脑"

为什么需要 NavigationAgent3D？

如果敌人只是朝玩家"直线"跑过去，遇到墙壁就会被卡住。NavigationAgent3D 就像手机里的导航软件——它能自动规划一条绕过障碍物的路线，让敌人聪明地追击玩家。

巡逻行为（PatrolState）

巡逻是敌人最基本的行为——在没有发现玩家时，在几个固定点之间来回走动，就像保安在巡逻。

C#
// 巡逻行为
using Godot;
using System.Collections.Generic;

public partial class PatrolState : Node
{
    [Export] public float PatrolSpeed { get; set; } = 2.0f;
    [Export] public float WaitTimeAtPoint { get; set; } = 2.0f;
    [Export] public float ArrivalThreshold { get; set; } = 0.5f;

    private CharacterBody3D _enemy;
    private NavigationAgent3D _navAgent;
    private List<Vector3> _patrolPoints = new();
    private int _currentPointIndex;
    private double _waitTimer;
    private bool _isWaiting;

    public override void _Ready()
    {
        _enemy = GetParent() as CharacterBody3D;
        _navAgent = _enemy.GetNode<NavigationAgent3D>("NavigationAgent3D");
    }

    /// <summary>设置巡逻点</summary>
    public void SetPatrolPoints(Vector3[] points)
    {
        _patrolPoints.Clear();
        _patrolPoints.AddRange(points);
        _currentPointIndex = 0;
        MoveToNextPoint();
    }

    public override void _PhysicsProcess(double delta)
    {
        if (_patrolPoints.Count == 0) return;

        if (_isWaiting)
        {
            _waitTimer -= delta;
            if (_waitTimer <= 0)
            {
                _isWaiting = false;
                _currentPointIndex = (_currentPointIndex + 1) % _patrolPoints.Count;
                MoveToNextPoint();
            }
            return;
        }

        // 检查是否到达巡逻点
        Vector3 targetPos = _navAgent.GetNextPathPosition();
        Vector3 direction = (targetPos - _enemy.GlobalPosition);
        direction.Y = 0; // 忽略Y轴
        float distance = direction.Length();

        if (distance <= ArrivalThreshold)
        {
            // 到达巡逻点，等待一会儿
            _isWaiting = true;
            _waitTimer = WaitTimeAtPoint;
            _enemy.Velocity = Vector3.Zero;
        }
        else
        {
            // 朝下一个路径点移动
            direction = direction.Normalized();
            Vector3 velocity = _enemy.Velocity;
            velocity.X = direction.X * PatrolSpeed;
            velocity.Z = direction.Z * PatrolSpeed;
            _enemy.Velocity = velocity;

            // 让敌人面向移动方向
            if (direction != Vector3.Zero)
            {
                _enemy.LookAt(
                    new Vector3(targetPos.X, _enemy.GlobalPosition.Y, targetPos.Z),
                    Vector3.Up
                );
            }
        }

        _enemy.MoveAndSlide();
    }

    private void MoveToNextPoint()
    {
        if (_patrolPoints.Count > 0)
        {
            _navAgent.TargetPosition = _patrolPoints[_currentPointIndex];
        }
    }
}

追击行为（ChaseState）

当敌人发现玩家后，会切换到追击状态——全力追向玩家。

C#
// 追击行为
using Godot;

public partial class ChaseState : Node
{
    [Export] public float ChaseSpeed { get; set; } = 4.5f;
    [Export] public float LosePlayerDistance { get; set; } = 15.0f;

    private CharacterBody3D _enemy;
    private NavigationAgent3D _navAgent;
    private Node3D _player;

    public override void _Ready()
    {
        _enemy = GetParent() as CharacterBody3D;
        _navAgent = _enemy.GetNode<NavigationAgent3D>("NavigationAgent3D");
    }

    /// <summary>设置玩家引用</summary>
    public void SetPlayer(Node3D player)
    {
        _player = player;
    }

    public override void _PhysicsProcess(double delta)
    {
        if (_player == null) return;

        // 更新寻路目标为玩家位置
        _navAgent.TargetPosition = _player.GlobalPosition;

        // 获取下一个路径点
        Vector3 nextPos = _navAgent.GetNextPathPosition();
        Vector3 direction = (nextPos - _enemy.GlobalPosition);
        direction.Y = 0;
        float distance = direction.Length();

        // 如果距离玩家太远，失去目标
        float distToPlayer = _enemy.GlobalPosition.DistanceTo(_player.GlobalPosition);
        if (distToPlayer > LosePlayerDistance)
        {
            GD.Print("失去玩家目标，返回巡逻");
            // 通知 AI 控制器切换回巡逻状态
            GetParent().Call("SwitchToPatrol");
            return;
        }

        // 朝玩家方向移动
        if (direction != Vector3.Zero)
        {
            direction = direction.Normalized();
            Vector3 velocity = _enemy.Velocity;
            velocity.X = direction.X * ChaseSpeed;
            velocity.Z = direction.Z * ChaseSpeed;
            _enemy.Velocity = velocity;

            // 面向玩家
            _enemy.LookAt(
                new Vector3(_player.GlobalPosition.X, _enemy.GlobalPosition.Y, _player.GlobalPosition.Z),
                Vector3.Up
            );
        }

        _enemy.MoveAndSlide();
    }
}

攻击行为（AttackState）

当敌人足够接近玩家时，开始攻击。

C#
// 攻击行为
using Godot;

public partial class AttackState : Node
{
    [Export] public int AttackDamage { get; set; } = 10;
    [Export] public float AttackRange { get; set; } = 2.0f;
    [Export] public float AttackCooldown { get; set; } = 1.0f;
    [Export] public float AttackDuration { get; set; } = 0.5f;

    private CharacterBody3D _enemy;
    private Node3D _player;
    private double _cooldownTimer;
    private double _attackTimer;
    private bool _isAttacking;
    private bool _hasHitThisAttack;

    public override void _Ready()
    {
        _enemy = GetParent() as CharacterBody3D;
    }

    public void SetPlayer(Node3D player)
    {
        _player = player;
    }

    public override void _PhysicsProcess(double delta)
    {
        if (_player == null) return;

        float distToPlayer = _enemy.GlobalPosition.DistanceTo(_player.GlobalPosition);

        // 如果玩家跑出了攻击范围，切换回追击
        if (distToPlayer > AttackRange * 1.5f)
        {
            GD.Print("玩家跑远了，继续追击");
            GetParent().Call("SwitchToChase");
            return;
        }

        // 面向玩家
        _enemy.LookAt(
            new Vector3(_player.GlobalPosition.X, _enemy.GlobalPosition.Y, _player.GlobalPosition.Z),
            Vector3.Up
        );

        // 攻击中
        if (_isAttacking)
        {
            _attackTimer -= delta;
            if (_attackTimer <= 0)
            {
                _isAttacking = false;
            }
            return;
        }

        // 冷却中
        if (_cooldownTimer > 0)
        {
            _cooldownTimer -= delta;
            return;
        }

        // 执行攻击
        if (distToPlayer <= AttackRange)
        {
            PerformAttack();
        }
    }

    private void PerformAttack()
    {
        _isAttacking = true;
        _hasHitThisAttack = false;
        _attackTimer = AttackDuration;
        _cooldownTimer = AttackCooldown;

        // 对玩家造成伤害
        if (_player.HasMethod("TakeDamage"))
        {
            _player.Call("TakeDamage", AttackDamage);
        }

        GD.Print($"敌人攻击玩家，造成 {AttackDamage} 点伤害！");
    }
}

AI 寻路完整实现

使用 NavigationRegion3D + NavigationAgent3D 实现 AI 寻路，是让敌人"聪明"的关键。

首先，在场景中添加 NavigationRegion3D 节点并烘焙导航网格。然后在敌人上使用 NavigationAgent3D：

C#
// 完整的敌人 AI 控制器
using Godot;

public enum EnemyState
{
    Patrol,
    Chase,
    Attack,
    Flee,
    Dead
}

public partial class EnemyAIController : Node
{
    [Export] public float DetectionRange { get; set; } = 10.0f;
    [Export] public float FieldOfView { get; set; } = 120.0f;
    [Export] public float AttackRange { get; set; } = 2.0f;
    [Export] public float LoseSightRange { get; set; } = 15.0f;
    [Export] public float FleeHealthPercent { get; set; } = 0.2f;

    private EnemyState _currentState = EnemyState.Patrol;
    private CharacterBody3D _enemy;
    private NavigationAgent3D _navAgent;
    private RayCast3D _lineOfSight;
    private Area3D _detectionArea;
    private Node3D _player;
    private PatrolState _patrolState;
    private ChaseState _chaseState;
    private AttackState _attackState;

    // 仇恨系统
    private int _aggroScore;

    public override void _Ready()
    {
        _enemy = GetParent() as CharacterBody3D;
        _navAgent = _enemy.GetNode<NavigationAgent3D>("NavigationAgent3D");
        _lineOfSight = _enemy.GetNode<RayCast3D>("LineOfSight");
        _detectionArea = _enemy.GetNode<Area3D>("DetectionArea");

        // 获取状态组件
        _patrolState = GetNode<PatrolState>("PatrolState");
        _chaseState = GetNode<ChaseState>("ChaseState");
        _attackState = GetNode<AttackState>("AttackState");

        // 初始化巡逻点
        _patrolState.SetPatrolPoints(new Vector3[]
        {
            new(5, 0, 5),
            new(-5, 0, 5),
            new(-5, 0, -5),
            new(5, 0, -5)
        });

        // 检测区域信号
        _detectionArea.BodyEntered += OnBodyEntered;
        _detectionArea.BodyExited += OnBodyExited;

        GD.Print("敌人 AI 初始化完成");
    }

    public override void _PhysicsProcess(double delta)
    {
        if (_currentState == EnemyState.Dead) return;

        // 更新状态
        UpdateState();

        // 仇恨系统衰减
        if (_aggroScore > 0)
        {
            _aggroScore = Mathf.Max(0, _aggroScore - 1);
        }
    }

    private void UpdateState()
    {
        if (_player == null)
        {
            if (_currentState != EnemyState.Patrol)
                SwitchState(EnemyState.Patrol);
            return;
        }

        float distToPlayer = _enemy.GlobalPosition.DistanceTo(_player.GlobalPosition);

        switch (_currentState)
        {
            case EnemyState.Patrol:
                if (CanSeePlayer())
                {
                    SwitchState(EnemyState.Chase);
                }
                break;

            case EnemyState.Chase:
                if (distToPlayer <= AttackRange)
                {
                    SwitchState(EnemyState.Attack);
                }
                else if (distToPlayer > LoseSightRange || !CanSeePlayer())
                {
                    SwitchState(EnemyState.Patrol);
                }
                break;

            case EnemyState.Attack:
                if (distToPlayer > AttackRange * 1.5f)
                {
                    SwitchState(EnemyState.Chase);
                }
                break;

            case EnemyState.Flee:
                if (distToPlayer > LoseSightRange)
                {
                    SwitchState(EnemyState.Patrol);
                }
                break;
        }
    }

    /// <summary>检查是否能"看到"玩家</summary>
    private bool CanSeePlayer()
    {
        if (_player == null) return false;

        Vector3 toPlayer = _player.GlobalPosition - _enemy.GlobalPosition;
        float distance = toPlayer.Length();

        // 距离检测
        if (distance > DetectionRange) return false;

        // 角度检测（视野锥）
        Vector3 forward = -_enemy.GlobalTransform.Basis.Z;
        float angle = Mathf.RadToDeg(forward.AngleTo(toPlayer.Normalized()));
        if (angle > FieldOfView / 2.0f) return false;

        // 射线检测（是否有遮挡物）
        _lineOfSight.LookAt(_player.GlobalPosition, Vector3.Up);
        _lineOfSight.ForceRaycastUpdate();
        if (_lineOfSight.IsColliding())
        {
            var hit = _lineOfSight.GetCollider();
            return hit == _player; // 只有直接看到玩家才算
        }

        return false;
    }

    private void SwitchState(EnemyState newState)
    {
        if (_currentState == newState) return;

        GD.Print($"敌人状态：{_currentState} → {newState}");
        _currentState = newState;

        // 禁用所有状态组件
        SetStateActive(_patrolState, false);
        SetStateActive(_chaseState, false);
        SetStateActive(_attackState, false);

        // 启用当前状态
        switch (newState)
        {
            case EnemyState.Patrol:
                SetStateActive(_patrolState, true);
                break;
            case EnemyState.Chase:
                _chaseState.SetPlayer(_player);
                SetStateActive(_chaseState, true);
                break;
            case EnemyState.Attack:
                _attackState.SetPlayer(_player);
                SetStateActive(_attackState, true);
                break;
            case EnemyState.Dead:
                _enemy.SetPhysicsProcess(false);
                break;
        }
    }

    private void SetStateActive(Node state, bool active)
    {
        state.SetProcess(active);
        state.SetPhysicsProcess(active);
    }

    private void OnBodyEntered(Node3D body)
    {
        if (body.IsInGroup("player"))
        {
            _player = body;
            GD.Print("发现玩家！");
        }
    }

    private void OnBodyExited(Node3D body)
    {
        if (body == _player)
        {
            _player = null;
            GD.Print("玩家离开检测范围");
        }
    }

    // 公开方法，供状态组件调用
    public void SwitchToPatrol() => SwitchState(EnemyState.Patrol);
    public void SwitchToChase() => SwitchState(EnemyState.Chase);

    /// <summary>被攻击时增加仇恨值</summary>
    public void AddAggro(int amount)
    {
        _aggroScore += amount;
        GD.Print($"仇恨值增加：{_aggroScore}");

        // 仇恨足够高时立即进入追击状态
        if (_aggroScore > 5 && _player != null)
        {
            SwitchState(EnemyState.Chase);
        }
    }
}

视野检测详解

视野检测是判断敌人能否"看到"玩家的核心逻辑，需要同时满足三个条件：

  1. 距离判断：玩家是否在检测范围内
  2. 角度判断：玩家是否在敌人的视野锥内
  3. 遮挡判断：敌人到玩家之间是否有墙壁等障碍物
C#
// 独立的视野检测工具类
using Godot;

public static class VisionUtils
{
    /// <summary>
    /// 检查敌人是否能看到目标
    /// </summary>
    /// <param name="observer">观察者（敌人）</param>
    /// <param name="target">目标（玩家）</param>
    /// <param name="maxRange">最大视野距离</param>
    /// <param name="fovDegrees">视野角度（度）</param>
    /// <param name="raycast">用于遮挡检测的射线</param>
    public static bool CanSeeTarget(
        Node3D observer,
        Node3D target,
        float maxRange,
        float fovDegrees,
        RayCast3D raycast
    )
    {
        Vector3 toTarget = target.GlobalPosition - observer.GlobalPosition;
        float distance = toTarget.Length();

        // 第1步：距离检测
        if (distance > maxRange) return false;

        // 第2步：角度检测
        Vector3 forward = -observer.GlobalTransform.Basis.Z;
        float angle = Mathf.RadToDeg(forward.AngleTo(toTarget.Normalized()));
        if (angle > fovDegrees / 2.0f) return false;

        // 第3步：遮挡检测（射线）
        raycast.GlobalPosition = observer.GlobalPosition + Vector3.Up * 1.0f;
        raycast.TargetPosition = raycast.ToLocal(
            target.GlobalPosition + Vector3.Up * 1.0f
        );
        raycast.ForceRaycastUpdate();

        if (raycast.IsColliding())
        {
            var hit = raycast.GetCollider();
            // 如果射线碰到的不是目标，说明被遮挡
            if (hit != target) return false;
        }

        return true;
    }
}

仇恨系统

仇恨系统决定了敌人"优先攻击谁"。当多个玩家攻击同一个敌人时，对敌人造成伤害最多的玩家会获得最高的仇恨值，敌人会优先追击高仇恨的玩家。

C#
// 仇恨系统
using Godot;
using System.Collections.Generic;

public partial class AggroSystem : Node
{
    private readonly Dictionary<Node3D, int> _aggroTable = new();

    /// <summary>增加对某个目标的仇恨值</summary>
    public void AddAggro(Node3D target, int amount)
    {
        if (!_aggroTable.ContainsKey(target))
        {
            _aggroTable[target] = 0;
        }
        _aggroTable[target] += amount;
    }

    /// <summary>获取仇恨值最高的目标</summary>
    public Node3D GetHighestAggroTarget()
    {
        Node3D highest = null;
        int maxAggro = 0;

        foreach (var pair in _aggroTable)
        {
            if (pair.Value > maxAggro && IsInstanceValid(pair.Key))
            {
                maxAggro = pair.Value;
                highest = pair.Key;
            }
        }

        return highest;
    }

    /// <summary>清除某个目标的仇恨</summary>
    public void RemoveTarget(Node3D target)
    {
        _aggroTable.Remove(target);
    }

    /// <summary>清除所有仇恨</summary>
    public void ClearAll()
    {
        _aggroTable.Clear();
    }
}

三种敌人类型设计

属性近战型（战士）远程型（射手）Boss 型
生命值8050500
移动速度3.52.53.0
攻击伤害151030
攻击范围2.015.04.0
攻击冷却1.0s2.0s0.8s
检测范围8.012.015.0
视野角度120度180度360度
特殊能力无无范围攻击、召唤小兵
碰撞形状CapsuleShape3DCapsuleShape3D更大的 CapsuleShape3D
掉落奖励少量金币中量金币大量金币 + 稀有装备
C#
// 敌人类型配置
using Godot;

public enum EnemyType
{
    Melee,
    Ranged,
    Boss
}

[GlobalClass]
public partial class EnemyConfig : Resource
{
    [Export] public EnemyType Type { get; set; }
    [Export] public int MaxHealth { get; set; }
    [Export] public float MoveSpeed { get; set; }
    [Export] public int AttackDamage { get; set; }
    [Export] public float AttackRange { get; set; }
    [Export] public float AttackCooldown { get; set; }
    [Export] public float DetectionRange { get; set; }
    [Export] public float FieldOfView { get; set; }

    /// <summary>创建近战型敌人配置</summary>
    public static EnemyConfig CreateMelee()
    {
        return new EnemyConfig
        {
            Type = EnemyType.Melee,
            MaxHealth = 80,
            MoveSpeed = 3.5f,
            AttackDamage = 15,
            AttackRange = 2.0f,
            AttackCooldown = 1.0f,
            DetectionRange = 8.0f,
            FieldOfView = 120.0f
        };
    }

    /// <summary>创建远程型敌人配置</summary>
    public static EnemyConfig CreateRanged()
    {
        return new EnemyConfig
        {
            Type = EnemyType.Ranged,
            MaxHealth = 50,
            MoveSpeed = 2.5f,
            AttackDamage = 10,
            AttackRange = 15.0f,
            AttackCooldown = 2.0f,
            DetectionRange = 12.0f,
            FieldOfView = 180.0f
        };
    }

    /// <summary>创建 Boss 型敌人配置</summary>
    public static EnemyConfig CreateBoss()
    {
        return new EnemyConfig
        {
            Type = EnemyType.Boss,
            MaxHealth = 500,
            MoveSpeed = 3.0f,
            AttackDamage = 30,
            AttackRange = 4.0f,
            AttackCooldown = 0.8f,
            DetectionRange = 15.0f,
            FieldOfView = 360.0f
        };
    }
}

常见问题

问题：敌人不移动或直线穿墙。

解决方案：

  1. 确保场景中有 NavigationRegion3D 节点
  2. 在 NavigationRegion3D 上烘焙导航网格（点击 Bake 按钮）
  3. 确保 NavigationAgent3D 的 Avoidance Enabled 可选开启
  4. 确认敌人的位置在导航网格范围内

视野检测不准确

问题：敌人背对玩家也能"看到"。

解决方案：

  1. 检查 FieldOfView 角度设置是否合理（建议 90-120 度）
  2. 确认 forward 方向计算正确（-GlobalTransform.Basis.Z）
  3. 确保角度比较时使用的是正确的度数/弧度单位

敌人卡在墙角

问题：敌人在拐角处卡住不动。

解决方案：

  1. 重新烘焙导航网格，确保拐角处有足够空间
  2. 增加导航网格的边距（Margin）
  3. 降低敌人移动速度

调试 AI 行为的方法

在 Godot 编辑器中，运行游戏后点击 Debug → Visible Navigation 可以看到导航网格的蓝色覆盖层。同时，可以在 NavigationAgent3D 上开启 Debug Enabled 属性，这样在运行时会用线条显示敌人的寻路路径。

本章小结

本章我们学习了完整的敌人 AI 系统：

模块功能关键技术
巡逻行为在固定点之间来回移动NavigationAgent3D + 巡逻点数组
追击行为发现玩家后追击NavigationAgent3D 实时更新目标
攻击行为到达范围后攻击距离判断 + 冷却计时
视野检测三重判断（距离+角度+遮挡）射线 + 向量运算
仇恨系统被攻击时触发追击仇恨值累加 + 阈值触发
状态机控制行为切换枚举 + switch/match

掌握这些技术后，你就能创建各种有趣的敌人——从简单的巡逻兵到复杂的 Boss 都不在话下。

最近更新:
贡献者: bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS