Hasebe/Assets/Code/Infrastructure/Audio/AudioInfo.cs

using System;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using Random = UnityEngine.Random;

namespace Code.Infrastructure.Audio
{
    [Serializable]
    public abstract class AudioReference
    {
        public abstract UniTask Load();
        public abstract void Unload();
    }

    [Serializable]
    public class AudioReferenceLODed : AudioReference
    {
        private AsyncOperationHandle<AudioClip> _interiorClipHandle;
        private AsyncOperationHandle<AudioClip> _closeClipHandle;
        private AsyncOperationHandle<AudioClip> _distantClipHandle;
        private AsyncOperationHandle<AudioClip> _farClipHandle;

        public override async UniTask Load()
        {
            if (_interiorClipHandle.IsValid()) return;
            
            _interiorClipHandle = Addressables.LoadAssetAsync<AudioClip>(interior);
            _closeClipHandle = Addressables.LoadAssetAsync<AudioClip>(close);
            _distantClipHandle = Addressables.LoadAssetAsync<AudioClip>(distant);
            _farClipHandle = Addressables.LoadAssetAsync<AudioClip>(far);

            await UniTask.WhenAll(
                _interiorClipHandle.ToUniTask(),
                _closeClipHandle.ToUniTask(),
                _distantClipHandle.ToUniTask(),
                _farClipHandle.ToUniTask()
            );

            Interior = _interiorClipHandle.Result;
            Close = _closeClipHandle.Result;
            Distant = _distantClipHandle.Result;
            Far = _farClipHandle.Result;
        }

        public override void Unload()
        {
            if (!_interiorClipHandle.IsValid()) return;
            
            _interiorClipHandle.Release();
            _closeClipHandle.Release();
            _distantClipHandle.Release();
            _farClipHandle.Release();
            
            Interior = null;
            Close = null;
            Distant = null;
            Far = null;
        }

        [SerializeField] private AssetReference interior;
        [SerializeField] private AssetReference close;
        [SerializeField] private AssetReference distant;
        [SerializeField] private AssetReference far;

        public AudioClip Interior { get; private set; }
        public AudioClip Close { get; private set; }
        public AudioClip Distant { get; private set; }
        public AudioClip Far { get; private set; }
    }
    
    [Serializable]
    public class AudioReferenceSingle : AudioReference
    {
        private AsyncOperationHandle<AudioClip> _clipHandle;

        public override async UniTask Load()
        {
            if (_clipHandle.IsValid()) return;
            
            _clipHandle = Addressables.LoadAssetAsync<AudioClip>(clip);

            await _clipHandle.ToUniTask();

            Clip = _clipHandle.Result;
        }

        public override void Unload()
        {
            if (!_clipHandle.IsValid()) return;
            
            _clipHandle.Release();
            
            Clip = null;
        }

        [SerializeField] private AssetReference clip;

        public AudioClip Clip { get; private set; }
    }
    [Serializable]
    public class AudioReferenceRandom : AudioReference
    {
        private AsyncOperationHandle<AudioClip>[] _clipHandles;

        public override async UniTask Load()
        {
            if (_clipHandles != null) return;

            _clipHandles = new AsyncOperationHandle<AudioClip>[clips.Length];
            
            for (var i = 0; i < clips.Length; i++)
            {
                _clipHandles[i] = Addressables.LoadAssetAsync<AudioClip>(clips[i]);    
                await _clipHandles[i].ToUniTask();
            }
        }

        public override void Unload()
        {
            if (_clipHandles == null) return;
            
            for (var i = 0; i < clips.Length; i++) Addressables.Release(_clipHandles[i]);
        }

        [SerializeField] private AssetReference[] clips;

        public AudioClip Clip => _clipHandles[Random.Range(0, _clipHandles.Length)].Result;
    }
}