Merge branch 'SoundManager' into Dev

Game/CourierOld/Assets/Code/App/AppStates/GameplayState.cs

@@ -44,8 +44,11 @@ namespace Code.App.AppStates
             Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug2, LooseHealth);
             Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, LooseMoney);
             Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, PlayDebugSFX);
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug6, PlayDebugDispatcher);
 
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             WaitForSceneToLoad();
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
 
         private async UniTaskVoid WaitForSceneToLoad()
@@ -57,8 +60,8 @@ namespace Code.App.AppStates
                 Context.AudioFactory.WarmSFX()
             );
             
-            Context.AudioService.PlayRandomPeacefulMusicUntilHumanityWillBeDestroyedForTheySins();
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Peaceful);
-            Context.AudioService.PlayRandomActionMusicUntilHumanityWillBeDestroyedForTheySins();
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Action);
             
             var sceneEnvironment = ((GameplaySceneEnvironment)SceneManager.GetActiveScene()
                 .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
@@ -77,6 +80,10 @@ namespace Code.App.AppStates
         {
             Context.AudioService.PlaySFX(SFXSounds.Crowbar, _testSFXTransform.position);
         }
+        private void PlayDebugDispatcher(InputAction.CallbackContext context)
+        {
+            Context.AudioService.PlayDispatcher(DispatcherSounds.AhFreeman);
+        }
         private void GiveHealth(InputAction.CallbackContext context)
         {
             _playerHealth.GetDamage(-1);
@@ -115,13 +122,15 @@ namespace Code.App.AppStates
             _playerMoney = null;
             
             Context.InputService.DisableMap(ActionMappings.Gameplay);
-            Context.AudioService.GladlyAskToStopGameplayMusic(Context.AudioFactory.ReleaseGameplayMusic);
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Action, callback: Context.AudioFactory.ReleaseActionMusic);
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, callback: Context.AudioFactory.ReleasePeacefulMusic);
             
             Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, GiveHealth);
             Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug3, GiveHealth);
             Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug2, LooseHealth);
             Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, LooseMoney);
             Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, PlayDebugSFX);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug6, PlayDebugDispatcher);
             
             base.ExitState();
         }

Game/CourierOld/Assets/Code/App/AppStates/MainMenuState.cs

@@ -26,7 +26,9 @@ namespace Code.App.AppStates
 
             Context.CameraStateMachine.SwitchState(CameraMode.Static);
         
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             WaitForSceneToLoad();
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
 
         private async UniTaskVoid WaitForSceneToLoad()
@@ -37,8 +39,8 @@ namespace Code.App.AppStates
                 Context.AudioFactory.WarmMenuMusic()
                 );
             
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Menu);
-            Context.AudioService.PlayRandomMenuMusicUntilHumanityWillBeDestroyedForTheySins();
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Menu);
 
             ((MainMenuPanel)Context.UIService.CurrentPanel).startButton.onClick.AddListener(StartGame);
             ((MainMenuPanel)Context.UIService.CurrentPanel).exitButton.onClick.AddListener(ExitGame);
@@ -74,7 +76,7 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             Context.InputService.DisableMap(ActionMappings.MainMenu);
-            Context.AudioService.GladlyAskToStopMenuMusic(Context.AudioFactory.ReleaseMenuMusic); 
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic); 
             
             base.ExitState();
         }

Game/CourierOld/Assets/Code/App/BootstrapInstaller.cs

@@ -1,4 +1,3 @@
-using System.Threading.Tasks;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Configs;
@@ -14,7 +13,6 @@ using Cysharp.Threading.Tasks;
 using Reflex.Core;
 using Reflex.Injectors;
 using UnityEngine;
-using UnityEngine.AddressableAssets;
 using UnityEngine.InputSystem;
 
 namespace Code.App
@@ -81,7 +79,6 @@ namespace Code.App
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
         }
 
-        private bool _onAudioLoaded;
         private AppStateMachine _appStateMachine;
 
         private void Bootstrap(Container container)
