audio_manager.gd

Go to the documentation of this file.

extends Node
 
 
 
const MUSIC_DIR := "res://assets/music"
const SFX_DIR := "res://assets/sfx"
const MUSIC_MANIFEST := "res://data/audio/music_tracks.json"
const AUDIO_EXTENSIONS := [".ogg", ".wav", ".mp3"]
const DataCacheManager = preload("res://scripts/systems/dataCacheManager/data_cache_manager.gd")
 
var music_player:AudioStreamPlayer
var next_music_player:AudioStreamPlayer
var sfx_player:AudioStreamPlayer
var music_tracks := []
var sfx_library := {}
var generated_sfx_library := {}
var current_track_index := -1
var queued_track_index := -1
var fallback_sfx_enabled := true
var fallback_music_enabled := true
var pending_next_track:bool = false
var music_rng := RandomNumberGenerator.new()
var data_cache_manager = DataCacheManager.new()
@onready var SettingsManager = get_node_or_null("/root/SettingsManager")
 
 
func _ready() -> void:
    set_process(true)
    music_rng.randomize()
    music_player = AudioStreamPlayer.new()
    music_player.bus = "Music"
    add_child(music_player)
    music_player.finished.connect(_on_music_finished)
 
    next_music_player = AudioStreamPlayer.new()
    next_music_player.bus = "Music"
    add_child(next_music_player)
    next_music_player.finished.connect(_on_music_finished)
 
    sfx_player = AudioStreamPlayer.new()
    sfx_player.bus = "SFX"
    add_child(sfx_player)
 
    _ensure_audio_buses()
    load_audio()
    if has_node("/root/SettingsManager"):
        SettingsManager.settings_changed.connect(_apply_settings)
        _apply_settings(SettingsManager.get_settings())
    play_all_music()
 
 
func _process(_delta:float) -> void:
    if pending_next_track:
        pending_next_track = false
        _play_next_track()
 
 
 
func load_audio(music_dir:String = MUSIC_DIR, sfx_dir:String = SFX_DIR) -> void:
    music_tracks = _load_music_manifest(MUSIC_MANIFEST)
    if music_tracks.is_empty():
        music_tracks = _load_audio_streams(music_dir)
    if music_tracks.is_empty() and fallback_music_enabled:
        music_tracks.append(_make_chord_loop())
    else:
        _shuffle_music_tracks()
    queued_track_index = -1
    if next_music_player != null:
        next_music_player.stream = null
    sfx_library.clear()
    for path in _find_audio_files(sfx_dir):
        sfx_library[path.get_file().get_basename()] = load(path)
    _preload_generated_sfx()
 
 
 
func play_all_music() -> void:
    if music_tracks.is_empty() or music_player.playing:
        return
    current_track_index = -1
    _play_next_track()
 
 
 
func play_music(track_name:String) -> void:
    for i in range(music_tracks.size()):
        var stream:AudioStream = music_tracks[i] as AudioStream
        if stream == null:
            continue
        if stream.resource_path.get_file().get_basename() == track_name:
            current_track_index = i
            _play_stream_from_index(i)
            _prepare_next_track()
            return
 
 
 
func prepare_next_music_track() -> void:
    _prepare_next_track()
 
 
 
func get_music_cache_state() -> Dictionary:
    return {
        "track_count": music_tracks.size(),
        "current_track_index": current_track_index,
        "queued_track_index": queued_track_index,
        "has_queued_stream": next_music_player != null and next_music_player.stream != null,
        "low_power_mode": _is_low_power_mode()
    }
 
 
 
func get_cache_stats() -> Dictionary:
    return {
        "music_tracks": music_tracks.size(),
        "sfx_streams": sfx_library.size(),
        "generated_sfx": generated_sfx_library.size(),
        "has_music_player": 1 if music_player != null and is_instance_valid(music_player) else 0,
        "has_next_music_player": 1 if next_music_player != null and is_instance_valid(next_music_player) else 0,
        "has_sfx_player": 1 if sfx_player != null and is_instance_valid(sfx_player) else 0,
        "has_queued_stream": 1 if next_music_player != null and is_instance_valid(next_music_player) and next_music_player.stream != null else 0,
        "low_power_mode": 1 if _is_low_power_mode() else 0,
        "music_playing": 1 if music_player != null and is_instance_valid(music_player) and music_player.playing else 0,
        "data_cache_entries": int(data_cache_manager.get_cache_stats().get("entries", 0)),
        "data_cache_hits": int(data_cache_manager.get_cache_stats().get("cache_hits", 0)),
        "data_cache_misses": int(data_cache_manager.get_cache_stats().get("cache_misses", 0))
    }
 
 
func _play_stream_from_index(index:int) -> void:
    if index < 0 or index >= music_tracks.size():
        return
    var stream:AudioStream = music_tracks[index] as AudioStream
    if stream == null:
        return
    if next_music_player != null and next_music_player.stream == stream:
        var previous_player:AudioStreamPlayer = music_player
        music_player = next_music_player
        next_music_player = previous_player
        next_music_player.stop()
        next_music_player.stream = null
    else:
        music_player.stream = stream
    music_player.play()
 
 
