9. 坦克大战——音效与特效

简介

音效和特效就是让游戏"听起来"和"看起来"更真实的东西。

• 音效：射击时的"砰"声、爆炸时的"轰"声、捡到道具时的"叮"声。就像电影里的配音——没有声音的电影看不了，没有音效的游戏玩不爽。
• 特效：子弹打中墙壁时的火花、坦克被摧毁时的爆炸火焰、出生时的闪烁光环。就像电影里的特效——没有爆炸场面的动作片不叫动作片。

为什么音效和特效很重要？

想象一下，如果游戏没有声音、没有爆炸效果——坦克打敌人就像在玩一个无声的表格游戏，毫无快感。好的音效和特效能让玩家获得即时反馈，知道"我的操作生效了"。

反馈类型	示例	作用
操作反馈	按射击键 → "砰"声 + 后坐力动画	让玩家确认操作生效
结果反馈	子弹命中 → 爆炸特效 + 计分动画	让玩家知道打中了
警告反馈	基地附近有敌人 → 警告音 + 红色闪烁	提醒玩家注意
奖励反馈	捡到道具 → "叮"声 + 光效	正向激励，让玩家开心

音效管理器

音效管理器就像一个DJ台——所有声音都通过它来播放和控制。这样做的好处是：可以统一调节音量、避免同时播放太多声音、方便管理音效资源。

// AudioManager.cs - 音效管理器（自动加载）
using Godot;
using System.Collections.Generic;

public partial class AudioManager : Node
{
    // ========== 单例 ==========
    public static AudioManager Instance { get; private set; }

    // ========== 音效配置 ==========
    [ExportGroup("Volume Settings")]
    [Export] public float MasterVolume { get; set; } = 1.0f;
    [Export] public float SfxVolume { get; set; } = 0.8f;
    [Export] public float MusicVolume { get; set; } = 0.5f;

    // ========== 音效名称定义 ==========
    public static class Sfx
    {
        public const string PlayerShoot = "player_shoot";
        public const string EnemyShoot = "enemy_shoot";
        public const string Explosion = "explosion";
        public const string SmallExplosion = "small_explosion";
        public const string BrickBreak = "brick_break";
        public const string SteelHit = "steel_hit";
        public const string PowerUp = "power_up";
        public const string PlayerDeath = "player_death";
        public const string EnemySpawn = "enemy_spawn";
        public const string GameOver = "game_over";
        public const string StageClear = "stage_clear";
        public const string MenuSelect = "menu_select";
    }

    public static class Music
    {
        public const string MainTheme = "main_theme";
        public const string GameTheme = "game_theme";
        public const string GameOverTheme = "game_over_theme";
    }

    // ========== 内部变量 ==========
    private Dictionary<string, AudioStream> _sfxStreams = new();
    private Dictionary<string, AudioStream> _musicStreams = new();
    private AudioStreamPlayer _musicPlayer;

    // 同时播放的最大音效数量
    private const int MAX_CONCURRENT_SFX = 8;
    private readonly List<AudioStreamPlayer> _sfxPlayers = new();

    // ========== 生命周期 ==========
    public override void _EnterTree()
    {
        if (Instance != null)
        {
            QueueFree();
            return;
        }
        Instance = this;
    }

    public override void _Ready()
    {
        // 创建背景音乐播放器
        _musicPlayer = new AudioStreamPlayer();
        AddChild(_musicPlayer);

        // 预创建音效播放器池
        for (int i = 0; i < MAX_CONCURRENT_SFX; i++)
        {
            var player = new AudioStreamPlayer();
            AddChild(player);
            _sfxPlayers.Add(player);
        }

        // 加载所有音效资源
        LoadAudioResources();

        GD.Print("AudioManager 初始化完成");
    }