@@ -94,12 +91,13 @@ namespace Code.App
             AttributeInjector.Inject(cameraStateMachine.StateMachineContext, container);
             cameraStateMachine.Initialize();
 
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             BootstrapFinish(container);
+            
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
         private async UniTaskVoid BootstrapFinish(Container container)
         {
-            // container.Resolve<IAudioFactory>();
-            
             var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
             DontDestroyOnLoad(loadingScreen);
             

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

@@ -30,9 +30,7 @@ namespace Code.Audio
         private AsyncOperationHandle<IList<AudioClip>> _enemiesHandle;
         private AsyncOperationHandle<IList<AudioClip>> _dispatcherHandle;
 
-        public List<AudioClip> PeacefulMusic { get; private set; } = new();
+        public Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; private set; } = new();
-        public List<AudioClip> ActionMusic { get; private set; } = new();
-        public List<AudioClip> MenuMusic { 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();
@@ -54,14 +52,11 @@ namespace Code.Audio
             _enemies = enemiesSoundListConfig.enemies;
             _dispatcher = dispatcherSoundListConfig.dispatcher;
             // _character = characterSoundListConfig.character;
-        }
             
-        // public async UniTask<AudioMixer> CreateMixer()
+            MusicDictionary.Add(MusicType.Menu, new ());
-        // { 
+            MusicDictionary.Add(MusicType.Peaceful, new ());
-        //     AudioMixer audioMixer = (await Addressables.InstantiateAsync(_audioMixerPrefab).ToUniTask()).GetComponent<AudioMixer>();
+            MusicDictionary.Add(MusicType.Action, new ());
-        //     
+        }
-        //     return audioMixer;
-        // }
 
         public async UniTask LoadAudioSourcePrefab(Action<GameObject> callback) =>
             callback?.Invoke(await Addressables.LoadAssetAsync<GameObject>(_audioSourcePrefab));
@@ -72,18 +67,17 @@ namespace Code.Audio
             _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.None);
             
             await UniTask.WhenAll(_actionMusicHandle.ToUniTask(), _peacefulMusicHandle.ToUniTask());
-             
         }
-        
+        public void ReleaseActionMusic()
-        public void ReleaseGameplayMusic()
         {
-            ActionMusic.Clear();
+            MusicDictionary[MusicType.Action].Clear();
             _actionMusicHandle.Release();
-            
+        }
-            PeacefulMusic.Clear();
+        public void ReleasePeacefulMusic()
+        {
+            MusicDictionary[MusicType.Peaceful].Clear();
             _peacefulMusicHandle.Release();
         }
-        
         public async UniTask WarmMenuMusic( )
         {            
             _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.None);
@@ -91,10 +85,9 @@ namespace Code.Audio
             await _menuMusicHandle.ToUniTask();
              
         }
-
         public void ReleaseMenuMusic()
         {
-            MenuMusic.Clear();
+            MusicDictionary[MusicType.Menu].Clear();
             // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
             _menuMusicHandle.Release();
         }
@@ -105,7 +98,6 @@ namespace Code.Audio
             await _SFXHandle.ToUniTask();
              
         }
-
         public void ReleaseSFX()
         {
             SFXAudios.Clear();
@@ -139,17 +131,17 @@ namespace Code.Audio
             _dispatcherHandle.Release();
         }
 
+        private void OnMenuTrackLoaded(AudioClip audioClip)
+        {
+            MusicDictionary[MusicType.Menu].Add(audioClip);
+        }
         private void OnActionTrackLoaded(AudioClip audioClip)
         {
-            ActionMusic.Add(audioClip);
+            MusicDictionary[MusicType.Action].Add(audioClip);
         }
         private void OnPeacefulTrackLoaded(AudioClip audioClip)
         {
-            PeacefulMusic.Add(audioClip);
+            MusicDictionary[MusicType.Peaceful].Add(audioClip);
-        }
-        private void OnMenuTrackLoaded(AudioClip audioClip)
-        {
-            MenuMusic.Add(audioClip);
         }
         private void OnSFXLoaded(AudioClip audioClip)
         {

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

@@ -22,9 +22,9 @@ namespace Code.Audio
         private AudioSource _peacefulMusicSource;
 
         private AudioMixerGroup _masterGroup,
-            _musicGroup,
+            // _musicGroup,
-            _actionMusicGroup,
+            // _actionMusicGroup,
-            _peacefulMusicGroup,
+            // _peacefulMusicGroup,
             _SFXGroup,
             _creaturesGroup,
             _dispatcherGroup,
@@ -46,110 +46,90 @@ namespace Code.Audio
             _mixer = _audioFactory.AudioMixer;
 
             _masterGroup = _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0];
