跳至主要內容

5. 敌人波次

EVOCOSMOS2026/4/14大约 8 分钟

5. 雷霆战机——敌人波次

5.1 波次系统是什么？

想象你打一场拳击比赛：对手不是一次性全部冲上来，而是一个回合一个回合地来。第一回合来几个轻量级的，第二回合来几个中量级的，第三回合来一个重量级Boss。

波次系统（Wave System） 就是管理敌人出场的"导演"——它决定什么时候、从哪里、出什么敌人、用什么阵型。

5.2 敌人基类

所有敌人都继承自同一个基类，共享基本的行为逻辑。

C
using Godot;

/// <summary>
/// 敌人基类——所有敌人的共同行为
/// </summary>
public partial class Enemy : Area2D
{
    // ===== 属性 =====
    [Export] public int MaxHP { get; set; } = 1;
    [Export] public int ScoreValue { get; set; } = 100;
    [Export] public float MoveSpeed { get; set; } = 100f;
    [Export] public float DropChance { get; set; } = 0.15f;

    // ===== 状态 =====
    protected int _currentHP;
    protected bool _alive = true;

    // ===== 引用 =====
    protected Node2D _bulletContainer;
    protected RaidenGameManager _gameManager;

    // ===== 信号 =====
    [Signal] public delegate void EnemyDestroyedEventHandler(
        Vector2 position, int score, float dropChance);

    public override void _Ready()
    {
        _currentHP = MaxHP;
        _bulletContainer = GetParent()
            ?.GetParent()
            ?.GetNode<Node2D>("GameArea/EnemyBullets");
        _gameManager = GetNode<RaidenGameManager>(
            "/root/RaidenGameManager");
    }

    public override void _Process(double delta)
    {
        if (!_alive) return;

        // 默认行为：向下移动
        Position += new Vector2(0, MoveSpeed) * (float)delta;

        // 超出屏幕底部
        if (Position.Y > GameConfig.ScreenHeight + 50f)
        {
            Deactivate();
        }
    }

    /// <summary>
    /// 受到伤害
    /// </summary>
    public virtual void TakeDamage(int damage)
    {
        if (!_alive) return;

        _currentHP -= damage;

        // 受伤闪烁
        var tween = CreateTween();
        tween.TweenProperty(this, "modulate",
            new Color(1, 0.5f, 0.5f), 0.05f);
        tween.TweenProperty(this, "modulate",
            Colors.White, 0.05f);

        if (_currentHP <= 0)
        {
            Die();
        }
    }

    /// <summary>
    /// 死亡处理
    /// </summary>
    protected virtual void Die()
    {
        _alive = false;
        EmitSignal(SignalName.EnemyDestroyed,
            GlobalPosition, ScoreValue, DropChance);

        // 播放爆炸特效
        SpawnExplosion();

        // 通知GameManager加分
        _gameManager?.AddScore(ScoreValue);

        // 生成道具（由PowerUpManager处理）
        Deactivate();
    }

    /// <summary>
    /// 生成爆炸特效
    /// </summary>
    protected void SpawnExplosion()
    {
        var scene = GD.Load<PackedScene>(
            "res://scenes/effects/explosion.tscn");
        var explosion = scene.Instantiate<Node2D>();
        explosion.GlobalPosition = GlobalPosition;
        GetParent()?.GetNode<Node2D>("../Effects")
            ?.AddChild(explosion);
    }

    /// <summary>
    /// 发射敌人子弹
    /// </summary>
    protected void FireBullet(
        Vector2 direction, float speed, EnemyBullet.BulletType type)
    {
        if (_bulletContainer == null) return;

        // 获取玩家位置（用于瞄准弹）
        var player = GetNodeOrNull<Node2D>(
            "/root/Main/GameArea/Player");
        if (player == null) return;

        var bullet = GD.Load<PackedScene>(
            "res://scenes/bullets/enemy_bullet.tscn")
            .Instantiate<EnemyBullet>();

        switch (type)
        {
            case EnemyBullet.BulletType.Straight:
                bullet.InitStraight(GlobalPosition, direction, speed);
                break;
            case EnemyBullet.BulletType.Aimed:
                bullet.InitAimed(
                    GlobalPosition, player.GlobalPosition, speed);
                break;
            case EnemyBullet.BulletType.Circular:
                float angle = Mathf.Atan2(direction.Y, direction.X);
                bullet.InitCircular(GlobalPosition, angle, speed);
                break;
        }

        _bulletContainer.AddChild(bullet);
    }

    /// <summary>
    /// 停用敌人
    /// </summary>
    protected void Deactivate()
    {
        _alive = false;
        Visible = false;
        ProcessMode = ProcessModeEnum.Disabled;
        QueueFree();
    }