    // ========== 加载音效资源 ==========
    private void LoadAudioResources()
    {
        // 加载音效
        var sfxFiles = new Dictionary<string, string>
        {
            { Sfx.PlayerShoot, "res://assets/audio/sfx/player_shoot.wav" },
            { Sfx.EnemyShoot, "res://assets/audio/sfx/enemy_shoot.wav" },
            { Sfx.Explosion, "res://assets/audio/sfx/explosion.wav" },
            { Sfx.SmallExplosion, "res://assets/audio/sfx/small_explosion.wav" },
            { Sfx.BrickBreak, "res://assets/audio/sfx/brick_break.wav" },
            { Sfx.SteelHit, "res://assets/audio/sfx/steel_hit.wav" },
            { Sfx.PowerUp, "res://assets/audio/sfx/power_up.wav" },
            { Sfx.PlayerDeath, "res://assets/audio/sfx/player_death.wav" },
            { Sfx.EnemySpawn, "res://assets/audio/sfx/enemy_spawn.wav" },
            { Sfx.GameOver, "res://assets/audio/sfx/game_over.wav" },
            { Sfx.StageClear, "res://assets/audio/sfx/stage_clear.wav" },
            { Sfx.MenuSelect, "res://assets/audio/sfx/menu_select.wav" }
        };

        foreach (var (name, path) in sfxFiles)
        {
            if (ResourceLoader.Exists(path))
            {
                _sfxStreams[name] = GD.Load<AudioStream>(path);
            }
        }

        // 加载音乐
        var musicFiles = new Dictionary<string, string>
        {
            { Music.MainTheme, "res://assets/audio/music/main_theme.ogg" },
            { Music.GameTheme, "res://assets/audio/music/game_theme.ogg" },
            { Music.GameOverTheme, "res://assets/audio/music/game_over_theme.ogg" }
        };

        foreach (var (name, path) in musicFiles)
        {
            if (ResourceLoader.Exists(path))
            {
                _musicStreams[name] = GD.Load<AudioStream>(path);
            }
        }
    }

    // ========== 播放音效 ==========
    public void PlaySfx(string sfxName)
    {
        if (!_sfxStreams.TryGetValue(sfxName, out var stream))
        {
            GD.PrintWarn($"音效不存在: {sfxName}");
            return;
        }

        // 从池中找一个空闲的播放器
        AudioStreamPlayer player = null;
        foreach (var p in _sfxPlayers)
        {
            if (!p.Playing)
            {
                player = p;
                break;
            }
        }

        // 如果都在播放，取最早开始播放的那个
        if (player == null)
        {
            player = _sfxPlayers[0];
        }

        player.Stream = stream;
        player.VolumeDb = Mathf.LinearToDb(SfxVolume * MasterVolume);
        player.Play();
    }

    // 播放音效（带音调变化）
    public void PlaySfxPitched(string sfxName, float pitchMin = 0.9f, float pitchMax = 1.1f)
    {
        if (!_sfxStreams.TryGetValue(sfxName, out var stream))
        {
            return;
        }

        AudioStreamPlayer player = null;
        foreach (var p in _sfxPlayers)
        {
            if (!p.Playing) { player = p; break; }
        }
        if (player == null) player = _sfxPlayers[0];

        player.Stream = stream;
        player.VolumeDb = Mathf.LinearToDb(SfxVolume * MasterVolume);
        player.PitchScale = (float)GD.RandRange(pitchMin, pitchMax);
        player.Play();
    }

    // ========== 播放音乐 ==========
    public void PlayMusic(string musicName, bool loop = true)
    {
        if (!_musicStreams.TryGetValue(musicName, out var stream))
        {
            GD.PrintWarn($"音乐不存在: {musicName}");
            return;
        }

        _musicPlayer.Stream = stream;
        _musicPlayer.VolumeDb = Mathf.LinearToDb(MusicVolume * MasterVolume);
        _musicPlayer.Autoplay = true; // 不使用 Autoplay，手动播放
        _musicPlayer.Play();
    }

    public void StopMusic()
    {
        _musicPlayer.Stop();
    }

    // 设置音乐音量
    public void SetMusicVolume(float volume)
    {
        MusicVolume = Mathf.Clamp(volume, 0.0f, 1.0f);
        if (_musicPlayer.Playing)
        {
            _musicPlayer.VolumeDb = Mathf.LinearToDb(MusicVolume * MasterVolume);
        }
    }

