Merge pull request #375 from djeada/copilot/modernize-game-audio

Modernize game/audio: eliminate magic numbers, standardize naming, consolidate constants

game/audio/AudioConstants.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstddef>
+
+// Audio system constants
+namespace AudioConstants {
+  // Volume constants
+  constexpr float DEFAULT_VOLUME = 1.0F;
+  constexpr float MIN_VOLUME = 0.0F;
+  constexpr float MAX_VOLUME = 1.0F;
+  
+  // Priority constants
+  constexpr int DEFAULT_PRIORITY = 0;
+  
+  // Channel constants
+  constexpr size_t DEFAULT_MAX_CHANNELS = 32;
+  constexpr size_t MIN_CHANNELS = 1;
+  
+  // Music player constants
+  constexpr int DEFAULT_MUSIC_CHANNELS = 4;
+  constexpr int DEFAULT_SAMPLE_RATE = 48000;
+  constexpr int DEFAULT_OUTPUT_CHANNELS = 2;
+  constexpr int DEFAULT_FADE_IN_MS = 250;
+  constexpr int DEFAULT_FADE_OUT_MS = 150;
+  constexpr int NO_FADE_MS = 0;
+}

game/audio/AudioEventHandler.cpp

@@ -111,7 +111,7 @@ void AudioEventHandler::onUnitSelected(
     if (should_play) {
       AudioCategory const category =
           m_useVoiceCategory ? AudioCategory::VOICE : AudioCategory::SFX;
-      AudioSystem::getInstance().playSound(it->second, 1.0F, false, 5,
+      AudioSystem::getInstance().playSound(it->second, UNIT_SELECTION_VOLUME, false, UNIT_SELECTION_PRIORITY,
                                            category);
       m_lastSelectionSoundTime = now;
       m_lastSelectionUnitType = unit_type_str;

game/audio/AudioEventHandler.h

@@ -16,6 +16,9 @@ namespace Game::Audio {
 
 class AudioEventHandler {
 public:
+  static constexpr float UNIT_SELECTION_VOLUME = 1.0F;
+  static constexpr int UNIT_SELECTION_PRIORITY = 5;
+  
   AudioEventHandler(Engine::Core::World *world);
   ~AudioEventHandler();
 

game/audio/AudioSystem.cpp

@@ -16,8 +16,8 @@
 #include <vector>
 
 AudioSystem::AudioSystem()
-    : isRunning(false), masterVolume(1.0F), soundVolume(1.0F),
-      musicVolume(1.0F), voiceVolume(1.0F) {}
+    : isRunning(false), masterVolume(AudioConstants::DEFAULT_VOLUME), soundVolume(AudioConstants::DEFAULT_VOLUME),
+      musicVolume(AudioConstants::DEFAULT_VOLUME), voiceVolume(AudioConstants::DEFAULT_VOLUME) {}
 
 AudioSystem::~AudioSystem() { shutdown(); }
 
@@ -100,14 +100,14 @@ void AudioSystem::stopMusic() {
 }
 
 void AudioSystem::setMasterVolume(float volume) {
-  masterVolume = std::clamp(volume, 0.0F, 1.0F);
+  masterVolume = std::clamp(volume, AudioConstants::MIN_VOLUME, AudioConstants::MAX_VOLUME);
 
   std::lock_guard<std::mutex> const lock(resourceMutex);
   for (auto &sound : sounds) {
     auto it = soundCategories.find(sound.first);
     AudioCategory const category =
         (it != soundCategories.end()) ? it->second : AudioCategory::SFX;
-    sound.second->setVolume(getEffectiveVolume(category, 1.0F));
+    sound.second->set_volume(getEffectiveVolume(category, AudioConstants::DEFAULT_VOLUME));
   }
 
   if (m_musicPlayer != nullptr) {
@@ -116,19 +116,19 @@ void AudioSystem::setMasterVolume(float volume) {
 }
 
 void AudioSystem::setSoundVolume(float volume) {
-  soundVolume = std::clamp(volume, 0.0F, 1.0F);
+  soundVolume = std::clamp(volume, AudioConstants::MIN_VOLUME, AudioConstants::MAX_VOLUME);
 
   std::lock_guard<std::mutex> const lock(resourceMutex);
   for (auto &sound : sounds) {
     auto it = soundCategories.find(sound.first);
     if (it != soundCategories.end() && it->second == AudioCategory::SFX) {
-      sound.second->setVolume(getEffectiveVolume(AudioCategory::SFX, 1.0F));
+      sound.second->set_volume(getEffectiveVolume(AudioCategory::SFX, AudioConstants::DEFAULT_VOLUME));
     }
   }
 }
 
 void AudioSystem::setMusicVolume(float volume) {
-  musicVolume = std::clamp(volume, 0.0F, 1.0F);
+  musicVolume = std::clamp(volume, AudioConstants::MIN_VOLUME, AudioConstants::MAX_VOLUME);
 
   std::lock_guard<std::mutex> const lock(resourceMutex);
   if (m_musicPlayer != nullptr) {
@@ -137,13 +137,13 @@ void AudioSystem::setMusicVolume(float volume) {
 }
 
 void AudioSystem::setVoiceVolume(float volume) {
-  voiceVolume = std::clamp(volume, 0.0F, 1.0F);
+  voiceVolume = std::clamp(volume, AudioConstants::MIN_VOLUME, AudioConstants::MAX_VOLUME);
 
   std::lock_guard<std::mutex> const lock(resourceMutex);
   for (auto &sound : sounds) {
     auto it = soundCategories.find(sound.first);
     if (it != soundCategories.end() && it->second == AudioCategory::VOICE) {
-      sound.second->setVolume(getEffectiveVolume(AudioCategory::VOICE, 1.0F));
+      sound.second->set_volume(getEffectiveVolume(AudioCategory::VOICE, AudioConstants::DEFAULT_VOLUME));
     }
   }
 }
@@ -171,7 +171,7 @@ auto AudioSystem::loadSound(const std::string &soundId,
   MiniaudioBackend *backend =
       (m_musicPlayer != nullptr) ? m_musicPlayer->getBackend() : nullptr;
   auto sound = std::make_unique<Sound>(filePath, backend);
-  if (!sound || !sound->isLoaded()) {
+  if (!sound || !sound->is_loaded()) {
     return false;
   }
 
@@ -235,7 +235,7 @@ void AudioSystem::unloadAllMusic() {
 }
 
 void AudioSystem::setMaxChannels(size_t channels) {
-  maxChannels = std::max(size_t(1), channels);
+  maxChannels = std::max(AudioConstants::MIN_CHANNELS, channels);
 }
 
 auto AudioSystem::getActiveChannelCount() const -> size_t {

game/audio/AudioSystem.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "AudioConstants.h"
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
@@ -37,13 +38,13 @@ enum class AudioCategory { SFX, VOICE, MUSIC };
 struct AudioEvent {
   AudioEventType type;
   std::string resourceId;
-  float volume = 1.0F;
+  float volume = AudioConstants::DEFAULT_VOLUME;
   bool loop = false;
-  int priority = 0;
+  int priority = AudioConstants::DEFAULT_PRIORITY;
   AudioCategory category = AudioCategory::SFX;
 
-  AudioEvent(AudioEventType t, std::string id = "", float vol = 1.0F,
-             bool l = false, int p = 0, AudioCategory cat = AudioCategory::SFX)
+  AudioEvent(AudioEventType t, std::string id = "", float vol = AudioConstants::DEFAULT_VOLUME,
+             bool l = false, int p = AudioConstants::DEFAULT_PRIORITY, AudioCategory cat = AudioCategory::SFX)
       : type(t), resourceId(std::move(id)), volume(vol), loop(l), priority(p),
         category(cat) {}
 };
@@ -55,10 +56,10 @@ public:
   auto initialize() -> bool;
   void shutdown();
 
-  void playSound(const std::string &soundId, float volume = 1.0F,
-                 bool loop = false, int priority = 0,
+  void playSound(const std::string &soundId, float volume = AudioConstants::DEFAULT_VOLUME,
+                 bool loop = false, int priority = AudioConstants::DEFAULT_PRIORITY,
                  AudioCategory category = AudioCategory::SFX);
-  void playMusic(const std::string &musicId, float volume = 1.0F,
+  void playMusic(const std::string &musicId, float volume = AudioConstants::DEFAULT_VOLUME,
                  bool crossfade = true);
   void stopSound(const std::string &soundId);
   void stopMusic();
@@ -120,7 +121,7 @@ private:
   std::atomic<float> musicVolume;
   std::atomic<float> voiceVolume;
 
-  size_t maxChannels{32};
+  size_t maxChannels{AudioConstants::DEFAULT_MAX_CHANNELS};
 
   struct ActiveSound {
     std::string id;

game/audio/MiniaudioBackend.cpp

@@ -28,53 +28,53 @@ struct DeviceWrapper {
   MiniaudioBackend *self;
 };
 
-static void audioCallback(ma_device *device, void *pOutput, const void *,
-                          ma_uint32 frameCount) {
-  auto *w = reinterpret_cast<DeviceWrapper *>(device->pUserData);
-  if ((w == nullptr) || (w->self == nullptr)) {
-    std::memset(pOutput, 0,
-                static_cast<unsigned long>(frameCount * 2) * sizeof(float));
+static void audioCallback(ma_device *device, void *output_buffer, const void *,
+                          ma_uint32 frame_count) {
+  auto *wrapper = reinterpret_cast<DeviceWrapper *>(device->pUserData);
+  if ((wrapper == nullptr) || (wrapper->self == nullptr)) {
+    std::memset(output_buffer, 0,
+                static_cast<unsigned long>(frame_count * MiniaudioBackend::DEFAULT_OUTPUT_CHANNELS) * sizeof(float));
     return;
   }
-  w->self->onAudio(reinterpret_cast<float *>(pOutput), frameCount);
+  wrapper->self->on_audio(reinterpret_cast<float *>(output_buffer), frame_count);
 }
 
 MiniaudioBackend::MiniaudioBackend(QObject *parent) : QObject(parent) {}
 MiniaudioBackend::~MiniaudioBackend() { shutdown(); }
 
-auto MiniaudioBackend::initialize(int deviceRate, int,
-                                  int musicChannels) -> bool {
-  m_rate = std::max(22050, deviceRate);
-  m_outCh = 2;
+auto MiniaudioBackend::initialize(int device_rate, int,
+                                  int music_channels) -> bool {
+  m_sample_rate = std::max(MIN_SAMPLE_RATE, device_rate);
+  m_output_channels = DEFAULT_OUTPUT_CHANNELS;
 
-  ma_device_config cfg = ma_device_config_init(ma_device_type_playback);
-  cfg.playback.format = ma_format_f32;
-  cfg.playback.channels = m_outCh;
-  cfg.sampleRate = m_rate;
-  cfg.dataCallback = audioCallback;
+  ma_device_config config = ma_device_config_init(ma_device_type_playback);
+  config.playback.format = ma_format_f32;
+  config.playback.channels = m_output_channels;
+  config.sampleRate = m_sample_rate;
+  config.dataCallback = audioCallback;
 
-  auto *wrap = new DeviceWrapper{this};
-  cfg.pUserData = wrap;
+  auto *wrapper = new DeviceWrapper{this};
+  config.pUserData = wrapper;
 
   m_device = new ma_device();
-  if (ma_device_init(nullptr, &cfg, m_device) != MA_SUCCESS) {
+  if (ma_device_init(nullptr, &config, m_device) != MA_SUCCESS) {
     qWarning() << "MiniaudioBackend: Failed to initialize audio device";
-    qWarning() << "  Requested sample rate:" << m_rate;
-    qWarning() << "  Requested channels:" << m_outCh;
+    qWarning() << "  Requested sample rate:" << m_sample_rate;
+    qWarning() << "  Requested channels:" << m_output_channels;
     qWarning() << "  This may indicate no audio device is available";
     delete m_device;
     m_device = nullptr;
-    delete wrap;
+    delete wrapper;
     return false;
   }
 
-  m_channels.resize(std::max(1, musicChannels));
-  for (auto &ch : m_channels) {
-    ch = Channel{};
+  m_channels.resize(std::max(1, music_channels));
+  for (auto &channel : m_channels) {
+    channel = Channel{};
   }
 
-  m_soundEffects.resize(32);
-  for (auto &sfx : m_soundEffects) {
+  m_sound_effects.resize(DEFAULT_SOUND_EFFECT_SLOTS);
+  for (auto &sfx : m_sound_effects) {
     sfx = SoundEffect{};
   }
 
@@ -83,90 +83,93 @@ auto MiniaudioBackend::initialize(int deviceRate, int,
     ma_device_uninit(m_device);
     delete m_device;
     m_device = nullptr;
-    delete wrap;
+    delete wrapper;
     return false;
   }
 
   qInfo() << "MiniaudioBackend: Initialized successfully";
-  qInfo() << "  Sample rate:" << m_rate;
-  qInfo() << "  Channels:" << m_outCh;
-  qInfo() << "  Music channels:" << musicChannels;
+  qInfo() << "  Sample rate:" << m_sample_rate;
+  qInfo() << "  Channels:" << m_output_channels;
+  qInfo() << "  Music channels:" << music_channels;
   return true;
 }
 
 void MiniaudioBackend::shutdown() {
-  QMutexLocker const lk(&m_mutex);
-  stopDevice();
+  QMutexLocker const locker(&m_mutex);
+  stop_device();
   m_tracks.clear();
   m_channels.clear();
 }
 
-void MiniaudioBackend::stopDevice() {
+void MiniaudioBackend::stop_device() {
   if (m_device == nullptr) {
     return;
   }
-  auto *wrap = reinterpret_cast<DeviceWrapper *>(m_device->pUserData);
+  auto *wrapper = reinterpret_cast<DeviceWrapper *>(m_device->pUserData);
   ma_device_stop(m_device);
   ma_device_uninit(m_device);
   delete m_device;
   m_device = nullptr;
-  delete wrap;
+  delete wrapper;
 }
 
 auto MiniaudioBackend::predecode(const QString &id,
                                  const QString &path) -> bool {
 
-  ma_decoder_config const dc =
-      ma_decoder_config_init(ma_format_f32, m_outCh, m_rate);
-  ma_decoder dec;
-  if (ma_decoder_init_file(path.toUtf8().constData(), &dc, &dec) !=
+  ma_decoder_config const decoder_config =
+      ma_decoder_config_init(ma_format_f32, m_output_channels, m_sample_rate);
+  ma_decoder decoder;
+  if (ma_decoder_init_file(path.toUtf8().constData(), &decoder_config, &decoder) !=
       MA_SUCCESS) {
     qWarning() << "miniaudio: cannot open" << path;
     return false;
   }
 
   QVector<float> pcm;
-  float buffer[4096 * 2];
+  float buffer[DECODE_BUFFER_FRAMES * DEFAULT_OUTPUT_CHANNELS];
   for (;;) {
     ma_uint64 frames_read = 0;
-    ma_result const r =
-        ma_decoder_read_pcm_frames(&dec, buffer, 4096, &frames_read);
+    ma_result const result =
+        ma_decoder_read_pcm_frames(&decoder, buffer, DECODE_BUFFER_FRAMES, &frames_read);
     if (frames_read > 0) {
-      const size_t samples = size_t(frames_read) * 2;
-      const size_t old = pcm.size();
-      pcm.resize(old + samples);
-      std::memcpy(pcm.data() + old, buffer, samples * sizeof(float));
+      const size_t samples = size_t(frames_read) * DEFAULT_OUTPUT_CHANNELS;
+      const size_t old_size = pcm.size();
+      pcm.resize(old_size + samples);
+      std::memcpy(pcm.data() + old_size, buffer, samples * sizeof(float));
     }
-    if (r == MA_AT_END) {
+    if (result == MA_AT_END) {
       break;
     }
-    if (r != MA_SUCCESS) {
-      ma_decoder_uninit(&dec);
+    if (result != MA_SUCCESS) {
+      ma_decoder_uninit(&decoder);
       return false;
     }
   }
-  ma_decoder_uninit(&dec);
+  ma_decoder_uninit(&decoder);
 
-  QMutexLocker const lk(&m_mutex);
-  DecodedTrack t;
-  t.frames = pcm.size() / 2;
-  t.pcm = std::move(pcm);
-  m_tracks[id] = std::move(t);
+  QMutexLocker const locker(&m_mutex);
+  DecodedTrack track;
+  track.frames = pcm.size() / DEFAULT_OUTPUT_CHANNELS;
+  track.pcm = std::move(pcm);
+  m_tracks[id] = std::move(track);
   return true;
 }
 
 void MiniaudioBackend::play(int channel, const QString &id, float volume,
-                            bool loop, int fadeMs) {
-  QMutexLocker lk(&m_mutex);
+                            bool loop, int fade_ms) {
+  static constexpr int MIN_FADE_MS = 1;
+  static constexpr int MS_PER_SECOND = 1000;
+  
+  QMutexLocker locker(&m_mutex);
   if (channel < 0 || channel >= m_channels.size()) {
     return;
   }
   auto it = m_tracks.find(id);
   if (it == m_tracks.end()) {
-    lk.unlock();
+    locker.unlock();
 
     predecode(id, id);
-    lk.relock();
+    locker.relock();
     it = m_tracks.find(id);
     if (it == m_tracks.end()) {
       qWarning() << "MiniaudioBackend: unknown track" << id;
@@ -176,21 +179,24 @@ void MiniaudioBackend::play(int channel, const QString &id, float volume,
 
   auto &ch = m_channels[channel];
   ch.track = &it.value();
-  ch.framePos = 0;
+  ch.frame_pos = 0;
   ch.looping = loop;
   ch.paused = false;
   ch.active = true;
-  ch.tgtVol = std::clamp(volume, 0.0F, 1.0F);
-  ch.curVol = 0.0F;
+  ch.target_volume = std::clamp(volume, MIN_VOLUME, MAX_VOLUME);
+  ch.current_volume = MIN_VOLUME;
 
   const unsigned fade_samples =
-      std::max(1U, unsigned((fadeMs * m_rate) / 1000));
+      std::max(unsigned(MIN_FADE_MS), unsigned((fade_ms * m_sample_rate) / MS_PER_SECOND));
   ch.fade_samples = fade_samples;
-  ch.volStep = (ch.tgtVol - ch.curVol) / float(fade_samples);
+  ch.volume_step = (ch.target_volume - ch.current_volume) / float(fade_samples);
 }
 
-void MiniaudioBackend::stop(int channel, int fadeMs) {
-  QMutexLocker const lk(&m_mutex);
+void MiniaudioBackend::stop(int channel, int fade_ms) {
+  static constexpr int MIN_FADE_MS = 1;
+  static constexpr int MS_PER_SECOND = 1000;
+  
+  QMutexLocker const locker(&m_mutex);
   if (channel < 0 || channel >= m_channels.size()) {
     return;
   }
@@ -199,28 +205,31 @@ void MiniaudioBackend::stop(int channel, int fadeMs) {
     return;
   }
   const unsigned fade_samples =
-      std::max(1U, unsigned((fadeMs * m_rate) / 1000));
-  ch.tgtVol = 0.0F;
+      std::max(unsigned(MIN_FADE_MS), unsigned((fade_ms * m_sample_rate) / MS_PER_SECOND));
+  ch.target_volume = MIN_VOLUME;
   ch.fade_samples = fade_samples;
-  ch.volStep = (ch.tgtVol - ch.curVol) / float(fade_samples);
+  ch.volume_step = (ch.target_volume - ch.current_volume) / float(fade_samples);
   ch.looping = false;
 }
 
 void MiniaudioBackend::pause(int channel) {
-  QMutexLocker const lk(&m_mutex);
+  QMutexLocker const locker(&m_mutex);
   if (channel >= 0 && channel < m_channels.size()) {
     m_channels[channel].paused = true;
   }
 }
 void MiniaudioBackend::resume(int channel) {
-  QMutexLocker const lk(&m_mutex);
+  QMutexLocker const locker(&m_mutex);
   if (channel >= 0 && channel < m_channels.size()) {
     m_channels[channel].paused = false;
   }
 }
 
-void MiniaudioBackend::setVolume(int channel, float volume, int fadeMs) {
-  QMutexLocker const lk(&m_mutex);
+void MiniaudioBackend::set_volume(int channel, float volume, int fade_ms) {
+  static constexpr int MIN_FADE_MS = 1;
+  static constexpr int MS_PER_SECOND = 1000;
+  
+  QMutexLocker const locker(&m_mutex);
   if (channel < 0 || channel >= m_channels.size()) {
     return;
   }
@@ -228,35 +237,38 @@ void MiniaudioBackend::setVolume(int channel, float volume, int fadeMs) {
   if (!ch.active) {
     return;
   }
-  ch.tgtVol = std::clamp(volume, 0.0F, 1.0F);
+  ch.target_volume = std::clamp(volume, MIN_VOLUME, MAX_VOLUME);
   const unsigned fade_samples =
-      std::max(1U, unsigned((fadeMs * m_rate) / 1000));
+      std::max(unsigned(MIN_FADE_MS), unsigned((fade_ms * m_sample_rate) / MS_PER_SECOND));
   ch.fade_samples = fade_samples;
-  ch.volStep = (ch.tgtVol - ch.curVol) / float(fade_samples);
+  ch.volume_step = (ch.target_volume - ch.current_volume) / float(fade_samples);
 }
 
-void MiniaudioBackend::stopAll(int fadeMs) {
-  QMutexLocker const lk(&m_mutex);
+void MiniaudioBackend::stop_all(int fade_ms) {
+  static constexpr int MIN_FADE_MS = 1;
+  static constexpr int MS_PER_SECOND = 1000;
+  
+  QMutexLocker const locker(&m_mutex);
   const unsigned fade_samples =
-      std::max(1U, unsigned((fadeMs * m_rate) / 1000));
+      std::max(unsigned(MIN_FADE_MS), unsigned((fade_ms * m_sample_rate) / MS_PER_SECOND));
   for (auto &ch : m_channels) {
     if (!ch.active) {
       continue;
     }
-    ch.tgtVol = 0.0F;
+    ch.target_volume = MIN_VOLUME;
     ch.fade_samples = fade_samples;
-    ch.volStep = (ch.tgtVol - ch.curVol) / float(fade_samples);
+    ch.volume_step = (ch.target_volume - ch.current_volume) / float(fade_samples);
     ch.looping = false;
   }
 }
 
-void MiniaudioBackend::setMasterVolume(float volume, int) {
-  QMutexLocker const lk(&m_mutex);
-  m_masterVol = std::clamp(volume, 0.0F, 1.0F);
+void MiniaudioBackend::set_master_volume(float volume, int) {
+  QMutexLocker const locker(&m_mutex);
+  m_master_volume = std::clamp(volume, MIN_VOLUME, MAX_VOLUME);
 }
 
-auto MiniaudioBackend::anyChannelPlaying() const -> bool {
-  QMutexLocker const lk(&m_mutex);
+auto MiniaudioBackend::any_channel_playing() const -> bool {
+  QMutexLocker const locker(&m_mutex);
   for (const auto &ch : m_channels) {
     if (ch.active && !ch.paused) {
       return true;
@@ -264,8 +276,8 @@ auto MiniaudioBackend::anyChannelPlaying() const -> bool {
   }
   return false;
 }
-auto MiniaudioBackend::channelPlaying(int channel) const -> bool {
-  QMutexLocker const lk(&m_mutex);
+auto MiniaudioBackend::channel_playing(int channel) const -> bool {
+  QMutexLocker const locker(&m_mutex);
   if (channel < 0 || channel >= m_channels.size()) {
     return false;
   }
@@ -273,8 +285,8 @@ auto MiniaudioBackend::channelPlaying(int channel) const -> bool {
   return ch.active && !ch.paused;
 }
 
-void MiniaudioBackend::playSound(const QString &id, float volume, bool loop) {
-  QMutexLocker const lk(&m_mutex);
+void MiniaudioBackend::play_sound(const QString &id, float volume, bool loop) {
+  QMutexLocker const locker(&m_mutex);
 
   auto it = m_tracks.find(id);
   if (it == m_tracks.end()) {
@@ -282,35 +294,36 @@ void MiniaudioBackend::playSound(const QString &id, float volume, bool loop) {
     return;
   }
 
-  int const slot = findFreeSoundSlot();
+  int const slot = find_free_sound_slot();
   if (slot < 0) {
     qWarning() << "MiniaudioBackend: No free sound slots available";
     return;
   }
 
-  auto &sfx = m_soundEffects[slot];
+  auto &sfx = m_sound_effects[slot];
   sfx.track = &it.value();
-  sfx.framePos = 0;
-  sfx.volume = std::clamp(volume, 0.0F, 1.0F);
+  sfx.frame_pos = 0;
+  sfx.volume = std::clamp(volume, MIN_VOLUME, MAX_VOLUME);
   sfx.looping = loop;
   sfx.active = true;
 }
 
-auto MiniaudioBackend::findFreeSoundSlot() const -> int {
-  for (int i = 0; i < m_soundEffects.size(); ++i) {
-    if (!m_soundEffects[i].active) {
+auto MiniaudioBackend::find_free_sound_slot() const -> int {
+  for (int i = 0; i < m_sound_effects.size(); ++i) {
+    if (!m_sound_effects[i].active) {
       return i;
     }
   }
   return -1;
 }
 
-void MiniaudioBackend::onAudio(float *out, unsigned frames) {
+void MiniaudioBackend::on_audio(float *output, unsigned frames) {
+  static constexpr int STEREO_CHANNELS = 2;
 
-  const unsigned samples = frames * 2;
-  std::memset(out, 0, samples * sizeof(float));
+  const unsigned samples = frames * STEREO_CHANNELS;
+  std::memset(output, 0, samples * sizeof(float));
 
-  QMutexLocker const lk(&m_mutex);
+  QMutexLocker const locker(&m_mutex);
 
   for (auto &ch : m_channels) {
     if (!ch.active || ch.paused || ch.track == nullptr) {
@@ -319,9 +332,9 @@ void MiniaudioBackend::onAudio(float *out, unsigned frames) {
 
     const auto *pcm = ch.track->pcm.constData();
     unsigned frames_left = frames;
-    unsigned pos = ch.framePos;
+    unsigned pos = ch.frame_pos;
 
-    float *dst = out;
+    float *dst = output;
 
     while (frames_left > 0) {
       if (pos >= ch.track->frames) {
@@ -332,20 +345,20 @@ void MiniaudioBackend::onAudio(float *out, unsigned frames) {
         }
       }
       const unsigned can_copy = std::min(frames_left, ch.track->frames - pos);
-      const float *src = pcm + static_cast<size_t>(pos * 2);
+      const float *src = pcm + static_cast<size_t>(pos * STEREO_CHANNELS);
 
       for (unsigned i = 0; i < can_copy; ++i) {
-        const float vol = ch.curVol * m_masterVol;
+        const float vol = ch.current_volume * m_master_volume;
         dst[0] += src[0] * vol;
         dst[1] += src[1] * vol;
-        dst += 2;
-        src += 2;
+        dst += STEREO_CHANNELS;
+        src += STEREO_CHANNELS;
 
         if (ch.fade_samples > 0) {
-          ch.curVol += ch.volStep;
+          ch.current_volume += ch.volume_step;
           --ch.fade_samples;
           if (ch.fade_samples == 0) {
-            ch.curVol = ch.tgtVol;
+            ch.current_volume = ch.target_volume;
           }
         }
       }
@@ -353,28 +366,28 @@ void MiniaudioBackend::onAudio(float *out, unsigned frames) {
       frames_left -= can_copy;
     }
 
-    ch.framePos = pos;
+    ch.frame_pos = pos;
 
-    if (!ch.looping && ch.framePos >= ch.track->frames) {
+    if (!ch.looping && ch.frame_pos >= ch.track->frames) {
       ch.active = false;
-      ch.curVol = ch.tgtVol = 0.0F;
+      ch.current_volume = ch.target_volume = MIN_VOLUME;
       ch.fade_samples = 0;
     }
-    if (ch.fade_samples == 0 && ch.curVol == 0.0F && ch.tgtVol == 0.0F &&
+    if (ch.fade_samples == 0 && ch.current_volume == MIN_VOLUME && ch.target_volume == MIN_VOLUME &&
         !ch.looping) {
       ch.active = false;
     }
   }
 
-  for (auto &sfx : m_soundEffects) {
+  for (auto &sfx : m_sound_effects) {
     if (!sfx.active || sfx.track == nullptr) {
       continue;
     }
 
     const auto *pcm = sfx.track->pcm.constData();
     unsigned frames_left = frames;
-    unsigned pos = sfx.framePos;
-    float *dst = out;
+    unsigned pos = sfx.frame_pos;
+    float *dst = output;
 
     while (frames_left > 0) {
       if (pos >= sfx.track->frames) {
@@ -387,28 +400,28 @@ void MiniaudioBackend::onAudio(float *out, unsigned frames) {
       }
 
       const unsigned can_copy = std::min(frames_left, sfx.track->frames - pos);
-      const float *src = pcm + static_cast<size_t>(pos * 2);
+      const float *src = pcm + static_cast<size_t>(pos * STEREO_CHANNELS);
 
       for (unsigned i = 0; i < can_copy; ++i) {
-        const float vol = sfx.volume * m_masterVol;
+        const float vol = sfx.volume * m_master_volume;
         dst[0] += src[0] * vol;
         dst[1] += src[1] * vol;
-        dst += 2;
-        src += 2;
+        dst += STEREO_CHANNELS;
+        src += STEREO_CHANNELS;
       }
 
       pos += can_copy;
       frames_left -= can_copy;
     }
 
-    sfx.framePos = pos;
+    sfx.frame_pos = pos;
   }
 
   for (unsigned i = 0; i < samples; ++i) {
-    if (out[i] > 1.0F) {
-      out[i] = 1.0F;
-    } else if (out[i] < -1.0F) {
-      out[i] = -1.0F;
+    if (output[i] > MAX_VOLUME) {
+      output[i] = MAX_VOLUME;
+    } else if (output[i] < -MAX_VOLUME) {
+      output[i] = -MAX_VOLUME;
     }
   }
 }

game/audio/MiniaudioBackend.h

@@ -11,29 +11,39 @@ struct ma_device;
 class MiniaudioBackend : public QObject {
   Q_OBJECT
 public:
+  static constexpr int DEFAULT_SAMPLE_RATE = 48000;
+  static constexpr int DEFAULT_OUTPUT_CHANNELS = 2;
+  static constexpr int DEFAULT_MUSIC_CHANNELS = 4;
+  static constexpr int DEFAULT_SOUND_EFFECT_SLOTS = 32;
+  static constexpr int DECODE_BUFFER_FRAMES = 4096;
+  static constexpr int MIN_SAMPLE_RATE = 22050;
+  static constexpr float MIN_VOLUME = 0.0F;
+  static constexpr float MAX_VOLUME = 1.0F;
+  static constexpr float DEFAULT_VOLUME = 1.0F;
+
   explicit MiniaudioBackend(QObject *parent = nullptr);
   ~MiniaudioBackend() override;
 
-  auto initialize(int deviceRate, int outChannels, int musicChannels) -> bool;
+  auto initialize(int device_rate, int output_channels, int music_channels) -> bool;
   void shutdown();
 
   auto predecode(const QString &id, const QString &path) -> bool;
 
   void play(int channel, const QString &id, float volume, bool loop,
-            int fadeMs);
-  void stop(int channel, int fadeMs);
+            int fade_ms);
+  void stop(int channel, int fade_ms);
   void pause(int channel);
   void resume(int channel);
-  void setVolume(int channel, float volume, int fadeMs);
-  void stopAll(int fadeMs);
-  void setMasterVolume(float volume, int fadeMs);
+  void set_volume(int channel, float volume, int fade_ms);
+  void stop_all(int fade_ms);
+  void set_master_volume(float volume, int fade_ms);
 
-  auto anyChannelPlaying() const -> bool;
-  auto channelPlaying(int channel) const -> bool;
+  auto any_channel_playing() const -> bool;
+  auto channel_playing(int channel) const -> bool;
 
-  void playSound(const QString &id, float volume, bool loop = false);
+  void play_sound(const QString &id, float volume, bool loop = false);
 
-  void onAudio(float *out, unsigned frames);
+  void on_audio(float *output, unsigned frames);
 
 private:
   struct DecodedTrack {
@@ -43,10 +53,10 @@ private:
 
   struct Channel {
     const DecodedTrack *track = nullptr;
-    unsigned framePos = 0;
-    float curVol = 0.0F;
-    float tgtVol = 1.0F;
-    float volStep = 0.0F;
+    unsigned frame_pos = 0;
+    float current_volume = 0.0F;
+    float target_volume = DEFAULT_VOLUME;
+    float volume_step = 0.0F;
     unsigned fade_samples = 0;
     bool looping = false;
     bool paused = false;
@@ -55,23 +65,23 @@ private:
 
   struct SoundEffect {
     const DecodedTrack *track = nullptr;
-    unsigned framePos = 0;
-    float volume = 1.0F;
+    unsigned frame_pos = 0;
+    float volume = DEFAULT_VOLUME;
     bool looping = false;
     bool active = false;
   };
 
-  void startDevice();
-  void stopDevice();
-  auto findFreeSoundSlot() const -> int;
+  void start_device();
+  void stop_device();
+  auto find_free_sound_slot() const -> int;
 
   ma_device *m_device{nullptr};
-  int m_rate{48000};
-  int m_outCh{2};
+  int m_sample_rate{DEFAULT_SAMPLE_RATE};
+  int m_output_channels{DEFAULT_OUTPUT_CHANNELS};
 
   mutable QMutex m_mutex;
   QMap<QString, DecodedTrack> m_tracks;
   QVector<Channel> m_channels;
-  QVector<SoundEffect> m_soundEffects;
-  float m_masterVol{1.0F};
+  QVector<SoundEffect> m_sound_effects;
+  float m_master_volume{DEFAULT_VOLUME};
 };

game/audio/Music.cpp

@@ -7,34 +7,34 @@
 #include <QTimer>
 #include <QUrl>
 
-Music::Music(const std::string &filePath)
-    : filepath(filePath), loaded(false), audioOutput(nullptr),
-      mainThread(nullptr), playing(false), markedForDeletion(false) {
+Music::Music(const std::string &file_path)
+    : file_path(file_path), loaded(false), audio_output(nullptr),
+      main_thread(nullptr), playing(false), marked_for_deletion(false) {
 
   if (!QCoreApplication::instance()) {
     return;
   }
 
-  mainThread = QCoreApplication::instance()->thread();
+  main_thread = QCoreApplication::instance()->thread();
   player = new QMediaPlayer();
 
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-  audioOutput = new QAudioOutput(player);
-  player->setAudioOutput(audioOutput);
+  audio_output = new QAudioOutput(player);
+  player->setAudioOutput(audio_output);
 
   QObject::connect(player, &QMediaPlayer::errorOccurred,
-                   [filepath = this->filepath](QMediaPlayer::Error error,
+                   [file_path = this->file_path](QMediaPlayer::Error error,
                                                const QString &desc) {
                      qWarning() << "QMediaPlayer error for"
-                                << QString::fromStdString(filepath)
+                                << QString::fromStdString(file_path)
                                 << "- Error code:" << static_cast<int>(error)
                                 << "Message:" << desc;
                    });
 
   QObject::connect(
       player, &QMediaPlayer::mediaStatusChanged,
-      [filepath = this->filepath, this](QMediaPlayer::MediaStatus status) {
-        qDebug() << "Media status for" << QString::fromStdString(filepath)
+      [file_path = this->file_path, this](QMediaPlayer::MediaStatus status) {
+        qDebug() << "Media status for" << QString::fromStdString(file_path)
                  << ":" << static_cast<int>(status);
         if (status == QMediaPlayer::EndOfMedia) {
           playing = false;
@@ -43,216 +43,218 @@ Music::Music(const std::string &filePath)
 
   QObject::connect(
       player, &QMediaPlayer::playbackStateChanged,
-      [filepath = this->filepath](QMediaPlayer::PlaybackState state) {
-        qDebug() << "Playback state for" << QString::fromStdString(filepath)
+      [file_path = this->file_path](QMediaPlayer::PlaybackState state) {
+        qDebug() << "Playback state for" << QString::fromStdString(file_path)
                  << ":" << static_cast<int>(state);
       });
 
-  player->setSource(QUrl::fromLocalFile(QString::fromStdString(filePath)));
+  player->setSource(QUrl::fromLocalFile(QString::fromStdString(file_path)));
   loaded = (player->error() == QMediaPlayer::NoError);
 #else
-  player->setMedia(QUrl::fromLocalFile(QString::fromStdString(filePath)));
+  player->setMedia(QUrl::fromLocalFile(QString::fromStdString(file_path)));
   loaded = (player->mediaStatus() != QMediaPlayer::InvalidMedia &&
             player->mediaStatus() != QMediaPlayer::NoMedia);
 #endif
 }
 
-Music::~Music() { cleanupPlayer(); }
+Music::~Music() { cleanup_player(); }
 
-void Music::cleanupPlayer() {
-  if (!player || markedForDeletion) {
+void Music::cleanup_player() {
+  if (!player || marked_for_deletion) {
     return;
   }
 
-  markedForDeletion = true;
-  QMediaPlayer *rawPlayer = player.data();
+  marked_for_deletion = true;
+  QMediaPlayer *raw_player = player.data();
 
-  if (!rawPlayer) {
+  if (!raw_player) {
     return;
   }
 
-  if (QCoreApplication::instance() && mainThread) {
-    rawPlayer->deleteLater();
+  if (QCoreApplication::instance() && main_thread) {
+    raw_player->deleteLater();
   }
 }
 
-bool Music::isLoaded() const { return loaded && !markedForDeletion; }
+bool Music::is_loaded() const { return loaded && !marked_for_deletion; }
 
 void Music::play(float volume, bool loop) {
-  if (!player || !loaded || markedForDeletion) {
+  if (!player || !loaded || marked_for_deletion) {
     return;
   }
 
-  QPointer<QMediaPlayer> p = player;
-  QAudioOutput *output = audioOutput;
+  QPointer<QMediaPlayer> player_ptr = player;
+  QAudioOutput *output = audio_output;
 
-  if (!p || !QCoreApplication::instance()) {
+  if (!player_ptr || !QCoreApplication::instance()) {
     return;
   }
 
   QMetaObject::invokeMethod(
       QCoreApplication::instance(),
-      [p, output, volume, loop, this]() {
-        if (!p) {
+      [player_ptr, output, volume, loop, this]() {
+        if (!player_ptr) {
           return;
         }
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 
-        bool isCurrentlyPlaying =
-            (p->playbackState() == QMediaPlayer::PlayingState);
+        bool is_currently_playing =
+            (player_ptr->playbackState() == QMediaPlayer::PlayingState);
 
         if (output) {
           output->setVolume(volume);
         }
-        p->setLoops(loop ? QMediaPlayer::Infinite : 1);
+        player_ptr->setLoops(loop ? QMediaPlayer::Infinite : 1);
 
-        if (!isCurrentlyPlaying) {
+        if (!is_currently_playing) {
           qDebug() << "Starting playback for"
-                   << QString::fromStdString(filepath);
+                   << QString::fromStdString(file_path);
           playing = true;
-          p->play();
+          player_ptr->play();
         } else {
-          qDebug() << "Already playing" << QString::fromStdString(filepath)
+          qDebug() << "Already playing" << QString::fromStdString(file_path)
                    << "- updating volume only";
         }
 #else
-        p->setVolume(static_cast<int>(volume * 100));
+        player_ptr->setVolume(static_cast<int>(volume * 100));
         playing = true;
-        p->play();
+        player_ptr->play();
 #endif
       },
       Qt::QueuedConnection);
 }
 
 void Music::stop() {
-  if (!player || markedForDeletion) {
+  if (!player || marked_for_deletion) {
     return;
   }
 
   playing = false;
-  QPointer<QMediaPlayer> p = player;
-  if (!p || !QCoreApplication::instance()) {
+  QPointer<QMediaPlayer> player_ptr = player;
+  if (!player_ptr || !QCoreApplication::instance()) {
     return;
   }
 
   QMetaObject::invokeMethod(
       QCoreApplication::instance(),
-      [p]() {
-        if (p) {
-          p->stop();
+      [player_ptr]() {
+        if (player_ptr) {
+          player_ptr->stop();
         }
       },
       Qt::QueuedConnection);
 }
 
 void Music::pause() {
-  if (!player || markedForDeletion) {
+  if (!player || marked_for_deletion) {
     return;
   }
 
-  QPointer<QMediaPlayer> p = player;
-  if (!p || !QCoreApplication::instance()) {
+  QPointer<QMediaPlayer> player_ptr = player;
+  if (!player_ptr || !QCoreApplication::instance()) {
     return;
   }
 
   QMetaObject::invokeMethod(
       QCoreApplication::instance(),
-      [p]() {
-        if (p) {
-          p->pause();
+      [player_ptr]() {
+        if (player_ptr) {
+          player_ptr->pause();
         }
       },
       Qt::QueuedConnection);
 }
 
 void Music::resume() {
-  if (!player || markedForDeletion) {
+  if (!player || marked_for_deletion) {
     return;
   }
 
-  QPointer<QMediaPlayer> p = player;
-  if (!p || !QCoreApplication::instance()) {
+  QPointer<QMediaPlayer> player_ptr = player;
+  if (!player_ptr || !QCoreApplication::instance()) {
     return;
   }
 
   QMetaObject::invokeMethod(
       QCoreApplication::instance(),
-      [p]() {
-        if (!p) {
+      [player_ptr]() {
+        if (!player_ptr) {
           return;
         }
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-        if (p->playbackState() == QMediaPlayer::PausedState) {
-          p->play();
+        if (player_ptr->playbackState() == QMediaPlayer::PausedState) {
+          player_ptr->play();
         }
 #else
-        if (p->state() == QMediaPlayer::PausedState) {
-          p->play();
+        if (player_ptr->state() == QMediaPlayer::PausedState) {
+          player_ptr->play();
         }
 #endif
       },
       Qt::QueuedConnection);
 }
 
-void Music::setVolume(float volume) {
-  if (!player || markedForDeletion) {
+void Music::set_volume(float volume) {
+  if (!player || marked_for_deletion) {
     return;
   }
 
-  QPointer<QMediaPlayer> p = player;
-  if (!p || !QCoreApplication::instance()) {
+  QPointer<QMediaPlayer> player_ptr = player;
+  if (!player_ptr || !QCoreApplication::instance()) {
     return;
   }
 
   QMetaObject::invokeMethod(
       QCoreApplication::instance(),
-      [p, volume]() {
-        if (!p) {
+      [player_ptr, volume]() {
+        if (!player_ptr) {
           return;
         }
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-        if (p->audioOutput()) {
-          p->audioOutput()->setVolume(volume);
+        if (player_ptr->audioOutput()) {
+          player_ptr->audioOutput()->setVolume(volume);
         }
 #else
-        p->setVolume(static_cast<int>(volume * 100));
+        player_ptr->setVolume(static_cast<int>(volume * 100));
 #endif
       },
       Qt::QueuedConnection);
 }
 
-void Music::fadeOut() {
-  if (!player || markedForDeletion) {
+void Music::fade_out() {
+  static constexpr int FADE_OUT_DELAY_MS = 50;
+  
+  if (!player || marked_for_deletion) {
     return;
   }
 
-  QPointer<QMediaPlayer> p = player;
-  if (!p || !QCoreApplication::instance()) {
+  QPointer<QMediaPlayer> player_ptr = player;
+  if (!player_ptr || !QCoreApplication::instance()) {
     return;
   }
 
   QMetaObject::invokeMethod(
       QCoreApplication::instance(),
-      [p, this]() {
-        if (!p) {
+      [player_ptr, this]() {
+        if (!player_ptr) {
           return;
         }
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-        if (p->audioOutput()) {
-          p->audioOutput()->setVolume(0.0F);
+        if (player_ptr->audioOutput()) {
+          player_ptr->audioOutput()->setVolume(0.0F);
         }
 
-        QTimer::singleShot(50, [p, this]() {
-          if (p && p->playbackState() == QMediaPlayer::PlayingState) {
+        QTimer::singleShot(FADE_OUT_DELAY_MS, [player_ptr, this]() {
+          if (player_ptr && player_ptr->playbackState() == QMediaPlayer::PlayingState) {
             qDebug() << "Fading out and pausing"
-                     << QString::fromStdString(filepath);
-            p->pause();
+                     << QString::fromStdString(file_path);
+            player_ptr->pause();
             playing = false;
           }
         });
 #else
-        p->setVolume(0);
-        p->pause();
+        player_ptr->setVolume(0);
+        player_ptr->pause();
         playing = false;
 #endif
       },

game/audio/Music.h

@@ -11,25 +11,27 @@ class QThread;
 
 class Music {
 public:
-  Music(const std::string &filePath);
+  static constexpr float DEFAULT_VOLUME = 1.0F;
+
+  Music(const std::string &file_path);
   ~Music();
 
-  bool isLoaded() const;
-  void play(float volume = 1.0F, bool loop = true);
+  bool is_loaded() const;
+  void play(float volume = DEFAULT_VOLUME, bool loop = true);
   void stop();
   void pause();
   void resume();
-  void setVolume(float volume);
-  void fadeOut();
+  void set_volume(float volume);
+  void fade_out();
 
 private:
-  void cleanupPlayer();
+  void cleanup_player();
 
   QPointer<QMediaPlayer> player;
-  QAudioOutput *audioOutput;
-  QThread *mainThread;
-  std::string filepath;
+  QAudioOutput *audio_output;
+  QThread *main_thread;
+  std::string file_path;
   bool loaded;
   bool playing;
-  std::atomic<bool> markedForDeletion;
+  std::atomic<bool> marked_for_deletion;
 };

game/audio/MusicPlayer.cpp

@@ -1,4 +1,5 @@
 #include "MusicPlayer.h"
+#include "AudioConstants.h"
 #include "MiniaudioBackend.h"
 #include <QCoreApplication>
 #include <QFileInfo>
@@ -34,6 +35,8 @@ MusicPlayer::MusicPlayer() : QObject(nullptr) {}
 MusicPlayer::~MusicPlayer() { shutdown(); }
 
 auto MusicPlayer::initialize(int musicChannels) -> bool {
+  static constexpr int MIN_CHANNELS = 1;
+  
   if (m_initialized) {
     return true;
   }
@@ -43,9 +46,9 @@ auto MusicPlayer::initialize(int musicChannels) -> bool {
   }
   ensureOnGuiThread("MusicPlayer::initialize");
 
-  m_channelCount = std::max(1, musicChannels);
+  m_channelCount = std::max(MIN_CHANNELS, musicChannels);
   m_backend = new MiniaudioBackend(this);
-  if (!m_backend->initialize(48000, 2, m_channelCount)) {
+  if (!m_backend->initialize(AudioConstants::DEFAULT_SAMPLE_RATE, AudioConstants::DEFAULT_OUTPUT_CHANNELS, m_channelCount)) {
     qWarning() << "MusicPlayer: backend init failed";
     m_backend->deleteLater();
     m_backend = nullptr;
@@ -114,12 +117,12 @@ void MusicPlayer::registerTrack(const std::string &trackId,
 }
 
 void MusicPlayer::play(const std::string &id, float v, bool loop) {
-  play(id, v, loop, m_defaultChannel, 250);
+  play(id, v, loop, m_defaultChannel, AudioConstants::DEFAULT_FADE_IN_MS);
 }
-void MusicPlayer::stop() { stop(m_defaultChannel, 150); }
+void MusicPlayer::stop() { stop(m_defaultChannel, AudioConstants::DEFAULT_FADE_OUT_MS); }
 void MusicPlayer::pause() { pause(m_defaultChannel); }
 void MusicPlayer::resume() { resume(m_defaultChannel); }
-void MusicPlayer::setVolume(float v) { setVolume(m_defaultChannel, v, 0); }
+void MusicPlayer::setVolume(float v) { setVolume(m_defaultChannel, v, AudioConstants::NO_FADE_MS); }
 
 auto MusicPlayer::play(const std::string &id, float vol, bool loop, int channel,
                        int fadeMs) -> int {
@@ -216,10 +219,10 @@ void MusicPlayer::setMasterVolume(float v, int ms) {
 }
 
 auto MusicPlayer::isPlaying() const -> bool {
-  return (m_backend != nullptr) && m_backend->anyChannelPlaying();
+  return (m_backend != nullptr) && m_backend->any_channel_playing();
 }
 auto MusicPlayer::isPlaying(int ch) const -> bool {
-  return (m_backend != nullptr) && m_backend->channelPlaying(ch);
+  return (m_backend != nullptr) && m_backend->channel_playing(ch);
 }
 
 void MusicPlayer::ensureOnGuiThread(const char *where) {
@@ -230,7 +233,7 @@ auto MusicPlayer::findFreeChannel() const -> int {
     return 0;
   }
   for (int i = 0; i < m_channelCount; ++i) {
-    if (!m_backend->channelPlaying(i)) {
+    if (!m_backend->channel_playing(i)) {
       return i;
     }
   }
@@ -253,9 +256,9 @@ void MusicPlayer::stop_gui(int ch, int ms) { m_backend->stop(ch, ms); }
 void MusicPlayer::pause_gui(int ch) { m_backend->pause(ch); }
 void MusicPlayer::resume_gui(int ch) { m_backend->resume(ch); }
 void MusicPlayer::setVolume_gui(int ch, float v, int ms) {
-  m_backend->setVolume(ch, v, ms);
+  m_backend->set_volume(ch, v, ms);
 }
 void MusicPlayer::setMasterVolume_gui(float v, int ms) {
-  m_backend->setMasterVolume(v, ms);
+  m_backend->set_master_volume(v, ms);
 }
-void MusicPlayer::stopAll_gui(int ms) { m_backend->stopAll(ms); }
+void MusicPlayer::stopAll_gui(int ms) { m_backend->stop_all(ms); }

game/audio/MusicPlayer.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "AudioConstants.h"
 #include "MiniaudioBackend.h"
 #include <QObject>
 #include <QPointer>
@@ -15,12 +16,12 @@ class MusicPlayer final : public QObject {
 public:
   static auto getInstance() -> MusicPlayer &;
 
-  auto initialize(int musicChannels = 4) -> bool;
+  auto initialize(int musicChannels = AudioConstants::DEFAULT_MUSIC_CHANNELS) -> bool;
   void shutdown();
 
   void registerTrack(const std::string &trackId, const std::string &filePath);
 
-  void play(const std::string &trackId, float volume = 1.0F, bool loop = true);
+  void play(const std::string &trackId, float volume = AudioConstants::DEFAULT_VOLUME, bool loop = true);
   void stop();
   void pause();
   void resume();
@@ -28,13 +29,13 @@ public:
 
   auto play(const std::string &trackId, float volume, bool loop, int channel,
             int fadeMs) -> int;
-  void stop(int channel, int fadeMs = 150);
+  void stop(int channel, int fadeMs = AudioConstants::DEFAULT_FADE_OUT_MS);
   void pause(int channel);
   void resume(int channel);
-  void setVolume(int channel, float volume, int fadeMs = 0);
+  void setVolume(int channel, float volume, int fadeMs = AudioConstants::NO_FADE_MS);
 
-  void stopAll(int fadeMs = 150);
-  void setMasterVolume(float volume, int fadeMs = 0);
+  void stopAll(int fadeMs = AudioConstants::DEFAULT_FADE_OUT_MS);
+  void setMasterVolume(float volume, int fadeMs = AudioConstants::NO_FADE_MS);
 
   auto isPlaying() const -> bool;
   auto isPlaying(int channel) const -> bool;

game/audio/Sound.cpp

@@ -10,31 +10,31 @@
 #include <qstringview.h>
 #include <string>
 
-Sound::Sound(const std::string &filePath, MiniaudioBackend *backend)
-    : QObject(nullptr), m_filepath(filePath), m_backend(backend),
-      m_loaded(false), m_volume(1.0F) {
+Sound::Sound(const std::string &file_path, MiniaudioBackend *backend)
+    : QObject(nullptr), m_file_path(file_path), m_backend(backend),
+      m_loaded(false), m_volume(Sound::DEFAULT_VOLUME) {
 
   QByteArray const hash = QCryptographicHash::hash(
-      QByteArray::fromStdString(filePath), QCryptographicHash::Md5);
-  m_trackId = "sound_" + QString(hash.toHex());
+      QByteArray::fromStdString(file_path), QCryptographicHash::Md5);
+  m_track_id = "sound_" + QString(hash.toHex());
 
-  QFileInfo const fi(QString::fromStdString(m_filepath));
-  if (!fi.exists()) {
-    qWarning() << "Sound: File does not exist:" << fi.absoluteFilePath();
+  QFileInfo const file_info(QString::fromStdString(m_file_path));
+  if (!file_info.exists()) {
+    qWarning() << "Sound: File does not exist:" << file_info.absoluteFilePath();
     return;
   }
 
   if (m_backend != nullptr) {
-    m_loaded = m_backend->predecode(m_trackId, fi.absoluteFilePath());
+    m_loaded = m_backend->predecode(m_track_id, file_info.absoluteFilePath());
     if (m_loaded) {
-      qDebug() << "Sound: Loaded" << fi.absoluteFilePath();
+      qDebug() << "Sound: Loaded" << file_info.absoluteFilePath();
     }
   }
 }
 
 Sound::~Sound() = default;
 
-void Sound::setBackend(MiniaudioBackend *backend) {
+void Sound::set_backend(MiniaudioBackend *backend) {
   if (m_backend == backend) {
     return;
   }
@@ -42,14 +42,14 @@ void Sound::setBackend(MiniaudioBackend *backend) {
   m_backend = backend;
 
   if ((m_backend != nullptr) && !m_loaded) {
-    QFileInfo const fi(QString::fromStdString(m_filepath));
-    if (fi.exists()) {
-      m_loaded = m_backend->predecode(m_trackId, fi.absoluteFilePath());
+    QFileInfo const file_info(QString::fromStdString(m_file_path));
+    if (file_info.exists()) {
+      m_loaded = m_backend->predecode(m_track_id, file_info.absoluteFilePath());
     }
   }
 }
 
-auto Sound::isLoaded() const -> bool { return m_loaded.load(); }
+auto Sound::is_loaded() const -> bool { return m_loaded.load(); }
 
 void Sound::play(float volume, bool loop) {
   if ((m_backend == nullptr) || !m_loaded) {
@@ -58,12 +58,12 @@ void Sound::play(float volume, bool loop) {
   }
 
   m_volume = volume;
-  m_backend->playSound(m_trackId, volume, loop);
+  m_backend->play_sound(m_track_id, volume, loop);
 
-  qDebug() << "Sound: Playing" << QString::fromStdString(m_filepath)
+  qDebug() << "Sound: Playing" << QString::fromStdString(m_file_path)
            << "volume:" << volume << "loop:" << loop;
 }
 
 void Sound::stop() {}
 
-void Sound::setVolume(float volume) { m_volume = volume; }
+void Sound::set_volume(float volume) { m_volume = volume; }

game/audio/Sound.h

@@ -10,20 +10,22 @@ class MiniaudioBackend;
 class Sound : public QObject {
   Q_OBJECT
 public:
-  explicit Sound(const std::string &filePath,
+  static constexpr float DEFAULT_VOLUME = 1.0F;
+
+  explicit Sound(const std::string &file_path,
                  MiniaudioBackend *backend = nullptr);
   ~Sound() override;
 
-  [[nodiscard]] auto isLoaded() const -> bool;
-  void play(float volume = 1.0F, bool loop = false);
+  [[nodiscard]] auto is_loaded() const -> bool;
+  void play(float volume = DEFAULT_VOLUME, bool loop = false);
   void stop();
-  void setVolume(float volume);
+  void set_volume(float volume);
 
-  void setBackend(MiniaudioBackend *backend);
+  void set_backend(MiniaudioBackend *backend);
 
 private:
-  std::string m_filepath;
-  QString m_trackId;
+  std::string m_file_path;
+  QString m_track_id;
   MiniaudioBackend *m_backend;
   std::atomic<bool> m_loaded;
   std::atomic<float> m_volume;