-            _actionMusicGroup = _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
+            // _actionMusicGroup = _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
-            _peacefulMusicGroup = _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0];
+            // _peacefulMusicGroup = _mixer.FindMatchingGroups(AudioGroups.PeacefulMusoup)[0];
+            // _musicGroup = _mixer.FindMatchingGroups(AudioGroups.MusicGroup)[0];
+            _musicAudioGroups.Add(MusicType.Menu, _mixer.FindMatchingGroups(AudioGroups.MenuMusicGroup)[0]);
+            _musicAudioGroups.Add(MusicType.Action, _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0]);
+            _musicAudioGroups.Add(MusicType.Peaceful, _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0]);
+            
+            _cancellationTokenSources.Add(MusicType.Menu, new());
+            _cancellationTokenSources.Add(MusicType.Action, new());
+            _cancellationTokenSources.Add(MusicType.Peaceful, new());
+            
+            _musicAudioSources.Add(MusicType.Menu, null);
+            _musicAudioSources.Add(MusicType.Action, null);
+            _musicAudioSources.Add(MusicType.Peaceful, null);
+            
             _SFXGroup = _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0];
-            _musicGroup = _mixer.FindMatchingGroups(AudioGroups.MusicGroup)[0];
             _creaturesGroup = _mixer.FindMatchingGroups(AudioGroups.CreaturesGroup)[0];
             _dispatcherGroup = _mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0];
             _courierGroup = _mixer.FindMatchingGroups(AudioGroups.CourierMusicGroup)[0];
             _enemiesGroup = _mixer.FindMatchingGroups(AudioGroups.EnemiesMusicGroup)[0];
 
+            _snapshots[AudioSnapshotState.None] = _mixer.FindSnapshot(AudioGroups.NoneSnapshot);
             _snapshots[AudioSnapshotState.Peaceful] = _mixer.FindSnapshot(AudioGroups.PeacefulSnapshot);
             _snapshots[AudioSnapshotState.Action] = _mixer.FindSnapshot(AudioGroups.ActionSnapshot);
-            _snapshots[AudioSnapshotState.None] = _mixer.FindSnapshot(AudioGroups.NoneSnapshot);
+            _snapshots[AudioSnapshotState.Menu] = _mixer.FindSnapshot(AudioGroups.MenuSnapshot);
 
             await _audioFactory.LoadAudioSourcePrefab(_audioSourcePool.Initialize);
 
-            InitializeMusicSources();
         }
 
