refactor: JA_* a namespace Ja:: (estil aee_arcade)

source/core/audio/audio.cpp

@@ -43,15 +43,15 @@ Audio::Audio() { initSDLAudio(); }
 
 // Destructor
 Audio::~Audio() {
-    JA_Quit();
+    Ja::quit();
 }
 
 // Método principal
 void Audio::update() {
-    JA_Update();
+    Ja::update();
 
     // Sincronizar estado: detectar cuando la música se para (ej. fade-out completado)
-    if (instance != nullptr && instance->music_.state == MusicState::PLAYING && JA_GetMusicState() != JA_MUSIC_PLAYING) {
+    if (instance != nullptr && instance->music_.state == MusicState::PLAYING && Ja::getMusicState() != Ja::MusicState::PLAYING) {
         instance->music_.state = MusicState::STOPPED;
     }
 }
@@ -71,12 +71,12 @@ void Audio::playMusic(const std::string& name, const int loop, const int crossfa
     if (resource == nullptr) { return; }
 
     if (crossfade_ms > 0 && music_.state == MusicState::PLAYING) {
-        JA_CrossfadeMusic(resource, crossfade_ms, loop);
+        Ja::crossfadeMusic(resource, crossfade_ms, loop);
     } else {
         if (music_.state == MusicState::PLAYING) {
-            JA_StopMusic();
+            Ja::stopMusic();
         }
-        JA_PlayMusic(resource, loop);
+        Ja::playMusic(resource, loop);
     }
 
     music_.name = name;
@@ -85,16 +85,16 @@ void Audio::playMusic(const std::string& name, const int loop, const int crossfa
 }
 
 // Reproduce la música por puntero (con crossfade opcional)
-void Audio::playMusic(JA_Music_t* music, const int loop, const int crossfade_ms) {
+void Audio::playMusic(Ja::Music* music, const int loop, const int crossfade_ms) {
     if (!music_enabled_ || music == nullptr) { return; }
 
     if (crossfade_ms > 0 && music_.state == MusicState::PLAYING) {
-        JA_CrossfadeMusic(music, crossfade_ms, loop);
+        Ja::crossfadeMusic(music, crossfade_ms, loop);
     } else {
         if (music_.state == MusicState::PLAYING) {
-            JA_StopMusic();
+            Ja::stopMusic();
         }
-        JA_PlayMusic(music, loop);
+        Ja::playMusic(music, loop);
     }
 
     music_.name.clear();  // nom desconegut quan es passa per punter
@@ -105,7 +105,7 @@ void Audio::playMusic(JA_Music_t* music, const int loop, const int crossfade_ms)
 // Pausa la música
 void Audio::pauseMusic() {
     if (music_enabled_ && music_.state == MusicState::PLAYING) {
-        JA_PauseMusic();
+        Ja::pauseMusic();
         music_.state = MusicState::PAUSED;
     }
 }
@@ -113,7 +113,7 @@ void Audio::pauseMusic() {
 // Continua la música pausada
 void Audio::resumeMusic() {
     if (music_enabled_ && music_.state == MusicState::PAUSED) {
-        JA_ResumeMusic();
+        Ja::resumeMusic();
         music_.state = MusicState::PLAYING;
     }
 }
@@ -121,7 +121,7 @@ void Audio::resumeMusic() {
 // Detiene la música
 void Audio::stopMusic() {
     if (music_enabled_) {
-        JA_StopMusic();
+        Ja::stopMusic();
         music_.state = MusicState::STOPPED;
     }
 }
@@ -129,42 +129,42 @@ void Audio::stopMusic() {
 // Reproduce un sonido por nombre
 void Audio::playSound(const std::string& name, Group group) const {
     if (sound_enabled_) {
-        JA_PlaySound(AudioResource::getSound(name), 0, static_cast<int>(group));
+        Ja::playSound(AudioResource::getSound(name), 0, static_cast<int>(group));
     }
 }
 
 // Reproduce un sonido por puntero directo
-void Audio::playSound(JA_Sound_t* sound, Group group) const {
+void Audio::playSound(Ja::Sound* sound, Group group) const {
     if (sound_enabled_ && sound != nullptr) {
-        JA_PlaySound(sound, 0, static_cast<int>(group));
+        Ja::playSound(sound, 0, static_cast<int>(group));
     }
 }
 
 // Detiene todos los sonidos
 void Audio::stopAllSounds() const {
     if (sound_enabled_) {
-        JA_StopChannel(-1);
+        Ja::stopChannel(-1);
     }
 }
 
 // Realiza un fundido de salida de la música
 void Audio::fadeOutMusic(int milliseconds) const {
     if (music_enabled_ && getRealMusicState() == MusicState::PLAYING) {
-        JA_FadeOutMusic(milliseconds);
+        Ja::fadeOutMusic(milliseconds);
     }
 }
 
 // Consulta directamente el estado real de la música en jailaudio
 auto Audio::getRealMusicState() -> MusicState {
-    JA_Music_state ja_state = JA_GetMusicState();
+    Ja::MusicState ja_state = Ja::getMusicState();
     switch (ja_state) {
-        case JA_MUSIC_PLAYING:
+        case Ja::MusicState::PLAYING:
             return MusicState::PLAYING;
-        case JA_MUSIC_PAUSED:
+        case Ja::MusicState::PAUSED:
             return MusicState::PAUSED;
-        case JA_MUSIC_STOPPED:
+        case Ja::MusicState::STOPPED:
-        case JA_MUSIC_INVALID:
+        case Ja::MusicState::INVALID:
-        case JA_MUSIC_DISABLED:
+        case Ja::MusicState::DISABLED:
         default:
             return MusicState::STOPPED;
     }
@@ -175,7 +175,7 @@ void Audio::setSoundVolume(float sound_volume, Group group) const {
     if (sound_enabled_) {
         sound_volume = std::clamp(sound_volume, MIN_VOLUME, MAX_VOLUME);
         const float CONVERTED_VOLUME = sound_volume * Options::audio.volume;
-        JA_SetSoundVolume(CONVERTED_VOLUME, static_cast<int>(group));
+        Ja::setSoundVolume(CONVERTED_VOLUME, static_cast<int>(group));
     }
 }
 
@@ -184,7 +184,7 @@ void Audio::setMusicVolume(float music_volume) const {
     if (music_enabled_) {
         music_volume = std::clamp(music_volume, MIN_VOLUME, MAX_VOLUME);
         const float CONVERTED_VOLUME = music_volume * Options::audio.volume;
-        JA_SetMusicVolume(CONVERTED_VOLUME);
+        Ja::setMusicVolume(CONVERTED_VOLUME);
     }
 }
 
@@ -206,7 +206,7 @@ void Audio::initSDLAudio() {
     if (!SDL_Init(SDL_INIT_AUDIO)) {
         std::cout << "SDL_AUDIO could not initialize! SDL Error: " << SDL_GetError() << '\n';
     } else {
-        JA_Init(FREQUENCY, SDL_AUDIO_S16LE, 2);
+        Ja::init(FREQUENCY, SDL_AUDIO_S16LE, 2);
         enable(Options::audio.enabled);
     }
 }

source/core/audio/audio.hpp

@@ -4,6 +4,11 @@
 #include <string>   // Para string
 #include <utility>  // Para move
 
+namespace Ja {
+    struct Music;
+    struct Sound;
+}  // namespace Ja
+
 // --- Clase Audio: gestor de audio (singleton) ---
 // Implementació canònica, byte-idèntica entre projectes.
 // Els volums es manegen internament com a float 0.0–1.0; la capa de
@@ -41,17 +46,17 @@ class Audio {
     static void update();  // Actualización del sistema de audio
 
     // --- Control de música ---
-    void playMusic(const std::string& name, int loop = -1, int crossfade_ms = 0);   // Reproducir música por nombre (con crossfade opcional)
+    void playMusic(const std::string& name, int loop = -1, int crossfade_ms = 0);  // Reproducir música por nombre (con crossfade opcional)
-    void playMusic(struct JA_Music_t* music, int loop = -1, int crossfade_ms = 0);  // Reproducir música por puntero (con crossfade opcional)
+    void playMusic(Ja::Music* music, int loop = -1, int crossfade_ms = 0);         // Reproducir música por puntero (con crossfade opcional)
-    void pauseMusic();                                                              // Pausar reproducción de música
+    void pauseMusic();                                                             // Pausar reproducción de música
-    void resumeMusic();                                                             // Continua la música pausada
+    void resumeMusic();                                                            // Continua la música pausada
-    void stopMusic();                                                               // Detener completamente la música
+    void stopMusic();                                                              // Detener completamente la música
-    void fadeOutMusic(int milliseconds) const;                                      // Fundido de salida de la música
+    void fadeOutMusic(int milliseconds) const;                                     // Fundido de salida de la música
 
     // --- Control de sonidos ---
-    void playSound(const std::string& name, Group group = Group::GAME) const;   // Reproducir sonido puntual por nombre
+    void playSound(const std::string& name, Group group = Group::GAME) const;  // Reproducir sonido puntual por nombre
-    void playSound(struct JA_Sound_t* sound, Group group = Group::GAME) const;  // Reproducir sonido puntual por puntero
+    void playSound(Ja::Sound* sound, Group group = Group::GAME) const;         // Reproducir sonido puntual por puntero
-    void stopAllSounds() const;                                                 // Detener todos los sonidos
+    void stopAllSounds() const;                                                // Detener todos los sonidos
 
     // --- Control de volumen (API interna: float 0.0..1.0) ---
     void setSoundVolume(float volume, Group group = Group::ALL) const;  // Ajustar volumen de efectos

source/core/audio/audio_adapter.cpp

@@ -3,11 +3,11 @@
 #include "core/resources/resource_cache.hpp"
 
 namespace AudioResource {
-    auto getMusic(const std::string& name) -> JA_Music_t* {
+    auto getMusic(const std::string& name) -> Ja::Music* {
         return Resource::Cache::get()->getMusic(name);
     }
 
-    auto getSound(const std::string& name) -> JA_Sound_t* {
+    auto getSound(const std::string& name) -> Ja::Sound* {
         return Resource::Cache::get()->getSound(name);
     }
 }  // namespace AudioResource

source/core/audio/audio_adapter.hpp

@@ -1,17 +1,19 @@
 #pragma once
 
 // --- Audio Resource Adapter ---
-// Aquest fitxer exposa una interfície comuna a Audio per obtenir JA_Music_t* /
+// Aquest fitxer exposa una interfície comuna a Audio per obtenir Ja::Music* /
-// JA_Sound_t* per nom. Cada projecte la implementa en audio_adapter.cpp
+// Ja::Sound* per nom. Cada projecte la implementa en audio_adapter.cpp
 // delegant al seu singleton de recursos (Resource::get(), Resource::Cache::get(),
 // etc.). Això permet que audio.hpp/audio.cpp siguin idèntics entre projectes.
 
 #include <string>  // Para string
 
-struct JA_Music_t;
+namespace Ja {
-struct JA_Sound_t;
+    struct Music;
+    struct Sound;
+}  // namespace Ja
 
 namespace AudioResource {
-    auto getMusic(const std::string& name) -> JA_Music_t*;
+    auto getMusic(const std::string& name) -> Ja::Music*;
-    auto getSound(const std::string& name) -> JA_Sound_t*;
+    auto getSound(const std::string& name) -> Ja::Sound*;
 }  // namespace AudioResource

source/core/resources/resource_cache.cpp

@@ -9,7 +9,7 @@
 #include <stdexcept>  // Para runtime_error
 #include <utility>
 
-#include "core/audio/jail_audio.hpp"           // Para JA_DeleteMusic, JA_DeleteSound, JA_Loa...
+#include "core/audio/jail_audio.hpp"           // Para Ja::deleteMusic, Ja::deleteSound, JA_Loa...
 #include "core/rendering/screen.hpp"           // Para Screen
 #include "core/rendering/text.hpp"             // Para Text, loadTextFile
 #include "core/resources/resource_helper.hpp"  // Para Helper
@@ -21,8 +21,10 @@
 #include "utils/defines.hpp"                   // Para WINDOW_CAPTION
 #include "utils/utils.hpp"                     // Para getFileName, printWithDots, PaletteColor
 #include "version.h"                           // Para Version::GIT_HASH
-struct JA_Music_t;                             // lines 17-17
+namespace Ja {
-struct JA_Sound_t;                             // lines 18-18
+    struct Music;
+    struct Sound;
+}  // namespace Ja
 
 namespace Resource {
 
@@ -234,7 +236,7 @@ namespace Resource {
     }
 
     // Obtiene el sonido a partir de un nombre
-    auto Cache::getSound(const std::string& name) -> JA_Sound_t* {  // NOLINT(readability-convert-member-functions-to-static)
+    auto Cache::getSound(const std::string& name) -> Ja::Sound* {  // NOLINT(readability-convert-member-functions-to-static)
         auto it = std::ranges::find_if(sounds_, [&name](const auto& s) -> bool { return s.name == name; });
 
         if (it != sounds_.end()) {
@@ -246,7 +248,7 @@ namespace Resource {
     }
 
     // Obtiene la música a partir de un nombre
-    auto Cache::getMusic(const std::string& name) -> JA_Music_t* {  // NOLINT(readability-convert-member-functions-to-static)
+    auto Cache::getMusic(const std::string& name) -> Ja::Music* {  // NOLINT(readability-convert-member-functions-to-static)
         auto it = std::ranges::find_if(musics_, [&name](const auto& m) -> bool { return m.name == name; });
 
         if (it != musics_.end()) {
@@ -398,14 +400,14 @@ namespace Resource {
         try {
             auto name = getFileName(l);
             setCurrentLoading(name);
-            JA_Sound_t* sound = nullptr;
+            Ja::Sound* sound = nullptr;
 
             auto audio_data = Helper::loadFile(l);
             if (!audio_data.empty()) {
-                sound = JA_LoadSound(audio_data.data(), static_cast<Uint32>(audio_data.size()));
+                sound = Ja::loadSound(audio_data.data(), static_cast<Uint32>(audio_data.size()));
             }
             if (sound == nullptr) {
-                sound = JA_LoadSound(l.c_str());
+                sound = Ja::loadSound(l.c_str());
             }
             if (sound == nullptr) {
                 throw std::runtime_error("Failed to decode audio file");
@@ -426,14 +428,14 @@ namespace Resource {
         try {
             auto name = getFileName(l);
             setCurrentLoading(name);
-            JA_Music_t* music = nullptr;
+            Ja::Music* music = nullptr;
 
             auto audio_data = Helper::loadFile(l);
             if (!audio_data.empty()) {
-                music = JA_LoadMusic(audio_data.data(), static_cast<Uint32>(audio_data.size()));
+                music = Ja::loadMusic(audio_data.data(), static_cast<Uint32>(audio_data.size()));
             }
             if (music == nullptr) {
-                music = JA_LoadMusic(l.c_str());
+                music = Ja::loadMusic(l.c_str());
             }
             if (music == nullptr) {
                 throw std::runtime_error("Failed to decode music file");
@@ -608,10 +610,10 @@ namespace Resource {
 
     // Vacía el vector de sonidos
     void Cache::clearSounds() {
-        // Itera sobre el vector y libera los recursos asociados a cada JA_Sound_t
+        // Itera sobre el vector y libera los recursos asociados a cada Ja::Sound
         for (auto& sound : sounds_) {
             if (sound.sound != nullptr) {
-                JA_DeleteSound(sound.sound);
+                Ja::deleteSound(sound.sound);
                 sound.sound = nullptr;
             }
         }
@@ -620,10 +622,10 @@ namespace Resource {
 
     // Vacía el vector de musicas
     void Cache::clearMusics() {
-        // Itera sobre el vector y libera los recursos asociados a cada JA_Music_t
+        // Itera sobre el vector y libera los recursos asociados a cada Ja::Music
         for (auto& music : musics_) {
             if (music.music != nullptr) {
-                JA_DeleteMusic(music.music);
+                Ja::deleteMusic(music.music);
                 music.music = nullptr;
             }
         }

source/core/resources/resource_cache.hpp

@@ -16,8 +16,8 @@ namespace Resource {
         static void destroy();        // Destrucción singleton
         static auto get() -> Cache*;  // Acceso al singleton
 
-        auto getSound(const std::string& name) -> JA_Sound_t*;  // Getters de recursos
+        auto getSound(const std::string& name) -> Ja::Sound*;  // Getters de recursos
-        auto getMusic(const std::string& name) -> JA_Music_t*;
+        auto getMusic(const std::string& name) -> Ja::Music*;
         auto getSurface(const std::string& name) -> std::shared_ptr<Surface>;
         auto getPalette(const std::string& name) -> Palette;
         auto getTextFile(const std::string& name) -> std::shared_ptr<Text::File>;

source/core/resources/resource_types.hpp

@@ -10,19 +10,21 @@
 #include "game/gameplay/room.hpp"      // Para Room::Data
 
 // Forward declarations
-struct JA_Music_t;
+namespace Ja {
-struct JA_Sound_t;
+    struct Music;
+    struct Sound;
+}  // namespace Ja
 
 // Estructura para almacenar ficheros de sonido y su nombre
 struct SoundResource {
-    std::string name;            // Nombre del sonido
+    std::string name;           // Nombre del sonido
-    JA_Sound_t* sound{nullptr};  // Objeto con el sonido
+    Ja::Sound* sound{nullptr};  // Objeto con el sonido
 };
 
 // Estructura para almacenar ficheros musicales y su nombre
 struct MusicResource {
-    std::string name;            // Nombre de la musica
+    std::string name;           // Nombre de la musica
-    JA_Music_t* music{nullptr};  // Objeto con la música
+    Ja::Music* music{nullptr};  // Objeto con la música
 };
 
 // Estructura para almacenar objetos Surface y su nombre

source/game/entities/player.hpp

@@ -14,7 +14,9 @@
 #include "game/options.hpp"   // Para Cheat, Options, options
 #include "utils/defines.hpp"  // Para BORDER_TOP, BLOCK
 #include "utils/utils.hpp"    // Para Color
-struct JA_Sound_t;            // lines 13-13
+namespace Ja {
+    struct Sound;
+}
 
 class Player {
    public:
@@ -156,12 +158,12 @@ class Player {
     int last_grounded_position_ = 0;           // Ultima posición en Y en la que se estaba en contacto con el suelo (hace doble función: tracking de caída + altura inicial del salto)
 
     // --- Variables de renderizado y sonido ---
-    Uint8 color_ = 0;                              // Color del jugador
+    Uint8 color_ = 0;                             // Color del jugador
-    std::array<JA_Sound_t*, 24> jumping_sound_{};  // Array con todos los sonidos del salto
+    std::array<Ja::Sound*, 24> jumping_sound_{};  // Array con todos los sonidos del salto
-    std::array<JA_Sound_t*, 14> falling_sound_{};  // Array con todos los sonidos de la caída
+    std::array<Ja::Sound*, 14> falling_sound_{};  // Array con todos los sonidos de la caída
-    JumpSoundController jump_sound_ctrl_;          // Controlador de sonidos de salto
+    JumpSoundController jump_sound_ctrl_;         // Controlador de sonidos de salto
-    FallSoundController fall_sound_ctrl_;          // Controlador de sonidos de caída
+    FallSoundController fall_sound_ctrl_;         // Controlador de sonidos de caída
-    int fall_start_position_ = 0;                  // Posición Y al iniciar la caída
+    int fall_start_position_ = 0;                 // Posición Y al iniciar la caída
 
     void handleConveyorBelts();
     void handleShouldFall();