    // 设置音效音量
    public void SetSfxVolume(float volume)
    {
        SfxVolume = Mathf.Clamp(volume, 0.0f, 1.0f);
    }
}

# audio_manager.gd - 音效管理器（自动加载）
extends Node

# ========== 单例 ==========
var instance: Node = null

# ========== 音效配置 ==========
@export_group("Volume Settings")
@export var master_volume: float = 1.0
@export var sfx_volume: float = 0.8
@export var music_volume: float = 0.5

# ========== 音效名称定义 ==========
class Sfx:
    const PLAYER_SHOOT = "player_shoot"
    const ENEMY_SHOOT = "enemy_shoot"
    const EXPLOSION = "explosion"
    const SMALL_EXPLOSION = "small_explosion"
    const BRICK_BREAK = "brick_break"
    const STEEL_HIT = "steel_hit"
    const POWER_UP = "power_up"
    const PLAYER_DEATH = "player_death"
    const ENEMY_SPAWN = "enemy_spawn"
    const GAME_OVER = "game_over"
    const STAGE_CLEAR = "stage_clear"
    const MENU_SELECT = "menu_select"

class Music:
    const MAIN_THEME = "main_theme"
    const GAME_THEME = "game_theme"
    const GAME_OVER_THEME = "game_over_theme"

# ========== 内部变量 ==========
var sfx_streams: Dictionary = {}
var music_streams: Dictionary = {}
var music_player: AudioStreamPlayer

# 同时播放的最大音效数量
const MAX_CONCURRENT_SFX: int = 8
var sfx_players: Array[AudioStreamPlayer] = []

# ========== 生命周期 ==========
func _enter_tree() -> void:
    if instance != null:
        queue_free()
        return
    instance = self

func _ready() -> void:
    # 创建背景音乐播放器
    music_player = AudioStreamPlayer.new()
    add_child(music_player)

    # 预创建音效播放器池
    for i in range(MAX_CONCURRENT_SFX):
        var player = AudioStreamPlayer.new()
        add_child(player)
        sfx_players.append(player)

    # 加载所有音效资源
    load_audio_resources()

    print("AudioManager 初始化完成")

# ========== 加载音效资源 ==========
func load_audio_resources() -> void:
    # 加载音效
    var sfx_files: Dictionary = {
        Sfx.PLAYER_SHOOT: "res://assets/audio/sfx/player_shoot.wav",
        Sfx.ENEMY_SHOOT: "res://assets/audio/sfx/enemy_shoot.wav",
        Sfx.EXPLOSION: "res://assets/audio/sfx/explosion.wav",
        Sfx.SMALL_EXPLOSION: "res://assets/audio/sfx/small_explosion.wav",
        Sfx.BRICK_BREAK: "res://assets/audio/sfx/brick_break.wav",
        Sfx.STEEL_HIT: "res://assets/audio/sfx/steel_hit.wav",
        Sfx.POWER_UP: "res://assets/audio/sfx/power_up.wav",
        Sfx.PLAYER_DEATH: "res://assets/audio/sfx/player_death.wav",
        Sfx.ENEMY_SPAWN: "res://assets/audio/sfx/enemy_spawn.wav",
        Sfx.GAME_OVER: "res://assets/audio/sfx/game_over.wav",
        Sfx.STAGE_CLEAR: "res://assets/audio/sfx/stage_clear.wav",
        Sfx.MENU_SELECT: "res://assets/audio/sfx/menu_select.wav"
    }

    for name in sfx_files:
        var path = sfx_files[name]
        if ResourceLoader.exists(path):
            sfx_streams[name] = load(path)

    # 加载音乐
    var music_files: Dictionary = {
        Music.MAIN_THEME: "res://assets/audio/music/main_theme.ogg",
        Music.GAME_THEME: "res://assets/audio/music/game_theme.ogg",
        Music.GAME_OVER_THEME: "res://assets/audio/music/game_over_theme.ogg"
    }

    for name in music_files:
        var path = music_files[name]
        if ResourceLoader.exists(path):
            music_streams[name] = load(path)

