tanqiu/assets/scripts/Core/AudioManager.ts

import { _decorator, Component, AudioClip, AudioSource, resources, Node } from 'cc';
const { ccclass, property } = _decorator;

/**
 * 音频管理器
 * 统一管理游戏中的音乐和音效播放
 */
@ccclass('AudioManager')
export class AudioManager extends Component {
    // 音频源组件
    @property({ type: AudioSource, tooltip: '音乐播放器' })
    public musicAudioSource: AudioSource = null;
    
    @property({ type: AudioSource, tooltip: '音效播放器' })
    public soundEffectAudioSource: AudioSource = null;
    
    // 音量设置
    private musicVolume: number = 0.8;
    private soundEffectVolume: number = 0.8;
    
    // 当前播放的音乐
    private currentMusicClip: AudioClip = null;
    
    // 单例实例
    private static _instance: AudioManager = null;
    
    onLoad() {
        // 设置单例
        if (AudioManager._instance === null) {
            AudioManager._instance = this;
            // 防止场景切换时被销毁
            // this.node.parent = null;
            // director.addPersistRootNode(this.node);
        } else {
            this.node.destroy();
            return;
        }
        
        this.initializeAudioSources();
    }
    
    /**
     * 获取单例实例
     */
    public static getInstance(): AudioManager {
        return AudioManager._instance;
    }
    
    /**
     * 初始化音频源
     */
    private initializeAudioSources() {
        // 如果没有指定音频源，尝试自动创建
        if (!this.musicAudioSource) {
            const musicNode = new Node('MusicAudioSource');
            musicNode.parent = this.node;
            this.musicAudioSource = musicNode.addComponent(AudioSource);
            this.musicAudioSource.loop = true;
        }
        
        if (!this.soundEffectAudioSource) {
            const sfxNode = new Node('SFXAudioSource');
            sfxNode.parent = this.node;
            this.soundEffectAudioSource = sfxNode.addComponent(AudioSource);
            this.soundEffectAudioSource.loop = false;
        }
        
        // 设置初始音量
        this.updateMusicVolume();
        this.updateSoundEffectVolume();
    }
    
    /**
     * 播放背景音乐
     * @param musicPath 音乐资源路径
     * @param loop 是否循环播放
     */
    public playMusic(musicPath: string, loop: boolean = true) {
        if (!this.musicAudioSource) {
            console.warn('[AudioManager] 音乐播放器未初始化');
            return;
        }
        
        resources.load(musicPath, AudioClip, (err, clip) => {
            if (err) {
                console.error(`[AudioManager] 加载音乐失败: ${musicPath}`, err);
                return;
            }
            
            this.currentMusicClip = clip;
            this.musicAudioSource.clip = clip;
            this.musicAudioSource.loop = loop;
            this.musicAudioSource.play();
            
            console.log(`[AudioManager] 播放音乐: ${musicPath}`);
        });
    }
    
    /**
     * 停止背景音乐
     */
    public stopMusic() {
        if (this.musicAudioSource && this.musicAudioSource.playing) {
            this.musicAudioSource.stop();
            console.log('[AudioManager] 停止音乐播放');
        }
    }
    
    /**
     * 暂停背景音乐
     */
    public pauseMusic() {
        if (this.musicAudioSource && this.musicAudioSource.playing) {
            this.musicAudioSource.pause();
            console.log('[AudioManager] 暂停音乐播放');
        }
    }
    
    /**
     * 恢复背景音乐
     */
    public resumeMusic() {
        if (this.musicAudioSource && this.currentMusicClip) {
            this.musicAudioSource.play();
            console.log('[AudioManager] 恢复音乐播放');
        }
    }
    