-        private void InitializeMusicSources()
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        {
+        private Dictionary<MusicType, CancellationTokenSource> _cancellationTokenSources = new();
-            _actionMusicSource = _audioSourcePool.GetSource();
+        private Dictionary<MusicType, AudioSource> _musicAudioSources = new();
-            _actionMusicSource.outputAudioMixerGroup = _actionMusicGroup;
+        private Dictionary<MusicType, AudioMixerGroup> _musicAudioGroups = new();
-            _actionMusicSource.spatialBlend = 0f;
 
-            _peacefulMusicSource = _audioSourcePool.GetSource();
+        public async UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType)
-            _peacefulMusicSource.outputAudioMixerGroup = _peacefulMusicGroup;
+        {
-            _peacefulMusicSource.spatialBlend = 0f;
+            if(!_musicAudioSources[musicType])
+            {
+                _musicAudioSources[musicType] = _audioSourcePool.GetSource();
+                _musicAudioSources[musicType].spatialBlend = 0f;
+                _musicAudioSources[musicType].outputAudioMixerGroup = _musicAudioGroups[musicType];
             }
             
-        public void PlayRandomGameplayMusic()
+            _musicAudioSources[musicType].resource =
+                _audioFactory.MusicDictionary[musicType][
+                    Random.Range(0, _audioFactory.MusicDictionary[musicType].Count)];
+            
+            _musicAudioSources[musicType].Play();
+            
+            // await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
+            //     _ => !_musicAudioSources[musicType].isPlaying,
+            //     cancellationToken: _cancellationTokenSources[musicType].Token);
+            await UniTask.WaitUntil(() => _musicAudioSources[musicType].isPlaying);
+            Debug.Log($"Playing {musicType}");
+            var isCanceled = await UniTask.WaitUntil(() => !_musicAudioSources[musicType].isPlaying,
+                cancellationToken: _cancellationTokenSources[musicType].Token).SuppressCancellationThrow();
+            Debug.Log($"Finished {musicType}");
+            
+            if (isCanceled)
             {
-            _peacefulMusicSource.resource = _audioFactory.PeacefulMusic[Random.Range(0, _audioFactory.PeacefulMusic.Count)];
+                Debug.Log($"Cancelled {musicType}");
-            _actionMusicSource.resource =
+                _cancellationTokenSources[musicType].Dispose();
-                _audioFactory.ActionMusic[Random.Range(0, _audioFactory.ActionMusic.Count)];
+                _cancellationTokenSources[musicType] = new();
                 
-            _peacefulMusicSource.Play();
+                _audioSourcePool.ReleaseSource(_musicAudioSources[musicType]);
-            _actionMusicSource.Play();
-        } 
-        public void PlayRandomMenuMusic()
-        {
-            TransitToSnapshot(AudioSnapshotState.Peaceful);
                 
-            _peacefulMusicSource.resource = _audioFactory.MenuMusic[Random.Range(0, _audioFactory.MenuMusic.Count)];
-
-            _peacefulMusicSource.Play();
-        }
-
-        private CancellationTokenSource _menuMusicTokenSource = new();
-        public async UniTaskVoid PlayRandomMenuMusicUntilHumanityWillBeDestroyedForTheySins()
-        {
-            TransitToSnapshot(AudioSnapshotState.Peaceful);
-            
-            _peacefulMusicSource.resource = _audioFactory.MenuMusic[Random.Range(0, _audioFactory.MenuMusic.Count)];
-
-            _peacefulMusicSource.Play();
-
-            await UniTask.WaitUntilValueChanged(_peacefulMusicSource, _ => _peacefulMusicSource.isPlaying, cancellationToken: _menuMusicTokenSource.Token);
-            if (_menuMusicTokenSource.IsCancellationRequested)
-            {
-                _menuMusicTokenSource.Dispose();
-                _menuMusicTokenSource = new();
                 return;
             }
 
-            PlayRandomMenuMusicUntilHumanityWillBeDestroyedForTheySins();
+            PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType);
         }