# ========== 播放音效 ==========
func play_sfx(sfx_name: String) -> void:
    if not sfx_name in sfx_streams:
        push_warning("音效不存在: %s" % sfx_name)
        return

    # 从池中找一个空闲的播放器
    var player: AudioStreamPlayer = null
    for p in sfx_players:
        if not p.playing:
            player = p
            break

    # 如果都在播放，取最早开始播放的那个
    if player == null:
        player = sfx_players[0]

    player.stream = sfx_streams[sfx_name]
    player.volume_db = linear_to_db(sfx_volume * master_volume)
    player.play()

## 播放音效（带音调变化）
func play_sfx_pitched(sfx_name: String, pitch_min: float = 0.9, pitch_max: float = 1.1) -> void:
    if not sfx_name in sfx_streams:
        return

    var player: AudioStreamPlayer = null
    for p in sfx_players:
        if not p.playing:
            player = p
            break
    if player == null:
        player = sfx_players[0]

    player.stream = sfx_streams[sfx_name]
    player.volume_db = linear_to_db(sfx_volume * master_volume)
    player.pitch_scale = randf_range(pitch_min, pitch_max)
    player.play()

# ========== 播放音乐 ==========
func play_music(music_name: String, loop: bool = true) -> void:
    if not music_name in music_streams:
        push_warning("音乐不存在: %s" % music_name)
        return

    music_player.stream = music_streams[music_name]
    music_player.volume_db = linear_to_db(music_volume * master_volume)
    music_player.play()

func stop_music() -> void:
    music_player.stop()

## 设置音乐音量
func set_music_volume(volume: float) -> void:
    music_volume = clampf(volume, 0.0, 1.0)
    if music_player.playing:
        music_player.volume_db = linear_to_db(music_volume * master_volume)

## 设置音效音量
func set_sfx_volume(volume: float) -> void:
    sfx_volume = clampf(volume, 0.0, 1.0)

爆炸粒子特效

爆炸效果是坦克大战最重要的视觉特效。我们用 Godot 的 GPUParticles2D 粒子系统来创建。

爆炸粒子场景

Explosion (Node2D)                    # 爆炸特效根节点
├── GPUParticles2D                    # 粒子系统（火焰）
│   ├── 粒子材质（ProcessMaterial）    # 粒子行为配置
│   └── 粒子纹理（红色/橙色圆形）      # 粒子外观
├── GPUParticles2D (Smoke)            # 烟雾粒子
│   └── 粒子材质（灰色，缓慢扩散）     # 烟雾行为
└── Timer (LifetimeTimer)             # 生命周期计时器

爆炸特效脚本

// Explosion.cs - 爆炸特效
using Godot;

public partial class Explosion : Node2D
{
    // 爆炸持续时间
    [Export] public float Duration { get; set; } = 0.8f;

    private Timer _timer;

    public override void _Ready()
    {
        // 创建自动销毁计时器
        _timer = new Timer { WaitTime = Duration, OneShot = true };
        _timer.Timeout += QueueFree;
        AddChild(_timer);
        _timer.Start();

        // 播放爆炸音效
        AudioManager.Instance.PlaySfx(AudioManager.Sfx.Explosion);

        // 启动粒子系统
        var particles = GetNodeOrNull<GPUParticles2D>("GPUParticles2D");
        if (particles != null)
        {
            particles.Emitting = true;
        }

        var smoke = GetNodeOrNull<GPUParticles2D>("Smoke");
        if (smoke != null)
        {
            smoke.Emitting = true;
        }
    }
}