    /**
     * 播放音效
     * @param sfxPath 音效资源路径
     * @param volume 音量（可选，0-1）
     */
    public playSoundEffect(sfxPath: string, volume?: number) {
        if (!this.soundEffectAudioSource) {
            console.warn('[AudioManager] 音效播放器未初始化');
            return;
        }
        
        resources.load(sfxPath, AudioClip, (err, clip) => {
            if (err) {
                console.error(`[AudioManager] 加载音效失败: ${sfxPath}`, err);
                return;
            }
            
            // 设置临时音量（如果指定）
            const originalVolume = this.soundEffectAudioSource.volume;
            if (volume !== undefined) {
                this.soundEffectAudioSource.volume = volume * this.soundEffectVolume;
            }
            
            this.soundEffectAudioSource.playOneShot(clip);
            
            // 恢复原始音量
            if (volume !== undefined) {
                this.soundEffectAudioSource.volume = originalVolume;
            }
            
            console.log(`[AudioManager] 播放音效: ${sfxPath}`);
        });
    }
    
    /**
     * 设置音乐音量
     * @param volume 音量值（0-1）
     */
    public setMusicVolume(volume: number) {
        this.musicVolume = Math.max(0, Math.min(1, volume));
        this.updateMusicVolume();
        //console.log(`[AudioManager] 设置音乐音量: ${this.musicVolume}`);
    }
    
    /**
     * 设置音效音量
     * @param volume 音量值（0-1）
     */
    public setSoundEffectVolume(volume: number) {
        this.soundEffectVolume = Math.max(0, Math.min(1, volume));
        this.updateSoundEffectVolume();
        //console.log(`[AudioManager] 设置音效音量: ${this.soundEffectVolume}`);
    }
    
    /**
     * 获取音乐音量
     */
    public getMusicVolume(): number {
        return this.musicVolume;
    }
    
    /**
     * 获取音效音量
     */
    public getSoundEffectVolume(): number {
        return this.soundEffectVolume;
    }
    
    /**
     * 更新音乐音量
     */
    private updateMusicVolume() {
        if (this.musicAudioSource) {
            this.musicAudioSource.volume = this.musicVolume;
        }
    }
    
    /**
     * 更新音效音量
     */
    private updateSoundEffectVolume() {
        if (this.soundEffectAudioSource) {
            this.soundEffectAudioSource.volume = this.soundEffectVolume;
        }
    }
    
    /**
     * 静音所有音频
     */
    public muteAll() {
        this.setMusicVolume(0);
        this.setSoundEffectVolume(0);
    }
    
    /**
     * 恢复所有音频音量
     */
    public unmuteAll() {
        this.setMusicVolume(0.8);
        this.setSoundEffectVolume(0.8);
    }
    
    /**
     * 检查音乐是否正在播放
     */
    public isMusicPlaying(): boolean {
        return this.musicAudioSource && this.musicAudioSource.playing;
    }
    
    onDestroy() {
        if (AudioManager._instance === this) {
            AudioManager._instance = null;
        }
    }
}

/**
 * 音频管理器的静态接口
 * 提供便捷的全局访问方法
 */
export class Audio {
    /**
     * 播放背景音乐
     */
    static playMusic(musicPath: string, loop: boolean = true) {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.playMusic(musicPath, loop);
        }
    }
    
    /**
     * 播放音效
     */
    static playSFX(sfxPath: string, volume?: number) {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.playSoundEffect(sfxPath, volume);
        }
    }
    
    /**
     * 设置音乐音量
     */
    static setMusicVolume(volume: number) {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.setMusicVolume(volume);
        }
    }
    
    /**
     * 设置音效音量
     */
    static setSFXVolume(volume: number) {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.setSoundEffectVolume(volume);
        }
    }
    
    /**
     * 停止音乐
     */
    static stopMusic() {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.stopMusic();
        }
    }
    
    /**
     * 暂停音乐
     */
    static pauseMusic() {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.pauseMusic();
        }
    }
    
    /**
     * 恢复音乐
     */
    static resumeMusic() {
        const manager = AudioManager.getInstance();
        if (manager) {
            manager.resumeMusic();
        }
    }
}