-        private CancellationTokenSource _peacefulMusicTokenSource = new();
+        
-        public async UniTaskVoid PlayRandomPeacefulMusicUntilHumanityWillBeDestroyedForTheySins()
+        public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType, AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
         {
-            TransitToSnapshot(AudioSnapshotState.Peaceful);
+            TransitToSnapshot(audioSnapshotState, time);
 
-            _peacefulMusicSource.resource = _audioFactory.PeacefulMusic[Random.Range(0, _audioFactory.PeacefulMusic.Count)];
+            await UniTask.WaitForSeconds(time);
             
-            _peacefulMusicSource.Play();
+            _cancellationTokenSources[musicType].Cancel();
 
-            await UniTask.WaitUntilValueChanged(_peacefulMusicSource, _ => _peacefulMusicSource.isPlaying, cancellationToken: _peacefulMusicTokenSource.Token);
+            callback?.Invoke();
-            if (_peacefulMusicTokenSource.IsCancellationRequested)
-            {
-                _peacefulMusicTokenSource.Dispose();
-                _peacefulMusicTokenSource = new();
-                return;
-            }
-            
-            PlayRandomPeacefulMusicUntilHumanityWillBeDestroyedForTheySins();
-        }
-        private CancellationTokenSource _actionMusicTokenSource = new();
-        public async UniTaskVoid PlayRandomActionMusicUntilHumanityWillBeDestroyedForTheySins()
-        {
-            TransitToSnapshot(AudioSnapshotState.Action);
-            
-            _actionMusicSource.resource = _audioFactory.ActionMusic[Random.Range(0, _audioFactory.ActionMusic.Count)];
-
-            _actionMusicSource.Play();
-
-            await UniTask.WaitUntilValueChanged(_actionMusicSource, _ => _actionMusicSource.isPlaying, cancellationToken: _actionMusicTokenSource.Token);
-            if (_actionMusicTokenSource.IsCancellationRequested)
-            {
-                _actionMusicTokenSource.Dispose();
-                _actionMusicTokenSource = new();
-                return;
-            }
-            
-            PlayRandomActionMusicUntilHumanityWillBeDestroyedForTheySins();
         }
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
 
         public void StopMusic()
         {
@@ -165,57 +145,6 @@ namespace Code.Audio
 
             callback?.Invoke();
         }
-        public async UniTaskVoid GladlyAskToStopMenuMusic(Action callback = null)
-        {
-            TransitToSnapshot(AudioSnapshotState.None);
-
-            await UniTask.WaitForSeconds(1f);
-
-            _peacefulMusicSource.Stop();
-            
-            _menuMusicTokenSource.Cancel();
-            
-            callback?.Invoke();
-        }
-
-        public async UniTaskVoid GladlyAskToStopGameplayMusic(Action callback = null)
-        {
-            TransitToSnapshot(AudioSnapshotState.None);
-
-            await UniTask.WaitForSeconds(1f);
-
-            _actionMusicSource.Stop();
-            _peacefulMusicSource.Stop();
-            
-            _actionMusicTokenSource.Cancel();
-            _peacefulMusicTokenSource.Cancel();
-            
-            callback?.Invoke();
-        }
-        public async UniTaskVoid GladlyAskToStopActionMusic(Action callback = null)
-        {
-            TransitToSnapshot(AudioSnapshotState.None);
-
-            await UniTask.WaitForSeconds(1f);
-
-            _actionMusicSource.Stop();
-            
-            _actionMusicTokenSource.Cancel();
-            
-            callback?.Invoke();
-        }
-        public async UniTaskVoid GladlyAskToStopPeacefulMusic(Action callback = null)
-        {
-            TransitToSnapshot(AudioSnapshotState.None);
-
-            await UniTask.WaitForSeconds(1f);
-
-            _peacefulMusicSource.Stop();
-            
-            _peacefulMusicTokenSource.Cancel();
-            
-            callback?.Invoke();
-        }
 
         public void TransitToSnapshot(AudioSnapshotState state, float time = 1f)
         {
@@ -227,10 +156,12 @@ namespace Code.Audio
         {
             _audioSourcePool.PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _SFXGroup);
         }
+
         public void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position)
         {
             _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
         }
+
         public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
         {
             _audioSourcePool.PlayShizo(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup);

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

@@ -4,6 +4,7 @@ namespace Code.Audio
     {
         None,
         Peaceful,
-        Action
+        Action,
+        Menu
     }
 }

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