    public bool IsAlive() => _alive;
}

5.3 敌人运动模式

不同的敌人有不同的飞行方式。我们用运动模式（Movement Pattern）来定义。

模式描述代码实现
直线下落从上往下直飞position.y += speed * delta
正弦波动左右摇摆下落x = baseX + sin(time * freq) * amplitude
弧形进入从侧边飞入后下落贝塞尔曲线
悬停到某个位置后停下来到达目标位置后速度归零
C
/// <summary>
/// 敌人运动模式组件
/// </summary>
public partial class MovementPattern : Node
{
    public enum PatternType
    {
        Straight,    // 直线下落
        SineWave,    // 正弦波动
        Hover,       // 悬停
        Zigzag       // Z字形
    }

    private PatternType _type;
    private Enemy _enemy;
    private float _timer = 0f;

    // 模式参数
    private float _sineFrequency = 2f;
    private float _sineAmplitude = 80f;
    private float _zigzagInterval = 1f;
    private int _zigzagDirection = 1;
    private Vector2 _hoverPosition;

    public void Initialize(Enemy enemy, PatternType type)
    {
        _enemy = enemy;
        _type = type;

        if (type == PatternType.Hover)
        {
            _hoverPosition = enemy.Position + new Vector2(0, 150f);
        }
    }

    public Vector2 GetMovement(float delta)
    {
        _timer += delta;
        var move = Vector2.Zero;

        switch (_type)
        {
            case PatternType.Straight:
                move.Y = _enemy.MoveSpeed;
                break;

            case PatternType.SineWave:
                move.Y = _enemy.MoveSpeed * 0.7f;
                move.X = Mathf.Sin(_timer * _sineFrequency)
                    * _sineAmplitude * delta * 3f;
                break;

            case PatternType.Hover:
                var toHover = _hoverPosition - _enemy.Position;
                if (toHover.Length() > 5f)
                {
                    move = toHover.Normalized() * _enemy.MoveSpeed;
                }
                // 到达后不动
                break;

            case PatternType.Zigzag:
                move.Y = _enemy.MoveSpeed * 0.5f;
                if (_timer > _zigzagInterval)
                {
                    _timer = 0f;
                    _zigzagDirection *= -1;
                }
                move.X = _zigzagDirection * _enemy.MoveSpeed * 0.8f;
                break;
        }

        return move * delta;
    }
}

5.4 波次管理器

波次管理器是整个敌人系统的"导演"。

C
using Godot;
using System.Collections.Generic;

/// <summary>
/// 波次管理器——控制敌人的出场顺序和阵型
/// </summary>
public partial class WaveManager : Node
{
    // 波次定义
    private List<WaveDefinition> _waves;
    private int _currentWave = 0;
    private float _waveTimer = 0f;
    private bool _waveActive = false;

    // 当前波次的敌人待生成列表
    private Queue<SpawnEntry> _spawnQueue = new Queue<SpawnEntry>();
    private float _spawnTimer = 0f;

    // 引用
    private Node2D _enemyContainer;

    [Signal] public delegate void WaveStartedEventHandler(int waveNum);
    [Signal] public delegate void WaveCompletedEventHandler(int waveNum);
    [Signal] public delegate void AllWavesCompletedEventHandler();
    [Signal] public delegate void BossWaveStartedEventHandler();

    public override void _Ready()
    {
        _enemyContainer = GetNode<Node2D>("../GameArea/Enemies");
        LoadWaves();
        StartNextWave();
    }

    /// <summary>
    /// 加载波次定义
    /// </summary>
    private void LoadWaves()
    {
        _waves = new List<WaveDefinition>
        {
            // 波次1：简单的直线敌人
            new WaveDefinition
            {
                Enemies = new List<SpawnEntry>
                {
                    new() { Type = "basic", Delay = 0f },
                    new() { Type = "basic", Delay = 0.5f },
                    new() { Type = "basic", Delay = 0.5f },
                },
                PostWaveDelay = 2f
            },
            // 波次2：带波动的敌人
            new WaveDefinition
            {
                Enemies = new List<SpawnEntry>
                {
                    new() { Type = "basic", Delay = 0f },
                    new() { Type = "basic", Delay = 0.3f, XOffset = -50 },
                    new() { Type = "basic", Delay = 0.3f, XOffset = 50 },
                    new() { Type = "medium", Delay = 1f },
                },
                PostWaveDelay = 2f
            },
            // 波次3：编队
            new WaveDefinition
            {
                Enemies = new List<SpawnEntry>
                {
                    new() { Type = "basic", Delay = 0f, XOffset = -80 },
                    new() { Type = "basic", Delay = 0.1f, XOffset = -40 },
                    new() { Type = "basic", Delay = 0.1f },
                    new() { Type = "basic", Delay = 0.1f, XOffset = 40 },
                    new() { Type = "basic", Delay = 0.1f, XOffset = 80 },
                },
                PostWaveDelay = 2f
            },
            // 波次4：Boss波
            new WaveDefinition
            {
                Enemies = new List<SpawnEntry>
                {
                    new() { Type = "boss", Delay = 1f },
                },
                PostWaveDelay = 0f,
                IsBossWave = true
            }
        };
    }