// ExplosionSmall.cs - 小型爆炸特效（子弹命中时）
public partial class ExplosionSmall : Node2D
{
    public override void _Ready()
    {
        // 播放小爆炸音效
        AudioManager.Instance.PlaySfxPitched(AudioManager.Sfx.SmallExplosion);

        var particles = GetNodeOrNull<GPUParticles2D>("GPUParticles2D");
        if (particles != null)
        {
            particles.Emitting = true;
        }

        // 短时间后自动销毁
        var timer = new Timer { WaitTime = 0.4f, OneShot = true };
        timer.Timeout += QueueFree;
        AddChild(timer);
        timer.Start();
    }
}

# explosion.gd - 爆炸特效
extends Node2D

## 爆炸持续时间
@export var duration: float = 0.8

var timer: Timer

func _ready() -> void:
    # 创建自动销毁计时器
    timer = Timer.new()
    timer.wait_time = duration
    timer.one_shot = true
    timer.timeout.connect(queue_free)
    add_child(timer)
    timer.start()

    # 播放爆炸音效
    AudioManager.play_sfx(AudioManager.Sfx.EXPLOSION)

    # 启动粒子系统
    var particles = get_node_or_null("GPUParticles2D") as GPUParticles2D
    if particles != null:
        particles.emitting = true

    var smoke = get_node_or_null("Smoke") as GPUParticles2D
    if smoke != null:
        smoke.emitting = true

# explosion_small.gd - 小型爆炸特效（子弹命中时）
extends Node2D

func _ready() -> void:
    # 播放小爆炸音效
    AudioManager.play_sfx_pitched(AudioManager.Sfx.SMALL_EXPLOSION)

    var particles = get_node_or_null("GPUParticles2D") as GPUParticles2D
    if particles != null:
        particles.emitting = true

    # 短时间后自动销毁
    var timer = Timer.new()
    timer.wait_time = 0.4
    timer.one_shot = true
    timer.timeout.connect(queue_free)
    add_child(timer)
    timer.start()

坦克出生特效

敌人坦克出生时，会有一个从中心向外扩展的闪光动画，就像一个"倒计时"效果——给玩家一个反应时间。

// SpawnEffect.cs - 坦克出生特效
using Godot;

public partial class SpawnEffect : Node2D
{
    // 出生动画的四个阶段
    private const int STAGE_COUNT = 4;
    private const float STAGE_DURATION = 0.2f; // 每阶段0.2秒

    private int _currentStage = 0;
    private Timer _stageTimer;
    private Sprite2D _sprite;

    // 动画完成时发出信号
    [Signal] public delegate void SpawnCompleteEventHandler();

    public override void _Ready()
    {
        _sprite = GetNode<Sprite2D>("Sprite2D");

        // 播放出生音效
        AudioManager.Instance.PlaySfx(AudioManager.Sfx.EnemySpawn);

        // 开始阶段动画
        _stageTimer = new Timer { WaitTime = STAGE_DURATION, OneShot = true };
        _stageTimer.Timeout += AdvanceStage;
        AddChild(_stageTimer);
        _stageTimer.Start();

        // 显示第一帧
        UpdateVisual();
    }

    // 推进到下一个阶段
    private void AdvanceStage()
    {
        _currentStage++;

        if (_currentStage >= STAGE_COUNT)
        {
            // 动画完成
            EmitSignal(SignalName.SpawnComplete);
            QueueFree();
            return;
        }

        UpdateVisual();
        _stageTimer.Start();
    }

    // 更新视觉效果
    private void UpdateVisual()
    {
        // 4个阶段用不同大小的白色闪烁表示
        float[] sizes = { 20, 30, 38, 44 };
        float[] alphas = { 0.3f, 0.6f, 0.9f, 1.0f };

        _sprite.Scale = new Vector2(
            sizes[_currentStage] / 20.0f,
            sizes[_currentStage] / 20.0f
        );

        var color = new Color(1, 1, 1, alphas[_currentStage]);
        _sprite.Modulate = color;
    }
}

# spawn_effect.gd - 坦克出生特效
extends Node2D

# 出生动画的四个阶段
const STAGE_COUNT: int = 4
const STAGE_DURATION: float = 0.2  # 每阶段0.2秒

var current_stage: int = 0
var stage_timer: Timer
var sprite: Sprite2D