@@ -19,7 +19,7 @@ namespace Code.Audio
             _pool = new ObjectPool<AudioSource>(
                 createFunc: CreateItem,
                 // actionOnGet: OnGet,
-                // actionOnRelease: OnRelease,
+                actionOnRelease: OnRelease,
                 actionOnDestroy: OnDestroyItem,
                 collectionCheck: true,   // helps catch double-release mistakes
                 defaultCapacity: 10,
@@ -45,6 +45,7 @@ namespace Code.Audio
         // Called when an item is returned to the pool.
         private void OnRelease(AudioSource source)
         {
+            source.Stop();
             //source.gameObject.SetActive(false);
         }
 

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

@@ -8,16 +8,14 @@ namespace Code.Audio
 {
     public interface IAudioFactory
     {
-        List<AudioClip> PeacefulMusic { get; }
-        List<AudioClip> ActionMusic { get; }
-        List<AudioClip> MenuMusic { get; }
         List<AudioClip> SFXAudios { get; }
         List<AudioClip> EnemiesAudios { get; }
         List<AudioClip> DispatcherAudios { get; }
         AudioMixer AudioMixer { get; }
+        Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; }
         UniTask LoadAudioSourcePrefab(Action<GameObject> callback);
         UniTask WarmGameplayMusic();
-        void ReleaseGameplayMusic();
+        void ReleaseActionMusic();
         UniTask WarmMenuMusic();
         void ReleaseMenuMusic();
         UniTask WarmSFX();
@@ -26,5 +24,6 @@ namespace Code.Audio
         void ReleaseEnemies();
         UniTask WarmDispatcher();
         void ReleaseDispatcher();
+        void ReleasePeacefulMusic();
     }
 }

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

@@ -7,20 +7,13 @@ namespace Code.Audio
     public interface IAudioService
     {
         UniTask Initialize();
-        void PlayRandomGameplayMusic();
+        UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType);
+        UniTaskVoid GladlyAskToStopMusic(MusicType musicType, AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null);
+        void StopMusic();
+        void GladlyAskToStopMusic(Action callback = null);
         void TransitToSnapshot(AudioSnapshotState state, float time = 1f);
         void PlaySFX(SFXSounds sfxId, Vector3 position);
         void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position);
         void PlayDispatcher(DispatcherSounds dispatcherSoundId);
-        void PlayRandomMenuMusic();
-        UniTaskVoid PlayRandomMenuMusicUntilHumanityWillBeDestroyedForTheySins();
-        void StopMusic();
-        void GladlyAskToStopMusic(Action callback = null);
-        UniTaskVoid GladlyAskToStopMenuMusic(Action callback = null);
-        UniTaskVoid GladlyAskToStopActionMusic(Action callback = null);
-        UniTaskVoid GladlyAskToStopPeacefulMusic(Action callback = null);
-        UniTaskVoid PlayRandomPeacefulMusicUntilHumanityWillBeDestroyedForTheySins();
-        UniTaskVoid PlayRandomActionMusicUntilHumanityWillBeDestroyedForTheySins();
-        UniTaskVoid GladlyAskToStopGameplayMusic(Action callback = null);
     }
 }

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

@@ -0,0 +1,9 @@
+namespace Code.Audio
+{
+    public enum MusicType
+    {
+        Menu,
+        Peaceful,
+        Action
+    }
+}

Game/CourierOld/Assets/Code/Audio/MusicType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 74ff08d5f1b741f69e37fc06fb07ae8d
+timeCreated: 1763151897

Game/CourierOld/Assets/Code/Constants/StringPaths.cs

@@ -25,5 +25,7 @@ namespace Code.Constants
         public const string PeacefulSnapshot = "Peaceful";
         public const string ActionSnapshot = "Action";
         public const string NoneSnapshot = "None";
+        public const string MenuSnapshot = "Menu";
+        public const string MenuMusicGroup = "Menu";
     }
 }

Game/CourierOld/Assets/Resources/Audio/MainMixer.mixer

@@ -52,6 +52,39 @@ AudioMixerEffectController:
   m_SendTarget: {fileID: 0}
   m_EnableWetMix: 0
   m_Bypass: 0