func _prepare_next_track() -> void:
    if next_music_player == null:
        return
    if not _should_queue_next_music_track():
        _clear_queued_music_stream()
        return
    if music_tracks.size() <= 1 or current_track_index < 0:
        _clear_queued_music_stream()
        return
    queued_track_index = (current_track_index + 1) % music_tracks.size()
    var stream:AudioStream = music_tracks[queued_track_index] as AudioStream
    if stream == null:
        return
    if next_music_player.stream != stream:
        next_music_player.stream = stream
 
 
 
func stop_music() -> void:
    music_player.stop()
    if next_music_player != null:
        next_music_player.stop()
 
 
 
func dispose() -> void:
    set_process(false)
    if SettingsManager != null and is_instance_valid(SettingsManager) and SettingsManager.settings_changed.is_connected(_apply_settings):
        SettingsManager.settings_changed.disconnect(_apply_settings)
    for player in [music_player, next_music_player, sfx_player]:
        if player == null or not is_instance_valid(player):
            continue
        player.stop()
        player.stream = null
        if player.get_parent() == self:
            player.queue_free()
        elif not player.is_inside_tree():
            player.free()
    music_tracks.clear()
    sfx_library.clear()
    generated_sfx_library.clear()
    music_player = null
    next_music_player = null
    sfx_player = null
 
 
 
func play_sfx(sound_name:String) -> void:
    if not sfx_library.has(sound_name):
        if fallback_sfx_enabled and generated_sfx_library.has(sound_name):
            sfx_player.stream = generated_sfx_library[sound_name]
            sfx_player.play()
        elif fallback_sfx_enabled and generated_sfx_library.has("default"):
            sfx_player.stream = generated_sfx_library["default"]
            sfx_player.play()
        return
    sfx_player.stream = sfx_library[sound_name]
    sfx_player.play()
 
 
 
func play_button_click() -> void:
    play_sfx("button_click")
 
 
 
func install_button_sounds(root:Node) -> void:
    if root == null:
        return
    for child in root.get_children():
        if child is BaseButton and not child.pressed.is_connected(play_button_click):
            child.pressed.connect(play_button_click)
        install_button_sounds(child)
 
 
func _play_next_track() -> void:
    if music_tracks.is_empty():
        return
    if queued_track_index >= 0:
        current_track_index = queued_track_index
    else:
        current_track_index = (current_track_index + 1) % music_tracks.size()
    _play_stream_from_index(current_track_index)
    _prepare_next_track()
 
 
func _on_music_finished() -> void:
    pending_next_track = true
 
 
func _preload_generated_sfx() -> void:
    if not generated_sfx_library.is_empty():
        return
    generated_sfx_library["default"] = _make_tone(420.0, 0.055, 0.34)
    generated_sfx_library["button_click"] = _make_tone(520.0, 0.045, 0.28)
    generated_sfx_library["paddle_hit"] = _make_tone(360.0, 0.04, 0.42)
    generated_sfx_library["score"] = _make_tone(660.0, 0.12, 0.4)
    generated_sfx_library["powerup"] = _make_tone(760.0, 0.09, 0.34)
    generated_sfx_library["powerup_use"] = _make_tone(880.0, 0.07, 0.38)
    generated_sfx_library["rocket"] = _make_tone(180.0, 0.13, 0.42)
    generated_sfx_library["stun"] = _make_tone(120.0, 0.16, 0.46)
    generated_sfx_library["match_win"] = _make_tone(980.0, 0.18, 0.38)
 
 
func _make_tone(frequency:float, duration:float, volume:float) -> AudioStreamWAV:
    var mix_rate:int = 22050
    var sample_count:int = max(1, int(float(mix_rate) * duration))
    var data:PackedByteArray = PackedByteArray()
    data.resize(sample_count * 2)
    for sample_index in range(sample_count):
        var t:float = float(sample_index) / float(mix_rate)
        var fade:float = 1.0 - (float(sample_index) / float(sample_count))
        var sample:float = sin(TAU * frequency * t) * volume * fade
        data.encode_s16(sample_index * 2, int(clamp(sample, -1.0, 1.0) * 32767.0))
    var stream:AudioStreamWAV = AudioStreamWAV.new()
    stream.format = AudioStreamWAV.FORMAT_16_BITS
    stream.mix_rate = mix_rate
    stream.stereo = false
    stream.data = data
    return stream
 
 