# 动画完成时发出信号
signal spawn_complete

func _ready() -> void:
    sprite = get_node("Sprite2D") as Sprite2D

    # 播放出生音效
    AudioManager.play_sfx(AudioManager.Sfx.ENEMY_SPAWN)

    # 开始阶段动画
    stage_timer = Timer.new()
    stage_timer.wait_time = STAGE_DURATION
    stage_timer.one_shot = true
    stage_timer.timeout.connect(advance_stage)
    add_child(stage_timer)
    stage_timer.start()

    # 显示第一帧
    update_visual()

## 推进到下一个阶段
func advance_stage() -> void:
    current_stage += 1

    if current_stage >= STAGE_COUNT:
        # 动画完成
        spawn_complete.emit()
        queue_free()
        return

    update_visual()
    stage_timer.start()

## 更新视觉效果
func update_visual() -> void:
    # 4个阶段用不同大小的白色闪烁表示
    var sizes = [20.0, 30.0, 38.0, 44.0]
    var alphas = [0.3, 0.6, 0.9, 1.0]

    var s = sizes[current_stage] / 20.0
    sprite.scale = Vector2(s, s)

    var color = Color(1, 1, 1, alphas[current_stage])
    sprite.modulate = color

屏幕震动效果

大爆炸时整个画面微微震动，让打击感更强：

// ScreenShake.cs - 屏幕震动
using Godot;

public partial class ScreenShake : Node
{
    private Camera2D _camera;
    private Tween _shakeTween;

    public override void _Ready()
    {
        // 找到场景中的摄像机
        _camera = GetParent()?.GetNode<Camera2D>("Camera");
    }

    // 触发屏幕震动
    // intensity: 震动强度（像素）
    // duration: 震动持续时间（秒）
    public void Shake(float intensity = 5.0f, float duration = 0.3f)
    {
        if (_camera == null) return;

        // 如果已有震动在进行，先停止
        if (_shakeTween != null)
        {
            _shakeTween.Kill();
            _camera.Offset = Vector2.Zero;
        }

        _shakeTween = _camera.CreateTween();

        // 随机偏移相机位置，模拟震动
        int steps = (int)(duration / 0.02f); // 每0.02秒一步
        for (int i = 0; i < steps; i++)
        {
            float randomX = (float)GD.RandRange(-intensity, intensity);
            float randomY = (float)GD.RandRange(-intensity, intensity);
            _shakeTween.TweenProperty(
                _camera, "offset",
                new Vector2(randomX, randomY),
                0.02f
            );
        }

        // 震动结束，归位
        _shakeTween.TweenProperty(_camera, "offset", Vector2.Zero, 0.05f);
    }
}

# screen_shake.gd - 屏幕震动
extends Node

var camera: Camera2D
var shake_tween: Tween

func _ready() -> void:
    # 找到场景中的摄像机
    camera = get_parent().get_node_or_null("Camera") as Camera2D

## 触发屏幕震动
## intensity: 震动强度（像素）
## duration: 震动持续时间（秒）
func shake(intensity: float = 5.0, duration: float = 0.3) -> void:
    if camera == null:
        return

    # 如果已有震动在进行，先停止
    if shake_tween != null:
        shake_tween.kill()
        camera.offset = Vector2.ZERO

    shake_tween = camera.create_tween()

    # 随机偏移相机位置，模拟震动
    var steps = int(duration / 0.02)  # 每0.02秒一步
    for i in range(steps):
        var random_x = randf_range(-intensity, intensity)
        var random_y = randf_range(-intensity, intensity)
        shake_tween.tween_property(camera, "offset", Vector2(random_x, random_y), 0.02)

    # 震动结束，归位
    shake_tween.tween_property(camera, "offset", Vector2.ZERO, 0.05)

下一章预告

音效和特效系统完成了！游戏现在有了射击声、爆炸火焰、屏幕震动，玩起来有感觉多了。最后一章，我们将进行最后的打磨和发布准备——双人对战、自定义关卡分享、导出设置。