Audio & Sound Systems

Audio Architecture

┌─────────────────────────────────────────────────────────────┐
│                    GAME AUDIO PIPELINE                       │
├─────────────────────────────────────────────────────────────┤
│  SOURCES: SFX | Music | Voice | Ambient                     │
│                         ↓                                    │
│  MIDDLEWARE: Wwise / FMOD / Engine Audio                    │
│                         ↓                                    │
│  PROCESSING: 3D Spatial | Reverb | EQ | Compression         │
│                         ↓                                    │
│  MIXING: Master → Submixes → Individual Tracks              │
│                         ↓                                    │
│  OUTPUT: Speakers / Headphones (Stereo/Surround/Binaural)  │
└─────────────────────────────────────────────────────────────┘

Audio Programming

Unity Audio Manager

// ✅ Production-Ready: Audio Manager
public class AudioManager : MonoBehaviour
{
    public static AudioManager Instance { get; private set; }

    [System.Serializable]
    public class SoundBank
    {
        public string id;
        public AudioClip[] clips;
        [Range(0f, 1f)] public float volume = 1f;
        [Range(0.1f, 3f)] public float pitchVariation = 0.1f;
    }

    [SerializeField] private SoundBank[] _soundBanks;
    [SerializeField] private int _poolSize = 20;

    private Dictionary<string, SoundBank> _bankLookup;
    private Queue<AudioSource> _sourcePool;

    private void Awake()
    {
        if (Instance != null) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);

        InitializePool();
        BuildLookup();
    }

    public void PlaySound(string id, Vector3 position)
    {
        if (!_bankLookup.TryGetValue(id, out var bank)) return;
        if (bank.clips.Length == 0) return;

        var source = GetPooledSource();
        source.transform.position = position;
        source.clip = bank.clips[Random.Range(0, bank.clips.Length)];
        source.volume = bank.volume;
        source.pitch = 1f + Random.Range(-bank.pitchVariation, bank.pitchVariation);
        source.Play();

        StartCoroutine(ReturnToPool(source, source.clip.length));
    }

    private AudioSource GetPooledSource()
    {
        if (_sourcePool.Count > 0) return _sourcePool.Dequeue();
        return CreateNewSource();
    }

    private void InitializePool() { /* ... */ }
    private void BuildLookup() { /* ... */ }
    private AudioSource CreateNewSource() { /* ... */ }
    private IEnumerator ReturnToPool(AudioSource s, float delay) { /* ... */ }
}

FMOD Integration

// ✅ Production-Ready: FMOD Event Player
public class FMODEventPlayer : MonoBehaviour
{
    [SerializeField] private FMODUnity.EventReference _eventRef;

    private FMOD.Studio.EventInstance _instance;
    private bool _isPlaying;

    public void Play()
    {
        if (_isPlaying) Stop();

        _instance = FMODUnity.RuntimeManager.CreateInstance(_eventRef);
        _instance.set3DAttributes(FMODUnity.RuntimeUtils.To3DAttributes(transform));
        _instance.start();
        _isPlaying = true;
    }

    public void SetParameter(string name, float value)
    {
        if (_isPlaying)
            _instance.setParameterByName(name, value);
    }

    public void Stop(bool allowFadeout = true)
    {
        if (!_isPlaying) return;

        _instance.stop(allowFadeout
            ? FMOD.Studio.STOP_MODE.ALLOWFADEOUT
            : FMOD.Studio.STOP_MODE.IMMEDIATE);
        _instance.release();
        _isPlaying = false;
    }

    private void OnDestroy() => Stop(false);
}

Spatial Audio

3D AUDIO CONFIGURATION:
┌─────────────────────────────────────────────────────────────┐
│  ATTENUATION CURVES:                                         │
│                                                              │
│  Volume │████████████                                       │
│         │            ████                                   │
│         │                ████                               │
│         │                    ████                           │
│         └──────────────────────────→ Distance               │
│         0m     10m    30m    50m                            │
│                                                              │
│  Min Distance: 1m (full volume)                             │
│  Max Distance: 50m (inaudible)                              │
│  Rolloff: Logarithmic (realistic)                           │
└─────────────────────────────────────────────────────────────┘

Music Systems

Adaptive Music State Machine

MUSIC STATE TRANSITIONS:
┌─────────────────────────────────────────────────────────────┐
│                                                              │
│   [EXPLORATION] ←──────────→ [TENSION]                      │
│        │                        │                           │

...