+--- !u!245 &-5566153147845745614
+AudioMixerSnapshotController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Menu
+  m_AudioMixer: {fileID: 24100000}
+  m_SnapshotID: ae02c0612d44bfd459883c67f6dab857
+  m_FloatValues:
+    b9fc0df121fe7134e9cbd35aa5a65755: 0.10800299
+    ddab7e07de3c686e296ff10b1cd77a47: -80
+    dd0b3fe80d006124baa36e791e6953f0: -80
+  m_TransitionOverrides: {}
+--- !u!243 &-5282050360126310577
+AudioMixerGroupController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Menu
+  m_AudioMixer: {fileID: 24100000}
+  m_GroupID: af6d3dead2e9e4848a2ca2fa55634108
+  m_Children: []
+  m_Volume: b9fc0df121fe7134e9cbd35aa5a65755
+  m_Pitch: 3cdebfce079b3864f93ef55f8bc453ae
+  m_Send: 00000000000000000000000000000000
+  m_Effects:
+  - {fileID: 5712107256638894671}
+  m_UserColorIndex: 0
+  m_Mute: 0
+  m_Solo: 0
+  m_BypassEffects: 0
 --- !u!243 &-4235790927912365957
 AudioMixerGroupController:
   m_ObjectHideFlags: 0
@@ -64,6 +97,7 @@ AudioMixerGroupController:
   m_Children:
   - {fileID: 1469200815455588746}
   - {fileID: 9214955797390454771}
+  - {fileID: -5282050360126310577}
   m_Volume: 4c469b14481ac855fb9fb2989e6e6b94
   m_Pitch: f5433a3ce2d2313f2b2d52521d9fa5bd
   m_Send: 00000000000000000000000000000000
@@ -119,6 +153,7 @@ AudioMixerSnapshotController:
   m_AudioMixer: {fileID: 24100000}
   m_SnapshotID: 6d6b0cfa14637d5f0a34277934971c34
   m_FloatValues:
+    b9fc0df121fe7134e9cbd35aa5a65755: -80
     ddab7e07de3c686e296ff10b1cd77a47: -80
   m_TransitionOverrides: {}
 --- !u!241 &24100000
@@ -134,6 +169,7 @@ AudioMixerController:
   - {fileID: 8341788112416184532}
   - {fileID: -1214924791136564940}
   - {fileID: 24500006}
+  - {fileID: -5566153147845745614}
   m_StartSnapshot: {fileID: 8341788112416184532}
   m_SuspendThreshold: -80
   m_EnableSuspend: 1
@@ -150,9 +186,10 @@ AudioMixerController:
     - 9bd058bbb94358d33a130fd50e352c2d
     - e04cdd7cb505ba69ea76a16038de727a
     - 9eb64ac0ca0e2f1098eafbba1f9633f5
+    - af6d3dead2e9e4848a2ca2fa55634108
     name: View
   m_CurrentViewIndex: 0
-  m_TargetSnapshot: {fileID: -1214924791136564940}
+  m_TargetSnapshot: {fileID: -5566153147845745614}
 --- !u!243 &24300002
 AudioMixerGroupController:
   m_ObjectHideFlags: 0
@@ -199,6 +236,7 @@ AudioMixerSnapshotController:
   m_AudioMixer: {fileID: 24100000}
   m_SnapshotID: bdbaa2a61b8857f568cd42dafa5c4811
   m_FloatValues:
+    b9fc0df121fe7134e9cbd35aa5a65755: -80
     dd0b3fe80d006124baa36e791e6953f0: -80
   m_TransitionOverrides: {}
 --- !u!244 &671806689151419646
@@ -272,6 +310,20 @@ AudioMixerGroupController:
   m_Mute: 0
   m_Solo: 0
   m_BypassEffects: 0
+--- !u!244 &5712107256638894671
+AudioMixerEffectController:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_EffectID: 8d1dc8039a4095e439a61f34c4e7f3a6
+  m_EffectName: Attenuation
+  m_MixLevel: fdc182acd523a7247a98663cce44aca2
+  m_Parameters: []
+  m_SendTarget: {fileID: 0}
+  m_EnableWetMix: 0
+  m_Bypass: 0
 --- !u!244 &5996723691131988381
 AudioMixerEffectController:
   m_ObjectHideFlags: 3