CourierOld/Game/CourierOld/Assets/Code/Audio/AudioFactory.cs

using System;
using System.Collections.Generic;
using Code.Configs;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Audio;
using UnityEngine.ResourceManagement.AsyncOperations;
using Object = UnityEngine.Object;

namespace Code.Audio
{
    public class AudioFactory : IAudioFactory
    {
        public AudioMixer AudioMixer { get; private set; }
        private AssetReference _audioSourcePrefab;
        
        private AssetReference[] _peacefulSoundtrack;
        private AssetReference[] _actionSoundtrack;
        private AssetReference[] _menuSoundtrack;
        private AssetReference[] _SFX;
        private AssetReference[] _enemies;
        private AssetReference[] _dispatcher;
        private AssetReference[] _character;
        
        private AsyncOperationHandle<IList<AudioClip>> _menuMusicHandle;
        private AsyncOperationHandle<IList<AudioClip>> _actionMusicHandle;
        private AsyncOperationHandle<IList<AudioClip>> _peacefulMusicHandle;
        private AsyncOperationHandle<IList<AudioClip>> _SFXHandle;
        private AsyncOperationHandle<IList<AudioClip>> _enemiesHandle;
        private AsyncOperationHandle<IList<AudioClip>> _dispatcherHandle;

        public Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; private set; } = new();
        public List<AudioClip> SFXAudios { get; private set; } = new();
        public List<AudioClip> EnemiesAudios { get; private set; } = new();
        public List<AudioClip> DispatcherAudios { get; private set; } = new();

        public AudioFactory(AudioMixerConfig audioMixerConfig, 
            SoundtrackListConfig soundtrackListConfig,
            SFXListConfig sfxListConfig, 
            EnemiesSoundListConfig enemiesSoundListConfig,
            DispatcherSoundListConfig dispatcherSoundListConfig
            )
        {
            AudioMixer = audioMixerConfig.audioMixerAsset;
            _audioSourcePrefab = audioMixerConfig.audioSourcePrefab;
            
            _peacefulSoundtrack = soundtrackListConfig.peacefulSoundtrack;
            _actionSoundtrack = soundtrackListConfig.actionSoundtrack;
            _menuSoundtrack = soundtrackListConfig.menuSoundtrack;
            _SFX = sfxListConfig.SFX;
            _enemies = enemiesSoundListConfig.enemies;
            _dispatcher = dispatcherSoundListConfig.dispatcher;
            
            MusicDictionary.Add(MusicType.Menu, new ());
            MusicDictionary.Add(MusicType.Peaceful, new ());
            MusicDictionary.Add(MusicType.Action, new ());
        }

        public async UniTask LoadAudioSourcePrefab(Action<GameObject> callback) =>
            callback?.Invoke(await Addressables.LoadAssetAsync<GameObject>(_audioSourcePrefab));

        public async UniTask WarmGameplayMusic( )
        {
            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.Union);
            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.Union);
            
            await UniTask.WhenAll(_actionMusicHandle.ToUniTask(), _peacefulMusicHandle.ToUniTask());
        }
        public void ReleaseActionMusic()
        {
            MusicDictionary[MusicType.Action].Clear();
            _actionMusicHandle.Release();
        }
        public void ReleasePeacefulMusic()
        {
            MusicDictionary[MusicType.Peaceful].Clear();
            _peacefulMusicHandle.Release();
        }
        public async UniTask WarmMenuMusic( )
        {            
            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.Union);
            // foreach (var assetReference in _menuSoundtrack) MenuMusic.Add(await assetReference.LoadAssetAsync<AudioClip>());
            await _menuMusicHandle.ToUniTask();
             
        }
        public void ReleaseMenuMusic()
        {
            MusicDictionary[MusicType.Menu].Clear();
            // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
            _menuMusicHandle.Release();
        }
        public async UniTask WarmSFX( )
        {            
            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.Union);
            
            await _SFXHandle.ToUniTask();
             
        }
        public void ReleaseSFX()
        {
            SFXAudios.Clear();
            _SFXHandle.Release();
        }
        public async UniTask WarmEnemies( )
        {            
            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.Union);
            
            await _enemiesHandle.ToUniTask();
             
        }

        public void ReleaseEnemies()
        {
            EnemiesAudios.Clear();
            _enemiesHandle.Release();
        }

        public async UniTask WarmDispatcher( )
        {            
            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.Union);
            
            await _dispatcherHandle.ToUniTask();
             
        }

        public void ReleaseDispatcher()
        {
            DispatcherAudios.Clear();
            _dispatcherHandle.Release();
        }

        private void OnMenuTrackLoaded(AudioClip audioClip)
        {
            MusicDictionary[MusicType.Menu].Add(audioClip);
        }
        private void OnActionTrackLoaded(AudioClip audioClip)
        {
            MusicDictionary[MusicType.Action].Add(audioClip);
        }
        private void OnPeacefulTrackLoaded(AudioClip audioClip)
        {
            MusicDictionary[MusicType.Peaceful].Add(audioClip);
        }
        private void OnSFXLoaded(AudioClip audioClip)
        {
            SFXAudios.Add(audioClip);
        }
        private void OnEnemiesLoaded(AudioClip audioClip)
        {
            EnemiesAudios.Add(audioClip);
        }
        private void OnDispatcherLoaded(AudioClip audioClip)
        {
            DispatcherAudios.Add(audioClip);
        }
    }
}