func _make_chord_loop() -> AudioStreamWAV:
    var mix_rate:int = 22050
    var duration:float = 3.5
    var sample_count:int = int(float(mix_rate) * duration)
    var data:PackedByteArray = PackedByteArray()
    data.resize(sample_count * 2)
    var frequencies:Array[float] = [196.0, 246.94, 293.66]
    for sample_index in range(sample_count):
        var t:float = float(sample_index) / float(mix_rate)
        var sample:float = 0.0
        for frequency in frequencies:
            sample += sin(TAU * frequency * t) * 0.045
        var fade_in:float = min(1.0, t / 0.18)
        var fade_out:float = min(1.0, (duration - t) / 0.35)
        sample *= min(fade_in, fade_out)
        data.encode_s16(sample_index * 2, int(clamp(sample, -1.0, 1.0) * 32767.0))
    var stream:AudioStreamWAV = AudioStreamWAV.new()
    stream.format = AudioStreamWAV.FORMAT_16_BITS
    stream.mix_rate = mix_rate
    stream.stereo = false
    stream.data = data
    return stream
 
 
func _load_audio_streams(dir_path:String) -> Array:
    var streams = []
    for path in _find_audio_files(dir_path):
        var stream = _load_audio_stream(path)
        if stream != null:
            streams.append(stream)
    return streams
 
 
func _load_music_manifest(path:String) -> Array:
    var streams = []
    var parsed:Dictionary = data_cache_manager.load_json(path)
    var rows = parsed.get("music", [])
    if not rows is Array:
        return streams
    for row in rows:
        var track_path := ""
        if row is Dictionary:
            track_path = str(row.get("path", ""))
        else:
            track_path = str(row)
        var stream = _load_audio_stream(track_path)
        if stream != null:
            streams.append(stream)
    return streams
 
 
func _load_audio_stream(path:String):
    if path == "":
        return null
    if ResourceLoader.exists(path):
        return ResourceLoader.load(path)
    if FileAccess.file_exists(path):
        return load(path)
    return null
 
 
func _shuffle_music_tracks() -> void:
    for i in range(music_tracks.size() - 1, 0, -1):
        var swap_index:int = music_rng.randi_range(0, i)
        if swap_index == i:
            continue
        var current = music_tracks[i]
        music_tracks[i] = music_tracks[swap_index]
        music_tracks[swap_index] = current
 
 
func _find_audio_files(dir_path:String) -> Array:
    var paths = []
    var dir = DirAccess.open(dir_path)
    if dir == null:
        return paths
    dir.list_dir_begin()
    var file_name = dir.get_next()
    while file_name != "":
        if not dir.current_is_dir() and _is_audio_file(file_name):
            paths.append(dir_path + "/" + file_name)
        file_name = dir.get_next()
    return paths
 
 
func _is_audio_file(file_name:String) -> bool:
    var lower = file_name.to_lower()
    for extension in AUDIO_EXTENSIONS:
        if lower.ends_with(extension):
            return true
    return false
 
 
func _ensure_audio_buses() -> void:
    _ensure_bus("Music")
    _ensure_bus("SFX")
 
 
func _ensure_bus(bus_name:String) -> void:
    if AudioServer.get_bus_index(bus_name) >= 0:
        return
    AudioServer.add_bus()
    var index = AudioServer.get_bus_count() - 1
    AudioServer.set_bus_name(index, bus_name)
 
 
func _apply_settings(settings:Dictionary) -> void:
    _set_bus("Master", float(settings.get("master_volume", 1.0)), bool(settings.get("master_muted", false)))
    _set_bus("Music", float(settings.get("music_volume", 1.0)), bool(settings.get("music_muted", false)))
    _set_bus("SFX", float(settings.get("sfx_volume", 1.0)), bool(settings.get("sfx_muted", false)))
    if bool(settings.get("low_power_mode", false)):
        _clear_queued_music_stream()
 
 
func _clear_queued_music_stream() -> void:
    queued_track_index = -1
    if next_music_player != null:
        next_music_player.stop()
        next_music_player.stream = null
 
 
func _is_low_power_mode() -> bool:
    if SettingsManager == null or not is_instance_valid(SettingsManager):
        if is_inside_tree():
            SettingsManager = get_node_or_null("/root/SettingsManager")
    if SettingsManager != null and SettingsManager.has_method("is_low_power_mode"):
        return bool(SettingsManager.call("is_low_power_mode"))
    if SettingsManager != null and SettingsManager.has_method("get_settings"):
        var settings:Dictionary = SettingsManager.call("get_settings") as Dictionary
        return bool(settings.get("low_power_mode", false))
    return false
 
 
func _should_queue_next_music_track() -> bool:
    if not _is_low_power_mode():
        return true
    if SettingsManager != null and SettingsManager.has_method("get_low_power_profile"):
        var profile:Dictionary = SettingsManager.call("get_low_power_profile") as Dictionary
        var audio_profile = profile.get("audio", {})
        if audio_profile is Dictionary:
            return bool(audio_profile.get("queue_next_music_track", false))
    return false
 
 
func _set_bus(bus_name:String, linear_volume:float, muted:bool) -> void:
    var index = AudioServer.get_bus_index(bus_name)
    if index < 0:
        return
    AudioServer.set_bus_volume_db(index, linear_to_db(clampf(linear_volume, 0.0, 1.0)))
    AudioServer.set_bus_mute(index, muted)