    public override void _Process(double delta)
    {
        if (!_waveActive) return;

        // 处理敌人生成队列
        if (_spawnQueue.Count > 0)
        {
            _spawnTimer -= (float)delta;
            if (_spawnTimer <= 0f)
            {
                var entry = _spawnQueue.Dequeue();
                SpawnEnemy(entry);

                if (_spawnQueue.Count > 0)
                {
                    _spawnTimer = _spawnQueue.Peek().Delay;
                }
            }
        }
        else
        {
            // 检查当前波次的敌人是否全部消灭
            bool allDead = true;
            foreach (var child in _enemyContainer.GetChildren())
            {
                var enemy = child as Enemy;
                if (enemy != null && enemy.IsAlive())
                {
                    allDead = false;
                    break;
                }
            }

            if (allDead)
            {
                CompleteCurrentWave();
            }
        }
    }

    /// <summary>
    /// 开始下一个波次
    /// </summary>
    private void StartNextWave()
    {
        if (_currentWave >= _waves.Count)
        {
            EmitSignal(SignalName.AllWavesCompleted);
            return;
        }

        var wave = _waves[_currentWave];
        _waveActive = true;

        // 把波次中的敌人加入生成队列
        foreach (var entry in wave.Enemies)
        {
            _spawnQueue.Enqueue(entry);
        }

        if (_spawnQueue.Count > 0)
        {
            _spawnTimer = _spawnQueue.Peek().Delay;
        }

        if (wave.IsBossWave)
        {
            EmitSignal(SignalName.BossWaveStarted);
        }

        EmitSignal(SignalName.WaveStarted, _currentWave + 1);
    }

    /// <summary>
    /// 完成当前波次
    /// </summary>
    private void CompleteCurrentWave()
    {
        _waveActive = false;
        EmitSignal(SignalName.WaveCompleted, _currentWave + 1);

        var wave = _waves[_currentWave];
        _currentWave++;

        // 延迟后开始下一个波次
        var timer = GetTree().CreateTimer(wave.PostWaveDelay);
        timer.Timeout += StartNextWave;
    }

    /// <summary>
    /// 生成敌人
    /// </summary>
    private void SpawnEnemy(SpawnEntry entry)
    {
        string scenePath = entry.Type switch
        {
            "basic" => "res://scenes/enemies/basic_enemy.tscn",
            "medium" => "res://scenes/enemies/medium_enemy.tscn",
            "heavy" => "res://scenes/enemies/heavy_enemy.tscn",
            "boss" => "res://scenes/enemies/boss.tscn",
            _ => "res://scenes/enemies/basic_enemy.tscn"
        };

        var scene = GD.Load<PackedScene>(scenePath);
        var enemy = scene.Instantiate<Node2D>();

        float x = GameConfig.ScreenWidth / 2f + (entry.XOffset ?? 0f);
        enemy.Position = new Vector2(x, -30f);

        _enemyContainer.AddChild(enemy);
    }
}

/// <summary>
/// 波次定义数据
/// </summary>
public class WaveDefinition
{
    public List<SpawnEntry> Enemies { get; set; }
    public float PostWaveDelay { get; set; } = 2f;
    public bool IsBossWave { get; set; } = false;
}

/// <summary>
/// 敌人生成条目
/// </summary>
public class SpawnEntry
{
    public string Type { get; set; } = "basic";
    public float Delay { get; set; } = 0.5f;
    public float? XOffset { get; set; }
}

5.5 本章小结

组件说明
敌人基类共享的HP、移动、受伤、死亡逻辑
运动模式直线、正弦波、悬停、Z字形
波次管理按顺序生成敌人，管理波次间隔
波次定义数据驱动，容易编辑和扩展

关键设计点：

  • 敌人用数据驱动（Dictionary），方便设计新的波次
  • 波次之间有间隔，给玩家喘息时间
  • Boss波有特殊标记，触发Boss战UI
  • 运动模式作为独立组件，可以自由组合

下一章我们将实现道具系统。

最近更新:
贡献者: zefeng.peng,bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS