chore: bump version a 0.8.0

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.16)
-project(orni VERSION 0.7.2 LANGUAGES CXX)
+project(orni VERSION 0.8.0 LANGUAGES CXX)
 
 # Info del projecte (font de veritat per a project.h)
 set(PROJECT_LONG_NAME "Orni Attack")
@@ -135,9 +135,8 @@ add_dependencies(${PROJECT_NAME} resource_pack)
 
 # --- COMPILACIÓ DE SHADERS GLSL → SPIR-V (headers C++ embedits) ---
 # Compila els shaders .glsl a SPIR-V i els converteix en headers C++ embedits
-# (source/core/rendering/gpu/spv/*.h). Aquests headers es commiteen al repo:
+# (source/core/rendering/gpu/spv/*.h). Aquests headers es commiteen al repo,
-# en macOS no cal glslc (els headers ja existeixen). En Linux/Windows glslc
+# així que glslc només és necessari quan canvien els .glsl o falten headers.
-# és obligatori per regenerar els headers en cada canvi del GLSL.
 #
 # Per a macOS hi ha a més els headers MSL escrits a mà a source/core/rendering/gpu/msl/.
 set(SHADERS_DIR  "${CMAKE_SOURCE_DIR}/shaders")
@@ -156,6 +155,13 @@ set(ALL_SHADER_SOURCES
     "${SHADERS_DIR}/postfx.frag.glsl"
     "${SHADERS_DIR}/bloom.frag.glsl"
 )
+set(ALL_SHADER_HEADERS_PRESENT TRUE)
+foreach(_spv_header IN LISTS ALL_SHADER_HEADERS)
+    if(NOT EXISTS "${_spv_header}")
+        set(ALL_SHADER_HEADERS_PRESENT FALSE)
+        break()
+    endif()
+endforeach()
 find_program(GLSLC_EXE NAMES glslc HINTS ${Vulkan_GLSLC_EXECUTABLE})
 if(GLSLC_EXE)
     add_custom_command(
@@ -172,10 +178,10 @@ if(GLSLC_EXE)
     add_custom_target(shaders DEPENDS ${ALL_SHADER_HEADERS})
     add_dependencies(${PROJECT_NAME} shaders)
     message(STATUS "Shaders: glslc trobat (${GLSLC_EXE}); headers SPV es regeneraran si canvia el GLSL")
-elseif(APPLE)
+elseif(ALL_SHADER_HEADERS_PRESENT)
-    message(STATUS "Shaders: glslc no trobat en macOS — s'usaran els headers SPV ja commiteats")
+    message(STATUS "Shaders: glslc no trobat — s'usaran els headers SPV ja commiteats al repo")
 else()
-    message(FATAL_ERROR "glslc no trobat: instal·la 'shaderc' o 'vulkan-sdk' per compilar shaders SPIR-V (obligatori a Linux/Windows)")
+    message(FATAL_ERROR "glslc no trobat i falten headers SPV: instal·la 'shaderc' o 'vulkan-sdk' per generar-los")
 endif()
 
 # --- STATIC ANALYSIS / FORMAT TARGETS ---

data/locale/ca.yaml

@@ -0,0 +1,112 @@
+# Orni Attack - locale: Catala (valencia)
+# Interficie traduida; pool in-game identic a en.yaml (es queda en angles).
+# Tots els textos en ASCII: VectorText no suporta caracters accentuats.
+
+notification:
+  press_again_exit: "PREMEU ESC UN ALTRE COP PER EIXIR"
+  zoom: "ZOOM: {z}X"
+  fullscreen_on: "PANTALLA COMPLETA"
+  fullscreen_off: "MODE FINESTRA"
+  vsync_on: "VSYNC ACTIU"
+  vsync_off: "VSYNC INACTIU"
+  antialias_on: "AA ACTIU"
+  antialias_off: "AA INACTIU"
+  postfx_on: "POSTPROCESSAT ACTIU"
+  postfx_off: "POSTPROCESSAT INACTIU"
+  locale_switched: "IDIOMA: {lang}"
+  gamepad_connected: "{name} CONNECTAT"
+  gamepad_disconnected: "{name} DESCONNECTAT"
+
+language:
+  ca: "CATALA"
+  en: "ANGLES"
+
+hud:
+  level: "NIVELL "
+
+title:
+  press_start: "PREMEU START PER JUGAR"
+
+game_screen:
+  game_over: "FI DEL JOC"
+  continue: "CONTINUAR"
+  continues_left: "CONTINUACIONS: {n}"
+
+stage:
+  start:
+    - "ORNI ALERT!"
+    - "INCOMING ORNIS!"
+    - "ROLLING THREAT!"
+    - "ENEMY WAVE!"
+    - "WAVE OF ORNIS DETECTED!"
+    - "NEXT SWARM APPROACHING!"
+    - "BRACE FOR THE NEXT WAVE!"
+    - "ANOTHER ATTACK INCOMING!"
+    - "SENSORS DETECT HOSTILE ORNIS..."
+    - "UNIDENTIFIED ROLLING OBJECTS INBOUND!"
+    - "ENEMY FORCES MOBILIZING!"
+    - "PREPARE FOR IMPACT!"
+  completed: "GOOD JOB COMMANDER!"
+
+service_menu:
+  title: "MENU DE SERVEI"
+  video: "VIDEO"
+  audio: "AUDIO"
+  options: "OPCIONS"
+  system: "SISTEMA"
+  controls: "CONTROLS"
+  back: "ENRERE"
+  exit: "EIXIR DEL JOC"
+  # Items del submenu VIDEO
+  video_zoom: "ZOOM"
+  video_fullscreen: "PANTALLA COMPLETA"
+  video_vsync: "VSYNC"
+  video_aa: "ANTIALIAS"
+  video_postfx: "POSTPROCESSAT"
+  video_resolution: "RESOLUCIO"
+  # Items del submenu OPCIONS
+  options_language: "IDIOMA"
+  options_show_info: "MOSTRAR INFO"
+  # Items del submenu AUDIO
+  audio_master: "AUDIO"
+  audio_master_volume: "VOLUM GENERAL"
+  audio_music: "MUSICA"
+  audio_music_volume: "VOLUM MUSICA"
+  audio_sound: "EFECTES"
+  audio_sound_volume: "VOLUM EFECTES"
+  # Items del submenu SISTEMA
+  system_restart: "REINICIAR"
+  # Pagines de confirmacio (estructura: titol + NO/SI)
+  confirm_restart: "ESTAS SEGUR DE REINICIAR?"
+  confirm_exit: "ESTAS SEGUR DE EIXIR?"
+  confirm_no: "NO"
+  confirm_yes: "SI"
+  # Valors comuns
+  value_on: "ACTIU"
+  value_off: "INACTIU"
+  # Items del submenu CONTROLS
+  controls_pad_p1: "MANDO JUGADOR 1"
+  controls_pad_p2: "MANDO JUGADOR 2"
+  controls_no_pad: "SENSE MANDO"
+  controls_define_keyboard_p1: "REDEFINIR TECLES P1"
+  controls_define_keyboard_p2: "REDEFINIR TECLES P2"
+  controls_define_gamepad_p1: "REDEFINIR BOTONS P1"
+  controls_define_gamepad_p2: "REDEFINIR BOTONS P2"
+
+# Overlay modal de redefinicio (DefineInputs)
+define:
+  title_keyboard_p1: "REDEFINIR TECLES P1"
+  title_keyboard_p2: "REDEFINIR TECLES P2"
+  title_gamepad_p1: "REDEFINIR BOTONS P1"
+  title_gamepad_p2: "REDEFINIR BOTONS P2"
+  press_key: "PREMEU UNA TECLA"
+  press_button: "PREMEU UN BOTO"
+  complete: "CONFIGURACIO COMPLETA"
+  no_gamepad: "CAP MANDO ASSIGNAT AL JUGADOR"
+  action:
+    left: "ESQUERRA"
+    right: "DRETA"
+    fire: "DISPARAR"
+    accelerate: "ACCELERAR"
+    start: "START"
+    menu: "MENU"

data/locale/en.yaml

@@ -0,0 +1,111 @@
+# Orni Attack - locale: English
+# In-game pool kept English in both locales per design.
+
+notification:
+  press_again_exit: "PRESS ESC AGAIN TO EXIT"
+  zoom: "ZOOM: {z}X"
+  fullscreen_on: "FULLSCREEN"
+  fullscreen_off: "WINDOWED"
+  vsync_on: "VSYNC ON"
+  vsync_off: "VSYNC OFF"
+  antialias_on: "AA ON"
+  antialias_off: "AA OFF"
+  postfx_on: "POSTPROCESS ON"
+  postfx_off: "POSTPROCESS OFF"
+  locale_switched: "LANGUAGE: {lang}"
+  gamepad_connected: "{name} CONNECTED"
+  gamepad_disconnected: "{name} DISCONNECTED"
+
+language:
+  ca: "CATALAN"
+  en: "ENGLISH"
+
+hud:
+  level: "LEVEL "
+
+title:
+  press_start: "PRESS START TO PLAY"
+
+game_screen:
+  game_over: "GAME OVER"
+  continue: "CONTINUE"
+  continues_left: "CONTINUES LEFT: {n}"
+
+stage:
+  start:
+    - "ORNI ALERT!"
+    - "INCOMING ORNIS!"
+    - "ROLLING THREAT!"
+    - "ENEMY WAVE!"
+    - "WAVE OF ORNIS DETECTED!"
+    - "NEXT SWARM APPROACHING!"
+    - "BRACE FOR THE NEXT WAVE!"
+    - "ANOTHER ATTACK INCOMING!"
+    - "SENSORS DETECT HOSTILE ORNIS..."
+    - "UNIDENTIFIED ROLLING OBJECTS INBOUND!"
+    - "ENEMY FORCES MOBILIZING!"
+    - "PREPARE FOR IMPACT!"
+  completed: "GOOD JOB COMMANDER!"
+
+service_menu:
+  title: "SERVICE MENU"
+  video: "VIDEO"
+  audio: "AUDIO"
+  options: "OPTIONS"
+  system: "SYSTEM"
+  controls: "CONTROLS"
+  back: "BACK"
+  exit: "EXIT GAME"
+  # Items of VIDEO submenu
+  video_zoom: "ZOOM"
+  video_fullscreen: "FULLSCREEN"
+  video_vsync: "VSYNC"
+  video_aa: "ANTIALIAS"
+  video_postfx: "POSTPROCESS"
+  video_resolution: "RESOLUTION"
+  # Items of OPTIONS submenu
+  options_language: "LANGUAGE"
+  options_show_info: "SHOW INFO"
+  # Items of AUDIO submenu
+  audio_master: "AUDIO"
+  audio_master_volume: "MASTER VOLUME"
+  audio_music: "MUSIC"
+  audio_music_volume: "MUSIC VOLUME"
+  audio_sound: "SOUNDS"
+  audio_sound_volume: "SOUND VOLUME"
+  # Items of SYSTEM submenu
+  system_restart: "RESTART"
+  # Confirmation pages (structure: title + NO/YES)
+  confirm_restart: "REALLY RESTART?"
+  confirm_exit: "REALLY EXIT?"
+  confirm_no: "NO"
+  confirm_yes: "YES"
+  # Common values
+  value_on: "ON"
+  value_off: "OFF"
+  # Items of CONTROLS submenu
+  controls_pad_p1: "PLAYER 1 GAMEPAD"
+  controls_pad_p2: "PLAYER 2 GAMEPAD"
+  controls_no_pad: "NO GAMEPAD"
+  controls_define_keyboard_p1: "REDEFINE KEYS P1"
+  controls_define_keyboard_p2: "REDEFINE KEYS P2"
+  controls_define_gamepad_p1: "REDEFINE BUTTONS P1"
+  controls_define_gamepad_p2: "REDEFINE BUTTONS P2"
+
+# Modal overlay for input redefinition (DefineInputs)
+define:
+  title_keyboard_p1: "REDEFINE KEYS P1"
+  title_keyboard_p2: "REDEFINE KEYS P2"
+  title_gamepad_p1: "REDEFINE BUTTONS P1"
+  title_gamepad_p2: "REDEFINE BUTTONS P2"
+  press_key: "PRESS A KEY"
+  press_button: "PRESS A BUTTON"
+  complete: "CONFIGURATION COMPLETE"
+  no_gamepad: "NO GAMEPAD ASSIGNED TO PLAYER"
+  action:
+    left: "LEFT"
+    right: "RIGHT"
+    fire: "FIRE"
+    accelerate: "ACCELERATE"
+    start: "START"
+    menu: "MENU"

data/shapes/enemy_pentagon.shp

@@ -1,7 +1,11 @@
-# enemy_pentagon.shp - ORNI enemic (pentàgon regular, radi=20)
+# enemy_pentagon.shp - ORNI enemic (pentàgon doble concentric, radi exterior=20)
 
 name: enemy_pentagon
 scale: 1.0
 center: 0, 0
 
+# Pentàgon exterior (vèrtex apuntant amunt, radi 20)
 polyline: 0,-20  19.02,-6.18  11.76,16.18  -11.76,16.18  -19.02,-6.18  0,-20
+
+# Pentàgon interior (radi 10, rotat 36° → vèrtex apuntant a les arestes exteriors)
+polyline: 5.88,-8.09  9.51,3.09  0,10  -9.51,3.09  -5.88,-8.09  5.88,-8.09

data/shapes/enemy_square.shp

@@ -1,7 +1,14 @@
-# enemy_square.shp - ORNI enemic (quadrat regular, radi=20)
+# enemy_square.shp - ORNI enemic (rombe, radi=20) + ull amb pupil·la al centre
 
 name: enemy_square
 scale: 1.0
 center: 0, 0
 
+# Rombe exterior
 polyline: 0,-20  20,0  0,20  -20,0  0,-20
+
+# Ull (dos arcs units, forma d'almetlla). Amplada 20px, altura 8px.
+polyline: -10,0  -5,-3  0,-4  5,-3  10,0  5,3  0,4  -5,3  -10,0
+
+# Pupil·la (octàgon, radi 2) al centre
+polyline: 0,-2  1.41,-1.41  2,0  1.41,1.41  0,2  -1.41,1.41  -2,0  -1.41,-1.41  0,-2

data/shapes/font/char_lparen.shp

@@ -0,0 +1,9 @@
+# char_lparen.shp - Símbol ( (parèntesi esquerre)
+# Dimensions: 20×40 (blocky display)
+
+name: char_lparen
+scale: 1.0
+center: 10, 20
+
+# Arc cap a l'esquerra aproximat amb 4 trams rectes
+polyline: 14,4  8,12  6,20  8,28  14,36

data/shapes/font/char_rparen.shp

@@ -0,0 +1,9 @@
+# char_rparen.shp - Símbol ) (parèntesi dret)
+# Dimensions: 20×40 (blocky display)
+
+name: char_rparen
+scale: 1.0
+center: 10, 20
+
+# Arc cap a la dreta aproximat amb 4 trams rectes
+polyline: 6,4  12,12  14,20  12,28  6,36

data/shapes/font/char_slash.shp

@@ -0,0 +1,9 @@
+# char_slash.shp - Símbol / (barra)
+# Dimensions: 20×40 (blocky display)
+
+name: char_slash
+scale: 1.0
+center: 10, 20
+
+# Línia diagonal de baix-esquerra a dalt-dreta
+line: 4,36  16,4

data/shapes/ship2_perspective.shp

@@ -1,28 +0,0 @@
-# ship2_perspective.shp - Nave P2 con perspectiva pre-calculada
-# Posición optimizada: "4 del reloj" (Abajo-Derecha)
-# Dirección: Volando hacia el fondo (centro pantalla)
-
-name: ship2_perspective
-scale: 1.0
-center: 0, 0
-
-# TRANSFORMACIÓN APLICADA:
-# 1. Rotación -45° (apuntando al centro desde abajo-dcha)
-# 2. Proyección de perspectiva:
-#    - Punta (p1): Reducida al 60% (simula lejanía)
-#    - Base (p2, p3): Aumentada al 110% (simula cercanía)
-# 3. Flip horizontal (simétrica a ship_starfield.shp)
-#
-# Nuevos Punts (aprox):
-#    p1 (Punta):    (-4, -4)  -> Lejos, pequeña y apuntando arriba-izq
-#    p2 (Ala Izq):  (-3, 11)  -> Cerca, lado interior
-#    p4 (Base Cnt): (3, 5)    -> Centro base
-#    p3 (Ala Dcha): (11, 2)   -> Cerca, lado exterior (más grande)
-
-#polyline: -4,-4  -3,11  3,5  11,2  -4,-4
-polyline: -4,-4  -3,11  11,2  -4,-4
-
-# Circulito central (octàgon r=2.5)
-# Distintiu visual del jugador 2
-# Sin perspectiva (está en el centro de la nave)
-polyline: 0,-2.5  1.77,-1.77  2.5,0  1.77,1.77  0,2.5  -1.77,1.77  -2.5,0  -1.77,-1.77  0,-2.5

data/shapes/ship_perspective.shp

@@ -1,21 +0,0 @@
-# ship_perspective.shp - Nave con perspectiva pre-calculada
-# Posición optimizada: "8 del reloj" (Abajo-Izquierda)
-# Dirección: Volando hacia el fondo (centro pantalla)
-
-name: ship_perspective
-scale: 1.0
-center: 0, 0
-
-# TRANSFORMACIÓN APLICADA:
-# 1. Rotación +45° (apuntando al centro desde abajo-izq)
-# 2. Proyección de perspectiva:
-#    - Punta (p1): Reducida al 60% (simula lejanía)
-#    - Base (p2, p3): Aumentada al 110% (simula cercanía)
-#
-# Nuevos Puntos (aprox):
-#    p1 (Punta):    (4, -4)   -> Lejos, pequeña y apuntando arriba-dcha
-#    p2 (Ala Dcha): (3, 11)   -> Cerca, lado interior
-#    p4 (Base Cnt): (-3, 5)   -> Centro base
-#    p3 (Ala Izq):  (-11, 2)  -> Cerca, lado exterior (más grande)
-
-polyline: 4,-4  3,11  -3,5  -11,2  4,-4

data/shapes/title_flash.shp

@@ -0,0 +1,9 @@
+# title_flash.shp - Sparkle 4-puntes amb costats còncaus (Atari-style)
+# 4 puntes als cardinals (radi 30) i valls còncaus als 45° (corba Bezier
+# quadràtica amb control point ±8). 5 punts per arc subdividint la corba.
+
+name: title_flash
+scale: 1.0
+center: 0, 0
+
+polyline: 0,-30  3.76,-21.76  8.64,-14.64  14.64,-8.64  21.76,-3.76  30,0  21.76,3.76  14.64,8.64  8.64,14.64  3.76,21.76  0,30  -3.76,21.76  -8.64,14.64  -14.64,8.64  -21.76,3.76  -30,0  -21.76,-3.76  -14.64,-8.64  -8.64,-14.64  -3.76,-21.76  0,-30

data/stages/stages.yaml

@@ -7,7 +7,7 @@ metadata:
   description: "Progressive difficulty curve from novice to expert"
 
 stages:
-  # STAGE 1: Tutorial - Only pentagons, slow speed
+  # STAGE 1: Tutorial - Mix de tots els tipus, velocitat lenta
   - stage_id: 1
     total_enemies: 50
     spawn_config:
@@ -15,9 +15,9 @@ stages:
       initial_delay: 0.3
       spawn_interval: 0.4
     enemy_distribution:
-      pentagon: 100
+      pentagon: 34
-      cuadrado: 0
+      cuadrado: 33
-      molinillo: 0
+      molinillo: 33
     difficulty_multipliers:
       speed_multiplier: 0.7
       rotation_multiplier: 0.8

source/core/audio/audio.cpp

@@ -51,8 +51,6 @@ void Audio::playMusic(const std::string& name, const int loop, const int crossfa
         return;
     }
 
-    if (!music_enabled_) { return; }
-
     auto* resource = AudioResource::getMusic(name);
     if (resource == nullptr) { return; }
 
@@ -62,7 +60,7 @@ void Audio::playMusic(const std::string& name, const int loop, const int crossfa
 
 // Reprodueix la música per punter (amb crossfade opcional)
 void Audio::playMusic(Ja::Music* music, const int loop, const int crossfade_ms) {
-    if (!music_enabled_ || music == nullptr) { return; }
+    if (music == nullptr) { return; }
 
     playMusicInternal(music, loop, crossfade_ms);
     // Si el Ja::Music es va crear con filename (loadMusic con 3 arguments), el
@@ -72,9 +70,12 @@ void Audio::playMusic(Ja::Music* music, const int loop, const int crossfade_ms)
 }
 
 // Camí comú dels dos overloads: fa el dispatch crossfade vs stop+play i
-// actualitza el loop cachejat. Els callers s'encarreguen del gating
+// actualitza el loop cachejat. Els callers s'encarreguen del same-track early
-// (music_enabled_, nullptr, same-track early return) y del nom. L'estat el
+// return i del nom. El gate de música deshabilitada NO atura la reproducció:
-// manté Ja (Ja::playMusic posa PLAYING al Ja::Music* corresponent).
+// effectiveVolume porta el volum efectiu a 0 i la pista continua sonant
+// silenciada, per garantir que reactivar la música la torne a sentir sense
+// haver de reiniciar la pista. L'estat el manté Ja (Ja::playMusic posa
+// PLAYING al Ja::Music* corresponent).
 void Audio::playMusicInternal(Ja::Music* music, const int loop, const int crossfade_ms) {
     const bool CURRENTLY_PLAYING = (getMusicState() == MusicState::PLAYING);
     if (crossfade_ms > 0 && CURRENTLY_PLAYING) {
@@ -91,41 +92,35 @@ void Audio::playMusicInternal(Ja::Music* music, const int loop, const int crossf
 
 // Pausa la música (l'estat el transiciona Engine::pauseMusic)
 void Audio::pauseMusic() {
-    if (music_enabled_ && getMusicState() == MusicState::PLAYING) {
+    if (getMusicState() == MusicState::PLAYING) {
         engine_->pauseMusic();
     }
 }
 
 // Continua la música pausada (l'estat el transiciona Engine::resumeMusic)
 void Audio::resumeMusic() {
-    if (music_enabled_ && getMusicState() == MusicState::PAUSED) {
+    if (getMusicState() == MusicState::PAUSED) {
         engine_->resumeMusic();
     }
 }
 
 // Atura la música (l'estat el transiciona Engine::stopMusic)
 void Audio::stopMusic() {
-    if (music_enabled_) {
     engine_->stopMusic();
-    }
 }
 
 void Audio::setMusicSpeed(float ratio) {
-    if (music_enabled_) {
     engine_->setMusicSpeed(ratio);
-    }
 }
 
 // Reprodueix un so per nom
 void Audio::playSound(const std::string& name, Group group) {
-    if (sound_enabled_) {
     engine_->playSound(AudioResource::getSound(name), 0, static_cast<int>(group));
-    }
 }
 
 // Reprodueix un so per punter directe
 void Audio::playSound(Ja::Sound* sound, Group group) {
-    if (sound_enabled_ && sound != nullptr) {
+    if (sound != nullptr) {
         engine_->playSound(sound, 0, static_cast<int>(group));
     }
 }
@@ -136,7 +131,6 @@ void Audio::playSound(Ja::Sound* sound, Group group) {
 // Si l'engine torna -1 (sense canal lliure) o el so no existeix, no fem
 // la crida al ratio — sin efectes col·laterals.
 void Audio::playSound(const std::string& name, Group group, float speed) {
-    if (!sound_enabled_) { return; }
     auto* sound = AudioResource::getSound(name);
     if (sound == nullptr) { return; }
     const int CH = engine_->playSound(sound, 0, static_cast<int>(group));
@@ -149,7 +143,6 @@ void Audio::playSound(const std::string& name, Group group, float speed) {
 // existeix o l'engine retorna -1 (sin de canals d'efecte plé), cau a playSound
 // sec — l'usuari sent el so aún que la cua no s'apliqui.
 void Audio::playSoundWithEcho(const std::string& name, const std::string& preset_name, Group group) {
-    if (!sound_enabled_) { return; }
     auto* sound = AudioResource::getSound(name);
     if (sound == nullptr) { return; }
 
@@ -168,7 +161,6 @@ void Audio::playSoundWithEcho(const std::string& name, const std::string& preset
 // Reprodueix un so processat per un reverb definit a sounds.yaml. Mateix
 // fallback que playSoundWithEcho.
 void Audio::playSoundWithReverb(const std::string& name, const std::string& preset_name, Group group) {
-    if (!sound_enabled_) { return; }
     auto* sound = AudioResource::getSound(name);
     if (sound == nullptr) { return; }
 
@@ -186,14 +178,12 @@ void Audio::playSoundWithReverb(const std::string& name, const std::string& pres
 
 // Atura tots los sons
 void Audio::stopAllSounds() {
-    if (sound_enabled_) {
     engine_->stopChannel(-1);
-    }
 }
 
 // Fa una fosa de sortida de la música
 void Audio::fadeOutMusic(int milliseconds) {
-    if (music_enabled_ && getMusicState() == MusicState::PLAYING) {
+    if (getMusicState() == MusicState::PLAYING) {
         engine_->fadeOutMusic(milliseconds);
     }
 }
@@ -238,14 +228,27 @@ auto Audio::effectiveVolume(float volume, bool channel_enabled) const -> float {
     return (enabled_ && channel_enabled) ? volume * config_.volume : 0.0F;
 }
 
-// Estableix el volum dels sons (float 0.0..1.0)
+// Estableix el volum dels sons (float 0.0..1.0). Actualitza el valor cachejat
+// a config_ perquè els getters i les re-aplicacions internes (enableSound,
+// setMasterVolume) puguin tornar al volum que l'usuari va triar.
 void Audio::setSoundVolume(float sound_volume, Group group) {
-    engine_->setSoundVolume(effectiveVolume(sound_volume, sound_enabled_), static_cast<int>(group));
+    config_.sound_volume = std::clamp(sound_volume, MIN_VOLUME, MAX_VOLUME);
+    engine_->setSoundVolume(effectiveVolume(config_.sound_volume, sound_enabled_), static_cast<int>(group));
 }
 
-// Estableix el volum de la música (float 0.0..1.0)
+// Estableix el volum de la música (float 0.0..1.0). Cf. setSoundVolume.
 void Audio::setMusicVolume(float music_volume) {
-    engine_->setMusicVolume(effectiveVolume(music_volume, music_enabled_));
+    config_.music_volume = std::clamp(music_volume, MIN_VOLUME, MAX_VOLUME);
+    engine_->setMusicVolume(effectiveVolume(config_.music_volume, music_enabled_));
+}
+
+// Estableix el volum master (multiplicador aplicat a sound + music). Re-aplica
+// els canals perquè el canvi tingui efecte immediat sense esperar al següent
+// setSoundVolume/setMusicVolume explícit.
+void Audio::setMasterVolume(float master_volume) {
+    config_.volume = std::clamp(master_volume, MIN_VOLUME, MAX_VOLUME);
+    setSoundVolume(config_.sound_volume);
+    setMusicVolume(config_.music_volume);
 }
 
 // Aplica una nueva configuración (substitueix la config cachejada i reaplica enables/volums)
@@ -256,12 +259,12 @@ void Audio::applySettings(const Config& config) {
     enable(config_.enabled);
 }
 
-// Estableix l'estat general
+// Estableix l'estat general. Re-aplica els volums actuals; effectiveVolume
+// retalla a 0 quan enabled_ és false, sense perdre els valors guardats.
 void Audio::enable(bool value) {
     enabled_ = value;
-
+    setSoundVolume(config_.sound_volume);
-    setSoundVolume(enabled_ ? config_.sound_volume : MIN_VOLUME);
+    setMusicVolume(config_.music_volume);
-    setMusicVolume(enabled_ ? config_.music_volume : MIN_VOLUME);
 }
 
 // Estableix l'estat dels sons i reaplica el volum porque los canals actius

source/core/audio/audio.hpp

@@ -101,6 +101,14 @@ class Audio {
     // --- Control de volum (API interna: float 0.0..1.0) ---
     void setSoundVolume(float volume, Group group = Group::ALL);  // Ajusta el volum dels efectes
     void setMusicVolume(float volume);                            // Ajusta el volum de la música
+    void setMasterVolume(float volume);                           // Ajusta el master (re-aplica sound + music)
+
+    // Getters dels volums actuals (lectura de la config_ cachejada). Reflexen
+    // el valor que l'usuari ha triat l'última vegada, independent del gating
+    // d'enabled/channel.
+    [[nodiscard]] auto getMasterVolume() const -> float { return config_.volume; }
+    [[nodiscard]] auto getSoundVolume() const -> float { return config_.sound_volume; }
+    [[nodiscard]] auto getMusicVolume() const -> float { return config_.music_volume; }
 
     // --- Helpers de conversió para la capa de presentació ---
     // UI (menús, notificacions) manega enters 0..100; internament viu float 0..1.

source/core/audio/jail_audio.hpp

@@ -46,7 +46,7 @@ namespace Ja {
     };
 
     // --- Constants ---
-    inline constexpr int MAX_SIMULTANEOUS_CHANNELS = 20;
+    inline constexpr int MAX_SIMULTANEOUS_CHANNELS = 50;
     inline constexpr int MAX_GROUPS = 2;
     // Cap superior de canals que poden estar simultàniament reproduint un so
     // con efecte (eco/reverb). Si está al límit, las noves crides con efecte

source/core/config/engine_config.hpp

@@ -12,7 +12,6 @@
 
 #include <SDL3/SDL.h>
 
-#include <functional>
 #include <string>
 
 namespace Config {
@@ -49,32 +48,36 @@ namespace Config {
         int button_right{SDL_GAMEPAD_BUTTON_DPAD_RIGHT};
         int button_thrust{SDL_GAMEPAD_BUTTON_WEST};  // X button
         int button_shoot{SDL_GAMEPAD_BUTTON_SOUTH};  // A button
+        int button_start{SDL_GAMEPAD_BUTTON_START};  // Start button
+        int button_menu{SDL_GAMEPAD_BUTTON_BACK};    // Select/Back -> obre menu servei
     };
 
     struct PlayerBindings {
         KeyboardBindings keyboard{};
         GamepadBindings gamepad{};
         std::string gamepad_name;  // Empty = auto-assign by index
+        std::string gamepad_path;  // Prioritari sobre name per distingir mateixos models
+    };
+
+    struct AudioConfig {
+        bool enabled{true};
+        float volume{1.0F};  // Master 0..1
+        bool music_enabled{true};
+        float music_volume{1.0F};
+        bool sound_enabled{true};
+        float sound_volume{0.25F};
     };
 
     struct EngineConfig {
         WindowConfig window{};
         RenderingConfig rendering{};
+        AudioConfig audio{};
         PlayerBindings player1{};
         PlayerBindings player2{};
         KeyboardBindings keyboard_controls{};  // Defaults globals per Input
         GamepadBindings gamepad_controls{};
         bool console{false};
-    };
+        std::string locale{"ca"};  // "ca" | "en" — fixat a l'arrencada, sense hot-swap
-
-    // Capa de persistència delegada cap a l'EngineConfig. Permet al Director
-    // orquestrar init/load/save sense conèixer cap esquema concret (YAML,
-    // SQLite, ...) ni la capa que el conté (`game/config_yaml.cpp`).
-    struct ConfigPersistence {
-        std::function<void()> init_defaults;                    // Restaura valors per defecte
-        std::function<void(const std::string& path)> set_path;  // Indica on guardar
-        std::function<bool()> load;                             // Llegeix path → EngineConfig
-        std::function<bool()> save;                             // Escriu EngineConfig → path
     };
 
 }  // namespace Config

source/core/defaults.hpp

@@ -26,6 +26,7 @@
 #include "core/defaults/playfield.hpp"
 #include "core/defaults/rendering.hpp"
 #include "core/defaults/ship.hpp"
+#include "core/defaults/starfield_parallax.hpp"
 #include "core/defaults/title.hpp"
 #include "core/defaults/trail.hpp"
 #include "core/defaults/window.hpp"

source/core/defaults/audio.hpp

@@ -39,6 +39,7 @@ namespace Defaults::Sound {
     constexpr const char* EXPLOSION2 = "effects/explosion2.wav";                 // Explosión alternativa
     constexpr const char* FRIENDLY_FIRE_HIT = "effects/friendly_fire.wav";       // Friendly fire hit
     constexpr const char* HIT = "effects/hit.wav";                               // Enemic ferit (primer impacte → HURT)
+    constexpr const char* HURT = "effects/hurt.wav";                             // Nau pròpia entra a HURT
     constexpr const char* INIT_HUD = "effects/init_hud.wav";                     // Para la animación del HUD
     constexpr const char* LASER = "effects/laser_shoot.wav";                     // Disparo
     constexpr const char* LOGO = "effects/logo.wav";                             // Logo

source/core/defaults/effects.hpp

@@ -5,6 +5,48 @@
 
 #include <SDL3/SDL.h>
 
+namespace Defaults::FX::Glow {
+
+    // Neon glow per outline gruixut, aplicat automàticament per renderShape.
+    // Els gruixos d'halo són RÀTIOS del bounding_radius de la shape (escalat
+    // per scale), de manera que un pentàgon (radius 20) té halo gros i una bala
+    // (radius 3) té halo subtil. El core (últim pass) usa el gruix de línia
+    // global (1.5px) — no escala amb la shape.
+    //
+    // Cap superior: si la shape és molt gran (logos del títol, intro), el
+    // bounding_radius es satura a aquest valor — així cap shape té més
+    // glow que el pentàgon (referència de gameplay).
+    constexpr float MAX_REFERENCE_RADIUS = 20.0F;
+
+    struct Pass {
+        float thickness_ratio;  // % del bounding_radius*scale. <0 → usa core (gruix global)
+        float alpha;
+    };
+    constexpr Pass PASSES[] = {
+        {.thickness_ratio = 0.55F, .alpha = 0.07F},
+        {.thickness_ratio = 0.35F, .alpha = 0.14F},
+        {.thickness_ratio = 0.20F, .alpha = 0.28F},
+        {.thickness_ratio = -1.0F, .alpha = 1.0F},  // core: línia "real"
+    };
+
+    // Glow per a línies "raw" (sense shape). Gruixos absoluts (px), no
+    // ratios — una línia individual no té bounding radius. Útil per a
+    // partícules de firework, sparks, etc.
+    namespace Line {
+        struct Pass {
+            float thickness;  // px. <0 → usa el thickness passat pel caller (core)
+            float alpha;
+        };
+        constexpr Pass PASSES[] = {
+            {.thickness = 18.0F, .alpha = 0.10F},
+            {.thickness = 12.0F, .alpha = 0.20F},
+            {.thickness = 6.0F, .alpha = 0.40F},
+            {.thickness = -1.0F, .alpha = 1.0F},  // core: línia "real"
+        };
+    }  // namespace Line
+
+}  // namespace Defaults::FX::Glow
+
 namespace Defaults::FX::Firework {
 
     // Color per defecte. La caller pot fer override (p.ex. heretar del pare),

source/core/defaults/enemies.hpp

@@ -1,4 +1,4 @@
-// enemies.hpp - Configuració per tipus d'enemic (Pentagon/Cuadrado/Molinillo), spawn i scoring
+// enemies.hpp - Configuració per tipus d'enemic (Pentagon/Square/Molinillo), spawn i scoring
 // © 2026 JailDesigner
 
 #pragma once
@@ -17,57 +17,57 @@ namespace Defaults::Enemies {
 
     // Pentagon (esquivador - zigzag evasion)
     namespace Pentagon {
-        constexpr float VELOCITAT = 35.0F;              // px/s (slightly slower)
+        constexpr float SPEED = 35.0F;                  // px/s (slightly slower)
         constexpr float MASS = 5.0F;                    // Masa estándar
-        constexpr float CANVI_ANGLE_PROB = 0.20F;       // 20% per wall hit (frequent zigzag)
+        constexpr float ANGLE_CHANGE_PROB = 0.20F;      // 20% per wall hit (frequent zigzag)
-        constexpr float CANVI_ANGLE_MAX = 1.0F;         // Max random angle change (rad)
+        constexpr float ANGLE_CHANGE_MAX = 1.0F;        // Max random angle change (rad)
         constexpr float ZIGZAG_PROB_PER_SECOND = 0.8F;  // Probabilidad de zigzag por segundo
-        constexpr float DROTACIO_MIN = 0.75F;           // Min visual rotation (rad/s) [+50%]
+        constexpr float ROTATION_DELTA_MIN = 0.75F;     // Min visual rotation (rad/s) [+50%]
-        constexpr float DROTACIO_MAX = 3.75F;           // Max visual rotation (rad/s) [+50%]
+        constexpr float ROTATION_DELTA_MAX = 3.75F;     // Max visual rotation (rad/s) [+50%]
         constexpr const char* SHAPE_FILE = "enemy_pentagon.shp";
     }  // namespace Pentagon
 
-    // Cuadrado (perseguidor - tracks player)
+    // Square (perseguidor - tracks player)
-    namespace Cuadrado {
+    namespace Square {
-        constexpr float VELOCITAT = 40.0F;         // px/s (medium speed)
+        constexpr float SPEED = 40.0F;              // px/s (medium speed)
         constexpr float MASS = 8.0F;                // Más pesado, "tanque"
         constexpr float TRACKING_STRENGTH = 0.5F;   // Interpolation toward player (0.0-1.0)
         constexpr float TRACKING_INTERVAL = 1.0F;   // Seconds between angle updates
-        constexpr float DROTACIO_MIN = 0.3F;       // Slow rotation [+50%]
+        constexpr float ROTATION_DELTA_MIN = 0.3F;  // Slow rotation [+50%]
-        constexpr float DROTACIO_MAX = 1.5F;       // [+50%]
+        constexpr float ROTATION_DELTA_MAX = 1.5F;  // [+50%]
         constexpr const char* SHAPE_FILE = "enemy_square.shp";
-    }  // namespace Cuadrado
+    }  // namespace Square
 
     // Molinillo (agressiu - fast straight lines, proximity spin-up)
-    namespace Molinillo {
+    namespace Pinwheel {
-        constexpr float VELOCITAT = 50.0F;                     // px/s (fastest)
+        constexpr float SPEED = 50.0F;                               // px/s (fastest)
         constexpr float MASS = 4.0F;                                 // Más liviano, ágil
-        constexpr float CANVI_ANGLE_PROB = 0.05F;              // 5% per wall hit (rare direction change)
+        constexpr float ANGLE_CHANGE_PROB = 0.05F;                   // 5% per wall hit (rare direction change)
-        constexpr float CANVI_ANGLE_MAX = 0.3F;                // Small angle adjustments
+        constexpr float ANGLE_CHANGE_MAX = 0.3F;                     // Small angle adjustments
-        constexpr float DROTACIO_MIN = 3.0F;                   // Base rotation (rad/s) [+50%]
+        constexpr float ROTATION_DELTA_MIN = 3.0F;                   // Base rotation (rad/s) [+50%]
-        constexpr float DROTACIO_MAX = 6.0F;                   // [+50%]
+        constexpr float ROTATION_DELTA_MAX = 6.0F;                   // [+50%]
-        constexpr float DROTACIO_PROXIMITY_MULTIPLIER = 3.0F;  // Spin-up multiplier when near ship
+        constexpr float ROTATION_DELTA_PROXIMITY_MULTIPLIER = 3.0F;  // Spin-up multiplier when near ship
         constexpr float PROXIMITY_DISTANCE = 100.0F;                 // Distance threshold (px)
         constexpr const char* SHAPE_FILE = "enemy_pinwheel.shp";
-    }  // namespace Molinillo
+    }  // namespace Pinwheel
 
     // Animation parameters (shared)
     namespace Animation {
         // Palpitation
-        constexpr float PALPITACIO_TRIGGER_PROB = 0.01F;  // 1% chance per second
+        constexpr float PULSE_TRIGGER_PROB = 0.01F;  // 1% chance per second
-        constexpr float PALPITACIO_DURACIO_MIN = 1.0F;    // Min duration (seconds)
+        constexpr float PULSE_DURATION_MIN = 1.0F;   // Min duration (seconds)
-        constexpr float PALPITACIO_DURACIO_MAX = 3.0F;    // Max duration (seconds)
+        constexpr float PULSE_DURATION_MAX = 3.0F;   // Max duration (seconds)
-        constexpr float PALPITACIO_AMPLITUD_MIN = 0.08F;  // Min scale variation
+        constexpr float PULSE_AMPLITUD_MIN = 0.08F;  // Min scale variation
-        constexpr float PALPITACIO_AMPLITUD_MAX = 0.20F;  // Max scale variation
+        constexpr float PULSE_AMPLITUD_MAX = 0.20F;  // Max scale variation
-        constexpr float PALPITACIO_FREQ_MIN = 1.5F;       // Min frequency (Hz)
+        constexpr float PULSE_FREQ_MIN = 1.5F;       // Min frequency (Hz)
-        constexpr float PALPITACIO_FREQ_MAX = 3.0F;       // Max frequency (Hz)
+        constexpr float PULSE_FREQ_MAX = 3.0F;       // Max frequency (Hz)
 
         // Rotation acceleration
-        constexpr float ROTACIO_ACCEL_TRIGGER_PROB = 0.02F;   // 2% chance per second [4x more frequent]
+        constexpr float ROTATION_ACCEL_TRIGGER_PROB = 0.02F;   // 2% chance per second [4x more frequent]
-        constexpr float ROTACIO_ACCEL_DURACIO_MIN = 3.0F;     // Min transition time
+        constexpr float ROTATION_ACCEL_DURATION_MIN = 3.0F;    // Min transition time
-        constexpr float ROTACIO_ACCEL_DURACIO_MAX = 8.0F;     // Max transition time
+        constexpr float ROTATION_ACCEL_DURATION_MAX = 8.0F;    // Max transition time
-        constexpr float ROTACIO_ACCEL_MULTIPLIER_MIN = 0.3F;  // Min speed multiplier [more dramatic]
+        constexpr float ROTATION_ACCEL_MULTIPLIER_MIN = 0.3F;  // Min speed multiplier [more dramatic]
-        constexpr float ROTACIO_ACCEL_MULTIPLIER_MAX = 4.0F;  // Max speed multiplier [more dramatic]
+        constexpr float ROTATION_ACCEL_MULTIPLIER_MAX = 4.0F;  // Max speed multiplier [more dramatic]
     }  // namespace Animation
 
     // Wounded state (entre primer impacto y explosión)
@@ -94,8 +94,8 @@ namespace Defaults::Enemies {
     // Scoring system (puntuación per type de enemy)
     namespace Scoring {
         constexpr int PENTAGON_SCORE = 100;  // Pentágono (esquivador, 35 px/s)
-        constexpr int QUADRAT_SCORE = 150;    // Cuadrado (perseguidor, 40 px/s)
+        constexpr int SQUARE_SCORE = 150;    // Square (perseguidor, 40 px/s)
-        constexpr int MOLINILLO_SCORE = 200;  // Molinillo (agressiu, 50 px/s)
+        constexpr int PINWHEEL_SCORE = 200;  // Molinillo (agressiu, 50 px/s)
     }  // namespace Scoring
 
 }  // namespace Defaults::Enemies

source/core/defaults/entities.hpp

@@ -6,7 +6,7 @@
 namespace Defaults::Entities {
 
     constexpr int MAX_ORNIS = 15;
-    constexpr int MAX_BALES = 50;
+    constexpr int MAX_BULLETS = 50;
 
     constexpr float SHIP_RADIUS = 12.0F;
     constexpr float ENEMY_RADIUS = 20.0F;

source/core/defaults/game.hpp

@@ -17,13 +17,18 @@ namespace Defaults::Game {
     // Valores centinela del temporitzador de mort per-jugador.
     constexpr float HIT_TIMER_INACTIVE_PLAYER = 999.0F;  // Jugador permanentment inactiu
     constexpr float HIT_TIMER_TRIGGER_DEATH = 0.001F;    // Trigger inicial post-impacte (>0 sense disparar regla)
-    constexpr float COLLISION_SHIP_ENEMY_AMPLIFIER = 0.80F;    // 80% hitbox (generous)
+    // Ha de ser ≥ 1.0F: PhysicsWorld separa els cossos al contacte exacte (dist == suma de radis),
+    // així que un amplificador < 1 fa que el check de gameplay no es dispari mai. Marge petit
+    // (1.05F) per tolerar floating-point i petites separacions post-impuls.
+    constexpr float COLLISION_SHIP_ENEMY_AMPLIFIER = 1.05F;
     constexpr float COLLISION_BULLET_ENEMY_AMPLIFIER = 1.15F;  // 115% hitbox (generous)
+    // Wounded chain: el rebot físic separa els cossos abans que arribi
+    // la detecció gameplay; amplier generós perquè el toc compti.
+    constexpr float COLLISION_WOUNDED_CHAIN_AMPLIFIER = 1.25F;
 
     // Friendly fire system
     constexpr bool FRIENDLY_FIRE_ENABLED = true;               // Activar friendly fire
     constexpr float COLLISION_BULLET_PLAYER_AMPLIFIER = 1.0F;  // Hitbox exacto (100%)
-    constexpr float BULLET_GRACE_PERIOD = 0.2F;                // Inmunidad post-disparo (s)
     constexpr float BULLET_SPEED = 700.0F;                     // Velocidad escalar (px/s). Pascal: 7 px/frame × 20 FPS
 
     // Transición LEVEL_START (mensajes aleatorios PRE-level)
@@ -54,7 +59,7 @@ namespace Defaults::Game {
     constexpr float INIT_HUD_SHIP2_RATIO_INIT = 0.20F;
     constexpr float INIT_HUD_SHIP2_RATIO_END = 1.0F;
 
-    // Posición inicial de la nave en INIT_HUD (75% de altura de zona de juego)
+    // Posición inicial de la nave en INIT_HUD (75% de altura de zone de juego)
     constexpr float INIT_HUD_SHIP_START_Y_RATIO = 0.75F;  // 75% desde el top de PLAYAREA
 
     // Spawn positions (distribución horizontal para 2 jugadores)

source/core/defaults/hud.hpp

@@ -33,7 +33,9 @@ namespace Defaults::Hud {
     namespace DebugOverlay {
         constexpr float X = 30.0F;
         constexpr float Y_FPS = 24.0F;
+        constexpr float FPS_LINE_HEIGHT = 28.0F;  // separació després del FPS (scale 0.7 → ~28 px)
         constexpr float LINE_HEIGHT = 18.0F;      // separació entre línies (scale 0.4 → ~16 px alt)
+        constexpr float FPS_SCALE = 0.7F;         // FPS més gran que la resta
         constexpr float TEXT_SCALE = 0.4F;
         constexpr float TEXT_SPACING = 2.0F;
         constexpr float BRIGHTNESS = 1.0F;

source/core/defaults/palette.hpp

@@ -16,9 +16,9 @@ namespace Defaults::Palette {
     // visible quan el halo s'expandeix.
     constexpr SDL_Color SHIP = {.r = 255, .g = 255, .b = 255, .a = 255};    // Blanco neutro
     constexpr SDL_Color BULLET = {.r = 155, .g = 255, .b = 175, .a = 255};  // Verde laser
-    constexpr SDL_Color PENTAGON = {.r = 155, .g = 195, .b = 255, .a = 255};   // Azul "esquivador"
+    constexpr SDL_Color PENTAGON = {.r = 0, .g = 255, .b = 255, .a = 255};  // Cyan pur "esquivador"
-    constexpr SDL_Color QUADRAT = {.r = 255, .g = 140, .b = 140, .a = 255};    // Rojo "tank"
+    constexpr SDL_Color SQUARE = {.r = 255, .g = 0, .b = 0, .a = 255};      // Roig pur "tank"
-    constexpr SDL_Color MOLINILLO = {.r = 255, .g = 160, .b = 255, .a = 255};  // Magenta agresivo
+    constexpr SDL_Color PINWHEEL = {.r = 255, .g = 0, .b = 255, .a = 255};  // Magenta pur "agressiu"
     constexpr SDL_Color WOUNDED = {.r = 255, .g = 220, .b = 60, .a = 255};  // Dorado: enemigo herido
 
 }  // namespace Defaults::Palette

source/core/defaults/physics.hpp

@@ -18,13 +18,21 @@ namespace Defaults::Physics {
         constexpr float IMPACT_MOMENTUM_FACTOR = 3.0F;  // Factor de transferència de moment bala→enemic
     }  // namespace Bullet
 
+    // Ship → enemy: impuls explícit aplicat a l'enemic en el moment exacte
+    // que la nau mor per col·lisió amb ell (afegit per damunt del rebot
+    // natural de PhysicsWorld, que ja és present però subtil amb la
+    // damping de la nau).
+    namespace Ship {
+        constexpr float DEATH_IMPACT_MOMENTUM_FACTOR = 0.3F;
+    }  // namespace Ship
+
     // Explosions (debris physics)
     namespace Debris {
-        constexpr float VELOCITAT_BASE = 80.0F;      // Velocidad inicial (px/s)
+        constexpr float SPEED_BASE = 80.0F;      // Velocidad inicial (px/s)
-        constexpr float VARIACIO_VELOCITAT = 40.0F;  // ±variació aleatòria (px/s)
+        constexpr float VARIACIO_SPEED = 40.0F;  // ±variació aleatòria (px/s)
         constexpr float ACCELERACIO = -60.0F;    // Fricció/desacceleració (px/s²)
-        constexpr float ROTACIO_MIN = 0.1F;          // Rotación mínima (rad/s ~5.7°/s)
+        constexpr float ROTATION_MIN = 0.1F;     // Rotación mínima (rad/s ~5.7°/s)
-        constexpr float ROTACIO_MAX = 0.3F;          // Rotación màxima (rad/s ~17.2°/s)
+        constexpr float ROTATION_MAX = 0.3F;     // Rotación màxima (rad/s ~17.2°/s)
         constexpr float TEMPS_VIDA = 2.0F;       // Vida mínima garantida (s) — després pot morir per velocitat baixa
         constexpr float TEMPS_VIDA_NAU = 3.0F;   // Ship debris min lifetime (matches DEATH_DURATION)
         constexpr float SHRINK_RATE = 1.0F;      // Reducció de mida (1.0 = encoge a 0 al final del min_lifetime)
@@ -40,8 +48,8 @@ namespace Defaults::Physics {
         constexpr float RESTITUTION_BOUNDS = 0.7F;
 
         // Herència de velocity angular (trayectorias curvas)
-        constexpr float FACTOR_HERENCIA_MIN = 0.7F;  // Mínimo 70% del drotacio heredat
+        constexpr float INHERITANCE_FACTOR_MIN = 0.7F;  // Mínimo 70% del drotacio heredat
-        constexpr float FACTOR_HERENCIA_MAX = 1.0F;  // Màxim 100% del drotacio heredat
+        constexpr float INHERITANCE_FACTOR_MAX = 1.0F;  // Màxim 100% del drotacio heredat
         constexpr float FRICCIO_ANGULAR = 0.5F;         // Desacceleració angular (rad/s²)
 
         // Velocity heredada de la nau a l'explosió (80% del feel original).
@@ -60,7 +68,7 @@ namespace Defaults::Physics {
         // Angular velocity sin for trajectory inheritance
         // Excess above this threshold is converted to tangential linear velocity
         // Prevents "vortex trap" problem with high-rotation enemies
-        constexpr float VELOCITAT_ROT_MAX = 1.5F;  // rad/s (~86°/s)
+        constexpr float SPEED_ROT_MAX = 1.5F;  // rad/s (~86°/s)
     }  // namespace Debris
 
 }  // namespace Defaults::Physics

source/core/defaults/playfield.hpp

@@ -3,16 +3,21 @@
 
 #pragma once
 
+#include <SDL3/SDL.h>
+
 namespace Defaults::Playfield {
 
     // Estructura de la graella (cel·les omplen tota la PLAYAREA)
     constexpr int COLUMNS = 16;      // cell_w = PLAYAREA.w / 16
     constexpr int ROWS = 8;          // cell_h = PLAYAREA.h / 8
-    constexpr int SUBDIVISIONS = 5;  // cada cel·la principal es divideix en N subcel·les
+    constexpr int SUBDIVISIONS = 4;  // cada cel·la principal es divideix en N subcel·les
 
     // Brillo respecte al color global (border = 1.0)
-    constexpr float GRID_BRIGHTNESS = 0.15F;
+    constexpr float GRID_BRIGHTNESS = 0.20F;
-    constexpr float SUBGRID_BRIGHTNESS = 0.05F;
+    constexpr float SUBGRID_BRIGHTNESS = 0.10F;
+
+    // Color de la rejilla (lila/violeta synthwave). Es modula amb brillantor.
+    constexpr SDL_Color GRID_COLOR = {.r = 160, .g = 80, .b = 255, .a = 255};
 
     // Animació de creació amb timer intern del Playfield.
     // L'animació total cobreix tot l'INIT_HUD (3 s). Cada línia es pinta en
@@ -25,20 +30,32 @@ namespace Defaults::Playfield {
     constexpr float HEAD_LENGTH_PX = 8.0F;   // longitud en píxels lògics del tram brillant
     constexpr float HEAD_BRIGHTNESS = 0.0F;  // brillo del cap (= border)
 
-    // Orbit (oscil·lació transversal de la línia quan la nau hi passa a prop).
+    // Ripples: deformacions circulars que travessen la graella com ones d'aigua.
-    constexpr float ORBIT_AMPLITUDE_MAX_PX = 3.0F;       // desplaçament transversal màxim
+    // Cada ripple desplaça radialment cap a fora els vèrtexs de les línies que
-    constexpr float ORBIT_DECAY_PER_S = 4.0F;            // decaiment de l'amplitud (px/s)
+    // travessa, amb una envoltant que decau a les vores de l'anell i amb el temps.
-    constexpr float ORBIT_FREQ_HZ = 8.0F;                // freqüència del sin
+    namespace Ripple {
-    constexpr float ORBIT_PROXIMITY_PX = 12.0F;          // distància max de la línia per excitar-la
+        constexpr int POOL_SIZE = 32;
-    constexpr float ORBIT_SHIP_SPEED_THRESHOLD = 60.0F;  // velocitat mínima per excitar (px/s)
 
-    // Pulse (reacció a fireworks: punt brillant que es propaga al llarg de la
+        // Ones grans (explosions / fireworks).
-    // línia a partir del punt de spawn).
+        constexpr float BIG_AMPLITUDE_PX = 10.0F;
-    constexpr int MAX_PULSES_PER_LINE = 2;
+        constexpr float BIG_SPEED_PX_S = 320.0F;
-    constexpr float PULSE_LIFETIME_S = 1.0F;      // temps total fins desaparèixer
+        constexpr float BIG_LIFETIME_S = 1.4F;
-    constexpr float PULSE_SPREAD_PER_S = 300.0F;  // px/s de propagació (cap a cada extrem)
+        constexpr float BIG_THICKNESS_PX = 40.0F;
-    constexpr unsigned char PULSE_COLOR_R = 180;
+
-    constexpr unsigned char PULSE_COLOR_G = 230;
+        // Ones petites (pas de nau, cadència estil trail).
-    constexpr unsigned char PULSE_COLOR_B = 255;
+        constexpr float SMALL_AMPLITUDE_PX = 2.5F;
+        constexpr float SMALL_SPEED_PX_S = 160.0F;
+        constexpr float SMALL_LIFETIME_S = 0.55F;
+        constexpr float SMALL_THICKNESS_PX = 18.0F;
+
+        // Cadència "soltar gotetes" per nau (patró TrailManager).
+        constexpr float SHIP_COOLDOWN_S = 0.10F;
+        constexpr float SHIP_COOLDOWN_JITTER_S = 0.03F;
+        constexpr float SHIP_SPEED_THRESHOLD_PX_S = 80.0F;
+
+        // Subdivisió de línies quan estan dins una ripple.
+        constexpr int MAIN_SEGMENTS = 24;  // línies principals
+        constexpr int SUB_SEGMENTS = 12;   // sub-graella
+    }  // namespace Ripple
 
 }  // namespace Defaults::Playfield

source/core/defaults/service_menu.hpp

@@ -0,0 +1,63 @@
+// service_menu.hpp - Constants del menu de servei (F12)
+// © 2026 JailDesigner
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+namespace Defaults::ServiceMenu {
+
+    // ---- Mides en coordenades logiques del joc (1280×720) ----
+    // BOX_WIDTH_MIN es el minim: si el titol o algun item no hi caben, el
+    // marc s'expandeix dinamicament amb animacio (cf. WIDTH_RATE).
+    constexpr int BOX_WIDTH_MIN = 460;
+    constexpr int GAP_Y = 22;
+    constexpr int TITLE_HEIGHT = 36;     // scale 0.85 ≈ 34 px de text
+    constexpr int SUBTITLE_HEIGHT = 18;  // scale 0.4 ≈ 16 px de text
+    constexpr int SEPARATOR_HEIGHT = 1;
+    constexpr int ITEM_HEIGHT = 38;  // scale 0.55 ≈ 22 px de text + padding per al highlight
+    constexpr int ITEM_GAP_Y = 6;
+
+    // Brackets als 4 cantons (substitueixen la vora completa: estètica sci-fi).
+    constexpr int CORNER_ARM_H = 48;
+    constexpr int CORNER_ARM_V = 28;
+    constexpr int CORNER_THICKNESS = 2;
+
+    // ---- Animacio open/close (mateixos parametres que aee_arcade) ----
+    constexpr float OPEN_SPEED = 8.0F;    // ~125 ms a obrir
+    constexpr float CLOSE_SPEED = 10.0F;  // ~100 ms a tancar
+    constexpr float HEIGHT_RATE = 12.0F;  // smoothing exponencial de l'alçada de la caixa
+    constexpr float WIDTH_RATE = 12.0F;   // smoothing per a canvis d'ample entre pagines
+
+    // ---- Animacio del highlight (rectangle del cursor) ----
+    // Rate=18 dona settling ~0.17 s al 95% (ease-out exponencial).
+    constexpr float HIGHLIGHT_RATE = 18.0F;
+    constexpr int HIGHLIGHT_TICK_LEN = 10;  // longitud dels ticks a cada cantonada
+    constexpr int HIGHLIGHT_THICKNESS = 1;
+    constexpr int HIGHLIGHT_PAD_X = 18;      // padding lateral del rect respecte al text
+    constexpr int HIGHLIGHT_PAD_Y = 4;       // padding vertical
+    constexpr int TEXT_INSET_X = 16;         // marge intern del text dins del highlight (label esq / valor dre)
+    constexpr int MIN_LABEL_VALUE_GAP = 30;  // mínim gap entre label i valor (per al càlcul d'ample dinàmic)
+
+    // ---- Colors RGBA ----
+    constexpr SDL_Color BG_COLOR{.r = 0, .g = 12, .b = 24, .a = 215};
+    constexpr SDL_Color CORNER_COLOR{.r = 120, .g = 220, .b = 255, .a = 255};  // cian neon
+    constexpr SDL_Color TITLE_COLOR{.r = 200, .g = 240, .b = 255, .a = 255};
+    constexpr SDL_Color SUBTITLE_COLOR{.r = 110, .g = 170, .b = 210, .a = 220};  // cian apagat
+    constexpr SDL_Color SEPARATOR_COLOR{.r = 60, .g = 120, .b = 180, .a = 180};
+    constexpr SDL_Color LABEL_COLOR{.r = 170, .g = 210, .b = 240, .a = 255};
+    constexpr SDL_Color CURSOR_COLOR{.r = 255, .g = 230, .b = 120, .a = 255};       // groc per al text sel·leccionat
+    constexpr SDL_Color HIGHLIGHT_OUTLINE{.r = 255, .g = 230, .b = 120, .a = 255};  // mateix groc, opac
+    constexpr SDL_Color HIGHLIGHT_FILL{.r = 255, .g = 230, .b = 120, .a = 36};      // wash translucid
+
+    // ---- Tipografia (VectorText). Scale 1.0 = caracter 20×40 px ----
+    constexpr float TITLE_SCALE = 0.85F;     // mateixa escala que el HUD del scoreboard
+    constexpr float SUBTITLE_SCALE = 0.40F;  // sota el titol, info decorativa (versio/hash)
+    constexpr float ITEM_SCALE = 0.55F;      // mateixa escala que les notificacions
+    constexpr float TEXT_SPACING = 2.0F;
+
+    // ---- Sons UI (relatius a data/sounds/), portats d'aee_arcade ----
+    constexpr const char* SELECT_SOUND = "ui/menu_select.wav";
+    constexpr const char* ACCEPT_SOUND = "ui/menu_accept.wav";
+
+}  // namespace Defaults::ServiceMenu

source/core/defaults/ship.hpp

@@ -24,4 +24,10 @@ namespace Defaults::Ship {
     constexpr float VISUAL_PUSH_DIVISOR = 33.33F;  // SPEED / DIVISOR = empuje visual
     constexpr float VISUAL_SCALE_DIVISOR = 12.0F;  // SCALE = 1 + (PUSH / DIVISOR)
 
+    // Estat "ferit": entre primera col·lisió amb enemic i recuperació o segona col·lisió mortal.
+    namespace Hurt {
+        constexpr float DURATION = 15.0F;  // Segons en estat ferit (provisional)
+        constexpr float BLINK_HZ = 10.0F;  // Freqüència parpelleig color normal ↔ ferit
+    }  // namespace Hurt
+
 }  // namespace Defaults::Ship

source/core/defaults/starfield_parallax.hpp

@@ -0,0 +1,36 @@
+// starfield_parallax.hpp - Capa de fons del playfield: estrelles 2D amb parallax
+// © 2026 JailDesigner
+//
+// 3 capes de profunditat. Cada capa té estrelles amb brillantor, mida i
+// factor parallax propis. Les més properes són més brillants i grans i es
+// mouen més ràpid quan el món es desplaça; les més llunyanes són tènues i
+// petites i amb prou feines es mouen.
+
+#pragma once
+
+namespace Defaults::StarfieldParallax {
+
+    namespace Far {
+        constexpr int COUNT = 60;
+        constexpr float BRIGHTNESS = 0.15F;
+        constexpr float PARALLAX_FACTOR = 0.15F;  // multiplicador sobre world_velocity
+        constexpr int SIZE_PX = 1;                // 1 px (punt)
+    }  // namespace Far
+
+    namespace Mid {
+        constexpr int COUNT = 50;
+        constexpr float BRIGHTNESS = 0.30F;
+        constexpr float PARALLAX_FACTOR = 0.35F;
+        constexpr int SIZE_PX = 2;  // creu de 3x3 (extensió ±1)
+    }  // namespace Mid
+
+    namespace Near {
+        constexpr int COUNT = 40;
+        constexpr float BRIGHTNESS = 0.55F;
+        constexpr float PARALLAX_FACTOR = 0.70F;
+        constexpr int SIZE_PX = 3;  // creu de 5x5 (extensió ±2)
+    }  // namespace Near
+
+    constexpr int TOTAL_COUNT = Far::COUNT + Mid::COUNT + Near::COUNT;
+
+}  // namespace Defaults::StarfieldParallax

source/core/defaults/title.hpp

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <SDL3/SDL.h>
+
 #include <cmath>
 
 #include "core/defaults/game.hpp"
@@ -66,7 +68,7 @@ namespace Defaults::Title {
         constexpr float FLOATING_SCALE = 1.0F * SHIP_BASE_SCALE;     // Flotante: scale base
 
         // Offset de entrada (ajustat automáticoament a l'scale)
-        // Fórmula: (radi màxim de la ship * scale de entrada) + margen
+        // Fórmula: (radius màxim de la ship * scale de entrada) + margen
         constexpr float ENTRY_OFFSET = (SHIP_MAX_RADIUS * ENTRY_SCALE_START) + ENTRY_OFFSET_MARGIN;
 
         // Vec2 de fuga (centro para l'animación de salida)
@@ -79,7 +81,7 @@ namespace Defaults::Title {
 
         // Durades de animación
         constexpr float ENTRY_DURATION = 2.0F;  // Entrada (segons)
-        constexpr float EXIT_DURATION = 1.0F;   // Salida (segons)
+        constexpr float EXIT_DURATION = 1.5F;   // Salida (segons)
 
         // Flotació (oscil·lació reduïda y diferenciada per ship)
         constexpr float FLOAT_AMPLITUDE_X = 4.0F;  // Amplitud X (píxels)
@@ -94,9 +96,6 @@ namespace Defaults::Title {
         constexpr float P1_ENTRY_DELAY = 0.0F;  // P1 entra immediatament
         constexpr float P2_ENTRY_DELAY = 0.5F;  // P2 entra 0.5s después
 
-        // Delay global antes de start l'animación de entrada al state MAIN
-        constexpr float ENTRANCE_DELAY = 5.0F;  // Temps de espera antes que las naves entrin
-
         // Multiplicadors de freqüència para cada ship (variació sutil ±12%)
         constexpr float P1_FREQUENCY_MULTIPLIER = 0.88F;  // 12% més lenta
         constexpr float P2_FREQUENCY_MULTIPLIER = 1.12F;  // 12% més ràpida
@@ -126,4 +125,46 @@ namespace Defaults::Title {
         constexpr float TEXT_SPACING = 2.0F;
     }  // namespace Layout
 
+    // Coreografia de la seqüència d'entrada al state MAIN.
+    // Tots els elements (logo, footer, naus, press start) entren ordenadament
+    // segons aquests thresholds. Vegeu title_scene.cpp/updateMainState.
+    //
+    // Per al logo i el footer, l'efecte simula un moviment 3D des de l'usuari
+    // cap al VP: el text arrenca gran i a la posició projectada extrema (com
+    // si estigués prop de la càmera, fora de pantalla) i acaba a la seva
+    // posició final amb escala normal (com si hagués aterrat al VP). Pivot:
+    // centre de pantalla (= projecció del VP 3D).
+    namespace Sequence {
+        // Factor d'escala inicial. >1 = sprite gran a l'inici (prop de l'usuari).
+        // La posició inicial es deriva: pivot=centre, delta multiplicat per aquest factor.
+        constexpr float LOGO_INTRO_SCALE_START = 2.5F;
+        constexpr float FOOTER_INTRO_SCALE_START = 2.5F;
+
+        // Durades de les animacions d'entrada (segons).
+        constexpr float LOGO_ENTRY_DURATION = 1.2F;
+        constexpr float JAILGAMES_ENTRY_DURATION = 0.7F;
+        constexpr float COPYRIGHT_ENTRY_DURATION = 0.7F;
+
+        // Stagger "pam-pam" entre l'arrencada de JAILGAMES i la de COPYRIGHT.
+        constexpr float COPYRIGHT_STAGGER = 0.18F;
+
+        // Delays entre etapes.
+        constexpr float SHIPS_DELAY_AFTER_FOOTER = 0.20F;
+        constexpr float PRESS_START_DELAY_AFTER_SHIPS = 0.40F;
+    }  // namespace Sequence
+
+    // Paleta neon de l'escena de títol (cian + magenta synthwave).
+    // alpha = 255 (sentinela "color vàlid") fa que el pipeline ignori
+    // el color global de l'oscil·lador per a aquesta crida.
+    namespace Colors {
+        constexpr SDL_Color LOGO_MAIN = {.r = 80, .g = 240, .b = 255, .a = 255};        // Cian elèctric
+        constexpr SDL_Color LOGO_SHADOW = {.r = 255, .g = 60, .b = 180, .a = 255};      // Magenta neon (offset)
+        constexpr SDL_Color SHIP_P1 = {.r = 255, .g = 100, .b = 200, .a = 255};         // Rosa hot
+        constexpr SDL_Color SHIP_P2 = {.r = 160, .g = 120, .b = 255, .a = 255};         // Violeta elèctric
+        constexpr SDL_Color STARFIELD = {.r = 200, .g = 220, .b = 255, .a = 255};       // Blanc-blau gel
+        constexpr SDL_Color PRESS_START = {.r = 255, .g = 200, .b = 70, .a = 255};      // Ambre neon
+        constexpr SDL_Color JAILGAMES_LOGO = {.r = 120, .g = 220, .b = 200, .a = 255};  // Teal suau
+        constexpr SDL_Color COPYRIGHT = {.r = 140, .g = 180, .b = 200, .a = 255};       // Gris-cian apagat
+    }  // namespace Colors
+
 }  // namespace Defaults::Title

source/core/graphics/border.cpp

@@ -23,12 +23,12 @@ namespace Graphics {
     }
 
     void Border::bumpAt(Vec2 contact_point, float strength) {
-        const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+        const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
         const std::array<float, SIDE_COUNT> DISTANCES = {
-            /* TOP    */ std::abs(contact_point.y - zona.y),
+            /* TOP    */ std::abs(contact_point.y - zone.y),
-            /* RIGHT  */ std::abs((zona.x + zona.w) - contact_point.x),
+            /* RIGHT  */ std::abs((zone.x + zone.w) - contact_point.x),
-            /* BOTTOM */ std::abs((zona.y + zona.h) - contact_point.y),
+            /* BOTTOM */ std::abs((zone.y + zone.h) - contact_point.y),
-            /* LEFT   */ std::abs(contact_point.x - zona.x)};
+            /* LEFT   */ std::abs(contact_point.x - zone.x)};
 
         int closest_idx = 0;
         float closest_dist = DISTANCES[0];
@@ -71,11 +71,11 @@ namespace Graphics {
     }  // namespace
 
     void Border::draw() const {
-        const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+        const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
-        const int X1 = static_cast<int>(zona.x);
+        const int X1 = static_cast<int>(zone.x);
-        const int Y1 = static_cast<int>(zona.y);
+        const int Y1 = static_cast<int>(zone.y);
-        const int X2 = static_cast<int>(zona.x + zona.w);
+        const int X2 = static_cast<int>(zone.x + zone.w);
-        const int Y2 = static_cast<int>(zona.y + zona.h);
+        const int Y2 = static_cast<int>(zone.y + zone.h);
 
         const int OFF_TOP = static_cast<int>(sides_[SIDE_TOP].displacement_px);
         const int OFF_RIGHT = static_cast<int>(sides_[SIDE_RIGHT].displacement_px);

source/core/graphics/playfield.cpp

@@ -5,8 +5,8 @@
 
 #include <algorithm>
 #include <cmath>
+#include <cstdint>
 #include <cstdlib>
-#include <limits>
 
 #include "core/defaults.hpp"
 #include "core/rendering/line_renderer.hpp"
@@ -21,20 +21,38 @@ namespace Graphics {
             return 1.0F - (INV * INV * INV);
         }
 
-        // Lerp del color base actual (oscil·lador) cap a un color destí en
+        auto randUniform(float min_v, float max_v) -> float {
-        // funció de f ∈ [0, 1]. Alpha > 0 perquè line_renderer l'usi directe.
+            const float NORM = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);
-        auto lerpColor(SDL_Color target, float f) -> SDL_Color {
+            return min_v + (NORM * (max_v - min_v));
-            const float CLAMPED = std::clamp(f, 0.0F, 1.0F);
+        }
-            const SDL_Color BASE = Rendering::getLineColor();
+
-            const auto LERP_U8 = [&](unsigned char a, unsigned char b) {
+        // Desplaçament radial acumulat al punt (px, py) sumant totes les ripples
-                const float OUT = (static_cast<float>(a) * (1.0F - CLAMPED)) + (static_cast<float>(b) * CLAMPED);
+        // que el toquen. Retorna {dx, dy} a sumar a la posició original.
-                return static_cast<unsigned char>(OUT);
+        auto computeRippleDisplacement(float px, float py, const Playfield::Ripple* const* hits, int n_hits) -> Vec2 {
-            };
+            float dx_total = 0.0F;
-            return SDL_Color{
+            float dy_total = 0.0F;
-                .r = LERP_U8(BASE.r, target.r),
+            for (int i = 0; i < n_hits; i++) {
-                .g = LERP_U8(BASE.g, target.g),
+                const auto& r = *hits[i];
-                .b = LERP_U8(BASE.b, target.b),
+                const float RADIUS = r.age_s * r.speed_px_s;
-                .a = 255};
+                const float THICKNESS = r.thickness_px;
+                const float DX = px - r.center.x;
+                const float DY = py - r.center.y;
+                const float D = std::sqrt((DX * DX) + (DY * DY));
+                if (D < 0.001F) {
+                    continue;  // centre exacte: no hi ha direcció radial
+                }
+                const float PHASE = (D - RADIUS) / THICKNESS;
+                if (std::fabs(PHASE) >= 1.0F) {
+                    continue;  // fora de l'anell d'aquesta ripple
+                }
+                const float ENVELOPE = std::cos(PHASE * Defaults::Math::PI * 0.5F);
+                const float AMP_EFF = r.amplitude_px * (1.0F - (r.age_s / r.lifetime_s));
+                const float UX = DX / D;
+                const float UY = DY / D;
+                dx_total += UX * AMP_EFF * ENVELOPE;
+                dy_total += UY * AMP_EFF * ENVELOPE;
+            }
+            return Vec2{.x = dx_total, .y = dy_total};
         }
 
     }  // namespace
@@ -46,101 +64,86 @@ namespace Graphics {
 
     void Playfield::update(float delta_time) {
         elapsed_s_ += delta_time;
-
+        for (auto& ripple : ripples_) {
-        // Decau l'orbit i avança la fase del sin per cada línia.
+            if (!ripple.active) {
-        const float ORBIT_DELTA_PHASE = Defaults::Playfield::ORBIT_FREQ_HZ * 2.0F * Defaults::Math::PI * delta_time;
-        const float ORBIT_DEC = Defaults::Playfield::ORBIT_DECAY_PER_S * delta_time;
-        for (auto& line : lines_) {
-            line.orbit_phase += ORBIT_DELTA_PHASE;
-            line.orbit_amplitude = std::max(0.0F, line.orbit_amplitude - ORBIT_DEC);
-
-            // Avança els pulses; els desactiva quan acaben de vida.
-            for (auto& pulse : line.pulses) {
-                if (!pulse.active) {
                 continue;
             }
-                pulse.age_s += delta_time;
+            ripple.age_s += delta_time;
-                if (pulse.age_s >= Defaults::Playfield::PULSE_LIFETIME_S) {
+            if (ripple.age_s >= ripple.lifetime_s) {
-                    pulse.active = false;
+                ripple.active = false;
-                }
             }
         }
     }
 
-    void Playfield::spawnPulseAt(Line& line, float center_t) {
+    auto Playfield::findFreeRipple() -> Ripple* {
-        for (auto& pulse : line.pulses) {
+        Ripple* oldest = nullptr;
-            if (!pulse.active) {
+        for (auto& ripple : ripples_) {
-                pulse.active = true;
+            if (!ripple.active) {
-                pulse.age_s = 0.0F;
+                return &ripple;
-                pulse.center_t = std::clamp(center_t, 0.0F, 1.0F);
+            }
+            if (oldest == nullptr || ripple.age_s > oldest->age_s) {
+                oldest = &ripple;
+            }
+        }
+        return oldest;  // pool ple: substituïm la més vella
+    }
+
+    void Playfield::spawnBig(Vec2 pos) {
+        Ripple* r = findFreeRipple();
+        if (r == nullptr) {
             return;
         }
-        }
+        r->center = pos;
-        // Cap slot lliure: substituïm el més vell.
+        r->age_s = 0.0F;
-        Pulse* oldest = line.pulses.data();
+        r->lifetime_s = Defaults::Playfield::Ripple::BIG_LIFETIME_S;
-        for (auto& pulse : line.pulses) {
+        r->speed_px_s = Defaults::Playfield::Ripple::BIG_SPEED_PX_S;
-            if (pulse.age_s > oldest->age_s) {
+        r->amplitude_px = Defaults::Playfield::Ripple::BIG_AMPLITUDE_PX;
-                oldest = &pulse;
+        r->thickness_px = Defaults::Playfield::Ripple::BIG_THICKNESS_PX;
-            }
+        r->active = true;
-        }
-        oldest->active = true;
-        oldest->age_s = 0.0F;
-        oldest->center_t = std::clamp(center_t, 0.0F, 1.0F);
     }
 
-    void Playfield::notifyFireworkSpawn(Vec2 pos) {
+    void Playfield::spawnSmall(Vec2 pos) {
-        // Línia vertical més propera (per posició x) i horitzontal més propera (per y).
+        Ripple* r = findFreeRipple();
-        Line* closest_v = nullptr;
+        if (r == nullptr) {
-        Line* closest_h = nullptr;
-        float min_dx = std::numeric_limits<float>::max();
-        float min_dy = std::numeric_limits<float>::max();
-        for (auto& line : lines_) {
-            if (line.is_vertical) {
-                const float DX = std::abs(pos.x - line.start.x);
-                if (DX < min_dx) {
-                    min_dx = DX;
-                    closest_v = &line;
-                }
-            } else {
-                const float DY = std::abs(pos.y - line.start.y);
-                if (DY < min_dy) {
-                    min_dy = DY;
-                    closest_h = &line;
-                }
-            }
-        }
-        if (closest_v != nullptr) {
-            const float LINE_LEN = closest_v->end.y - closest_v->start.y;
-            const float CENTER_T = (LINE_LEN > 0.0F) ? (pos.y - closest_v->start.y) / LINE_LEN : 0.5F;
-            spawnPulseAt(*closest_v, CENTER_T);
-        }
-        if (closest_h != nullptr) {
-            const float LINE_LEN = closest_h->end.x - closest_h->start.x;
-            const float CENTER_T = (LINE_LEN > 0.0F) ? (pos.x - closest_h->start.x) / LINE_LEN : 0.5F;
-            spawnPulseAt(*closest_h, CENTER_T);
-        }
-    }
-
-    void Playfield::notifyShipPass(Vec2 pos, float speed_px_s) {
-        if (speed_px_s < Defaults::Playfield::ORBIT_SHIP_SPEED_THRESHOLD) {
             return;
         }
-        const float MAX_DIST = Defaults::Playfield::ORBIT_PROXIMITY_PX;
+        r->center = pos;
-        for (auto& line : lines_) {
+        r->age_s = 0.0F;
-            // Distància perpendicular del punt a la línia (que és horitzontal o vertical).
+        r->lifetime_s = Defaults::Playfield::Ripple::SMALL_LIFETIME_S;
-            const float DIST = line.is_vertical
+        r->speed_px_s = Defaults::Playfield::Ripple::SMALL_SPEED_PX_S;
-                ? std::abs(pos.x - line.start.x)
+        r->amplitude_px = Defaults::Playfield::Ripple::SMALL_AMPLITUDE_PX;
-                : std::abs(pos.y - line.start.y);
+        r->thickness_px = Defaults::Playfield::Ripple::SMALL_THICKNESS_PX;
-            if (DIST < MAX_DIST) {
+        r->active = true;
-                line.orbit_amplitude = Defaults::Playfield::ORBIT_AMPLITUDE_MAX_PX;
     }
+
+    void Playfield::notifyExplosion(Vec2 pos) {
+        spawnBig(pos);
     }
+
+    void Playfield::notifyShipMoving(std::uint8_t player_id, Vec2 pos, float speed_px_s, float delta_time) {
+        if (player_id >= ship_ripple_cooldown_.size()) {
+            return;
+        }
+        if (speed_px_s < Defaults::Playfield::Ripple::SHIP_SPEED_THRESHOLD_PX_S) {
+            ship_ripple_cooldown_[player_id] = 0.0F;
+            return;
+        }
+        ship_ripple_cooldown_[player_id] -= delta_time;
+        if (ship_ripple_cooldown_[player_id] > 0.0F) {
+            return;
+        }
+        spawnSmall(pos);
+        const float JITTER = randUniform(
+            -Defaults::Playfield::Ripple::SHIP_COOLDOWN_JITTER_S,
+            Defaults::Playfield::Ripple::SHIP_COOLDOWN_JITTER_S);
+        ship_ripple_cooldown_[player_id] =
+            Defaults::Playfield::Ripple::SHIP_COOLDOWN_S + JITTER;
     }
 
     void Playfield::buildLines() {
-        const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+        const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
-        const float CELL_W = zona.w / static_cast<float>(Defaults::Playfield::COLUMNS);
+        const float CELL_W = zone.w / static_cast<float>(Defaults::Playfield::COLUMNS);
-        const float CELL_H = zona.h / static_cast<float>(Defaults::Playfield::ROWS);
+        const float CELL_H = zone.h / static_cast<float>(Defaults::Playfield::ROWS);
         const float SUB_W = CELL_W / static_cast<float>(Defaults::Playfield::SUBDIVISIONS);
         const float SUB_H = CELL_H / static_cast<float>(Defaults::Playfield::SUBDIVISIONS);
         const int SUB_VERTS = Defaults::Playfield::COLUMNS * Defaults::Playfield::SUBDIVISIONS;
@@ -151,38 +154,32 @@ namespace Graphics {
 
         // Verticals: posicions i ∈ [1, SUB_VERTS-1].
         for (int i = 1; i < SUB_VERTS; i++) {
-            const float X = zona.x + (static_cast<float>(i) * SUB_W);
+            const float X = zone.x + (static_cast<float>(i) * SUB_W);
             const bool IS_MAIN = (i % Defaults::Playfield::SUBDIVISIONS) == 0;
             const float BRIGHTNESS = IS_MAIN
                 ? Defaults::Playfield::GRID_BRIGHTNESS
                 : Defaults::Playfield::SUBGRID_BRIGHTNESS;
             verticals.push_back(Line{
-                .start = {.x = X, .y = zona.y},
+                .start = {.x = X, .y = zone.y},
-                .end = {.x = X, .y = zona.y + zona.h},
+                .end = {.x = X, .y = zone.y + zone.h},
                 .brightness = BRIGHTNESS,
                 .spawn_time_s = 0.0F,
-                .is_vertical = true,
+                .is_vertical = true});
-                .orbit_amplitude = 0.0F,
-                .orbit_phase = 0.0F,
-                .pulses = {}});
         }
 
         // Horitzontals: posicions j ∈ [1, SUB_HORIZ-1].
         for (int j = 1; j < SUB_HORIZ; j++) {
-            const float Y = zona.y + (static_cast<float>(j) * SUB_H);
+            const float Y = zone.y + (static_cast<float>(j) * SUB_H);
             const bool IS_MAIN = (j % Defaults::Playfield::SUBDIVISIONS) == 0;
             const float BRIGHTNESS = IS_MAIN
                 ? Defaults::Playfield::GRID_BRIGHTNESS
                 : Defaults::Playfield::SUBGRID_BRIGHTNESS;
             horizontals.push_back(Line{
-                .start = {.x = zona.x, .y = Y},
+                .start = {.x = zone.x, .y = Y},
-                .end = {.x = zona.x + zona.w, .y = Y},
+                .end = {.x = zone.x + zone.w, .y = Y},
                 .brightness = BRIGHTNESS,
                 .spawn_time_s = 0.0F,
-                .is_vertical = false,
+                .is_vertical = false});
-                .orbit_amplitude = 0.0F,
-                .orbit_phase = 0.0F,
-                .pulses = {}});
         }
 
         // Ona diagonal: la línia esquerra/superior naix a t=0 i les següents
@@ -199,13 +196,39 @@ namespace Graphics {
         lines_.clear();
         lines_.reserve(verticals.size() + horizontals.size());
 
+        // El spawn_time_s s'assigna per índex espacial perquè la diagonal de
+        // l'ona de creixement avanci uniformement. L'ordre dins lines_, en
+        // canvi, ha de garantir que el grid principal (més brillant) es
+        // dibuixi DESPRÉS del subgrid: així a les interseccions guanya el
+        // principal i no queden tallades pel subgrid.
         for (int i = 0; i < NUM_V; i++) {
             verticals[i].spawn_time_s = static_cast<float>(i) * INTERVAL_V;
-            lines_.push_back(verticals[i]);
         }
         for (int i = 0; i < NUM_H; i++) {
             horizontals[i].spawn_time_s = static_cast<float>(i) * INTERVAL_H;
-            lines_.push_back(horizontals[i]);
+        }
+
+        // Passada 1: subgrid (verticals + horitzontals).
+        for (const auto& v : verticals) {
+            if (v.brightness < Defaults::Playfield::GRID_BRIGHTNESS) {
+                lines_.push_back(v);
+            }
+        }
+        for (const auto& h : horizontals) {
+            if (h.brightness < Defaults::Playfield::GRID_BRIGHTNESS) {
+                lines_.push_back(h);
+            }
+        }
+        // Passada 2: grid principal (verticals + horitzontals).
+        for (const auto& v : verticals) {
+            if (v.brightness >= Defaults::Playfield::GRID_BRIGHTNESS) {
+                lines_.push_back(v);
+            }
+        }
+        for (const auto& h : horizontals) {
+            if (h.brightness >= Defaults::Playfield::GRID_BRIGHTNESS) {
+                lines_.push_back(h);
+            }
         }
     }
 
@@ -215,90 +238,106 @@ namespace Graphics {
     }
 
     void Playfield::draw() const {
+        // Recollir ripples actives (punters per accés ràpid al hot loop).
+        std::array<const Ripple*, Defaults::Playfield::Ripple::POOL_SIZE> active{};
+        int n_active = 0;
+        for (const auto& ripple : ripples_) {
+            if (ripple.active) {
+                active[n_active++] = &ripple;
+            }
+        }
         for (const auto& line : lines_) {
+            drawLine(line, active.data(), n_active);
+        }
+    }
+
+    void Playfield::drawLine(const Line& line, const Ripple* const* active, int n_active) const {
         const float RAW_P = computeLineProgress(line);
         if (RAW_P <= 0.0F) {
-                continue;
+            return;
         }
         const float P = easeOutCubic(RAW_P);
 
-            // Desplaçament perpendicular per orbit (verticals → x, horitzontals → y).
+        const float START_X = line.start.x;
-            const float ORBIT_OFFSET = line.orbit_amplitude * std::sin(line.orbit_phase);
+        const float START_Y = line.start.y;
-            const float ORBIT_DX = line.is_vertical ? ORBIT_OFFSET : 0.0F;
-            const float ORBIT_DY = line.is_vertical ? 0.0F : ORBIT_OFFSET;
-
-            const float START_X = line.start.x + ORBIT_DX;
-            const float START_Y = line.start.y + ORBIT_DY;
         const float DX = line.end.x - line.start.x;
         const float DY = line.end.y - line.start.y;
-            const float CURRENT_X = START_X + (DX * P);
+        const float END_X = START_X + (DX * P);
-            const float CURRENT_Y = START_Y + (DY * P);
+        const float END_Y = START_Y + (DY * P);
 
-            // Tram base (brillo de la línia).
+        // AABB de la porció visible de la línia + filtre de ripples.
+        const float LINE_MIN_X = std::min(START_X, END_X);
+        const float LINE_MAX_X = std::max(START_X, END_X);
+        const float LINE_MIN_Y = std::min(START_Y, END_Y);
+        const float LINE_MAX_Y = std::max(START_Y, END_Y);
+        std::array<const Ripple*, Defaults::Playfield::Ripple::POOL_SIZE> hits{};
+        int n_hits = 0;
+        for (int i = 0; i < n_active; i++) {
+            const auto& r = *active[i];
+            const float R_MAX = (r.age_s * r.speed_px_s) + r.thickness_px;
+            if ((r.center.x + R_MAX) < LINE_MIN_X || (r.center.x - R_MAX) > LINE_MAX_X ||
+                (r.center.y + R_MAX) < LINE_MIN_Y || (r.center.y - R_MAX) > LINE_MAX_Y) {
+                continue;
+            }
+            hits[n_hits++] = &r;
+        }
+
+        if (n_hits == 0) {
+            // Camí ràpid: una sola crida com abans.
             Rendering::linea(
                 renderer_,
                 static_cast<int>(START_X),
                 static_cast<int>(START_Y),
-                static_cast<int>(CURRENT_X),
+                static_cast<int>(END_X),
-                static_cast<int>(CURRENT_Y),
+                static_cast<int>(END_Y),
-                line.brightness);
+                line.brightness,
-
+                0.0F,
-            // Cap brillant mentre creix: l'últim tram de la línia es repinta més brillant.
+                Defaults::Playfield::GRID_COLOR);
+            // Cap brillant mentre creix.
             if (P < 1.0F) {
                 const float LENGTH = std::sqrt((DX * DX) + (DY * DY));
                 if (LENGTH > 0.0F) {
                     const float HEAD_T = std::max(0.0F, P - (Defaults::Playfield::HEAD_LENGTH_PX / LENGTH));
-                    const float HEAD_X = START_X + (DX * HEAD_T);
-                    const float HEAD_Y = START_Y + (DY * HEAD_T);
                     Rendering::linea(
                         renderer_,
-                        static_cast<int>(HEAD_X),
+                        static_cast<int>(START_X + (DX * HEAD_T)),
-                        static_cast<int>(HEAD_Y),
+                        static_cast<int>(START_Y + (DY * HEAD_T)),
-                        static_cast<int>(CURRENT_X),
+                        static_cast<int>(END_X),
-                        static_cast<int>(CURRENT_Y),
+                        static_cast<int>(END_Y),
-                        Defaults::Playfield::HEAD_BRIGHTNESS);
+                        Defaults::Playfield::HEAD_BRIGHTNESS,
+                        0.0F,
+                        Defaults::Playfield::GRID_COLOR);
                 }
             }
+            return;
+        }
 
-            // Pulses: cada un és un segment brillant centrat a center_t que
+        // Camí deformat: subdividir en N segments i desplaçar cada vèrtex.
-            // s'expandeix amb el temps i s'apaga.
+        const bool IS_MAIN = line.brightness >= Defaults::Playfield::GRID_BRIGHTNESS;
-            const float LINE_LENGTH = std::sqrt((DX * DX) + (DY * DY));
+        const int N = IS_MAIN
-            if (LINE_LENGTH <= 0.0F) {
+            ? Defaults::Playfield::Ripple::MAIN_SEGMENTS
-                continue;
+            : Defaults::Playfield::Ripple::SUB_SEGMENTS;
-            }
+        const Vec2 D0 = computeRippleDisplacement(START_X, START_Y, hits.data(), n_hits);
-            const SDL_Color PULSE_TARGET = {
+        float prev_x = START_X + D0.x;
-                .r = Defaults::Playfield::PULSE_COLOR_R,
+        float prev_y = START_Y + D0.y;
-                .g = Defaults::Playfield::PULSE_COLOR_G,
+        for (int i = 1; i <= N; i++) {
-                .b = Defaults::Playfield::PULSE_COLOR_B,
+            const float T = static_cast<float>(i) / static_cast<float>(N);
-                .a = 255};
+            const float X = START_X + (DX * P * T);
-            for (const auto& pulse : line.pulses) {
+            const float Y = START_Y + (DY * P * T);
-                if (!pulse.active) {
+            const Vec2 D = computeRippleDisplacement(X, Y, hits.data(), n_hits);
-                    continue;
+            const float NX = X + D.x;
-                }
+            const float NY = Y + D.y;
-                const float HALF_WIDTH_T = (pulse.age_s * Defaults::Playfield::PULSE_SPREAD_PER_S) / LINE_LENGTH;
-                const float INTENSITY = std::max(
-                    0.0F,
-                    1.0F - (pulse.age_s / Defaults::Playfield::PULSE_LIFETIME_S));
-                const float T1 = std::clamp(pulse.center_t - HALF_WIDTH_T, 0.0F, 1.0F);
-                const float T2 = std::clamp(pulse.center_t + HALF_WIDTH_T, 0.0F, 1.0F);
-                if (T2 <= T1) {
-                    continue;
-                }
-                const float P1_X = START_X + (DX * T1);
-                const float P1_Y = START_Y + (DY * T1);
-                const float P2_X = START_X + (DX * T2);
-                const float P2_Y = START_Y + (DY * T2);
-                const SDL_Color SEG_COLOR = lerpColor(PULSE_TARGET, INTENSITY);
             Rendering::linea(
                 renderer_,
-                    static_cast<int>(P1_X),
+                static_cast<int>(prev_x),
-                    static_cast<int>(P1_Y),
+                static_cast<int>(prev_y),
-                    static_cast<int>(P2_X),
+                static_cast<int>(NX),
-                    static_cast<int>(P2_Y),
+                static_cast<int>(NY),
-                    1.0F,
+                line.brightness,
                 0.0F,
-                    SEG_COLOR);
+                Defaults::Playfield::GRID_COLOR);
-            }
+            prev_x = NX;
+            prev_y = NY;
         }
     }
 

source/core/graphics/playfield.hpp

@@ -5,13 +5,16 @@
 // rep un `creation_progress` global ∈ [0, 1] i cada línia computa quina porció
 // li toca dibuixar segons el seu slot a la timeline.
 //
-// Disseny preparat per a futures capacitats:
+// Reaccions disponibles:
-//   - Línies "vives" que reaccionen a explosions / pas de la nau (reaction_intensity).
+//   - Ripples: deformacions circulars (ones d'aigua) que travessen la graella.
-//   - Capes addicionals al fons (estrelles, gradients, scanlines).
+//     Disparades per explosions (grans) i pas de la nau (petites, cadència estil
+//     trail). Cada vèrtex d'una línia afectada es desplaça radialment cap a fora
+//     amb una envoltant en cos(·) que decau a les vores de l'anell i amb el temps.
 
 #pragma once
 
 #include <array>
+#include <cstdint>
 #include <vector>
 
 #include "core/defaults/playfield.hpp"
@@ -24,44 +27,51 @@ namespace Graphics {
        public:
         explicit Playfield(Rendering::Renderer* renderer);
 
-        // Avança timers interns (creació + reaccions).
+        // Avança timers interns (creació + ripples).
         void update(float delta_time);
 
-        // Pinta la graella. La porció dibuixada de cada línia depèn del timer intern.
+        // Pinta la graella. La porció dibuixada de cada línia depèn del timer intern,
+        // i s'aplica deformació radial per cada ripple activa que afecti la línia.
         void draw() const;
 
-        // Notifica que una nau ha passat per (pos) a velocitat (speed_px_s).
+        // Notifica que una nau ha passat per (pos) a (speed_px_s). Genera ones
-        // Si està prop d'alguna línia i va prou ràpida, la línia entra en orbit.
+        // petites darrere la nau a cadència regular amb jitter (estil TrailManager).
-        void notifyShipPass(Vec2 pos, float speed_px_s);
+        void notifyShipMoving(std::uint8_t player_id, Vec2 pos, float speed_px_s, float delta_time);
 
-        // Notifica el spawn d'un firework a (pos). Les línies V i H més properes
+        // Notifica una explosió a (pos): genera una ripple gran centrada al punt.
-        // generen un pulse brillant que es propaga.
+        void notifyExplosion(Vec2 pos);
-        void notifyFireworkSpawn(Vec2 pos);
 
-       private:
+        // Pública per accés des d'helpers a l'anonymous namespace del .cpp.
-        struct Pulse {
+        struct Ripple {
-            bool active{false};
+            Vec2 center{};
-            float center_t{0.5F};  // posició al llarg de la línia (0..1)
             float age_s{0.0F};
+            float lifetime_s{0.0F};
+            float speed_px_s{0.0F};
+            float amplitude_px{0.0F};
+            float thickness_px{0.0F};
+            bool active{false};
         };
 
+       private:
         struct Line {
             Vec2 start;          // top (verticals) o left (horitzontals)
             Vec2 end;            // bottom (verticals) o right (horitzontals)
             float brightness;    // base (GRID_BRIGHTNESS o SUBGRID_BRIGHTNESS)
             float spawn_time_s;  // moment de naixement
-            bool is_vertical;       // direcció (per saber el perpendicular de l'orbit)
+            bool is_vertical;    // direcció
-            float orbit_amplitude;  // amplitud actual de l'orbit (px, ≥ 0)
-            float orbit_phase;      // fase del sin (avança contínuament)
-            std::array<Pulse, Defaults::Playfield::MAX_PULSES_PER_LINE> pulses;
         };
 
         void buildLines();
+        void drawLine(const Line& line, const Ripple* const* active, int n_active) const;
         [[nodiscard]] auto computeLineProgress(const Line& line) const -> float;
-        static void spawnPulseAt(Line& line, float center_t);
+        void spawnBig(Vec2 pos);
+        void spawnSmall(Vec2 pos);
+        auto findFreeRipple() -> Ripple*;
 
         Rendering::Renderer* renderer_;
         std::vector<Line> lines_;
+        std::array<Ripple, Defaults::Playfield::Ripple::POOL_SIZE> ripples_{};
+        std::array<float, 2> ship_ripple_cooldown_{};
         float elapsed_s_{0.0F};
     };
 

source/core/graphics/shape.cpp

@@ -4,20 +4,21 @@
 #include "core/graphics/shape.hpp"
 
 #include <algorithm>
+#include <cmath>
 #include <fstream>
 #include <iostream>
 #include <sstream>
 
 namespace Graphics {
 
-Shape::Shape(const std::string& filepath)
+    Shape::Shape(const std::string& filepath)
         : center_({.x = 0.0F, .y = 0.0F}),
 
           nom_("unnamed") {
         load(filepath);
-}
+    }
 
-auto Shape::load(const std::string& filepath) -> bool {
+    auto Shape::load(const std::string& filepath) -> bool {
         // Llegir file
         std::ifstream file(filepath);
         if (!file.is_open()) {
@@ -33,9 +34,9 @@ auto Shape::load(const std::string& filepath) -> bool {
 
         // Parsejar
         return parseFile(contingut);
-}
+    }
 
-auto Shape::parseFile(const std::string& contingut) -> bool {
+    auto Shape::parseFile(const std::string& contingut) -> bool {
         std::istringstream iss(contingut);
         std::string line;
 
@@ -85,11 +86,25 @@ auto Shape::parseFile(const std::string& contingut) -> bool {
             return false;
         }
 
+        bounding_radius_ = computeBoundingRadius(primitives_, center_);
         return true;
-}
+    }
 
-// Helper: trim whitespace
+    auto Shape::computeBoundingRadius(const std::vector<ShapePrimitive>& primitives,
-auto Shape::trim(const std::string& str) -> std::string {
+        const Vec2& center) -> float {
+        float max_dist_sq = 0.0F;
+        for (const auto& prim : primitives) {
+            for (const auto& p : prim.points) {
+                const float DX = p.x - center.x;
+                const float DY = p.y - center.y;
+                max_dist_sq = std::max(max_dist_sq, (DX * DX) + (DY * DY));
+            }
+        }
+        return std::sqrt(max_dist_sq);
+    }
+
+    // Helper: trim whitespace
+    auto Shape::trim(const std::string& str) -> std::string {
         const char* whitespace = " \t\n\r";
         size_t start = str.find_first_not_of(whitespace);
         if (start == std::string::npos) {
@@ -98,28 +113,28 @@ auto Shape::trim(const std::string& str) -> std::string {
 
         size_t end = str.find_last_not_of(whitespace);
         return str.substr(start, end - start + 1);
-}
+    }
 
-// Helper: startsWith
+    // Helper: startsWith
-auto Shape::startsWith(const std::string& str,
+    auto Shape::startsWith(const std::string& str,
         const std::string& prefix) -> bool {
         if (str.length() < prefix.length()) {
             return false;
         }
         return str.starts_with(prefix);
-}
+    }
 
-// Helper: extract value after ':'
+    // Helper: extract value after ':'
-auto Shape::extractValue(const std::string& line) -> std::string {
+    auto Shape::extractValue(const std::string& line) -> std::string {
         size_t colon = line.find(':');
         if (colon == std::string::npos) {
             return "";
         }
         return line.substr(colon + 1);
-}
+    }
 
-// Helper: parse center "x, y"
+    // Helper: parse center "x, y"
-void Shape::parseCenter(const std::string& value) {
+    void Shape::parseCenter(const std::string& value) {
         std::string val = trim(value);
         size_t comma = val.find(',');
         if (comma != std::string::npos) {
@@ -131,10 +146,10 @@ void Shape::parseCenter(const std::string& value) {
                 center_ = {.x = 0.0F, .y = 0.0F};
             }
         }
-}
+    }
 
-// Helper: parse points "x1,y1  x2,y2  x3,y3"
+    // Helper: parse points "x1,y1  x2,y2  x3,y3"
-auto Shape::parsePoints(const std::string& str) -> std::vector<Vec2> {
+    auto Shape::parsePoints(const std::string& str) -> std::vector<Vec2> {
         std::vector<Vec2> points;
         std::istringstream iss(trim(str));
         std::string pair;
@@ -154,6 +169,6 @@ auto Shape::parsePoints(const std::string& str) -> std::vector<Vec2> {
         }
 
         return points;
-}
+    }
 
 }  // namespace Graphics

source/core/graphics/shape.hpp

@@ -11,20 +11,20 @@
 
 namespace Graphics {
 
-// Tipo de primitiva dins de una shape
+    // Tipo de primitiva dins de una shape
-enum class PrimitiveType : std::uint8_t {
+    enum class PrimitiveType : std::uint8_t {
         POLYLINE,  // Secuencia de points connectats
         LINE       // Línia individual (2 points)
-};
+    };
 
-// Primitiva individual (polyline o line)
+    // Primitiva individual (polyline o line)
-struct ShapePrimitive {
+    struct ShapePrimitive {
         PrimitiveType type;
         std::vector<Vec2> points;  // 2+ points per polyline, exactament 2 per line
-};
+    };
 
-// Clase Shape - representa una shape vectorial carregada desde .shp
+    // Clase Shape - representa una shape vectorial carregada desde .shp
-class Shape {
+    class Shape {
        public:
         // Constructors
         Shape() = default;
@@ -42,6 +42,9 @@ class Shape {
         }
         [[nodiscard]] auto getCenter() const -> const Vec2& { return center_; }
         [[nodiscard]] auto getDefaultScale() const -> float { return escala_defecte_; }
+        // Distància màx. del center_ al vèrtex més llunyà; ús: dimensionar
+        // efectes proporcionals a la mida de la shape (halos, glow).
+        [[nodiscard]] auto getBoundingRadius() const -> float { return bounding_radius_; }
         [[nodiscard]] auto isValid() const -> bool { return !primitives_.empty(); }
 
         // Info de depuració
@@ -53,6 +56,7 @@ class Shape {
         Vec2 center_;                  // Centro/origin de la shape
         float escala_defecte_{1.0F};   // Escala per defecte (normalment 1.0). Inicializada para
                                        // que el ctor por defecto no deje el campo indeterminado.
+        float bounding_radius_{0.0F};  // Distància màx. del center_ al vèrtex més llunyà.
         std::string nom_;              // Nom de la shape (per depuració)
 
         // Helpers privats per parsejar. Son estáticos: no necesitan estado
@@ -62,6 +66,9 @@ class Shape {
         [[nodiscard]] static auto extractValue(const std::string& line) -> std::string;
         void parseCenter(const std::string& value);
         [[nodiscard]] static auto parsePoints(const std::string& str) -> std::vector<Vec2>;
-};
+        [[nodiscard]] static auto computeBoundingRadius(
+            const std::vector<ShapePrimitive>& primitives,
+            const Vec2& center) -> float;
+    };
 
 }  // namespace Graphics

source/core/graphics/starfield.cpp

@@ -1,168 +1,109 @@
-// starfield.cpp - Implementació del sistema de estrelles de fons
+// starfield.cpp - Implementació del starfield 3D
 // © 2026 JailDesigner
 
 #include "core/graphics/starfield.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <cstdlib>
-#include <iostream>
 
 #include "core/defaults.hpp"
-#include "core/graphics/shape_loader.hpp"
-#include "core/rendering/shape_renderer.hpp"
 
 namespace Graphics {
 
-// Constructor
+    namespace {
-Starfield::Starfield(Rendering::Renderer* renderer,
+
-    const Vec2& punt_fuga,
+        // Helper: número aleatori en [0, 1) usant rand()/RAND_MAX (mateixa convenció
-    const SDL_FRect& area,
+        // que la resta del joc — veure starfield.cpp).
-    int densitat)
+        auto randFloat01() -> float {
-    : shape_estrella_(ShapeLoader::load("star.shp")),
+            return static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
-      renderer_(renderer),
+        }
-      punt_fuga_(punt_fuga),
+
-      area_(area) {
+        auto randRange(float lo, float hi) -> float {
-    if (!shape_estrella_ || !shape_estrella_->isValid()) {
+            return lo + (randFloat01() * (hi - lo));
-        std::cerr << "ERROR: No s'ha pogut load star.shp" << '\n';
+        }
+
+    }  // namespace
+
+    Starfield::Starfield(Rendering::Renderer* renderer, const Camera3D* camera, int density)
+        : renderer_(renderer),
+          camera_(camera),
+          octahedron_(makeOctahedron()) {
+        stars_.resize(static_cast<std::size_t>(std::max(0, density)));
+        for (auto& star : stars_) {
+            // Pre-omplir amb estrelles distribuïdes per tot el rang Z, no només al far.
+            initStar(star, /*spawn_at_far=*/false);
+        }
+    }
+
+    void Starfield::initStar(Star& star, bool spawn_at_far) {
+        star.position.x = randRange(-HALF_SPAWN_X, HALF_SPAWN_X);
+        star.position.y = randRange(-HALF_SPAWN_Y, HALF_SPAWN_Y);
+        star.position.z = spawn_at_far
+            ? Z_FAR_SPAWN
+            : randRange(Z_NEAR_RESPAWN, Z_FAR_SPAWN);
+
+        star.velocity_z = -randRange(MIN_VELOCITY_Z, MAX_VELOCITY_Z);
+        star.rot_phase_y = randFloat01() * Defaults::Math::PI * 2.0F;
+        star.rot_phase_x = randFloat01() * Defaults::Math::PI * 2.0F;
+        star.rot_speed_y = randRange(MIN_ROT_SPEED, MAX_ROT_SPEED);
+        star.rot_speed_x = randRange(MIN_ROT_SPEED, MAX_ROT_SPEED);
+        star.scale = STAR_BASE_SCALE + (randRange(-1.0F, 1.0F) * STAR_SCALE_JITTER);
+    }
+
+    auto Starfield::computeBrightness(const Star& star) const -> float {
+        // Lerp segons distància Z normalitzada [Z_NEAR_RESPAWN .. Z_FAR_SPAWN].
+        const float SPAN = Z_FAR_SPAWN - Z_NEAR_RESPAWN;
+        const float T_RAW = (star.position.z - Z_NEAR_RESPAWN) / SPAN;
+        const float T = std::clamp(T_RAW, 0.0F, 1.0F);
+        const float BRIGHTNESS = BRIGHTNESS_NEAR + (T * (BRIGHTNESS_FAR - BRIGHTNESS_NEAR));
+        return std::clamp(BRIGHTNESS * brightness_mult_, 0.0F, 1.0F);
+    }
+
+    void Starfield::update(float delta_time) {
+        for (auto& star : stars_) {
+            star.position.z += star.velocity_z * delta_time;
+            star.rot_phase_y += star.rot_speed_y * delta_time;
+            star.rot_phase_x += star.rot_speed_x * delta_time;
+
+            if (star.position.z < Z_NEAR_RESPAWN) {
+                initStar(star, /*spawn_at_far=*/true);
+            }
+        }
+    }
+
+    void Starfield::draw() const {
+        if (camera_ == nullptr || renderer_ == nullptr) {
             return;
         }
+        // Ordena de més lluny a més a prop perquè el blending additiu acumule
+        // brightness sense que els elements de davant queden tapats pels de
+        // darrere. Còpia d'índexs per no modificar l'ordre intern de stars_.
+        std::vector<std::size_t> order(stars_.size());
+        for (std::size_t i = 0; i < order.size(); ++i) {
+            order[i] = i;
+        }
+        std::ranges::sort(order, [&](std::size_t a, std::size_t b) {
+            return stars_[a].position.z > stars_[b].position.z;
+        });
 
-    // Configurar 3 capes con diferents velocitats i escales
+        for (std::size_t idx : order) {
-    // Capa 0: Fons llunyà (lenta, pequeña)
+            const Star& star = stars_[idx];
-    capes_.push_back({20.0F, 0.3F, 0.8F, densitat / 3});
+            const Transform3D TRANSFORM{
-
+                .position = star.position,
-    // Capa 1: Profunditat mitjana
+                .rotation_euler = Vec3{.x = star.rot_phase_x, .y = star.rot_phase_y, .z = 0.0F},
-    capes_.push_back({40.0F, 0.5F, 1.2F, densitat / 3});
+                .scale = star.scale,
-
+            };
-    // Capa 2: Primer pla (ràpida, grande)
+            drawWireframe(renderer_, *camera_, octahedron_, TRANSFORM, computeBrightness(star), color_);
-    capes_.push_back({80.0F, 0.8F, 2.0F, densitat / 3});
-
-    // Calcular radi màxim (distancia del centro al racó més llunyà)
-    float dx = std::max(punt_fuga_.x, area_.w - punt_fuga_.x);
-    float dy = std::max(punt_fuga_.y, area_.h - punt_fuga_.y);
-    radi_max_ = std::sqrt((dx * dx) + (dy * dy));
-
-    // Inicialitzar estrelles con posicions distribuïdes (pre-omplir pantalla)
-    for (int capa_idx = 0; capa_idx < 3; capa_idx++) {
-        int num = capes_[capa_idx].num_estrelles;
-        for (int i = 0; i < num; i++) {
-            Estrella estrella;
-            estrella.capa = capa_idx;
-
-            // Angle aleatori
-            estrella.angle = (static_cast<float>(rand()) / static_cast<float>(RAND_MAX)) * 2.0F * Defaults::Math::PI;
-
-            // Distancia aleatòria (0.0 a 1.0) per omplir toda la pantalla
-            estrella.distancia_centre = static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
-
-            // Calcular posición desde la distancia
-            float radi = estrella.distancia_centre * radi_max_;
-            estrella.position.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
-            estrella.position.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
-
-            estrelles_.push_back(estrella);
         }
     }
-}
 
-// Inicialitzar una estrella (nueva o regenerada)
+    void Starfield::setBrightness(float multiplier) {
-void Starfield::initStar(Estrella& estrella) const {
+        brightness_mult_ = std::max(0.0F, multiplier);
-    // Angle aleatori des del point de fuga hacia fuera
-    estrella.angle = (static_cast<float>(rand()) / static_cast<float>(RAND_MAX)) * 2.0F * Defaults::Math::PI;
-
-    // Distancia inicial pequeña (5% del radi màxim) - neix prop del centro
-    estrella.distancia_centre = 0.05F;
-
-    // Posición inicial: mucho prop del point de fuga
-    float radi = estrella.distancia_centre * radi_max_;
-    estrella.position.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
-    estrella.position.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
-}
-
-// Verificar si una estrella está fuera de l'àrea
-auto Starfield::isOutsideArea(const Estrella& estrella) const -> bool {
-    return (estrella.position.x < area_.x ||
-        estrella.position.x > area_.x + area_.w ||
-        estrella.position.y < area_.y ||
-        estrella.position.y > area_.y + area_.h);
-}
-
-// Calcular scale dinàmica segons distancia del centro
-auto Starfield::computeScale(const Estrella& estrella) const -> float {
-    const CapaConfig& capa = capes_[estrella.capa];
-
-    // Interpolació lineal basada en distancia del centro
-    // distancia_centre: 0.0 (centro) → 1.0 (vora)
-    return capa.escala_min +
-        ((capa.escala_max - capa.escala_min) * estrella.distancia_centre);
-}
-
-// Calcular brightness dinàmica segons distancia del centro
-auto Starfield::computeBrightness(const Estrella& estrella) const -> float {
-    // Interpolació lineal: estrelles properes (vora) més brillants
-    // distancia_centre: 0.0 (centro, llunyanes) → 1.0 (vora, properes)
-    float brightness_base = Defaults::Brightness::STARFIELD_MIN +
-        ((Defaults::Brightness::STARFIELD_MAX - Defaults::Brightness::STARFIELD_MIN) *
-            estrella.distancia_centre);
-
-    // Aplicar multiplicador i limitar a 1.0
-    return std::min(1.0F, brightness_base * multiplicador_brightness_);
-}
-
-// Actualitzar posicions de las estrelles
-void Starfield::update(float delta_time) {
-    for (auto& estrella : estrelles_) {
-        // Obtenir configuración de la capa
-        const CapaConfig& capa = capes_[estrella.capa];
-
-        // Moure hacia fuera des del centro
-        float velocity = capa.velocitat_base;
-        float dx = velocity * std::cos(estrella.angle) * delta_time;
-        float dy = velocity * std::sin(estrella.angle) * delta_time;
-
-        estrella.position.x += dx;
-        estrella.position.y += dy;
-
-        // Actualitzar distancia del centro
-        float dx_centre = estrella.position.x - punt_fuga_.x;
-        float dy_centre = estrella.position.y - punt_fuga_.y;
-        float dist_px = std::sqrt((dx_centre * dx_centre) + (dy_centre * dy_centre));
-        estrella.distancia_centre = dist_px / radi_max_;
-
-        // Si ha sortit de l'àrea, regenerar-la
-        if (isOutsideArea(estrella)) {
-            initStar(estrella);
-        }
-    }
-}
-
-// Establir multiplicador de brightness
-void Starfield::setBrightness(float multiplier) {
-    multiplicador_brightness_ = std::max(0.0F, multiplier);  // Evitar valors negatius
-}
-
-// Dibuixar todas las estrelles
-void Starfield::draw() {
-    if (!shape_estrella_->isValid()) {
-        return;
     }
 
-    for (const auto& estrella : estrelles_) {
+    void Starfield::setColor(SDL_Color color) {
-        // Calcular scale i brightness dinàmicament
+        color_ = color;
-        float scale = computeScale(estrella);
-        float brightness = computeBrightness(estrella);
-
-        // Renderizar estrella sin rotación
-        Rendering::renderShape(
-            renderer_,
-            shape_estrella_,
-            estrella.position,
-            0.0F,       // angle (las estrelles no giren)
-            scale,     // scale dinàmica
-            1.0F,       // progress (siempre visible)
-            brightness  // brightness dinàmica
-        );
     }
-}
 
 }  // namespace Graphics

source/core/graphics/starfield.hpp

@@ -1,83 +1,72 @@
-// starfield.hpp - Sistema de estrelles de fons con efecte de profunditat
+// starfield.hpp - Camp d'estrelles 3D per a l'escena de títol
 // © 2026 JailDesigner
+//
+// Cada estrella és un octaedre
+// wireframe situat en l'espai mundial (Vec3). Es desplacen cap a la càmera
+// (Z disminueix); quan creuen el pla Z_NEAR_RESPAWN es regeneren a Z_FAR_SPAWN
+// amb X/Y aleatori. Cada octaedre rota lentament sobre Y i X per donar volum.
 
 #pragma once
 
-#include "core/rendering/render_context.hpp"
-
 #include <SDL3/SDL.h>
 
-#include <memory>
 #include <vector>
 
-#include "core/graphics/shape.hpp"
+#include "core/graphics/camera3d.hpp"
+#include "core/graphics/wireframe3d.hpp"
+#include "core/rendering/render_context.hpp"
 #include "core/types.hpp"
 
 namespace Graphics {
 
-// Configuración per cada capa de profunditat
+    class Starfield {
-struct CapaConfig {
-        float velocitat_base;  // Velocidad base de esta capa (px/s)
-        float escala_min;      // Escala mínima prop del centro
-        float escala_max;      // Escala màxima al límit de pantalla
-        int num_estrelles;     // Nombre de estrelles en esta capa
-};
-
-// Clase Starfield - camp de estrelles animat con efecte de profunditat
-class Starfield {
        public:
-        // Constructor
+        Starfield(Rendering::Renderer* renderer, const Camera3D* camera, int density = 200);
-        // - renderer: SDL renderer
-        // - punt_fuga: point de origin/fuga des de on surten las estrelles
-        // - area: rectangle on actuen las estrelles (SDL_FRect)
-        // - densitat: nombre total de estrelles (es divideix entre capes)
-        Starfield(Rendering::Renderer* renderer,
-            const Vec2& punt_fuga,
-            const SDL_FRect& area,
-            int densitat = 150);
 
-        // Actualitzar posicions de las estrelles
         void update(float delta_time);
+        void draw() const;
 
-        // Dibuixar todas las estrelles
-        void draw();
-
-        // Setters per ajustar parámetros en time real
-        void setVanishingPoint(const Vec2& point) { punt_fuga_ = point; }
         void setBrightness(float multiplier);
+        void setColor(SDL_Color color);
 
        private:
-        // Estructura interna per cada estrella
+        struct Star {
-        struct Estrella {
+            Vec3 position{};
-                Vec2 position;            // Posición actual
+            float velocity_z{0.0F};  // Negatiu: cap a càmera
-                float angle;             // Angle de movement (radians)
+            float rot_phase_y{0.0F};
-                float distancia_centre;  // Distancia normalitzada del centro (0.0-1.0)
+            float rot_phase_x{0.0F};
-                int capa;                // Índex de capa (0=lluny, 1=mitjà, 2=prop)
+            float rot_speed_y{0.0F};
+            float rot_speed_x{0.0F};
+            float scale{1.0F};
         };
 
-        // Inicialitzar una estrella (nueva o regenerada)
+        static void initStar(Star& star, bool spawn_at_far);
-        void initStar(Estrella& estrella) const;
+        [[nodiscard]] auto computeBrightness(const Star& star) const -> float;
 
-        // Verificar si una estrella está fuera de l'àrea
-        [[nodiscard]] auto isOutsideArea(const Estrella& estrella) const -> bool;
-
-        // Calcular scale dinàmica segons distancia del centro
-        [[nodiscard]] auto computeScale(const Estrella& estrella) const -> float;
-
-        // Calcular brightness dinàmica segons distancia del centro
-        [[nodiscard]] auto computeBrightness(const Estrella& estrella) const -> float;
-
-        // Dades
-        std::vector<Estrella> estrelles_;
-        std::vector<CapaConfig> capes_;  // Configuración de las 3 capes
-        std::shared_ptr<Shape> shape_estrella_;
         Rendering::Renderer* renderer_;
+        const Camera3D* camera_;
+        std::vector<Star> stars_;
+        Mesh3D octahedron_;
+        float brightness_mult_{1.0F};
+        SDL_Color color_{.r = 0, .g = 0, .b = 0, .a = 0};  // alpha=0 → usa color global
 
-        // Configuración
+        // Volum de spawn / regeneració en l'espai 3D.
-        Vec2 punt_fuga_;                        // Vec2 de origin de las estrelles
+        static constexpr float Z_NEAR_RESPAWN = 5.0F;  // Si Z < aquest valor → regenera
-        SDL_FRect area_;                        // Àrea activa
+        static constexpr float Z_FAR_SPAWN = 1500.0F;  // Z de regeneració (lluny — més profunditat)
-        float radi_max_;                        // Distancia màxima del centro al límit de pantalla
+        static constexpr float HALF_SPAWN_X = 900.0F;  // X aleatori dins [-, +]
-        float multiplicador_brightness_{1.0F};  // Multiplicador de brightness (1.0 = default)
+        static constexpr float HALF_SPAWN_Y = 540.0F;  // Y aleatori dins [-, +]
-};
+
+        // Mida i moviment.
+        static constexpr float STAR_BASE_SCALE = 1.8F;
+        static constexpr float STAR_SCALE_JITTER = 0.6F;
+        static constexpr float MIN_VELOCITY_Z = 80.0F;
+        static constexpr float MAX_VELOCITY_Z = 200.0F;
+        static constexpr float MIN_ROT_SPEED = 0.2F;
+        static constexpr float MAX_ROT_SPEED = 0.8F;
+
+        // Brightness en funció de la distància Z (a prop = més brillant).
+        static constexpr float BRIGHTNESS_FAR = 0.15F;
+        static constexpr float BRIGHTNESS_NEAR = 1.0F;
+    };
 
 }  // namespace Graphics

source/core/graphics/starfield3d.cpp

@@ -1,105 +0,0 @@
-// starfield3d.cpp - Implementació del starfield 3D
-// © 2026 JailDesigner
-
-#include "core/graphics/starfield3d.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-
-#include "core/defaults.hpp"
-
-namespace Graphics {
-
-    namespace {
-
-        // Helper: número aleatori en [0, 1) usant rand()/RAND_MAX (mateixa convenció
-        // que la resta del joc — veure starfield.cpp).
-        auto randFloat01() -> float {
-            return static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
-        }
-
-        auto randRange(float lo, float hi) -> float {
-            return lo + (randFloat01() * (hi - lo));
-        }
-
-    }  // namespace
-
-    Starfield3D::Starfield3D(Rendering::Renderer* renderer, const Camera3D* camera, int density)
-        : renderer_(renderer),
-          camera_(camera),
-          octahedron_(makeOctahedron()) {
-        stars_.resize(static_cast<std::size_t>(std::max(0, density)));
-        for (auto& star : stars_) {
-            // Pre-omplir amb estrelles distribuïdes per tot el rang Z, no només al far.
-            initStar(star, /*spawn_at_far=*/false);
-        }
-    }
-
-    void Starfield3D::initStar(Star& star, bool spawn_at_far) {
-        star.position.x = randRange(-HALF_SPAWN_X, HALF_SPAWN_X);
-        star.position.y = randRange(-HALF_SPAWN_Y, HALF_SPAWN_Y);
-        star.position.z = spawn_at_far
-            ? Z_FAR_SPAWN
-            : randRange(Z_NEAR_RESPAWN, Z_FAR_SPAWN);
-
-        star.velocity_z = -randRange(MIN_VELOCITY_Z, MAX_VELOCITY_Z);
-        star.rot_phase_y = randFloat01() * Defaults::Math::PI * 2.0F;
-        star.rot_phase_x = randFloat01() * Defaults::Math::PI * 2.0F;
-        star.rot_speed_y = randRange(MIN_ROT_SPEED, MAX_ROT_SPEED);
-        star.rot_speed_x = randRange(MIN_ROT_SPEED, MAX_ROT_SPEED);
-        star.scale = STAR_BASE_SCALE + (randRange(-1.0F, 1.0F) * STAR_SCALE_JITTER);
-    }
-
-    auto Starfield3D::computeBrightness(const Star& star) const -> float {
-        // Lerp segons distància Z normalitzada [Z_NEAR_RESPAWN .. Z_FAR_SPAWN].
-        const float SPAN = Z_FAR_SPAWN - Z_NEAR_RESPAWN;
-        const float T_RAW = (star.position.z - Z_NEAR_RESPAWN) / SPAN;
-        const float T = std::clamp(T_RAW, 0.0F, 1.0F);
-        const float BRIGHTNESS = BRIGHTNESS_NEAR + (T * (BRIGHTNESS_FAR - BRIGHTNESS_NEAR));
-        return std::clamp(BRIGHTNESS * brightness_mult_, 0.0F, 1.0F);
-    }
-
-    void Starfield3D::update(float delta_time) {
-        for (auto& star : stars_) {
-            star.position.z += star.velocity_z * delta_time;
-            star.rot_phase_y += star.rot_speed_y * delta_time;
-            star.rot_phase_x += star.rot_speed_x * delta_time;
-
-            if (star.position.z < Z_NEAR_RESPAWN) {
-                initStar(star, /*spawn_at_far=*/true);
-            }
-        }
-    }
-
-    void Starfield3D::draw() const {
-        if (camera_ == nullptr || renderer_ == nullptr) {
-            return;
-        }
-        // Ordena de més lluny a més a prop perquè el blending additiu acumule
-        // brightness sense que els elements de davant queden tapats pels de
-        // darrere. Còpia d'índexs per no modificar l'ordre intern de stars_.
-        std::vector<std::size_t> order(stars_.size());
-        for (std::size_t i = 0; i < order.size(); ++i) {
-            order[i] = i;
-        }
-        std::ranges::sort(order, [&](std::size_t a, std::size_t b) {
-            return stars_[a].position.z > stars_[b].position.z;
-        });
-
-        for (std::size_t idx : order) {
-            const Star& star = stars_[idx];
-            const Transform3D TRANSFORM{
-                .position = star.position,
-                .rotation_euler = Vec3{.x = star.rot_phase_x, .y = star.rot_phase_y, .z = 0.0F},
-                .scale = star.scale,
-            };
-            drawWireframe(renderer_, *camera_, octahedron_, TRANSFORM, computeBrightness(star));
-        }
-    }
-
-    void Starfield3D::setBrightness(float multiplier) {
-        brightness_mult_ = std::max(0.0F, multiplier);
-    }
-
-}  // namespace Graphics

source/core/graphics/starfield3d.hpp

@@ -1,68 +0,0 @@
-// starfield3d.hpp - Camp de estrelles 3D real per a l'escena de títol
-// © 2026 JailDesigner
-//
-// Equivalent 3D del `Graphics::Starfield`. Cada estrella és un octaedre
-// wireframe situat en l'espai mundial (Vec3). Es desplacen cap a la càmera
-// (Z disminueix); quan creuen el pla Z_NEAR_RESPAWN es regeneren a Z_FAR_SPAWN
-// amb X/Y aleatori. Cada octaedre rota lentament sobre Y i X per donar volum.
-
-#pragma once
-
-#include <vector>
-
-#include "core/graphics/camera3d.hpp"
-#include "core/graphics/wireframe3d.hpp"
-#include "core/rendering/render_context.hpp"
-#include "core/types.hpp"
-
-namespace Graphics {
-
-    class Starfield3D {
-       public:
-        Starfield3D(Rendering::Renderer* renderer, const Camera3D* camera, int density = 200);
-
-        void update(float delta_time);
-        void draw() const;
-
-        void setBrightness(float multiplier);
-
-       private:
-        struct Star {
-            Vec3 position{};
-            float velocity_z{0.0F};  // Negatiu: cap a càmera
-            float rot_phase_y{0.0F};
-            float rot_phase_x{0.0F};
-            float rot_speed_y{0.0F};
-            float rot_speed_x{0.0F};
-            float scale{1.0F};
-        };
-
-        static void initStar(Star& star, bool spawn_at_far);
-        [[nodiscard]] auto computeBrightness(const Star& star) const -> float;
-
-        Rendering::Renderer* renderer_;
-        const Camera3D* camera_;
-        std::vector<Star> stars_;
-        Mesh3D octahedron_;
-        float brightness_mult_{1.0F};
-
-        // Volum de spawn / regeneració en l'espai 3D.
-        static constexpr float Z_NEAR_RESPAWN = 5.0F;  // Si Z < aquest valor → regenera
-        static constexpr float Z_FAR_SPAWN = 800.0F;   // Z de regeneració (lluny)
-        static constexpr float HALF_SPAWN_X = 600.0F;  // X aleatori dins [-, +]
-        static constexpr float HALF_SPAWN_Y = 360.0F;  // Y aleatori dins [-, +]
-
-        // Mida i moviment.
-        static constexpr float STAR_BASE_SCALE = 1.8F;
-        static constexpr float STAR_SCALE_JITTER = 0.6F;
-        static constexpr float MIN_VELOCITY_Z = 80.0F;
-        static constexpr float MAX_VELOCITY_Z = 200.0F;
-        static constexpr float MIN_ROT_SPEED = 0.2F;
-        static constexpr float MAX_ROT_SPEED = 0.8F;
-
-        // Brightness en funció de la distància Z (a prop = més brillant).
-        static constexpr float BRIGHTNESS_FAR = 0.15F;
-        static constexpr float BRIGHTNESS_NEAR = 1.0F;
-    };
-
-}  // namespace Graphics

source/core/graphics/starfield_parallax.cpp

@@ -0,0 +1,140 @@
+// starfield_parallax.cpp - Implementació del starfield 2D amb parallax
+// © 2026 JailDesigner
+
+#include "core/graphics/starfield_parallax.hpp"
+
+#include <cstdlib>
+
+#include "core/defaults.hpp"
+#include "core/rendering/line_renderer.hpp"
+
+namespace Graphics {
+
+    namespace {
+
+        auto randUniform(float min_v, float max_v) -> float {
+            const float NORM = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);
+            return min_v + (NORM * (max_v - min_v));
+        }
+
+    }  // namespace
+
+    StarfieldParallax::StarfieldParallax(Rendering::Renderer* renderer)
+        : renderer_(renderer) {
+        buildStars();
+    }
+
+    void StarfieldParallax::buildStars() {
+        const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
+        const float MIN_X = zone.x;
+        const float MAX_X = zone.x + zone.w;
+        const float MIN_Y = zone.y;
+        const float MAX_Y = zone.y + zone.h;
+
+        // Color únic per a totes les estrelles: el mateix blanc-blau gel
+        // del starfield del títol (Defaults::Title::Colors::STARFIELD).
+        const auto FILL_LAYER = [&](int layer, int count, int& idx) {
+            for (int i = 0; i < count; i++) {
+                stars_[idx++] = Star{
+                    .x = randUniform(MIN_X, MAX_X),
+                    .y = randUniform(MIN_Y, MAX_Y),
+                    .layer = layer,
+                    .color = Defaults::Title::Colors::STARFIELD};
+            }
+        };
+
+        int idx = 0;
+        FILL_LAYER(0, Defaults::StarfieldParallax::Far::COUNT, idx);
+        FILL_LAYER(1, Defaults::StarfieldParallax::Mid::COUNT, idx);
+        FILL_LAYER(2, Defaults::StarfieldParallax::Near::COUNT, idx);
+    }
+
+    auto StarfieldParallax::layerBrightness(int layer) -> float {
+        switch (layer) {
+            case 0:
+                return Defaults::StarfieldParallax::Far::BRIGHTNESS;
+            case 1:
+                return Defaults::StarfieldParallax::Mid::BRIGHTNESS;
+            case 2:
+                return Defaults::StarfieldParallax::Near::BRIGHTNESS;
+            default:
+                return 0.0F;
+        }
+    }
+
+    auto StarfieldParallax::layerParallax(int layer) -> float {
+        switch (layer) {
+            case 0:
+                return Defaults::StarfieldParallax::Far::PARALLAX_FACTOR;
+            case 1:
+                return Defaults::StarfieldParallax::Mid::PARALLAX_FACTOR;
+            case 2:
+                return Defaults::StarfieldParallax::Near::PARALLAX_FACTOR;
+            default:
+                return 0.0F;
+        }
+    }
+
+    auto StarfieldParallax::layerSize(int layer) -> int {
+        switch (layer) {
+            case 0:
+                return Defaults::StarfieldParallax::Far::SIZE_PX;
+            case 1:
+                return Defaults::StarfieldParallax::Mid::SIZE_PX;
+            case 2:
+                return Defaults::StarfieldParallax::Near::SIZE_PX;
+            default:
+                return 1;
+        }
+    }
+
+    void StarfieldParallax::update(float delta_time, Vec2 world_velocity) {
+        const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
+        const float MIN_X = zone.x;
+        const float MAX_X = zone.x + zone.w;
+        const float MIN_Y = zone.y;
+        const float MAX_Y = zone.y + zone.h;
+        const float W = zone.w;
+        const float H = zone.h;
+
+        for (auto& star : stars_) {
+            const float FACTOR = layerParallax(star.layer);
+            star.x += world_velocity.x * FACTOR * delta_time;
+            star.y += world_velocity.y * FACTOR * delta_time;
+
+            // Wraparound (PLAYAREA torica).
+            while (star.x < MIN_X) {
+                star.x += W;
+            }
+            while (star.x > MAX_X) {
+                star.x -= W;
+            }
+            while (star.y < MIN_Y) {
+                star.y += H;
+            }
+            while (star.y > MAX_Y) {
+                star.y -= H;
+            }
+        }
+    }
+
+    void StarfieldParallax::draw() const {
+        for (const auto& star : stars_) {
+            const float B = layerBrightness(star.layer);
+            const int SIZE = layerSize(star.layer);
+            const int X = static_cast<int>(star.x);
+            const int Y = static_cast<int>(star.y);
+
+            if (SIZE <= 1) {
+                // Punt d'1 px: línia degenerada horitzontal de 1 px.
+                Rendering::linea(renderer_, X, Y, X + 1, Y, B, 0.0F, star.color);
+            } else {
+                // Creu "+" amb extensió HALF des del centre en cada direcció.
+                const int HALF = SIZE - 1;  // SIZE=2 → ±1 (creu 3x3); SIZE=3 → ±2 (creu 5x5)
+                Rendering::linea(renderer_, X - HALF, Y, X + HALF + 1, Y, B, 0.0F, star.color);
+                Rendering::linea(renderer_, X, Y - HALF, X, Y + HALF + 1, B, 0.0F, star.color);
+            }
+        }
+    }
+
+}  // namespace Graphics

source/core/graphics/starfield_parallax.hpp

@@ -0,0 +1,51 @@
+// starfield_parallax.hpp - Capa més profunda del fons: estrelles 2D amb parallax
+// © 2026 JailDesigner
+//
+// Estrelles 2D distribuïdes en 3 capes de profunditat. Cada capa té el seu
+// factor parallax: el "món" es desplaça amb world_velocity i les estrelles
+// d'una capa es mouen amb world_velocity * parallax_factor. Les més
+// properes es mouen més (factor alt) → sensació de profunditat.
+// Quan una estrella surt de PLAYAREA, reapareix per la banda oposada
+// (wraparound).
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <array>
+
+#include "core/defaults/starfield_parallax.hpp"
+#include "core/rendering/render_context.hpp"
+#include "core/types.hpp"
+
+namespace Graphics {
+
+    class StarfieldParallax {
+       public:
+        explicit StarfieldParallax(Rendering::Renderer* renderer);
+
+        // Avança el desplaçament de les estrelles segons world_velocity (vector
+        // del moviment del món en px/s; típicament = -ship_velocity).
+        // world_velocity == {0, 0} → estrelles quietes.
+        void update(float delta_time, Vec2 world_velocity);
+
+        void draw() const;
+
+       private:
+        struct Star {
+            float x{0.0F};
+            float y{0.0F};
+            int layer{0};       // 0=Far, 1=Mid, 2=Near
+            SDL_Color color{};  // tint precomputat entre blanc i cyan
+        };
+
+        void buildStars();
+        static auto layerBrightness(int layer) -> float;
+        static auto layerParallax(int layer) -> float;
+        static auto layerSize(int layer) -> int;
+
+        Rendering::Renderer* renderer_;
+        std::array<Star, Defaults::StarfieldParallax::TOTAL_COUNT> stars_{};
+    };
+
+}  // namespace Graphics

source/core/graphics/vector_text.cpp

@@ -47,7 +47,7 @@ namespace Graphics {
         }
 
         // Cargar símbolos
-        const std::string SYMBOLS[] = {".", ",", "-", ":", "!", "?"};
+        const std::string SYMBOLS[] = {".", ",", "-", ":", "!", "?", "/", "(", ")"};
         for (const auto& sym : SYMBOLS) {
             char c = sym[0];
             std::string filename = getShapeFilename(c);
@@ -164,6 +164,12 @@ namespace Graphics {
                 return "font/char_exclamation.shp";
             case '?':
                 return "font/char_question.shp";
+            case '/':
+                return "font/char_slash.shp";
+            case '(':
+                return "font/char_lparen.shp";
+            case ')':
+                return "font/char_rparen.shp";
             case ' ':
                 return "";  // Espai es maneja sin load shape
 
@@ -221,7 +227,8 @@ namespace Graphics {
                 // Ajustar X e Y para que position represente esquina superior izquierda
                 // (render_shape espera el centro, así que sumamos la mitad de ancho y altura)
                 Vec2 char_pos = {.x = current_x + (CHAR_WIDTH_SCALED / 2.0F), .y = position.y + (CHAR_HEIGHT_SCALED / 2.0F)};
-                Rendering::renderShape(renderer_, it->second, char_pos, 0.0F, scale, 1.0F, brightness, color);
+                // Text opt-out del glow: HUD/marker s'ha de mantenir net.
+                Rendering::renderShape(renderer_, it->second, char_pos, 0.0F, scale, 1.0F, brightness, color, 0.0F, 1.0F, /*glow=*/false);
 
                 // Avanzar posición
                 current_x += CHAR_WIDTH_SCALED + SPACING_SCALED;
@@ -234,19 +241,19 @@ namespace Graphics {
         }
     }
 
-    void VectorText::renderCentered(const std::string& text, const Vec2& centre_punt, float scale, float spacing, float brightness, SDL_Color color) const {
+    void VectorText::renderCentered(const std::string& text, const Vec2& centre_point, float scale, float spacing, float brightness, SDL_Color color) const {
         // Calcular dimensions del text
         float text_width = getTextWidth(text, scale, spacing);
         float text_height = getTextHeight(scale);
 
         // Calcular posición de l'esquina superior izquierda
         // restant la meitat de las dimensions del point central
-        Vec2 posicio_esquerra = {
+        Vec2 top_left_position = {
-            .x = centre_punt.x - (text_width / 2.0F),
+            .x = centre_point.x - (text_width / 2.0F),
-            .y = centre_punt.y - (text_height / 2.0F)};
+            .y = centre_point.y - (text_height / 2.0F)};
 
         // Delegar al método render() existent
-        render(text, posicio_esquerra, scale, spacing, brightness, color);
+        render(text, top_left_position, scale, spacing, brightness, color);
     }
 
     auto VectorText::getTextWidth(const std::string& text, float scale, float spacing) -> float {

source/core/graphics/vector_text.hpp

@@ -21,7 +21,7 @@ namespace Graphics {
 
         // Renderizar string completo
         // - text: cadena a renderizar (soporta: A-Z, a-z, 0-9, '.', ',', '-', ':',
-        // '!', '?', ' ')
+        // '!', '?', '/', '(', ')', ' ')
         // - position: posición inicial (esquina superior izquierda)
         // - scale: factor de scale (1.0 = 20×40 px por carácter)
         // - spacing: espacio entre caracteres en píxeles (a scale 1.0)
@@ -31,12 +31,12 @@ namespace Graphics {
 
         // Renderizar string centrado en un punto
         // - text: cadena a renderizar
-        // - centre_punt: punto central del texto (no esquina superior izquierda)
+        // - centre_point: punto central del texto (no esquina superior izquierda)
         // - scale: factor de scale (1.0 = 20×40 px por carácter)
         // - spacing: espacio entre caracteres en píxeles (a scale 1.0)
         // - brightness: factor de brightness (0.0-1.0, default 1.0 = màxima brightness)
         // - color: color RGBA explícit; si alpha==0 (default) s'usa l'oscil·lador global
-        void renderCentered(const std::string& text, const Vec2& centre_punt, float scale = 1.0F, float spacing = 2.0F, float brightness = 1.0F, SDL_Color color = {0, 0, 0, 0}) const;
+        void renderCentered(const std::string& text, const Vec2& centre_point, float scale = 1.0F, float spacing = 2.0F, float brightness = 1.0F, SDL_Color color = {0, 0, 0, 0}) const;
 
         // Calcular ancho total de un string (útil para centrado).
         // Es estático: no depende del estado del VectorText (el ancho viene de

source/core/input/define_inputs.cpp

@@ -0,0 +1,405 @@
+// define_inputs.cpp - Implementacio de l'overlay modal de redefinicio
+// © 2026 JailDesigner
+
+#include "core/input/define_inputs.hpp"
+
+#include <algorithm>
+#include <format>
+#include <string>
+#include <vector>
+
+#include "core/audio/audio.hpp"
+#include "core/defaults/service_menu.hpp"
+#include "core/input/input.hpp"
+#include "core/locale/locale.hpp"
+#include "core/types.hpp"
+#include "game/config_yaml.hpp"
+
+namespace {
+
+    constexpr float CANVAS_W = 1280.0F;
+    constexpr float CANVAS_H = 720.0F;
+
+    // Llindar de trigger per a edge-detect L2/R2 com a boto virtual.
+    constexpr Sint16 TRIGGER_THRESHOLD = 16384;
+
+    // Codis virtuals per als triggers (consistents amb input_types.cpp).
+    constexpr int TRIGGER_L2_VIRTUAL = 100;
+    constexpr int TRIGGER_R2_VIRTUAL = 101;
+
+    // Durada del missatge de confirmacio abans de tancar-se.
+    constexpr float COMPLETE_DISPLAY_S = 1.5F;
+
+    // Llindar dpad als axis sticks: no es captura per evitar conflicte amb el
+    // moviment LEFT/RIGHT/UP/DOWN (que es presuposen no redefinibles al mando).
+    constexpr Sint16 STICK_THRESHOLD = 16384;
+
+    // Crida pushRect amb un SDL_Color (les components s'escalen a [0..1]).
+    void fillRect(Rendering::Renderer* renderer, float x, float y, float w, float h, SDL_Color color) {
+        renderer->pushRect(x, y, w, h, static_cast<float>(color.r) / 255.0F, static_cast<float>(color.g) / 255.0F, static_cast<float>(color.b) / 255.0F, static_cast<float>(color.a) / 255.0F);
+    }
+
+    auto titleKey(System::DefineInputs::Mode mode, System::DefineInputs::Player player) -> std::string {
+        const bool IS_KB = (mode == System::DefineInputs::Mode::KEYBOARD);
+        const bool IS_P1 = (player == System::DefineInputs::Player::P1);
+        if (IS_KB && IS_P1) {
+            return "define.title_keyboard_p1";
+        }
+        if (IS_KB) {
+            return "define.title_keyboard_p2";
+        }
+        if (IS_P1) {
+            return "define.title_gamepad_p1";
+        }
+        return "define.title_gamepad_p2";
+    }
+
+    // Scancodes que MAI capturem com a binding (reservats per a navegacio o
+    // global hotkeys). Tornen true → handleEvent les deixa passar al pipeline
+    // global perque facin la seua feina (ESC obre el prompt d'eixida, F1-F12
+    // son hotkeys de sistema, RETURN/BACKSPACE/TAB son navegacio).
+    auto isReservedScancode(SDL_Scancode sc) -> bool {
+        if (sc == SDL_SCANCODE_ESCAPE) {
+            return true;
+        }
+        if (sc >= SDL_SCANCODE_F1 && sc <= SDL_SCANCODE_F12) {
+            return true;
+        }
+        if (sc == SDL_SCANCODE_RETURN || sc == SDL_SCANCODE_KP_ENTER) {
+            return true;
+        }
+        if (sc == SDL_SCANCODE_BACKSPACE || sc == SDL_SCANCODE_TAB) {
+            return true;
+        }
+        return false;
+    }
+
+    // Conversio sense pèrdua de SDL_Scancode → int per a comparacions
+    // homogenies dins de sequence_ (que guarda codis de tots dos modes).
+    auto scancodeToInt(SDL_Scancode sc) -> int {
+        return static_cast<int>(sc);
+    }
+
+}  // namespace
+
+namespace System {
+
+    std::unique_ptr<DefineInputs> DefineInputs::instance;
+
+    void DefineInputs::init(Rendering::Renderer* renderer) {
+        if (!instance) {
+            instance = std::unique_ptr<DefineInputs>(new DefineInputs(renderer));
+        }
+    }
+
+    void DefineInputs::destroy() { instance.reset(); }
+
+    auto DefineInputs::get() -> DefineInputs* { return instance.get(); }
+
+    DefineInputs::DefineInputs(Rendering::Renderer* renderer)
+        : renderer_(renderer),
+          text_(renderer) {}
+
+    auto DefineInputs::isActive() const -> bool {
+        return phase_ != Phase::INACTIVE;
+    }
+
+    auto DefineInputs::begin(Mode mode, Player player) -> bool {
+        if (mode == Mode::GAMEPAD) {
+            // Requereix un pad assignat al jugador.
+            const auto* input = Input::get();
+            if (input == nullptr) {
+                return false;
+            }
+            const int IDX = (player == Player::P1) ? 0 : 1;
+            if (input->getPlayerGamepad(IDX) == nullptr) {
+                return false;
+            }
+        }
+
+        mode_ = mode;
+        player_ = player;
+        index_ = 0;
+        complete_timer_s_ = 0.0F;
+        l2_was_pressed_ = false;
+        r2_was_pressed_ = false;
+
+        buildSequence();
+        phase_ = Phase::CAPTURING;
+        return true;
+    }
+
+    void DefineInputs::cancel() {
+        phase_ = Phase::INACTIVE;
+        sequence_.clear();
+        index_ = 0;
+        complete_timer_s_ = 0.0F;
+    }
+
+    void DefineInputs::buildSequence() {
+        sequence_.clear();
+        if (mode_ == Mode::KEYBOARD) {
+            // Teclat: LEFT, RIGHT, FIRE (SHOOT), ACCELERATE (THRUST)
+            sequence_.push_back({.action_label_key = "define.action.left", .action = InputAction::LEFT, .captured = -1});
+            sequence_.push_back({.action_label_key = "define.action.right", .action = InputAction::RIGHT, .captured = -1});
+            sequence_.push_back({.action_label_key = "define.action.fire", .action = InputAction::SHOOT, .captured = -1});
+            sequence_.push_back({.action_label_key = "define.action.accelerate", .action = InputAction::THRUST, .captured = -1});
+        } else {
+            // Mando: FIRE, ACCELERATE, START, MENU
+            sequence_.push_back({.action_label_key = "define.action.fire", .action = InputAction::SHOOT, .captured = -1});
+            sequence_.push_back({.action_label_key = "define.action.accelerate", .action = InputAction::THRUST, .captured = -1});
+            sequence_.push_back({.action_label_key = "define.action.start", .action = InputAction::START, .captured = -1});
+            sequence_.push_back({.action_label_key = "define.action.menu", .action = InputAction::MENU, .captured = -1});
+        }
+    }
+
+    auto DefineInputs::isInUse(int code) const -> bool {
+        return std::ranges::any_of(sequence_, [code](const Step& s) {
+            return s.captured == code;
+        });
+    }
+
+    void DefineInputs::captureAndAdvance(int code) {
+        if (index_ >= sequence_.size()) {
+            return;
+        }
+        if (isInUse(code)) {
+            return;  // Duplicat dins de la sessio: rebutgem silenciosament
+        }
+        sequence_[index_].captured = code;
+        ++index_;
+        if (auto* audio = Audio::get(); audio != nullptr) {
+            audio->playSound(Defaults::ServiceMenu::ACCEPT_SOUND, Audio::Group::INTERFACE);
+        }
+        if (index_ >= sequence_.size()) {
+            persistAndComplete();
+        }
+    }
+
+    void DefineInputs::persistAndComplete() {
+        auto& cfg = (player_ == Player::P1)
+            ? ConfigYaml::engine_config.player1
+            : ConfigYaml::engine_config.player2;
+
+        if (mode_ == Mode::KEYBOARD) {
+            for (const Step& s : sequence_) {
+                switch (s.action) {
+                    case InputAction::LEFT:
+                        cfg.keyboard.key_left = static_cast<SDL_Scancode>(s.captured);
+                        break;
+                    case InputAction::RIGHT:
+                        cfg.keyboard.key_right = static_cast<SDL_Scancode>(s.captured);
+                        break;
+                    case InputAction::SHOOT:
+                        cfg.keyboard.key_shoot = static_cast<SDL_Scancode>(s.captured);
+                        break;
+                    case InputAction::THRUST:
+                        cfg.keyboard.key_thrust = static_cast<SDL_Scancode>(s.captured);
+                        break;
+                    default:
+                        break;  // START / MENU no es redefineixen al teclat
+                }
+            }
+        } else {
+            for (const Step& s : sequence_) {
+                switch (s.action) {
+                    case InputAction::SHOOT:
+                        cfg.gamepad.button_shoot = s.captured;
+                        break;
+                    case InputAction::THRUST:
+                        cfg.gamepad.button_thrust = s.captured;
+                        break;
+                    case InputAction::START:
+                        cfg.gamepad.button_start = s.captured;
+                        break;
+                    case InputAction::MENU:
+                        cfg.gamepad.button_menu = s.captured;
+                        break;
+                    default:
+                        break;  // LEFT / RIGHT no es redefineixen al mando
+                }
+            }
+        }
+
+        // Aplicar canvis al runtime de l'Input i persistir a disc.
+        if (auto* input = Input::get(); input != nullptr) {
+            if (player_ == Player::P1) {
+                input->applyPlayer1Bindings(ConfigYaml::engine_config.player1);
+            } else {
+                input->applyPlayer2Bindings(ConfigYaml::engine_config.player2);
+            }
+        }
+        ConfigYaml::saveToFile();
+
+        phase_ = Phase::COMPLETE;
+        complete_timer_s_ = COMPLETE_DISPLAY_S;
+    }
+
+    void DefineInputs::update(float delta_time) {
+        if (phase_ != Phase::COMPLETE) {
+            return;
+        }
+        complete_timer_s_ -= delta_time;
+        if (complete_timer_s_ <= 0.0F) {
+            cancel();
+        }
+    }
+
+    void DefineInputs::processTrigger(int virtual_button, bool& was_pressed, bool now) {
+        if (now && !was_pressed) {
+            captureAndAdvance(virtual_button);
+        }
+        was_pressed = now;
+    }
+
+    auto DefineInputs::handleKeyboardEvent(const SDL_Event& event) -> bool {
+        if (event.type != SDL_EVENT_KEY_DOWN) {
+            return true;  // Empassem la resta sense fer res
+        }
+        const SDL_Scancode SC = event.key.scancode;
+        if (isReservedScancode(SC)) {
+            // ESC, F1-F12, RETURN, BACKSPACE, TAB es deixen passar al pipeline
+            // global (ESC obre el prompt d'eixida; F1-F12 hotkeys, etc.).
+            return false;
+        }
+        captureAndAdvance(scancodeToInt(SC));
+        return true;
+    }
+
+    auto DefineInputs::handleGamepadEvent(const SDL_Event& event) -> bool {
+        // KEY_DOWN no es per al rebind de mando: deixem que el global el
+        // gestioni (ex. ESC → prompt d'eixida, F12 → tanca menu, etc.).
+        if (event.type == SDL_EVENT_KEY_DOWN) {
+            return false;
+        }
+
+        // Filtrar events al pad del jugador actiu.
+        const auto* input = Input::get();
+        if (input == nullptr) {
+            return true;
+        }
+        const int IDX = (player_ == Player::P1) ? 0 : 1;
+        auto pad = input->getPlayerGamepad(IDX);
+        if (!pad) {
+            return true;
+        }
+
+        if (event.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+            if (event.gbutton.which != pad->instance_id) {
+                return true;
+            }
+            captureAndAdvance(static_cast<int>(event.gbutton.button));
+            return true;
+        }
+
+        if (event.type == SDL_EVENT_GAMEPAD_AXIS_MOTION) {
+            if (event.gaxis.which != pad->instance_id) {
+                return true;
+            }
+            const auto AXIS = static_cast<SDL_GamepadAxis>(event.gaxis.axis);
+            const Sint16 VAL = event.gaxis.value;
+            if (AXIS == SDL_GAMEPAD_AXIS_LEFT_TRIGGER) {
+                processTrigger(TRIGGER_L2_VIRTUAL, l2_was_pressed_, VAL >= TRIGGER_THRESHOLD);
+            } else if (AXIS == SDL_GAMEPAD_AXIS_RIGHT_TRIGGER) {
+                processTrigger(TRIGGER_R2_VIRTUAL, r2_was_pressed_, VAL >= TRIGGER_THRESHOLD);
+            }
+            // Sticks LEFTX/LEFTY/RIGHTX/RIGHTY: ignorats (no son redefinibles).
+            (void)STICK_THRESHOLD;
+            return true;
+        }
+
+        return true;
+    }
+
+    auto DefineInputs::handleEvent(const SDL_Event& event) -> bool {
+        if (phase_ == Phase::INACTIVE) {
+            return false;
+        }
+        // SDL_EVENT_QUIT i WINDOW_CLOSE_REQUESTED han de poder tancar la
+        // finestra encara que el modal estiga obert; els passem al pipeline.
+        if (event.type == SDL_EVENT_QUIT ||
+            event.type == SDL_EVENT_WINDOW_CLOSE_REQUESTED) {
+            return false;
+        }
+        if (phase_ == Phase::COMPLETE) {
+            // Mentre mostrem el missatge OK, empassem la resta d'events sense
+            // capturar perque l'usuari no puga avançar accions sense voler.
+            return true;
+        }
+        if (mode_ == Mode::KEYBOARD) {
+            return handleKeyboardEvent(event);
+        }
+        return handleGamepadEvent(event);
+    }
+
+    void DefineInputs::draw() const {
+        if (phase_ == Phase::INACTIVE) {
+            return;
+        }
+
+        using namespace Defaults::ServiceMenu;
+
+        // Caixa centrada, dimensions fixes (no depen del contingut a redefinir).
+        constexpr float BOX_W = 560.0F;
+        constexpr float BOX_H = 280.0F;
+        const float BOX_X = (CANVAS_W - BOX_W) * 0.5F;
+        const float BOX_Y = (CANVAS_H - BOX_H) * 0.5F;
+
+        // Fons + brackets als 4 cantons (estil HUD del menu de servei).
+        fillRect(renderer_, BOX_X, BOX_Y, BOX_W, BOX_H, BG_COLOR);
+
+        const auto T = static_cast<float>(CORNER_THICKNESS);
+        const auto AH = static_cast<float>(CORNER_ARM_H);
+        const auto AV = static_cast<float>(CORNER_ARM_V);
+        fillRect(renderer_, BOX_X, BOX_Y, AH, T, CORNER_COLOR);
+        fillRect(renderer_, BOX_X, BOX_Y, T, AV, CORNER_COLOR);
+        fillRect(renderer_, BOX_X + BOX_W - AH, BOX_Y, AH, T, CORNER_COLOR);
+        fillRect(renderer_, BOX_X + BOX_W - T, BOX_Y, T, AV, CORNER_COLOR);
+        fillRect(renderer_, BOX_X, BOX_Y + BOX_H - T, AH, T, CORNER_COLOR);
+        fillRect(renderer_, BOX_X, BOX_Y + BOX_H - AV, T, AV, CORNER_COLOR);
+        fillRect(renderer_, BOX_X + BOX_W - AH, BOX_Y + BOX_H - T, AH, T, CORNER_COLOR);
+        fillRect(renderer_, BOX_X + BOX_W - T, BOX_Y + BOX_H - AV, T, AV, CORNER_COLOR);
+
+        const std::string TITLE = Locale::get().text(titleKey(mode_, player_));
+        const float TITLE_W = Graphics::VectorText::getTextWidth(TITLE, TITLE_SCALE, TEXT_SPACING);
+        const float TITLE_X = BOX_X + ((BOX_W - TITLE_W) * 0.5F);
+        const float TITLE_Y = BOX_Y + 26.0F;
+        text_.render(TITLE, Vec2{.x = TITLE_X, .y = TITLE_Y}, TITLE_SCALE, TEXT_SPACING, 1.0F, TITLE_COLOR);
+
+        if (phase_ == Phase::COMPLETE) {
+            const std::string OK = Locale::get().text("define.complete");
+            constexpr float OK_SCALE = 0.7F;
+            const float OK_W = Graphics::VectorText::getTextWidth(OK, OK_SCALE, TEXT_SPACING);
+            const float OK_X = BOX_X + ((BOX_W - OK_W) * 0.5F);
+            const float OK_Y = BOX_Y + (BOX_H * 0.5F) - 10.0F;
+            constexpr SDL_Color OK_COLOR{.r = 120, .g = 255, .b = 140, .a = 255};
+            text_.render(OK, Vec2{.x = OK_X, .y = OK_Y}, OK_SCALE, TEXT_SPACING, 1.0F, OK_COLOR);
+            return;
+        }
+
+        // Instruccio (premeu tecla / boto) + accio actual + progres.
+        const std::string PROMPT = Locale::get().text(
+            mode_ == Mode::KEYBOARD ? "define.press_key" : "define.press_button");
+        const float PROMPT_W = Graphics::VectorText::getTextWidth(PROMPT, ITEM_SCALE, TEXT_SPACING);
+        const float PROMPT_X = BOX_X + ((BOX_W - PROMPT_W) * 0.5F);
+        const float PROMPT_Y = BOX_Y + 86.0F;
+        text_.render(PROMPT, Vec2{.x = PROMPT_X, .y = PROMPT_Y}, ITEM_SCALE, TEXT_SPACING, 1.0F, SUBTITLE_COLOR);
+
+        if (index_ < sequence_.size()) {
+            const std::string ACTION = Locale::get().text(sequence_[index_].action_label_key);
+            constexpr float ACTION_SCALE = 0.9F;
+            const float ACTION_W = Graphics::VectorText::getTextWidth(ACTION, ACTION_SCALE, TEXT_SPACING);
+            const float ACTION_X = BOX_X + ((BOX_W - ACTION_W) * 0.5F);
+            const float ACTION_Y = BOX_Y + 130.0F;
+            text_.render(ACTION, Vec2{.x = ACTION_X, .y = ACTION_Y}, ACTION_SCALE, TEXT_SPACING, 1.0F, CURSOR_COLOR);
+        }
+
+        const std::string PROGRESS = std::format("{}/{}", index_ + 1, sequence_.size());
+        constexpr float PROG_SCALE = 0.4F;
+        const float PROG_W = Graphics::VectorText::getTextWidth(PROGRESS, PROG_SCALE, TEXT_SPACING);
+        const float PROG_X = BOX_X + ((BOX_W - PROG_W) * 0.5F);
+        const float PROG_Y = BOX_Y + 200.0F;
+        text_.render(PROGRESS, Vec2{.x = PROG_X, .y = PROG_Y}, PROG_SCALE, TEXT_SPACING, 1.0F, LABEL_COLOR);
+    }
+
+}  // namespace System

source/core/input/define_inputs.hpp

@@ -0,0 +1,107 @@
+// define_inputs.hpp - Overlay modal de redefinici de controls (singleton)
+// © 2026 JailDesigner
+//
+// Sub-mòdul inspirat en aee_arcade/source/core/input/define_buttons. Quan el
+// menú de servei dispara una acció "Redefinir tecles/botons P1/P2", aquest
+// singleton pren el control: pinta una caixa central, captura events SDL i
+// avança per una seqüència fixa d'accions, persistint les noves assignacions
+// a config.yaml en acabar.
+//
+// Cicle de vida:
+//   1. begin(mode, player) → construeix la seqüència (4 passos) i activa
+//      l'overlay. Per a GAMEPAD, retorna false si el jugador no té pad.
+//   2. handleEvent() captura el següent event vàlid; ESC cancel·la sense
+//      desar; duplicats dins de la sessió es rebutgen silenciosament.
+//   3. Quan la seqüència es completa, persistim a engine_config + saveToFile,
+//      reapliquem els bindings i mostrem un missatge "OK" durant 1.5 s
+//      abans d'auto-tancar-se.
+//
+// El routing d'events es fa des de GlobalEvents::handle: mentre isActive()
+// retorna true, tots els events SDL es desvien aquí i no arriben al joc ni
+// al menú de servei.
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "core/graphics/vector_text.hpp"
+#include "core/input/input_types.hpp"
+#include "core/rendering/render_context.hpp"
+
+namespace System {
+
+    class DefineInputs {
+       public:
+        enum class Mode : std::uint8_t { KEYBOARD,
+            GAMEPAD };
+        enum class Player : std::uint8_t { P1,
+            P2 };
+
+        static void init(Rendering::Renderer* renderer);
+        static void destroy();
+        [[nodiscard]] static auto get() -> DefineInputs*;
+
+        // Comença la sessió. Retorna false per a GAMEPAD si el jugador no té
+        // cap pad assignat (el caller hauria de notificar a l'usuari abans).
+        auto begin(Mode mode, Player player) -> bool;
+        void cancel();
+
+        [[nodiscard]] auto isActive() const -> bool;
+
+        void update(float delta_time);
+        void draw() const;
+
+        // Retorna true si l'event s'ha consumit (és a dir, mentre l'overlay
+        // és actiu sempre consumeix tot per evitar passages al joc o menú).
+        auto handleEvent(const SDL_Event& event) -> bool;
+
+       private:
+        explicit DefineInputs(Rendering::Renderer* renderer);
+
+        enum class Phase : std::uint8_t {
+            INACTIVE,
+            CAPTURING,
+            COMPLETE,  // mostra missatge OK breu abans d'auto-cancel
+        };
+
+        struct Step {
+            std::string action_label_key;  // p.ex. "define.action.left"
+            InputAction action;            // mapeig a la struct PlayerBindings
+            int captured{-1};              // scancode o button code; -1 = sense capturar
+        };
+
+        void buildSequence();
+        [[nodiscard]] auto isInUse(int code) const -> bool;
+        void captureAndAdvance(int code);
+        void persistAndComplete();
+
+        // Handlers especialitzats segons mode_.
+        auto handleKeyboardEvent(const SDL_Event& event) -> bool;
+        auto handleGamepadEvent(const SDL_Event& event) -> bool;
+
+        // Edge-detect per als triggers L2/R2 com a botons virtuals.
+        void processTrigger(int virtual_button, bool& was_pressed, bool now);
+
+        Rendering::Renderer* renderer_;
+        Graphics::VectorText text_;
+
+        Phase phase_{Phase::INACTIVE};
+        Mode mode_{Mode::KEYBOARD};
+        Player player_{Player::P1};
+        std::vector<Step> sequence_;
+        std::size_t index_{0};
+        float complete_timer_s_{0.0F};
+
+        // Estat d'edge-detect dels triggers durant la sessió GAMEPAD.
+        bool l2_was_pressed_{false};
+        bool r2_was_pressed_{false};
+
+        static std::unique_ptr<DefineInputs> instance;
+    };
+
+}  // namespace System

source/core/input/input.cpp

@@ -8,6 +8,10 @@
 #include <unordered_map>  // Para unordered_map, _Node_iterator, operator==, _Node_iterator_base, _Node_const_iterator
 #include <utility>        // Para move
 
+#include "core/locale/locale.hpp"
+#include "core/system/notifier.hpp"
+#include "core/utils/string_utils.hpp"
+
 // Singleton
 Input* Input::instance = nullptr;
 
@@ -373,9 +377,25 @@ void Input::update() {
 
     // --- MANDOS ---
     for (const auto& gamepad : gamepads_) {
+        // LEFT i RIGHT NO son redefinibles al mando (assumits dpad o stick).
+        // Llegim el left stick X i el fusionem amb l'estat del dpad: qualsevol
+        // de les dos fonts activa l'accio. Llindar AXIS_THRESHOLD (30000).
+        const Sint16 STICK_X = SDL_GetGamepadAxis(gamepad->pad, SDL_GAMEPAD_AXIS_LEFTX);
+        const bool STICK_LEFT = STICK_X < -AXIS_THRESHOLD;
+        const bool STICK_RIGHT = STICK_X > AXIS_THRESHOLD;
+
         for (auto& binding : gamepad->bindings) {
             bool button_is_down_now = static_cast<int>(SDL_GetGamepadButton(gamepad->pad, static_cast<SDL_GamepadButton>(binding.second.button))) != 0;
 
+            // Per a LEFT/RIGHT, fer un OR amb el stick X. La resta d'accions
+            // (THRUST/SHOOT/START/MENU) ignoren el stick aqui — si es vol
+            // dispar amb trigger L2/R2 cal binding amb codi 100/101.
+            if (binding.first == Action::LEFT) {
+                button_is_down_now = button_is_down_now || STICK_LEFT;
+            } else if (binding.first == Action::RIGHT) {
+                button_is_down_now = button_is_down_now || STICK_RIGHT;
+            }
+
             // El estado .is_held del fotograma anterior nos sirve para saber si es un pulso nuevo
             binding.second.just_pressed = button_is_down_now && !binding.second.is_held;
             binding.second.is_held = button_is_down_now;
@@ -407,6 +427,16 @@ auto Input::addGamepad(int device_index) -> std::string {
     auto name = gamepad->name;
     std::cout << "Gamepad connected (" << name << ")" << '\n';
     gamepads_.push_back(std::move(gamepad));
+
+    // Toast a pantalla. Pot ser nullptr durant discoverGamepads() inicial
+    // (l'Input::init() es crida abans que el Director instanciï el Notifier).
+    if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
+        notifier->notifyInfo(localeSubstitute(
+            Locale::get().text("notification.gamepad_connected"),
+            "{name}",
+            Utils::toUpperAscii(name)));
+    }
+
     return name + " CONNECTED";
 }
 
@@ -419,6 +449,14 @@ auto Input::removeGamepad(SDL_JoystickID id) -> std::string {
         std::string name = (*it)->name;
         std::cout << "Gamepad disconnected (" << name << ")" << '\n';
         gamepads_.erase(it);
+
+        if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
+            notifier->notifyInfo(localeSubstitute(
+                Locale::get().text("notification.gamepad_disconnected"),
+                "{name}",
+                Utils::toUpperAscii(name)));
+        }
+
         return name + " DISCONNECTED";
     }
     std::cerr << "No se encontró el gamepad con ID " << id << '\n';
@@ -465,6 +503,33 @@ auto Input::findAvailableGamepadByName(const std::string& gamepad_name) -> std::
 
 // ========== MÉTODOS ESPECÍFICOS POR JUGADOR (ORNI) ==========
 
+// Cerca el gamepad assignat a un jugador. Prioritat path > name. Si els
+// dos camps venen buits o no n'hi ha cap match retornem nullptr (sense
+// mando explicit). L'autoassignacio inicial es resol al boot.
+auto Input::resolvePlayerGamepad(const Config::PlayerBindings& bindings) -> std::shared_ptr<Gamepad> {
+    if (gamepads_.empty()) {
+        return nullptr;
+    }
+
+    if (!bindings.gamepad_path.empty()) {
+        for (const auto& pad : gamepads_) {
+            if (pad && pad->path == bindings.gamepad_path) {
+                return pad;
+            }
+        }
+    }
+
+    if (!bindings.gamepad_name.empty()) {
+        for (const auto& pad : gamepads_) {
+            if (pad && pad->name == bindings.gamepad_name) {
+                return pad;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
 // Aplica configuración de controles del player 1
 void Input::applyPlayer1Bindings(const Config::PlayerBindings& bindings) {
     // 1. Aplicar bindings de teclado (NO usar bindKey, llenar mapa específico)
@@ -474,15 +539,8 @@ void Input::applyPlayer1Bindings(const Config::PlayerBindings& bindings) {
     player1_keyboard_bindings_[Action::SHOOT].scancode = bindings.keyboard.key_shoot;
     player1_keyboard_bindings_[Action::START].scancode = bindings.keyboard.key_start;
 
-    // 2. Encontrar gamepad por nombre (o usar primer gamepad como fallback)
+    // 2. Resoldre gamepad per path/name
-    std::shared_ptr<Gamepad> gamepad = nullptr;
+    std::shared_ptr<Gamepad> gamepad = resolvePlayerGamepad(bindings);
-    if (bindings.gamepad_name.empty()) {
-        // Fallback: usar primer gamepad disponible
-        gamepad = (!gamepads_.empty()) ? gamepads_[0] : nullptr;
-    } else {
-        // Buscar por nombre
-        gamepad = findAvailableGamepadByName(bindings.gamepad_name);
-    }
 
     if (!gamepad) {
         player1_gamepad_ = nullptr;
@@ -494,6 +552,8 @@ void Input::applyPlayer1Bindings(const Config::PlayerBindings& bindings) {
     gamepad->bindings[Action::RIGHT].button = bindings.gamepad.button_right;
     gamepad->bindings[Action::THRUST].button = bindings.gamepad.button_thrust;
     gamepad->bindings[Action::SHOOT].button = bindings.gamepad.button_shoot;
+    gamepad->bindings[Action::START].button = bindings.gamepad.button_start;
+    gamepad->bindings[Action::MENU].button = bindings.gamepad.button_menu;
 
     // 4. Cachear referencia
     player1_gamepad_ = gamepad;
@@ -508,15 +568,8 @@ void Input::applyPlayer2Bindings(const Config::PlayerBindings& bindings) {
     player2_keyboard_bindings_[Action::SHOOT].scancode = bindings.keyboard.key_shoot;
     player2_keyboard_bindings_[Action::START].scancode = bindings.keyboard.key_start;
 
-    // 2. Encontrar gamepad por nombre (o usar segundo gamepad como fallback)
+    // 2. Resoldre gamepad per path/name
-    std::shared_ptr<Gamepad> gamepad = nullptr;
+    std::shared_ptr<Gamepad> gamepad = resolvePlayerGamepad(bindings);
-    if (bindings.gamepad_name.empty()) {
-        // Fallback: usar segundo gamepad disponible
-        gamepad = (gamepads_.size() > 1) ? gamepads_[1] : nullptr;
-    } else {
-        // Buscar por nombre
-        gamepad = findAvailableGamepadByName(bindings.gamepad_name);
-    }
 
     if (!gamepad) {
         player2_gamepad_ = nullptr;
@@ -528,6 +581,8 @@ void Input::applyPlayer2Bindings(const Config::PlayerBindings& bindings) {
     gamepad->bindings[Action::RIGHT].button = bindings.gamepad.button_right;
     gamepad->bindings[Action::THRUST].button = bindings.gamepad.button_thrust;
     gamepad->bindings[Action::SHOOT].button = bindings.gamepad.button_shoot;
+    gamepad->bindings[Action::START].button = bindings.gamepad.button_start;
+    gamepad->bindings[Action::MENU].button = bindings.gamepad.button_menu;
 
     // 4. Cachear referencia
     player2_gamepad_ = gamepad;
@@ -555,6 +610,17 @@ auto Input::checkActionPlayer1(Action action, bool repeat) -> bool {
     return keyboard_active || gamepad_active;
 }
 
+// Retorna el pad assignat (0=P1, 1=P2). Pot ser nullptr.
+auto Input::getPlayerGamepad(int player_index) const -> std::shared_ptr<Input::Gamepad> {
+    if (player_index == 0) {
+        return player1_gamepad_;
+    }
+    if (player_index == 1) {
+        return player2_gamepad_;
+    }
+    return nullptr;
+}
+
 // Consulta de input para player 2
 auto Input::checkActionPlayer2(Action action, bool repeat) -> bool {
     // Comprobar teclado con el mapa específico de P2

source/core/input/input.hpp

@@ -62,7 +62,9 @@ class Input {
                   {Action::LEFT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_LEFT)}},
                   {Action::RIGHT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_RIGHT)}},
                   {Action::THRUST, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_WEST)}},
-                  {Action::SHOOT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_SOUTH)}}} {}
+                  {Action::SHOOT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_SOUTH)}},
+                  {Action::START, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_START)}},
+                  {Action::MENU, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_BACK)}}} {}
 
         ~Gamepad() {
             if (pad != nullptr) {
@@ -107,6 +109,10 @@ class Input {
     auto checkActionPlayer1(Action action, bool repeat = true) -> bool;
     auto checkActionPlayer2(Action action, bool repeat = true) -> bool;
 
+    // Accés al gamepad assignat per jugador (0=P1, 1=P2). nullptr si no n'hi
+    // ha cap d'assignat o connectat. Usat per la UI de redefinició de botons.
+    [[nodiscard]] auto getPlayerGamepad(int player_index) const -> std::shared_ptr<Gamepad>;
+
     // Check if any player pressed any action from a list
     auto checkAnyPlayerAction(const std::span<const InputAction>& actions, bool repeat = DO_NOT_ALLOW_REPEAT) -> bool;
 
@@ -142,6 +148,7 @@ class Input {
     auto removeGamepad(SDL_JoystickID id) -> std::string;
     void addGamepadMappingsFromFile();
     void discoverGamepads();
+    auto resolvePlayerGamepad(const Config::PlayerBindings& bindings) -> std::shared_ptr<Gamepad>;
 
     // --- Variables miembro ---
     static Input* instance;  // Instancia única del singleton

source/core/input/input_types.cpp

@@ -6,6 +6,8 @@ const std::unordered_map<InputAction, std::string> ACTION_TO_STRING = {
     {InputAction::RIGHT, "RIGHT"},
     {InputAction::THRUST, "THRUST"},
     {InputAction::SHOOT, "SHOOT"},
+    {InputAction::START, "START"},
+    {InputAction::MENU, "MENU"},
     {InputAction::WINDOW_INC_ZOOM, "WINDOW_INC_ZOOM"},
     {InputAction::WINDOW_DEC_ZOOM, "WINDOW_DEC_ZOOM"},
     {InputAction::TOGGLE_FULLSCREEN, "TOGGLE_FULLSCREEN"},
@@ -18,6 +20,8 @@ const std::unordered_map<std::string, InputAction> STRING_TO_ACTION = {
     {"RIGHT", InputAction::RIGHT},
     {"THRUST", InputAction::THRUST},
     {"SHOOT", InputAction::SHOOT},
+    {"START", InputAction::START},
+    {"MENU", InputAction::MENU},
     {"WINDOW_INC_ZOOM", InputAction::WINDOW_INC_ZOOM},
     {"WINDOW_DEC_ZOOM", InputAction::WINDOW_DEC_ZOOM},
     {"TOGGLE_FULLSCREEN", InputAction::TOGGLE_FULLSCREEN},

source/core/input/input_types.hpp

@@ -15,6 +15,7 @@ enum class InputAction : std::uint8_t {  // Acciones de entrada posibles en el j
     THRUST,  // Acelerar
     SHOOT,   // Disparar
     START,   // Empezar match
+    MENU,    // Abrir/cerrar menu de servicio (equivalent a F12)
 
     // Inputs de sistema (globales)
     WINDOW_INC_ZOOM,    // F2

source/core/locale/locale.cpp

@@ -0,0 +1,109 @@
+// locale.cpp - Implementació del sistema de locale
+// © 2026 JailDesigner
+
+#include "core/locale/locale.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "core/resources/resource_helper.hpp"
+#include "external/fkyaml_node.hpp"
+
+namespace {
+
+    // Recorre el node YAML i aplana jerarquies en claus "a.b.c". Suporta
+    // mappings (recursió) i seqüències de strings (desa "a.b.0", "a.b.1"...).
+    // Altres tipus (nombres, booleans solts) s'ignoren silenciosament.
+    void flatten(const fkyaml::node& node, const std::string& prefix, std::unordered_map<std::string, std::string>& out) {
+        if (node.is_mapping()) {
+            for (auto it = node.begin(); it != node.end(); ++it) {
+                const std::string KEY = prefix.empty()
+                    ? it.key().get_value<std::string>()
+                    : prefix + "." + it.key().get_value<std::string>();
+                flatten(it.value(), KEY, out);
+            }
+            return;
+        }
+        if (node.is_sequence()) {
+            std::size_t index = 0;
+            for (const auto& item : node) {
+                const std::string KEY = prefix + "." + std::to_string(index);
+                flatten(item, KEY, out);
+                index++;
+            }
+            return;
+        }
+        if (node.is_string()) {
+            out[prefix] = node.get_value<std::string>();
+        }
+    }
+
+}  // namespace
+
+auto Locale::get() -> Locale& {
+    static Locale instance_;
+    return instance_;
+}
+
+auto Locale::load(const std::string& file_path) -> bool {
+    // Normalitza traient prefix "data/" com fa StageLoader: el pack de
+    // recursos indexa rutes relatives a `data/`.
+    std::string normalized = file_path;
+    if (normalized.starts_with("data/")) {
+        normalized = normalized.substr(5);
+    }
+
+    std::vector<uint8_t> bytes = Resource::Helper::loadFile(normalized);
+    if (bytes.empty()) {
+        std::cerr << "[Locale] no s'ha pogut load " << normalized << '\n';
+        return false;
+    }
+
+    try {
+        std::string yaml_content(bytes.begin(), bytes.end());
+        std::stringstream stream(yaml_content);
+        fkyaml::node yaml = fkyaml::node::deserialize(stream);
+        strings_.clear();
+        flatten(yaml, "", strings_);
+        std::cout << "[Locale] " << strings_.size() << " traduccions des de " << normalized << '\n';
+        return true;
+    } catch (const std::exception& e) {
+        std::cerr << "[Locale] error parsejant " << normalized << ": " << e.what() << '\n';
+        return false;
+    }
+}
+
+auto Locale::switchTo(const std::string& lang) -> bool {
+    return load("locale/" + lang + ".yaml");
+}
+
+auto Locale::text(const std::string& key) const -> std::string {
+    auto it = strings_.find(key);
+    if (it != strings_.end()) {
+        return it->second;
+    }
+    std::cerr << "[Locale] clau no trobada: " << key << '\n';
+    return key;
+}
+
+auto Locale::count(const std::string& prefix) const -> std::size_t {
+    std::size_t n = 0;
+    while (strings_.contains(prefix + "." + std::to_string(n))) {
+        n++;
+    }
+    return n;
+}
+
+auto localeSubstitute(std::string tpl, std::string_view placeholder, std::string_view value) -> std::string {
+    auto pos = tpl.find(placeholder);
+    if (pos != std::string::npos) {
+        tpl.replace(pos, placeholder.size(), value);
+    }
+    return tpl;
+}

source/core/locale/locale.hpp

@@ -0,0 +1,56 @@
+// locale.hpp - Sistema d'internacionalització (i18n) basat en YAML
+// © 2026 JailDesigner
+//
+// Locale amb claus en notació de punts ("notification.fullscreen_on"). El YAML
+// pot ser jerarquitzat i s'aplana en càrrega, així el consumidor només veu
+// claus planes. Suporta seqüències de strings (es desen com prefix.0,
+// prefix.1, ...). No hi ha hot-swap d'idioma: es fixa a l'arrencada des de
+// `config.yaml` (camp `locale`) i només es recarrega reiniciant el joc.
+
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+class Locale {
+   public:
+    static auto get() -> Locale&;
+
+    Locale(const Locale&) = delete;
+    Locale(Locale&&) = delete;
+    auto operator=(const Locale&) -> Locale& = delete;
+    auto operator=(Locale&&) -> Locale& = delete;
+
+    // Llig el fitxer YAML i emplena el mapping intern. Si hi ha un error de
+    // parse o el fitxer no existeix, deixa el mapping com estava i ho
+    // notifica per stderr. Retorna true només si la càrrega ha tingut èxit.
+    auto load(const std::string& file_path) -> bool;
+
+    // Canvi d'idioma en runtime. Recarrega `locale/<lang>.yaml`. Retorna true
+    // si la càrrega ha tingut èxit. Els lookups posteriors (tots els draw*
+    // criden Locale::text() cada frame) ja veuen el nou idioma. Els missatges
+    // ja capturats (toast actiu, banner de stage start ja triat) sobreviuen
+    // fins al seu cicle natural.
+    auto switchTo(const std::string& lang) -> bool;
+
+    // Retorna la traducció; si la clau no existeix, retorna la pròpia clau
+    // com a fallback visible (així una clau mal escrita es detecta sense
+    // trencar el render).
+    [[nodiscard]] auto text(const std::string& key) const -> std::string;
+
+    // Compta quantes claus consecutives existeixen amb el prefix donat
+    // (prefix.0, prefix.1, ...). Útil per pools indexats com stage.start.N.
+    [[nodiscard]] auto count(const std::string& prefix) const -> std::size_t;
+
+   private:
+    Locale() = default;
+    ~Locale() = default;
+
+    std::unordered_map<std::string, std::string> strings_;
+};
+
+// Substitució simple d'un placeholder dins una plantilla (p.ex. "{n}" → "3").
+// S'usa per interpolar valors runtime en strings traduïdes.
+[[nodiscard]] auto localeSubstitute(std::string tpl, std::string_view placeholder, std::string_view value) -> std::string;

source/core/physics/collision.hpp

@@ -3,19 +3,21 @@
 
 #pragma once
 
+#include <algorithm>
+
 #include "core/entities/entity.hpp"
 #include "core/types.hpp"
 
 namespace Physics {
 
-// Comprobación genèrica de colisión entre dues entidades
+    // Comprobación genèrica de colisión entre dues entidades
-inline auto checkCollision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
+    inline auto checkCollision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
         // Comprovar si ambdós són col·lisionables
         if (!a.isCollidable() || !b.isCollidable()) {
             return false;
         }
 
-    // Calcular radi combinat (con amplificador per hitbox generós)
+        // Calcular radius combinat (con amplificador per hitbox generós)
         float suma_radis = (a.getCollisionRadius() + b.getCollisionRadius()) * amplifier;
         float suma_radis_sq = suma_radis * suma_radis;
 
@@ -27,6 +29,36 @@ inline auto checkCollision(const Entities::Entity& a, const Entities::Entity& b,
         float dist_sq = (dx * dx) + (dy * dy);
 
         return dist_sq <= suma_radis_sq;
-}
+    }
+
+    // Swept collision: una entitat mòbil (radius r_a) s'ha desplaçat de p0 a p1 aquest
+    // frame. Comprova si el segment expandit pel radius conjunt (r_a + radius de b, amb
+    // amplificador) toca el cercle de l'entity b. Equival al check discrete quan
+    // p0 == p1 (sense moviment). Evita tunneling a velocitats altes.
+    inline auto checkCollisionSwept(const Vec2& p0, const Vec2& p1, float r_a, const Entities::Entity& b, float amplifier = 1.0F) -> bool {
+        if (!b.isCollidable()) {
+            return false;
+        }
+        const float SUM_R = (r_a + b.getCollisionRadius()) * amplifier;
+        const float SUM_R_SQ = SUM_R * SUM_R;
+        const Vec2& center_b = b.getCenter();
+        const float DX_SEG = p1.x - p0.x;
+        const float DY_SEG = p1.y - p0.y;
+        const float LEN_SQ = (DX_SEG * DX_SEG) + (DY_SEG * DY_SEG);
+        // Degenerat: punt-cercle (frame de spawn, o entitat parada).
+        if (LEN_SQ <= 0.0F) {
+            const float DX = p0.x - center_b.x;
+            const float DY = p0.y - center_b.y;
+            return ((DX * DX) + (DY * DY)) <= SUM_R_SQ;
+        }
+        // Projecció del centre sobre la recta del segment, clamp a [0,1] per acotar al segment.
+        const float T_RAW = (((center_b.x - p0.x) * DX_SEG) + ((center_b.y - p0.y) * DY_SEG)) / LEN_SQ;
+        const float T_CLAMPED = std::clamp(T_RAW, 0.0F, 1.0F);
+        const float CLOSEST_X = p0.x + (DX_SEG * T_CLAMPED);
+        const float CLOSEST_Y = p0.y + (DY_SEG * T_CLAMPED);
+        const float DX = CLOSEST_X - center_b.x;
+        const float DY = CLOSEST_Y - center_b.y;
+        return ((DX * DX) + (DY * DY)) <= SUM_R_SQ;
+    }
 
 }  // namespace Physics

source/core/rendering/gpu/gpu_frame_renderer.cpp

@@ -5,6 +5,7 @@
 #include <SDL3/SDL.h>
 #include <SDL3/SDL_gpu.h>
 
+#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <cstring>
@@ -390,6 +391,10 @@ namespace Rendering::GPU {
         color_target.store_op = SDL_GPU_STOREOP_STORE;
         render_pass_ = SDL_BeginGPURenderPass(cmd_buffer_, &color_target, 1, nullptr);
 
+        // L'scissor és per render pass: en reobrir cal restaurar-lo des del top
+        // de la pila si pushClip/popClip s'han usat mid-frame.
+        applyCurrentScissor();
+
         SDL_BindGPUGraphicsPipeline(render_pass_, line_pipeline_.get());
 
         // UBO de líneas usa el tamaño lógico (también del offscreen).
@@ -415,6 +420,11 @@ namespace Rendering::GPU {
         SDL_ReleaseGPUBuffer(dev, vbo);
         SDL_ReleaseGPUBuffer(dev, ibo);
         SDL_ReleaseGPUTransferBuffer(dev, tbo);
+
+        // Buidem el batch perquè pushClip/popClip puguin emetre seccions
+        // separades dins el mateix frame sense re-enviar geometria.
+        vertices_.clear();
+        indices_.clear();
     }
 
     void GpuFrameRenderer::bloomPass() {
@@ -603,6 +613,51 @@ namespace Rendering::GPU {
         SDL_DrawGPUPrimitives(render_pass_, 3, 1, 0, 0);
     }
 
+    void GpuFrameRenderer::pushClip(int logical_x, int logical_y, int logical_w, int logical_h) {
+        // Convertim coordenades lògiques (espai del joc, 1280×720) a píxels
+        // físics del offscreen (render_w_ × render_h_). Si l'usuari hi treballa
+        // amb upscale (p.ex. 1920×1080), l'scissor escala proporcionalment.
+        const float SX = render_w_ / logical_w_;
+        const float SY = render_h_ / logical_h_;
+        SDL_Rect rect{
+            .x = static_cast<int>(static_cast<float>(logical_x) * SX),
+            .y = static_cast<int>(static_cast<float>(logical_y) * SY),
+            .w = std::max(0, static_cast<int>(static_cast<float>(logical_w) * SX)),
+            .h = std::max(0, static_cast<int>(static_cast<float>(logical_h) * SY)),
+        };
+        // Emetem tot el batch acumulat *abans* d'activar l'scissor perquè quedi
+        // dibuixat sense retallar.
+        flushBatch();
+        clip_stack_.push_back(rect);
+        applyCurrentScissor();
+    }
+
+    void GpuFrameRenderer::popClip() {
+        // Emetem el batch que s'ha acumulat *dins* del clip actiu.
+        flushBatch();
+        if (!clip_stack_.empty()) {
+            clip_stack_.pop_back();
+        }
+        applyCurrentScissor();
+    }
+
+    void GpuFrameRenderer::applyCurrentScissor() {
+        if (render_pass_ == nullptr) {
+            return;
+        }
+        SDL_Rect rect{};
+        if (clip_stack_.empty()) {
+            // Sense clips: scissor cobreix tot el offscreen.
+            rect.x = 0;
+            rect.y = 0;
+            rect.w = static_cast<int>(render_w_);
+            rect.h = static_cast<int>(render_h_);
+        } else {
+            rect = clip_stack_.back();
+        }
+        SDL_SetGPUScissor(render_pass_, &rect);
+    }
+
     void GpuFrameRenderer::endFrame() {
         if (cmd_buffer_ == nullptr) {
             return;

source/core/rendering/gpu/gpu_frame_renderer.hpp

@@ -94,6 +94,15 @@ namespace Rendering::GPU {
         // d'UI (notificacions, panels).
         void pushRect(float x, float y, float w, float h, float r, float g, float b, float a);
 
+        // Clipping rectangular per a UI (scissor a SDL_GPU). pushClip/popClip
+        // forcen un flush intermedi del batch i activen/restauren l'scissor del
+        // pase actiu. Coordenades en píxels lògics del joc (1280×720); es
+        // converteixen a píxels físics del offscreen automàticament. Stack
+        // d'scissors per a clips niats. Quan la pila queda buida, l'scissor
+        // torna a cobrir el target sencer.
+        void pushClip(int logical_x, int logical_y, int logical_w, int logical_h);
+        void popClip();
+
         // endFrame: flush del batch de líneas → composite postpro → submit + presenta.
         void endFrame();
 
@@ -168,6 +177,10 @@ namespace Rendering::GPU {
         std::vector<LineVertex> vertices_;
         std::vector<uint16_t> indices_;
 
+        // Pila d'scissors actius en píxels físics del offscreen. Buida = sense
+        // clip (full target). Cada push/pop fa un flushBatch i reaplica scissor.
+        std::vector<SDL_Rect> clip_stack_;
+
         // Estado del frame en curso.
         SDL_GPUCommandBuffer* cmd_buffer_{nullptr};
         SDL_GPUTexture* swapchain_texture_{nullptr};
@@ -190,6 +203,7 @@ namespace Rendering::GPU {
         void bloomPass();  // pre-composite: H + V passes sobre les bloom textures
         void compositePass();
         void applyFinalViewport();
+        void applyCurrentScissor();  // re-aplica el top de clip_stack_ al render_pass_
     };
 
 }  // namespace Rendering::GPU

source/core/rendering/line_renderer.cpp

@@ -4,6 +4,7 @@
 #include "core/rendering/line_renderer.hpp"
 
 #include "core/defaults.hpp"
+#include "core/defaults/effects.hpp"
 
 namespace Rendering {
 
@@ -22,7 +23,8 @@ namespace Rendering {
         int y2,
         float brightness,
         float thickness,
-        SDL_Color color) {
+        SDL_Color color,
+        float alpha) {
         if (renderer == nullptr) {
             return;
         }
@@ -42,7 +44,28 @@ namespace Rendering {
 
         const float W = (thickness > 0.0F) ? thickness : g_current_line_thickness;
 
-        renderer->pushLine(FX1, FY1, FX2, FY2, W, R, G, B, 1.0F);
+        renderer->pushLine(FX1, FY1, FX2, FY2, W, R, G, B, alpha);
+    }
+
+    void lineaGlow(Renderer* renderer,
+        int x1,
+        int y1,
+        int x2,
+        int y2,
+        float brightness,
+        float thickness,
+        SDL_Color color,
+        SDL_Color glow_color) {
+        // Color dels passes de halo: si glow_color té alpha>0, l'usem;
+        // altrament fem servir el color de la línia.
+        const SDL_Color HALO_COLOR = (glow_color.a > 0) ? glow_color : color;
+
+        for (const auto& pass : Defaults::FX::Glow::Line::PASSES) {
+            const bool IS_CORE = pass.thickness < 0.0F;
+            const float PASS_T = IS_CORE ? thickness : pass.thickness;
+            const SDL_Color PASS_C = IS_CORE ? color : HALO_COLOR;
+            linea(renderer, x1, y1, x2, y2, brightness, PASS_T, PASS_C, pass.alpha);
+        }
     }
 
     void setLineColor(SDL_Color color) { g_current_line_color = color; }

source/core/rendering/line_renderer.hpp

@@ -17,9 +17,13 @@ namespace Rendering {
 
     // Dibuja una línea entre dos puntos en coordenadas lógicas (1280×720).
     // brightness: factor de brillo (0.0..1.0, default 1.0 = brillo máximo).
+    //             Pre-multiplica el RGB del color (color dim sobre fons negre).
     // thickness: grosor en píxeles lógicos. Si <= 0 usa g_current_line_thickness.
     // color: si alpha==0, se usa el color global del oscilador; si alpha>0 se
     //        usa este color directo (paleta semántica por entidad).
+    // alpha: alpha que arriba al GPU (default 1.0 = opac, behavior original).
+    //        Valors <1.0 fan que la línia es barregi de veritat sobre el dest
+    //        en comptes de sobrepintar-lo (útil per halos translúcids).
     void linea(Renderer* renderer,
         int x1,
         int y1,
@@ -27,7 +31,23 @@ namespace Rendering {
         int y2,
         float brightness = 1.0F,
         float thickness = 0.0F,
-        SDL_Color color = {0, 0, 0, 0});
+        SDL_Color color = {0, 0, 0, 0},
+        float alpha = 1.0F);
+
+    // Versió amb halo neon: dibuixa la línia amb diversos passos de gruix
+    // creixent i alfa decreixent (config a Defaults::FX::Glow::Line::PASSES).
+    // El core (últim pass) usa el thickness/alpha que passa el caller.
+    // glow_color: si alpha>0, els passes de halo usen aquest color en lloc
+    //             del color de la línia (p.ex. línia blanca amb halo daurat).
+    void lineaGlow(Renderer* renderer,
+        int x1,
+        int y1,
+        int x2,
+        int y2,
+        float brightness = 1.0F,
+        float thickness = 0.0F,
+        SDL_Color color = {0, 0, 0, 0},
+        SDL_Color glow_color = {0, 0, 0, 0});
 
     // Color global de las líneas (lo actualiza ColorOscillator vía SDLManager).
     void setLineColor(SDL_Color color);

source/core/rendering/sdl_manager.cpp

@@ -14,6 +14,7 @@
 #include "core/defaults/rendering.hpp"
 #include "core/defaults/window.hpp"
 #include "core/input/mouse.hpp"
+#include "core/locale/locale.hpp"
 #include "core/rendering/coordinate_transform.hpp"
 #include "core/system/notifier.hpp"
 #include "project.h"
@@ -250,7 +251,10 @@ void SDLManager::increaseWindowSize() {
     float new_zoom = zoom_factor_ + Defaults::Window::ZOOM_INCREMENT;
     applyZoom(new_zoom);
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
-        notifier->notifyInfo(std::format("ZOOM: {:.1f}X", zoom_factor_));
+        notifier->notifyInfo(localeSubstitute(
+            Locale::get().text("notification.zoom"),
+            "{z}",
+            std::format("{:.1f}", zoom_factor_)));
     }
 }
 
@@ -261,7 +265,10 @@ void SDLManager::decreaseWindowSize() {
     float new_zoom = zoom_factor_ - Defaults::Window::ZOOM_INCREMENT;
     applyZoom(new_zoom);
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
-        notifier->notifyInfo(std::format("ZOOM: {:.1f}X", zoom_factor_));
+        notifier->notifyInfo(localeSubstitute(
+            Locale::get().text("notification.zoom"),
+            "{z}",
+            std::format("{:.1f}", zoom_factor_)));
     }
 }
 
@@ -310,7 +317,7 @@ void SDLManager::toggleFullscreen() {
     Mouse::setForceHidden(is_fullscreen_);
 
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
-        notifier->notifyInfo(is_fullscreen_ ? "PANTALLA COMPLETA" : "MODE FINESTRA");
+        notifier->notifyInfo(Locale::get().text(is_fullscreen_ ? "notification.fullscreen_on" : "notification.fullscreen_off"));
     }
 }
 
@@ -364,7 +371,7 @@ void SDLManager::toggleVSync() {
         on_persist_();
     }
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
-        notifier->notifyInfo(cfg_->rendering.vsync != 0 ? "VSYNC ACTIU" : "VSYNC INACTIU");
+        notifier->notifyInfo(Locale::get().text(cfg_->rendering.vsync != 0 ? "notification.vsync_on" : "notification.vsync_off"));
     }
 }
 
@@ -374,7 +381,27 @@ void SDLManager::toggleAntialias() {
     // No persistim: l'AA és toggleable runtime però el seu estat no es
     // guarda al YAML de moment (decisió volgudament conservadora).
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
-        notifier->notifyInfo(cfg_->rendering.antialias != 0 ? "AA ACTIU" : "AA INACTIU");
+        notifier->notifyInfo(Locale::get().text(cfg_->rendering.antialias != 0 ? "notification.antialias_on" : "notification.antialias_off"));
+    }
+}
+
+void SDLManager::setRenderResolution(int w, int h) {
+    if (!Defaults::Rendering::isValidRenderResolution(w, h)) {
+        std::cerr << "[SDLManager] Resolucio no valida (" << w << "x" << h
+                  << "), ignorant.\n";
+        return;
+    }
+    if (w == cfg_->rendering.render_width && h == cfg_->rendering.render_height) {
+        return;  // ja era l'actual
+    }
+    if (!gpu_renderer_.resizeRenderTarget(static_cast<float>(w), static_cast<float>(h))) {
+        std::cerr << "[SDLManager] resizeRenderTarget ha fallat.\n";
+        return;
+    }
+    cfg_->rendering.render_width = w;
+    cfg_->rendering.render_height = h;
+    if (on_persist_) {
+        on_persist_();
     }
 }
 
@@ -384,6 +411,6 @@ void SDLManager::togglePostFx() {
     // No persistim: el toggle és per A/B testing visual, l'estat per defecte
     // del joc continua sent "postfx ON" segons defaults/YAML.
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
-        notifier->notifyInfo(NEW_STATE ? "POSTPROCESSAT ACTIU" : "POSTPROCESSAT INACTIU");
+        notifier->notifyInfo(Locale::get().text(NEW_STATE ? "notification.postfx_on" : "notification.postfx_off"));
     }
 }

source/core/rendering/sdl_manager.hpp

@@ -36,6 +36,10 @@ class SDLManager {
     void toggleVSync();         // F4
     void toggleAntialias();     // F5
     void togglePostFx();        // F6
+    // Canvia la resolució del render target offscreen (recrea la textura).
+    // Cal cridar-lo fora d'un frame (event phase, no draw phase). Si el
+    // valor no es un preset valid o ja es l'actual, es no-op.
+    void setRenderResolution(int w, int h);
     auto handleWindowEvent(const SDL_Event& event) -> bool;  // Per a SDL_EVENT_WINDOW_RESIZED
 
     // Funciones principals (renderizado).
@@ -47,6 +51,8 @@ class SDLManager {
     // Getters
     auto getRenderer() -> Rendering::Renderer* { return &gpu_renderer_; }
     [[nodiscard]] auto getScaleFactor() const -> float { return zoom_factor_; }
+    [[nodiscard]] auto isFullscreen() const -> bool { return is_fullscreen_; }
+    [[nodiscard]] auto isPostFxEnabled() const -> bool { return gpu_renderer_.isPostFxEnabled(); }
 
     // [NUEVO] Actualitzar context de renderizado (factor de scale global)
     void updateRenderingContext() const;

source/core/rendering/shape_renderer.cpp

@@ -3,31 +3,77 @@
 
 #include "core/rendering/shape_renderer.hpp"
 
+#include <algorithm>
 #include <cmath>
 
+#include "core/defaults/effects.hpp"
+#include "core/graphics/shape.hpp"
 #include "core/rendering/line_renderer.hpp"
 
 namespace Rendering {
 
     // Helper: transformar un point con rotación, scale i traslación
     static auto transformPoint(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale) -> Vec2 {
-        // 1. Centrar el point respecte al centro de la shape
+        const float CENTERED_X = point.x - shape_centre.x;
-        float centered_x = point.x - shape_centre.x;
+        const float CENTERED_Y = point.y - shape_centre.y;
-        float centered_y = point.y - shape_centre.y;
 
-        // 2. Aplicar scale al point
+        const float SCALED_X = CENTERED_X * scale;
-        float scaled_x = centered_x * scale;
+        const float SCALED_Y = CENTERED_Y * scale;
-        float scaled_y = centered_y * scale;
 
-        // 3. Aplicar rotación 2D (Z-axis)
+        const float COS_A = std::cos(angle);
-        float cos_a = std::cos(angle);
+        const float SIN_A = std::sin(angle);
-        float sin_a = std::sin(angle);
 
-        float rotated_x = (scaled_x * cos_a) - (scaled_y * sin_a);
+        const float ROTATED_X = (SCALED_X * COS_A) - (SCALED_Y * SIN_A);
-        float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);
+        const float ROTATED_Y = (SCALED_X * SIN_A) + (SCALED_Y * COS_A);
 
-        // 4. Aplicar traslación a posición mundial
+        return {.x = ROTATED_X + position.x, .y = ROTATED_Y + position.y};
-        return {.x = rotated_x + position.x, .y = rotated_y + position.y};
+    }
+
+    // Una passada de renderitzat: itera primitives de la shape i emet línies
+    // amb el thickness/alpha indicats. Es crida N vegades en glow mode (una
+    // per pass de halo + core), o 1 vegada quan glow=false.
+    static void renderSinglePass(Rendering::Renderer* renderer,
+        const std::shared_ptr<Graphics::Shape>& shape,
+        const Vec2& position,
+        float angle,
+        float scale,
+        float brightness,
+        SDL_Color color,
+        float thickness,
+        float alpha) {
+        const Vec2& shape_centre = shape->getCenter();
+
+        // Petita extensió a línies gruixudes per tapar forats entre segments.
+        // A vèrtex aguts (~108°) un valor alt produeix "espigues" — 15%.
+        const float EFFECTIVE_T = (thickness > 0.0F) ? thickness : getLineThickness();
+        const float EXTEND = (EFFECTIVE_T > 2.0F) ? (EFFECTIVE_T * 0.15F) : 0.0F;
+
+        for (const auto& primitive : shape->getPrimitives()) {
+            if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
+                for (size_t i = 0; i < primitive.points.size() - 1; i++) {
+                    Vec2 p1 = transformPoint(primitive.points[i], shape_centre, position, angle, scale);
+                    Vec2 p2 = transformPoint(primitive.points[i + 1], shape_centre, position, angle, scale);
+                    if (EXTEND > 0.0F) {
+                        const float DX = p2.x - p1.x;
+                        const float DY = p2.y - p1.y;
+                        const float LEN = std::sqrt((DX * DX) + (DY * DY));
+                        if (LEN > 1e-6F) {
+                            const float UX = (DX / LEN) * EXTEND;
+                            const float UY = (DY / LEN) * EXTEND;
+                            p1.x -= UX;
+                            p1.y -= UY;
+                            p2.x += UX;
+                            p2.y += UY;
+                        }
+                    }
+                    linea(renderer, static_cast<int>(p1.x), static_cast<int>(p1.y), static_cast<int>(p2.x), static_cast<int>(p2.y), brightness, thickness, color, alpha);
+                }
+            } else if (primitive.points.size() >= 2) {  // LINE
+                const Vec2 P1 = transformPoint(primitive.points[0], shape_centre, position, angle, scale);
+                const Vec2 P2 = transformPoint(primitive.points[1], shape_centre, position, angle, scale);
+                linea(renderer, static_cast<int>(P1.x), static_cast<int>(P1.y), static_cast<int>(P2.x), static_cast<int>(P2.y), brightness, thickness, color, alpha);
+            }
+        }
     }
 
     void renderShape(Rendering::Renderer* renderer,
@@ -37,7 +83,10 @@ namespace Rendering {
         float scale,
         float progress,
         float brightness,
-        SDL_Color color) {
+        SDL_Color color,
+        float thickness,
+        float alpha,
+        bool glow) {
         if (!shape || !shape->isValid()) {
             return;
         }
@@ -45,21 +94,26 @@ namespace Rendering {
             return;
         }
 
-        const Vec2& shape_centre = shape->getCenter();
+        if (!glow) {
+            renderSinglePass(renderer, shape, position, angle, scale, brightness, color, thickness, alpha);
+            return;
+        }
 
-        for (const auto& primitive : shape->getPrimitives()) {
+        // Glow: multi-pass amb halos translúcids proporcionals al tamany de
-            if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
+        // la shape. Cada pass amb thickness_ratio<0 usa el thickness/alpha
-                // POLYLINE: conectar puntos consecutivos.
+        // que ha passat el caller (és el "core" / línia real). Saturem la
-                for (size_t i = 0; i < primitive.points.size() - 1; i++) {
+        // mida de referència a MAX_REFERENCE_RADIUS perquè shapes molt
-                    const Vec2 P1 = transformPoint(primitive.points[i], shape_centre, position, angle, scale);
+        // grans (logos) no tinguin halo desproporcionat.
-                    const Vec2 P2 = transformPoint(primitive.points[i + 1], shape_centre, position, angle, scale);
+        const float RAW_REF = shape->getBoundingRadius() * scale;
-                    linea(renderer, static_cast<int>(P1.x), static_cast<int>(P1.y), static_cast<int>(P2.x), static_cast<int>(P2.y), brightness, 0.0F, color);
+        const float REFERENCE_SIZE = std::min(RAW_REF, Defaults::FX::Glow::MAX_REFERENCE_RADIUS);
-                }
+        for (const auto& pass : Defaults::FX::Glow::PASSES) {
-            } else if (primitive.points.size() >= 2) {  // LINE
+            float pass_thickness = thickness;
-                const Vec2 P1 = transformPoint(primitive.points[0], shape_centre, position, angle, scale);
+            float pass_alpha = alpha;
-                const Vec2 P2 = transformPoint(primitive.points[1], shape_centre, position, angle, scale);
+            if (pass.thickness_ratio > 0.0F) {
-                linea(renderer, static_cast<int>(P1.x), static_cast<int>(P1.y), static_cast<int>(P2.x), static_cast<int>(P2.y), brightness, 0.0F, color);
+                pass_thickness = REFERENCE_SIZE * pass.thickness_ratio;
+                pass_alpha = pass.alpha * alpha;  // respecta el master alpha del caller
             }
+            renderSinglePass(renderer, shape, position, angle, scale, brightness, color, pass_thickness, pass_alpha);
         }
     }
 

source/core/rendering/shape_renderer.hpp

@@ -21,6 +21,11 @@ namespace Rendering {
     // - scale: factor de scale (1.0 = mida original)
     // - progress: progrés de l'animación (0.0-1.0, default 1.0 = tot visible)
     // - brightness: factor de brightness (0.0-1.0, default 1.0 = màxima brightness)
+    // - color: si alpha==0, usa oscil·lador global
+    // - thickness: gruix de línia. <=0 → usa global (g_current_line_thickness)
+    // - alpha: alpha que arriba al GPU (default 1.0 = opac). <1.0 = halo real
+    // - glow: si true, redibuixa la shape amb halos translúcids proporcionals
+    //         al bounding_radius*scale (efecte neon). Si false, single-pass.
     void renderShape(Rendering::Renderer* renderer,
         const std::shared_ptr<Graphics::Shape>& shape,
         const Vec2& position,
@@ -28,6 +33,9 @@ namespace Rendering {
         float scale = 1.0F,
         float progress = 1.0F,
         float brightness = 1.0F,
-        SDL_Color color = {0, 0, 0, 0});  // alpha==0 → usa global oscilador
+        SDL_Color color = {0, 0, 0, 0},
+        float thickness = 0.0F,
+        float alpha = 1.0F,
+        bool glow = true);
 
 }  // namespace Rendering

source/core/resources/resource_helper.cpp

@@ -9,29 +9,34 @@
 
 namespace Resource::Helper {
 
-// Inicialitzar el sistema de recursos
+    // Inicialitzar el sistema de recursos
-auto initializeResourceSystem(const std::string& pack_file, bool fallback) -> bool {
+    auto initializeResourceSystem(const std::string& pack_file, bool fallback) -> bool {
         return Loader::get().initialize(pack_file, fallback);
-}
+    }
 
-// Carregar un file
+    // Carregar un file
-auto loadFile(const std::string& filepath) -> std::vector<uint8_t> {
+    auto loadFile(const std::string& filepath) -> std::vector<uint8_t> {
         // Normalitzar la ruta
         std::string normalized = normalizePath(filepath);
 
         // Carregar del sistema de recursos
         return Loader::get().loadResource(normalized);
-}
+    }
 
-// Comprovar si existeix un file
+    // Llistar recursos amb un prefix donat
-auto fileExists(const std::string& filepath) -> bool {
+    auto listResources(const std::string& prefix) -> std::vector<std::string> {
+        return Loader::get().listResources(prefix);
+    }
+
+    // Comprovar si existeix un file
+    auto fileExists(const std::string& filepath) -> bool {
         std::string normalized = normalizePath(filepath);
         return Loader::get().resourceExists(normalized);
-}
+    }
 
-// Obtenir ruta normalitzada per al paquet
+    // Obtenir ruta normalitzada per al paquet
-// Elimina prefixos "data/", rutes absolutes, etc.
+    // Elimina prefixos "data/", rutes absolutes, etc.
-auto getPackPath(const std::string& asset_path) -> std::string {
+    auto getPackPath(const std::string& asset_path) -> std::string {
         std::string path = asset_path;
 
         // Eliminar rutes absolutes (detectar / o C:\ al principi)
@@ -65,16 +70,16 @@ auto getPackPath(const std::string& asset_path) -> std::string {
         std::ranges::replace(path, '\\', '/');
 
         return path;
-}
+    }
 
-// Normalitzar ruta (alias de getPackPath)
+    // Normalitzar ruta (alias de getPackPath)
-auto normalizePath(const std::string& path) -> std::string {
+    auto normalizePath(const std::string& path) -> std::string {
         return getPackPath(path);
-}
+    }
 
-// Comprovar si hay paquet carregat
+    // Comprovar si hay paquet carregat
-auto isPackLoaded() -> bool {
+    auto isPackLoaded() -> bool {
         return Loader::get().isPackLoaded();
-}
+    }
 
 }  // namespace Resource::Helper

source/core/resources/resource_helper.hpp

@@ -10,18 +10,21 @@
 
 namespace Resource::Helper {
 
-// Inicialización del sistema
+    // Inicialización del sistema
-auto initializeResourceSystem(const std::string& pack_file, bool fallback) -> bool;
+    auto initializeResourceSystem(const std::string& pack_file, bool fallback) -> bool;
 
-// Càrrega de archivos
+    // Càrrega de archivos
-auto loadFile(const std::string& filepath) -> std::vector<uint8_t>;
+    auto loadFile(const std::string& filepath) -> std::vector<uint8_t>;
-auto fileExists(const std::string& filepath) -> bool;
+    auto fileExists(const std::string& filepath) -> bool;
 
-// Normalització de rutes
+    // Llistat de recursos disponibles amb un prefix (ex. "shapes/", "sounds/").
-auto getPackPath(const std::string& asset_path) -> std::string;
+    auto listResources(const std::string& prefix) -> std::vector<std::string>;
-auto normalizePath(const std::string& path) -> std::string;
 
-// Estat
+    // Normalització de rutes
-auto isPackLoaded() -> bool;
+    auto getPackPath(const std::string& asset_path) -> std::string;
+    auto normalizePath(const std::string& path) -> std::string;
+
+    // Estat
+    auto isPackLoaded() -> bool;
 
 }  // namespace Resource::Helper

source/core/resources/resource_loader.cpp

@@ -3,20 +3,21 @@
 
 #include "resource_loader.hpp"
 
+#include <algorithm>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 
 namespace Resource {
 
-// Singleton
+    // Singleton
-auto Loader::get() -> Loader& {
+    auto Loader::get() -> Loader& {
         static Loader instance_;
         return instance_;
-}
+    }
 
-// Inicialitzar el sistema de recursos
+    // Inicialitzar el sistema de recursos
-auto Loader::initialize(const std::string& pack_file, bool enable_fallback) -> bool {
+    auto Loader::initialize(const std::string& pack_file, bool enable_fallback) -> bool {
         fallback_enabled_ = enable_fallback;
 
         // Intentar load el paquet
@@ -36,10 +37,10 @@ auto Loader::initialize(const std::string& pack_file, bool enable_fallback) -> b
 
         std::cout << "[ResourceLoader] Paquet carregat: " << pack_file << "\n";
         return true;
-}
+    }
 
-// Carregar un recurs
+    // Carregar un recurs
-auto Loader::loadResource(const std::string& filename) -> std::vector<uint8_t> {
+    auto Loader::loadResource(const std::string& filename) -> std::vector<uint8_t> {
         // Intentar load del paquet primer
         if (pack_) {
             if (pack_->hasResource(filename)) {
@@ -65,10 +66,46 @@ auto Loader::loadResource(const std::string& filename) -> std::vector<uint8_t> {
         }
 
         return {};
-}
+    }
 
-// Comprovar si existeix un recurs
+    auto Loader::listResources(const std::string& prefix) -> std::vector<std::string> {
-auto Loader::resourceExists(const std::string& filename) -> bool {
+        std::vector<std::string> result;
+
+        if (pack_) {
+            for (const auto& path : pack_->getResourceList()) {
+                if (path.starts_with(prefix)) {
+                    result.push_back(path);
+                }
+            }
+            return result;
+        }
+
+        if (!fallback_enabled_) {
+            return result;
+        }
+
+        std::string root = base_path_.empty() ? "data/" + prefix : base_path_ + "/data/" + prefix;
+        if (!std::filesystem::exists(root)) {
+            return result;
+        }
+
+        for (const auto& entry : std::filesystem::recursive_directory_iterator(root)) {
+            if (!entry.is_regular_file()) {
+                continue;
+            }
+            std::string full = entry.path().generic_string();
+            if (auto pos = full.find("/data/"); pos != std::string::npos) {
+                result.push_back(full.substr(pos + 6));
+            } else if (full.starts_with("data/")) {
+                result.push_back(full.substr(5));
+            }
+        }
+        std::ranges::sort(result);
+        return result;
+    }
+
+    // Comprovar si existeix un recurs
+    auto Loader::resourceExists(const std::string& filename) -> bool {
         // Comprovar al paquet
         if (pack_ && pack_->hasResource(filename)) {
             return true;
@@ -81,36 +118,36 @@ auto Loader::resourceExists(const std::string& filename) -> bool {
         }
 
         return false;
-}
+    }
 
-// Validar el paquet
+    // Validar el paquet
-auto Loader::validatePack() -> bool {
+    auto Loader::validatePack() -> bool {
         if (!pack_) {
             std::cerr << "[ResourceLoader] Advertència: no hay paquet carregat per validar\n";
             return false;
         }
 
         return pack_->validatePack();
-}
+    }
 
-// Comprovar si hay paquet carregat
+    // Comprovar si hay paquet carregat
-auto Loader::isPackLoaded() const -> bool {
+    auto Loader::isPackLoaded() const -> bool {
         return pack_ != nullptr;
-}
+    }
 
-// Establir la ruta base
+    // Establir la ruta base
-void Loader::setBasePath(const std::string& path) {
+    void Loader::setBasePath(const std::string& path) {
         base_path_ = path;
         std::cout << "[ResourceLoader] Ruta base establerta: " << base_path_ << "\n";
-}
+    }
 
-// Obtenir la ruta base
+    // Obtenir la ruta base
-auto Loader::getBasePath() const -> const std::string& {
+    auto Loader::getBasePath() const -> const std::string& {
         return base_path_;
-}
+    }
 
-// Carregar des del sistema de archivos (fallback)
+    // Carregar des del sistema de archivos (fallback)
-auto Loader::loadFromFilesystem(const std::string& filename) -> std::vector<uint8_t> {
+    auto Loader::loadFromFilesystem(const std::string& filename) -> std::vector<uint8_t> {
         // The filename is already normalized (e.g., "shapes/logo/letra_j.shp")
         // We need to prepend base_path + "data/"
         std::string fullpath;
@@ -138,6 +175,6 @@ auto Loader::loadFromFilesystem(const std::string& filename) -> std::vector<uint
 
         std::cout << "[ResourceLoader] Carregat des del sistema de archivos: " << fullpath << "\n";
         return data;
-}
+    }
 
 }  // namespace Resource

source/core/resources/resource_loader.hpp

@@ -12,8 +12,8 @@
 
 namespace Resource {
 
-// Singleton per gestionar la càrrega de recursos
+    // Singleton per gestionar la càrrega de recursos
-class Loader {
+    class Loader {
        public:
         // Singleton
         static auto get() -> Loader&;
@@ -25,6 +25,11 @@ class Loader {
         auto loadResource(const std::string& filename) -> std::vector<uint8_t>;
         auto resourceExists(const std::string& filename) -> bool;
 
+        // Llistat de recursos amb prefix (ex. "shapes/", "sounds/"). Si hi ha
+        // pack, retorna els fitxers del pack filtrats; si no, escaneja el
+        // sistema de fitxers recursivament a `data/<prefix>`.
+        auto listResources(const std::string& prefix) -> std::vector<std::string>;
+
         // Validació
         auto validatePack() -> bool;
         [[nodiscard]] auto isPackLoaded() const -> bool;
@@ -48,6 +53,6 @@ class Loader {
 
         // Funciones auxiliars
         auto loadFromFilesystem(const std::string& filename) -> std::vector<uint8_t>;
-};
+    };
 
 }  // namespace Resource

source/core/system/debug_overlay.cpp

@@ -2,20 +2,33 @@
 
 #include "core/system/debug_overlay.hpp"
 
+#include <SDL3/SDL.h>
+
+#include <cctype>
+#include <cmath>
 #include <string>
 
 #include "core/defaults.hpp"
+#include "core/rendering/gpu/gpu_frame_renderer.hpp"
 #include "core/types.hpp"
 
 namespace System {
 
     namespace {
         namespace Cfg = Defaults::Hud::DebugOverlay;
+
+        auto toUpperAscii(std::string s) -> std::string {
+            for (char& c : s) {
+                c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
+            }
+            return s;
+        }
     }  // namespace
 
     DebugOverlay::DebugOverlay(Rendering::Renderer* renderer,
         const Config::RenderingConfig& rendering_cfg)
         : text_(renderer),
+          renderer_(renderer),
           rendering_cfg_(&rendering_cfg) {}
 
     void DebugOverlay::update(float delta_time) {
@@ -23,7 +36,7 @@ namespace System {
         fps_frame_count_++;
 
         if (fps_accumulator_ >= Cfg::FPS_UPDATE_INTERVAL) {
-            fps_display_ = static_cast<int>(fps_frame_count_ / fps_accumulator_);
+            fps_display_ = static_cast<int>(std::lround(static_cast<float>(fps_frame_count_) / fps_accumulator_));
             fps_frame_count_ = 0;
             fps_accumulator_ = 0.0F;
         }
@@ -35,23 +48,43 @@ namespace System {
         }
 
         const std::string FPS_TEXT = "FPS: " + std::to_string(fps_display_);
+        const std::string RES_TEXT = "RES: " + std::to_string(rendering_cfg_->render_width) + "X" + std::to_string(rendering_cfg_->render_height);
+        const char* driver_raw = SDL_GetGPUDeviceDriver(renderer_->device().get());
+        const std::string DRIVER_TEXT = "DRIVER: " + toUpperAscii(driver_raw != nullptr ? driver_raw : "?");
         const std::string VSYNC_TEXT = std::string("VSYNC: ") + (rendering_cfg_->vsync == 1 ? "ON" : "OFF");
         const std::string AA_TEXT = std::string("AA: ") + (rendering_cfg_->antialias == 1 ? "ON" : "OFF");
 
+        float y = Cfg::Y_FPS;
         text_.render(FPS_TEXT,
-            Vec2{.x = Cfg::X, .y = Cfg::Y_FPS},
+            Vec2{.x = Cfg::X, .y = y},
+            Cfg::FPS_SCALE,
+            Cfg::TEXT_SPACING,
+            Cfg::BRIGHTNESS,
+            Cfg::COLOR);
+        y += Cfg::FPS_LINE_HEIGHT;
+        text_.render(RES_TEXT,
+            Vec2{.x = Cfg::X, .y = y},
             Cfg::TEXT_SCALE,
             Cfg::TEXT_SPACING,
             Cfg::BRIGHTNESS,
             Cfg::COLOR);
+        y += Cfg::LINE_HEIGHT;
+        text_.render(DRIVER_TEXT,
+            Vec2{.x = Cfg::X, .y = y},
+            Cfg::TEXT_SCALE,
+            Cfg::TEXT_SPACING,
+            Cfg::BRIGHTNESS,
+            Cfg::COLOR);
+        y += Cfg::LINE_HEIGHT;
         text_.render(VSYNC_TEXT,
-            Vec2{.x = Cfg::X, .y = Cfg::Y_FPS + Cfg::LINE_HEIGHT},
+            Vec2{.x = Cfg::X, .y = y},
             Cfg::TEXT_SCALE,
             Cfg::TEXT_SPACING,
             Cfg::BRIGHTNESS,
             Cfg::COLOR);
+        y += Cfg::LINE_HEIGHT;
         text_.render(AA_TEXT,
-            Vec2{.x = Cfg::X, .y = Cfg::Y_FPS + (2.0F * Cfg::LINE_HEIGHT)},
+            Vec2{.x = Cfg::X, .y = y},
             Cfg::TEXT_SCALE,
             Cfg::TEXT_SPACING,
             Cfg::BRIGHTNESS,

source/core/system/debug_overlay.hpp

@@ -2,8 +2,8 @@
 // © 2026 JailDesigner
 //
 // Sistema global propiedad del Director. Se actualiza y dibuja cada frame
-// después de la escena (queda on top). En builds debug arranca visible,
+// después de la escena (queda on top). Arranca oculto sempre; F11 alterna
-// en release oculto. F11 alterna visibilidad.
+// visibilidad durant l'execució.
 
 #pragma once
 
@@ -31,8 +31,9 @@ namespace System {
 
        private:
         Graphics::VectorText text_;
+        Rendering::Renderer* renderer_;
         const Config::RenderingConfig* rendering_cfg_;
-        bool visible_{true};
+        bool visible_{false};
 
         // FPS counter — se actualiza cada FPS_UPDATE_INTERVAL segundos.
         float fps_accumulator_{0.0F};

source/core/system/director.cpp

@@ -11,20 +11,23 @@
 
 #include "core/audio/audio.hpp"
 #include "core/audio/audio_adapter.hpp"
-#include "core/defaults/audio.hpp"
 #include "core/defaults/window.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/input/define_inputs.hpp"
 #include "core/input/input.hpp"
 #include "core/input/mouse.hpp"
+#include "core/locale/locale.hpp"
 #include "core/rendering/sdl_manager.hpp"
 #include "core/resources/resource_helper.hpp"
 #include "core/resources/resource_loader.hpp"
 #include "core/system/notifier.hpp"
+#include "core/system/service_menu.hpp"
 #include "core/utils/path_utils.hpp"
 #include "debug_overlay.hpp"
+#include "game/config_yaml.hpp"
 #include "game/scenes/game_scene.hpp"
 #include "game/scenes/logo_scene.hpp"
 #include "game/scenes/title_scene.hpp"
-#include "game/scenes/title_scene_3d.hpp"
 #include "global_events.hpp"
 #include "project.h"
 #include "scene.hpp"
@@ -40,17 +43,15 @@ using SceneManager::SceneContext;
 using SceneType = SceneContext::SceneType;
 
 // Constructor
-Director::Director(std::vector<std::string> const& args,
+Director::Director(int argc, char* argv[])
-    Config::EngineConfig& cfg,
+    : cfg_(&ConfigYaml::engine_config) {
-    Config::ConfigPersistence persistence)
+    std::cout << "Game start\n";
-    : cfg_(&cfg),
-      persistence_(std::move(persistence)) {
-    std::cout << "Orni Attack - Inici\n";
 
     // Inicialitzar opciones con valors per defecte
-    persistence_.init_defaults();
+    ConfigYaml::init();
 
-    // Comprovar arguments del programa
+    // Convertir arguments a std::vector<std::string> i comprovar-los
+    std::vector<std::string> args(argv, argv + argc);
     executable_path_ = checkProgramArguments(args);
 
     // Inicialitzar sistema de rutes
@@ -96,14 +97,46 @@ Director::Director(std::vector<std::string> const& args,
     createSystemFolder(std::string("jailgames/") + Project::NAME);
 
     // Establir ruta del file de configuración
-    persistence_.set_path(system_folder_ + "/config.yaml");
+    ConfigYaml::setConfigFile(system_folder_ + "/config.yaml");
 
     // Carregar o crear configuración
-    persistence_.load();
+    ConfigYaml::loadFromFile();
+
+    // Carregar locale segons la config (per defecte "ca"). Si la càrrega
+    // falla, Locale::text() retorna la clau crua i el joc segueix funcionant.
+    Locale::get().load(std::string("locale/") + cfg_->locale + ".yaml");
 
     // Inicialitzar sistema de input
     Input::init("data/gamecontrollerdb.txt");
 
+    // Autoassignacio de primer arranque: si cap dels dos jugadors te mando
+    // assignat al config, repartim els que hi haja detectats (P1 = pad 0,
+    // P2 = pad 1 si existeix) i ho persistim. Aixo nomes dispara amb tots
+    // dos buits perque un "SENSE MANDO" explicit ha de sobreviure entre
+    // arrancades.
+    {
+        auto& p1 = cfg_->player1;
+        auto& p2 = cfg_->player2;
+        const bool BOTH_EMPTY = p1.gamepad_name.empty() && p1.gamepad_path.empty() && p2.gamepad_name.empty() && p2.gamepad_path.empty();
+        if (BOTH_EMPTY) {
+            const auto& pads = Input::get()->getGamepads();
+            bool changed = false;
+            if (!pads.empty() && pads[0]) {
+                p1.gamepad_name = pads[0]->name;
+                p1.gamepad_path = pads[0]->path;
+                changed = true;
+            }
+            if (pads.size() > 1 && pads[1]) {
+                p2.gamepad_name = pads[1]->name;
+                p2.gamepad_path = pads[1]->path;
+                changed = true;
+            }
+            if (changed) {
+                ConfigYaml::saveToFile();
+            }
+        }
+    }
+
     // Aplicar configuración de controls dels jugadors
     Input::get()->applyPlayer1Bindings(cfg_->player1);
     Input::get()->applyPlayer2Bindings(cfg_->player2);
@@ -117,22 +150,88 @@ Director::Director(std::vector<std::string> const& args,
     }
 
     std::cout << '\n';
+
+    // === Bootstrap de finestra, audio i subsistemes de runtime ===
+
+    int initial_width = static_cast<int>(std::round(
+        Defaults::Window::WIDTH * cfg_->window.zoom_factor));
+    int initial_height = static_cast<int>(std::round(
+        Defaults::Window::HEIGHT * cfg_->window.zoom_factor));
+
+    sdl_ = std::make_unique<SDLManager>(initial_width, initial_height, cfg_->window.fullscreen, *cfg_, [] { ConfigYaml::saveToFile(); });
+
+    // CRÍTIC: forçar ocultació del cursor DESPRÉS d'inicialitzar SDL,
+    // perquè la creació de la finestra el reactiva.
+    if (!cfg_->window.fullscreen) {
+        Mouse::forceHide();
+    }
+
+    const Audio::Config AUDIO_CONFIG{
+        .enabled = cfg_->audio.enabled,
+        .volume = cfg_->audio.volume,
+        .music_enabled = cfg_->audio.music_enabled,
+        .music_volume = cfg_->audio.music_volume,
+        .sound_enabled = cfg_->audio.sound_enabled,
+        .sound_volume = cfg_->audio.sound_volume,
+    };
+    Audio::init(AUDIO_CONFIG);
+    Audio::get()->applySettings(AUDIO_CONFIG);
+
+    // Precàrrega blocant de tots els recursos al boot per evitar hits d'I/O i
+    // de decodificació en transicions (TITLE → GAME, primera explosió, etc.).
+    // Mateix patró que aee_arcade: iterem `listResources` i forcem la càrrega
+    // al cache de cada subsistema.
+    for (const auto& path : Resource::Helper::listResources("music/")) {
+        AudioResource::getMusic(path.substr(std::string_view{"music/"}.size()));
+    }
+    for (const auto& path : Resource::Helper::listResources("sounds/")) {
+        AudioResource::getSound(path.substr(std::string_view{"sounds/"}.size()));
+    }
+    for (const auto& path : Resource::Helper::listResources("shapes/")) {
+        Graphics::ShapeLoader::load(path.substr(std::string_view{"shapes/"}.size()));
+    }
+    if (cfg_->console) {
+        std::cout << "Recursos precachejats (música, sons, shapes)\n";
+    }
+
+    context_ = std::make_unique<SceneContext>();
+#ifdef _DEBUG
+    context_->setNextScene(SceneType::TITLE);
+#else
+    context_->setNextScene(SceneType::LOGO);
+#endif
+
+    debug_overlay_ = std::make_unique<System::DebugOverlay>(
+        sdl_->getRenderer(),
+        cfg_->rendering);
+
+    System::Notifier::init(sdl_->getRenderer());
+    System::ServiceMenu::init(sdl_->getRenderer(), sdl_.get(), debug_overlay_.get());
+    System::DefineInputs::init(sdl_->getRenderer());
+
+    last_ticks_ms_ = SDL_GetTicks();
 }
 
 Director::~Director() {
     // Guardar opciones
-    persistence_.save();
+    ConfigYaml::saveToFile();
+
+    // Destruir subsistemes en ordre invers a la construcció. El Notifier
+    // referencia el renderer, així que ha de morir abans que sdl_.
+    // SDL_Quit() el crida SDL automàticament després de SDL_AppQuit; no
+    // l'hem de cridar nosaltres.
+    current_scene_.reset();
+    debug_overlay_.reset();
+    System::DefineInputs::destroy();
+    System::ServiceMenu::destroy();
+    System::Notifier::destroy();
+    context_.reset();
+    sdl_.reset();
 
-    // Cleanup input
     Input::destroy();
-
-    // Cleanup audio
     Audio::destroy();
 
-    // Cleanup SDL
+    std::cout << "\nBye!\n";
-    SDL_Quit();
-
-    std::cout << "\nAdéu!\n";
 }
 
 // Comprovar arguments del programa
@@ -145,8 +244,8 @@ auto Director::checkProgramArguments(std::vector<std::string> const& args)
             cfg_->console = true;
             std::cout << "Mode consola activat\n";
         } else if (argument == "--reset-config") {
-            persistence_.init_defaults();
+            ConfigYaml::init();
-            persistence_.save();
+            ConfigYaml::saveToFile();
             std::cout << "Configuración restablida als valors per defecte\n";
         }
     }
@@ -218,91 +317,13 @@ void Director::createSystemFolder(const std::string& folder) {
     }
 }
 
-// Bucle principal del juego
-auto Director::run() -> int {
-    // Calculate initial size from saved zoom_factor
-    int initial_width = static_cast<int>(std::round(
-        Defaults::Window::WIDTH * cfg_->window.zoom_factor));
-    int initial_height = static_cast<int>(std::round(
-        Defaults::Window::HEIGHT * cfg_->window.zoom_factor));
-
-    // Crear gestor SDL amb la engine_config + callback de persistència
-    // per a quan toggleVSync (F4) muti vsync. Mantenim sdl_manager agnòstic.
-    SDLManager sdl(initial_width, initial_height, cfg_->window.fullscreen, *cfg_, [this] { persistence_.save(); });
-
-    // CRÍTIC: Forçar ocultació del cursor DESPRÉS de toda la inicialización SDL
-    // Això evita que SDL mostre el cursor automàticament durante la creació de la finestra
-    if (!cfg_->window.fullscreen) {
-        Mouse::forceHide();
-    }
-
-    // Inicializar sistema de audio (config inyectada desde Defaults)
-    const Audio::Config AUDIO_CONFIG{
-        .enabled = Defaults::Audio::ENABLED,
-        .volume = Defaults::Audio::VOLUME,
-        .music_enabled = Defaults::Audio::MUSIC_ENABLED,
-        .music_volume = Defaults::Audio::MUSIC_VOLUME,
-        .sound_enabled = Defaults::Audio::SOUND_ENABLED,
-        .sound_volume = Defaults::Audio::SOUND_VOLUME,
-    };
-    Audio::init(AUDIO_CONFIG);
-    Audio::get()->applySettings(AUDIO_CONFIG);  // Aplicar volúmenes iniciales al motor
-
-    // Precachear música para evitar lag al empezar
-    AudioResource::getMusic("title.ogg");
-    AudioResource::getMusic("game.ogg");
-    if (cfg_->console) {
-        std::cout << "Música precacheada\n";
-    }
-
-    // Crear context de escenes
-    SceneContext context;
-#ifdef _DEBUG
-    context.setNextScene(SceneType::TITLE);
-#else
-    context.setNextScene(SceneType::LOGO);
-#endif
-
-    // Overlay de debug (FPS + VSync). Vive en el Director porque es global
-    // a todas las escenas. Toggle con F11 (visible por defecto en _DEBUG).
-    System::DebugOverlay debug_overlay(sdl.getRenderer(), cfg_->rendering);
-
-    // Sistema de notificacions toast: singleton accessible des d'on calgui
-    // (F1-F5 a sdl_manager, ESC a global_events). El renderer ha de viure
-    // tant com el Notifier; el destruim explícitament abans de tornar.
-    System::Notifier::init(sdl.getRenderer());
-
-    // Bucle principal: construir escena → frame loop → destruir → siguiente.
-    while (context.nextScene() != SceneType::EXIT) {
-        SceneManager::actual = context.nextScene();
-        std::unique_ptr<Scene> scene = buildScene(context.nextScene(), sdl, context);
-        if (!scene) {
-            break;
-        }
-        runFrameLoop(*scene, sdl, context, debug_overlay);
-    }
-
-    SceneManager::actual = SceneType::EXIT;
-    System::Notifier::destroy();
-    return 0;
-}
-
 auto Director::buildScene(SceneType type, SDLManager& sdl, SceneContext& context)
     -> std::unique_ptr<Scene> {
     switch (type) {
         case SceneType::LOGO:
             return std::make_unique<LogoScene>(sdl, context);
-        case SceneType::TITLE: {
+        case SceneType::TITLE:
-            // Env var ORNI_TITLE_3D=1 redirigeix la TITLE clàssica cap a la
-            // variant 3D real en proves; en qualsevol altre cas, la 2D.
-            const char* env = std::getenv("ORNI_TITLE_3D");
-            if (env != nullptr && env[0] == '1' && env[1] == '\0') {
-                return std::make_unique<TitleScene3D>(sdl, context);
-            }
             return std::make_unique<TitleScene>(sdl, context);
-        }
-        case SceneType::TITLE_3D:
-            return std::make_unique<TitleScene3D>(sdl, context);
         case SceneType::GAME:
             return std::make_unique<GameScene>(sdl, context);
         case SceneType::EXIT:
@@ -311,55 +332,108 @@ auto Director::buildScene(SceneType type, SDLManager& sdl, SceneContext& context
     }
 }
 
-void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context, System::DebugOverlay& debug_overlay) {
+auto Director::advanceScene() -> SDL_AppResult {
-    SDL_Event event;
+    current_scene_.reset();
-    Uint64 last_time = SDL_GetTicks();
+    const SceneType NEXT = context_->nextScene();
+    if (NEXT == SceneType::EXIT) {
+        SceneManager::actual = SceneType::EXIT;
+        return SDL_APP_SUCCESS;
+    }
+    SceneManager::actual = NEXT;
+    current_scene_ = buildScene(NEXT, *sdl_, *context_);
+    if (!current_scene_) {
+        SceneManager::actual = SceneType::EXIT;
+        return SDL_APP_SUCCESS;
+    }
+    return SDL_APP_CONTINUE;
+}
 
-    while (!scene.isFinished()) {
+auto Director::handleEvent(const SDL_Event& event) -> SDL_AppResult {
-        // Delta time real, capeado a 50ms para evitar grandes saltos.
+    // 1. Window events (resize, minimize, focus...)
+    if (sdl_->handleWindowEvent(event)) {
+        return SDL_APP_CONTINUE;
+    }
+
+    // 2. Events globals (F1-F6, ESC, QUIT, gamepad hotplug).
+    // GlobalEvents marca context_->nextScene() = EXIT en ESC doble o QUIT;
+    // activem la bandera per fer-ho fluir cap a SDL_APP_SUCCESS al pròxim tick.
+    if (GlobalEvents::handle(event, *sdl_, *context_)) {
+        if (context_->nextScene() == SceneType::EXIT) {
+            wants_quit_ = true;
+        }
+        return SDL_APP_CONTINUE;
+    }
+
+    // 3. F11 → toggle del debug overlay (cas especial fora de GlobalEvents).
+    if (event.type == SDL_EVENT_KEY_DOWN && event.key.scancode == SDL_SCANCODE_F11) {
+        debug_overlay_->toggle();
+        return SDL_APP_CONTINUE;
+    }
+
+    // 4. Esdeveniment específic de l'escena actual.
+    if (current_scene_) {
+        current_scene_->handleEvent(event);
+    }
+    return SDL_APP_CONTINUE;
+}
+
+auto Director::iterate() -> SDL_AppResult {
+    if (wants_quit_) {
+        return SDL_APP_SUCCESS;
+    }
+
+    // Pivotar a la següent escena si l'actual ha acabat (o és la primera).
+    if (!current_scene_ || current_scene_->isFinished()) {
+        SDL_AppResult pivot = advanceScene();
+        if (pivot != SDL_APP_CONTINUE) {
+            return pivot;
+        }
+    }
+
+    // Delta time real, capeado a 50ms per evitar grans salts.
     const Uint64 NOW = SDL_GetTicks();
-        float delta_time = static_cast<float>(NOW - last_time) / 1000.0F;
+    float delta_time = static_cast<float>(NOW - last_ticks_ms_) / 1000.0F;
-        last_time = NOW;
+    last_ticks_ms_ = NOW;
     delta_time = std::min(delta_time, 0.05F);
 
     Mouse::updateCursorVisibility();
     Input::get()->update();
 
-        // Event loop: primero ventana, después globales, después F11
+    current_scene_->update(delta_time);
-        // (toggle del overlay), después escena.
+    debug_overlay_->update(delta_time);
-        while (SDL_PollEvent(&event)) {
-            if (sdl.handleWindowEvent(event)) {
-                continue;
-            }
-            if (GlobalEvents::handle(event, sdl, context)) {
-                continue;
-            }
-            if (event.type == SDL_EVENT_KEY_DOWN && event.key.scancode == SDL_SCANCODE_F11) {
-                debug_overlay.toggle();
-                continue;
-            }
-            scene.handleEvent(event);
-        }
-
-        scene.update(delta_time);
-        debug_overlay.update(delta_time);
     if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
         notifier->update(delta_time);
     }
+    if (auto* menu = System::ServiceMenu::get(); menu != nullptr) {
+        menu->update(delta_time);
+    }
+    if (auto* di = System::DefineInputs::get(); di != nullptr) {
+        di->update(delta_time);
+    }
     Audio::update();
 
-        // Si la swapchain no está disponible (ventana minimizada, etc.),
+    // Si la swapchain no està disponible (finestra minimitzada, etc.),
-        // saltarse draw+present ese frame: dibujar dejaría vértices
+    // saltar-se draw+present aquest frame.
-        // colgando en el batch interno sin nadie que los presente.
+    if (!sdl_->clear(0, 0, 0)) {
-        if (!sdl.clear(0, 0, 0)) {
+        return SDL_APP_CONTINUE;
-            continue;
     }
-        sdl.updateRenderingContext();
+    sdl_->updateRenderingContext();
-        scene.draw();
+    current_scene_->draw();
-        debug_overlay.draw();  // sempre per damunt de l'escena
+    debug_overlay_->draw();  // sempre per damunt de l'escena
     if (const auto* notifier = System::Notifier::get(); notifier != nullptr) {
         notifier->draw();  // toast: per damunt de tot
     }
-        sdl.present();
+    // Mentre l'overlay de redefinicio esta actiu, amaguem el menu de servei
+    // (encara queda "open" per a absorbir events un cop el modal s'auto-tanqui,
+    // pero no es pinta per no confondre's visualment amb el modal).
+    const auto* di = System::DefineInputs::get();
+    const bool DEFINE_ACTIVE = (di != nullptr) && di->isActive();
+    if (const auto* menu = System::ServiceMenu::get(); menu != nullptr && !DEFINE_ACTIVE) {
+        menu->draw();  // service menu: per damunt fins i tot dels toasts
     }
+    if (di != nullptr) {
+        di->draw();  // overlay de rebind: per damunt de tot
+    }
+    sdl_->present();
+    return SDL_APP_CONTINUE;
 }

source/core/system/director.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <SDL3/SDL.h>
+
 #include <memory>
 #include <string>
 #include <vector>
@@ -15,22 +17,38 @@ namespace System {
 
 class Director {
    public:
-    // `cfg` ha de viure tant com el Director (típicament owned per main).
+    // El Director és el programa: posseeix la configuració (via ConfigYaml)
-    // `persistence` encapsula init/load/save delegats a la capa concreta
+    // i orquestra tots els subsistemes. main.cpp és pur tràmit que el
-    // (game/ConfigYaml::*).
+    // construeix i delega cap a SDL.
-    Director(std::vector<std::string> const& args,
+    Director(int argc, char* argv[]);
-        Config::EngineConfig& cfg,
-        Config::ConfigPersistence persistence);
     ~Director();
 
-    // Bucle principal del juego.
+    // Una iteració del bucle: pivot d'escena si cal, delta time, update i
-    auto run() -> int;
+    // render. Retorna SDL_APP_CONTINUE per seguir, SDL_APP_SUCCESS si vol
+    // sortir net, SDL_APP_FAILURE si no es pot recuperar.
+    auto iterate() -> SDL_AppResult;
+
+    // Enruta un sol esdeveniment cap a la cadena finestra → globals → F11 →
+    // escena. Si detecta sortida (ESC doble, QUIT) marca wants_quit_ perquè
+    // el següent iterate() retorni SDL_APP_SUCCESS.
+    auto handleEvent(const SDL_Event& event) -> SDL_AppResult;
 
    private:
     std::string executable_path_;
     std::string system_folder_;
-    Config::EngineConfig* cfg_;
+    Config::EngineConfig* cfg_{nullptr};
-    Config::ConfigPersistence persistence_;
+
+    // Subsistemes que viuen tant com el Director (abans eren locals de run()).
+    // Preparació per a la migració a SDL_MAIN_USE_CALLBACKS: amb les 4
+    // callbacks de SDL3 no hi ha un scope que englobi tot el bucle, així
+    // que cal que aquest estat sigui membre del Director.
+    std::unique_ptr<SDLManager> sdl_;
+    std::unique_ptr<SceneManager::SceneContext> context_;
+    std::unique_ptr<System::DebugOverlay> debug_overlay_;
+    std::unique_ptr<Scene> current_scene_;
+
+    Uint64 last_ticks_ms_{0};
+    bool wants_quit_{false};
 
     auto checkProgramArguments(std::vector<std::string> const& args)
         -> std::string;
@@ -43,8 +61,8 @@ class Director {
         SceneManager::SceneContext& context)
         -> std::unique_ptr<Scene>;
 
-    // Ejecuta el bucle de frames de UNA escena hasta que scene.isFinished()
+    // Pivota a la següent escena: destrueix l'actual, llegeix context_->nextScene()
-    // sea true. Maneja delta_time, eventos (globales + escena), update y draw.
+    // i construeix la nova. Retorna SDL_APP_SUCCESS si la nova és EXIT o no es pot
-    // El debug_overlay es global a todas las escenas; el Director lo posee.
+    // construir; SDL_APP_CONTINUE si tot OK.
-    static void runFrameLoop(Scene& scene, SDLManager& sdl, SceneManager::SceneContext& context, System::DebugOverlay& debug_overlay);
+    auto advanceScene() -> SDL_AppResult;
 };

source/core/system/game_config.hpp

@@ -4,52 +4,52 @@
 
 namespace GameConfig {
 
-// Mode de juego
+    // Mode de juego
-enum class Mode : std::uint8_t {
+    enum class Mode : std::uint8_t {
         NORMAL,  // Partida normal
         DEMO     // Mode demostració (futur)
-};
+    };
 
-// Configuración de una match
+    // Configuración de una match
-struct MatchConfig {
+    struct MatchConfig {
-        bool jugador1_actiu{false};  // Es active el player 1?
+        bool player1_active{false};  // Es active el player 1?
-        bool jugador2_actiu{false};  // Es active el player 2?
+        bool player2_active{false};  // Es active el player 2?
         Mode mode{Mode::NORMAL};     // Mode de juego
 
         // Métodos auxiliars
 
         // Retorna true si solo hay un player active
         [[nodiscard]] auto isSinglePlayer() const -> bool {
-            return (jugador1_actiu && !jugador2_actiu) ||
+            return (player1_active && !player2_active) ||
-                (!jugador1_actiu && jugador2_actiu);
+                (!player1_active && player2_active);
         }
 
         // Retorna true si hay dos jugadors active
         [[nodiscard]] auto isCoop() const -> bool {
-            return jugador1_actiu && jugador2_actiu;
+            return player1_active && player2_active;
         }
 
         // Retorna true si no hay sin player active
         [[nodiscard]] auto hasNoPlayers() const -> bool {
-            return !jugador1_actiu && !jugador2_actiu;
+            return !player1_active && !player2_active;
         }
 
         // Compte de jugadors active (0, 1 o 2)
         [[nodiscard]] auto getPlayerCount() const -> uint8_t {
-            return (jugador1_actiu ? 1 : 0) + (jugador2_actiu ? 1 : 0);
+            return (player1_active ? 1 : 0) + (player2_active ? 1 : 0);
         }
 
         // Retorna l'ID de l'únic player active (0 o 1)
         // Solo vàlid si es_un_jugador() retorna true
         [[nodiscard]] auto getSinglePlayerId() const -> uint8_t {
-            if (jugador1_actiu && !jugador2_actiu) {
+            if (player1_active && !player2_active) {
                 return 0;
             }
-            if (!jugador1_actiu && jugador2_actiu) {
+            if (!player1_active && player2_active) {
                 return 1;
             }
             return 0;  // Fallback (necesario comprovar es_un_jugador() primer)
         }
-};
+    };
 
 }  // namespace GameConfig

source/core/system/global_events.cpp

@@ -5,10 +5,14 @@
 
 #include <iostream>
 
+#include "core/input/define_inputs.hpp"
 #include "core/input/input.hpp"
 #include "core/input/mouse.hpp"
+#include "core/locale/locale.hpp"
 #include "core/rendering/sdl_manager.hpp"
 #include "core/system/notifier.hpp"
+#include "core/system/service_menu.hpp"
+#include "game/config_yaml.hpp"
 #include "scene_context.hpp"
 
 // Using declarations per simplificar el codi
@@ -17,6 +21,81 @@ using SceneType = SceneContext::SceneType;
 
 namespace GlobalEvents {
 
+    namespace {
+
+        // Reenvia events al menu de servei si esta obert. Accepta:
+        //   - KEY_DOWN (excepte F1-F12 i ESC, que sempre passen com a globals)
+        //   - GAMEPAD_BUTTON_DOWN (per navegacio amb dpad + FIRE/ACCELERATE)
+        //   - GAMEPAD_AXIS_MOTION (per navegacio amb stick)
+        // Retorna true si l'event s'ha entregat al menu.
+        auto forwardToServiceMenu(const SDL_Event& event) -> bool {
+            auto* menu = System::ServiceMenu::get();
+            if (menu == nullptr || !menu->isOpen()) {
+                return false;
+            }
+            if (event.type == SDL_EVENT_KEY_DOWN) {
+                const SDL_Scancode SC = event.key.scancode;
+                const bool PASSTHROUGH = (SC == SDL_SCANCODE_ESCAPE) ||
+                    (SC >= SDL_SCANCODE_F1 && SC <= SDL_SCANCODE_F12);
+                if (PASSTHROUGH) {
+                    return false;
+                }
+                menu->handleEvent(event);
+                return true;
+            }
+            if (event.type == SDL_EVENT_GAMEPAD_BUTTON_DOWN ||
+                event.type == SDL_EVENT_GAMEPAD_AXIS_MOTION) {
+                menu->handleEvent(event);
+                return true;
+            }
+            return false;
+        }
+
+        // Engoleix els events que DefineInputs vol consumir mentre l'overlay
+        // es actiu. Els events que el modul torna a passar (QUIT, ESC) cauen
+        // cap al pipeline normal i poden tancar la finestra o obrir el prompt
+        // d'eixida sense haver de completar la sequencia.
+        auto consumeIfDefineActive(const SDL_Event& event) -> bool {
+            auto* di = System::DefineInputs::get();
+            if (di == nullptr || !di->isActive()) {
+                return false;
+            }
+            return di->handleEvent(event);
+        }
+
+        // Botó MENU al mando d'algun jugador → alterna el menú de servei
+        // (mateix comportament que F12 al teclat). Retorna true si l'event és
+        // un GAMEPAD_BUTTON_DOWN consumit.
+        auto handleGamepadMenuButton(const SDL_Event& event) -> bool {
+            if (event.type != SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+                return false;
+            }
+            auto* input = Input::get();
+            if (input == nullptr) {
+                return false;
+            }
+            auto match_player = [&](int player_index) {
+                auto pad = input->getPlayerGamepad(player_index);
+                if (!pad || pad->instance_id != event.gbutton.which) {
+                    return false;
+                }
+                auto it = pad->bindings.find(InputAction::MENU);
+                if (it == pad->bindings.end()) {
+                    return false;
+                }
+                return it->second.button == static_cast<int>(event.gbutton.button);
+            };
+            if (!match_player(0) && !match_player(1)) {
+                return false;
+            }
+            if (auto* menu = System::ServiceMenu::get(); menu != nullptr) {
+                menu->toggle();
+            }
+            return true;
+        }
+
+    }  // namespace
+
     auto handle(const SDL_Event& event, SDLManager& sdl, SceneContext& context) -> bool {
         // 1. Permitir que Input procese el evento (para hotplug de gamepads)
         auto event_msg = Input::get()->handleEvent(event);
@@ -24,6 +103,12 @@ namespace GlobalEvents {
             std::cout << "[Input] " << event_msg << '\n';
         }
 
+        // 1b. Si l'overlay de redefinicio esta actiu, engoleix tots els events
+        // (cap arriba al joc, al menu de servei ni als hotkeys F1-F12).
+        if (consumeIfDefineActive(event)) {
+            return true;
+        }
+
         // 2. Procesar SDL_EVENT_QUIT directamente (no es input de juego)
         if (event.type == SDL_EVENT_QUIT) {
             context.setNextScene(SceneType::EXIT);
@@ -34,7 +119,20 @@ namespace GlobalEvents {
         // 3. Gestió del ratolí (auto-ocultar)
         Mouse::handleEvent(event);
 
-        // 4. Procesar acciones globales directamente desde eventos SDL
+        // 3b. Botó MENU al mando (equivalent a F12)
+        if (handleGamepadMenuButton(event)) {
+            return true;
+        }
+
+        // 4. Service Menu (F12): consumeix tot KEY_DOWN excepte tecles de
+        // funció (F1-F12) i ESC, que continuen sent globals (zoom, fullscreen,
+        // vsync, AA, postfx, locale, exit prompt). Aixi el menu captura
+        // ENTER/BACKSPACE/UP/DOWN/LEFT/RIGHT i lletres mentre esta obert.
+        if (forwardToServiceMenu(event)) {
+            return true;
+        }
+
+        // 5. Procesar acciones globales directamente desde eventos SDL
         // (NO usar Input::checkAction() para evitar desfase de timing)
         if (event.type == SDL_EVENT_KEY_DOWN) {
             switch (event.key.scancode) {
@@ -62,6 +160,35 @@ namespace GlobalEvents {
                     sdl.togglePostFx();
                     return true;
 
+                case SDL_SCANCODE_F7: {
+                    // Toggle d'idioma en runtime entre català i anglès. Els
+                    // strings ja capturats (toast actiu, banner stage start)
+                    // sobreviuen fins al seu cicle; la resta (HUD, pantalles,
+                    // pròxims toasts) es refresquen al següent frame perquè
+                    // criden Locale::text() cada draw.
+                    const std::string NEW_LANG = (ConfigYaml::engine_config.locale == "ca") ? "en" : "ca";
+                    if (Locale::get().switchTo(NEW_LANG)) {
+                        ConfigYaml::engine_config.locale = NEW_LANG;
+                        ConfigYaml::saveToFile();
+                        if (auto* notifier = System::Notifier::get(); notifier != nullptr) {
+                            notifier->notifyInfo(localeSubstitute(
+                                Locale::get().text("notification.locale_switched"),
+                                "{lang}",
+                                Locale::get().text("language." + NEW_LANG)));
+                        }
+                    }
+                    return true;
+                }
+
+                case SDL_SCANCODE_F12: {
+                    // Toggle del menu de servei. Sempre passa com a global
+                    // (alterna obert/tancat des de qualsevol escena).
+                    if (auto* menu = System::ServiceMenu::get(); menu != nullptr) {
+                        menu->toggle();
+                    }
+                    return true;
+                }
+
                 case SDL_SCANCODE_ESCAPE: {
                     // Doble pulsació per confirmar sortida: la primera ESC
                     // dispara un toast d'avís; només si aquest toast concret
@@ -71,7 +198,7 @@ namespace GlobalEvents {
                     // sortida en lloc de tancar.
                     auto* notifier = System::Notifier::get();
                     if (notifier != nullptr && !notifier->isExitPromptActive()) {
-                        notifier->notifyExit("PREMEU ESC UN ALTRE COP PER EIXIR");
+                        notifier->notifyExit(Locale::get().text("notification.press_again_exit"));
                         return true;
                     }
                     // Notifier inexistent (degradació elegant) o segona ESC

source/core/system/relaunch.cpp

@@ -0,0 +1,61 @@
+// relaunch.cpp - Implementacio del reinici en calent
+// © 2026 JailDesigner
+
+#include "core/system/relaunch.hpp"
+
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+
+#ifdef _WIN32
+#include <process.h>  // _execv
+#else
+#include <unistd.h>  // execv
+#endif
+
+namespace {
+
+    // Estat global (process-scope). Aquesta TU es la unica que gestiona el
+    // reinici, aixi que els static interns no s'escapen.
+    char** g_argv = nullptr;
+    bool g_requested = false;
+
+}  // namespace
+
+namespace System::Relaunch {
+
+    void setArgv(int /*argc*/, char** argv) {
+        g_argv = argv;
+    }
+
+    void request() {
+        g_requested = true;
+    }
+
+    auto isRequested() -> bool {
+        return g_requested;
+    }
+
+    void execIfRequested() {
+#ifdef __EMSCRIPTEN__
+        // Al navegador el reinici real seria location.reload(); aqui no fem res.
+        return;
+#else
+        if (!g_requested || g_argv == nullptr || g_argv[0] == nullptr) {
+            return;
+        }
+        std::cout << "[Relaunch] Reiniciant " << g_argv[0] << "...\n";
+#ifdef _WIN32
+        _execv(g_argv[0], g_argv);
+#else
+        execv(g_argv[0], g_argv);
+#endif
+        // Si arribem aqui, execv ha fallat. Tots els subsistemes ja estan
+        // destruits; sortim amb error i el shell rebra el codi.
+        std::cerr << "[Relaunch] Ha fallat: " << std::strerror(errno) << '\n';
+        std::exit(EXIT_FAILURE);
+#endif
+    }
+
+}  // namespace System::Relaunch

source/core/system/relaunch.hpp

@@ -0,0 +1,33 @@
+// relaunch.hpp - Reinici en calent del proces (execv)
+// © 2026 JailDesigner
+//
+// Helper desacoblat per a permetre que el menu de servei demani un reinici
+// sense conèixer Director ni main.cpp. Patro:
+//
+//   main()       → Relaunch::setArgv(argc, argv)      (a l'arrencada)
+//   ServiceMenu  → Relaunch::request()                 (en activar REINICIAR)
+//   main()       → Relaunch::execIfRequested()         (a SDL_AppQuit)
+//
+// L'execv() reemplaca el proces actual: si torna, ha fallat. A EMSCRIPTEN
+// no es pot reiniciar; isRequested() seguira dient true pero execIfRequested
+// sera no-op.
+
+#pragma once
+
+namespace System::Relaunch {
+
+    // Emmagatzema l'argv original. Cal cridar-ho una vegada des de main.
+    void setArgv(int argc, char** argv);
+
+    // Demana un reinici (no actua immediatament; nomes marca el flag).
+    void request();
+
+    // Consulta del flag.
+    [[nodiscard]] auto isRequested() -> bool;
+
+    // Si hi ha reinici demanat i tenim argv valid, fa execv. En cas d'exit
+    // no torna. Si execv falla, registra l'error i torna; el caller hauria
+    // de sortir normalment.
+    void execIfRequested();
+
+}  // namespace System::Relaunch

source/core/system/scene_context.hpp

@@ -16,10 +16,7 @@ namespace SceneManager {
         // Tipo de escena del juego
         enum class SceneType : std::uint8_t {
             LOGO,   // Pantalla de start (logo JAILGAMES)
-            TITLE,     // Pantalla de título (versió 2D actual). Si l'env var
+            TITLE,  // Pantalla de título (3D)
-                       // ORNI_TITLE_3D=1 està activa, Director::buildScene
-                       // redirigeix aquest valor a TitleScene3D.
-            TITLE_3D,  // Pantalla de títol 3D real (variant en proves)
             GAME,   // Juego principal (Asteroids)
             EXIT    // Salir del programa
         };

source/core/system/service_menu.hpp

@@ -0,0 +1,179 @@
+// service_menu.hpp - Menu de servei (singleton)
+// © 2026 JailDesigner
+//
+// Overlay de configuracio global accessible amb F12 des de qualsevol escena
+// (LOGO, TITLE, GAME). Captura tots els KEY_DOWN excepte F1-F12 i ESC, que
+// continuen arribant a GlobalEvents. Mentre esta obert, GameScene::update()
+// fa early return per pausar el joc; LOGO i TITLE continuen renderitzant-se
+// sota el menu.
+//
+// Arquitectura inspirada en aee_arcade service_menu.{hpp,cpp}: pila de
+// pagines amb cursor, animacio open/close amb easing easeOutQuad i clipping
+// del contingut mentre la caixa creix/decreix.
+//
+// API singleton equivalent a Notifier: init() al startup amb un renderer,
+// get() retorna el punter, destroy() al teardown.
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "core/graphics/vector_text.hpp"
+#include "core/rendering/render_context.hpp"
+
+class SDLManager;
+
+namespace System {
+
+    class DebugOverlay;
+
+    class ServiceMenu {
+       public:
+        // Tipus d'item de menu. En aquesta iteracio nomes s'usen SUBMENU i
+        // LABEL; la resta queden reservats per a iteracions futures (toggles
+        // de vsync/zoom, picker d'idioma, restart, exit...).
+        enum class Kind : std::uint8_t {
+            LABEL,      // No interactiu, nomes es dibuixa
+            TOGGLE,     // bool flip — reservat
+            CYCLE,      // index amb modul — reservat
+            INT_RANGE,  // step ± — reservat
+            SUBMENU,    // pushPage en activar — usat
+            ACTION      // call al lambda en activar — reservat
+        };
+
+        struct Item {
+            Kind kind = Kind::LABEL;
+            std::string label_key;   // Clau de locale (s'ignora si label_text no esta buit)
+            std::string label_text;  // Text literal (no locale). Util per a labels que no necessiten traduccio (resolucions, etc.)
+            bool selectable = true;
+            // SUBMENU / ACTION: callback en ENTER / RIGHT.
+            std::function<void()> on_activate;
+            // TOGGLE / CYCLE / INT_RANGE: text del valor actual (renderitzat a la dreta).
+            std::function<std::string()> get_value_text;
+            // TOGGLE / CYCLE / INT_RANGE: callback amb +1 (RIGHT/ENTER) o -1 (LEFT).
+            std::function<void(int)> on_change;
+        };
+
+        struct Page {
+            std::string title_key;
+            // Subtitol opcional, renderitzat sota el titol amb tipografia mes
+            // petita i color apagat. Es una funcio perque pot ser dinamic
+            // (versio+hash, etc.). Si esta buit, no es renderitza.
+            std::function<std::string()> subtitle_provider;
+            std::vector<Item> items;
+            std::size_t cursor = 0;
+        };
+
+        // Inicialitza el singleton amb el renderer global, l'SDLManager (video
+        // toggles: fullscreen, vsync, AA, postfx, zoom) i el DebugOverlay
+        // (toggle del HUD de debug a OPCIONS). Tots propietat del Director.
+        static void init(Rendering::Renderer* renderer, SDLManager* sdl, DebugOverlay* debug_overlay);
+        static void destroy();
+        [[nodiscard]] static auto get() -> ServiceMenu*;
+
+        // F12: alterna obrir/tancar amb animacio.
+        void toggle();
+        [[nodiscard]] auto isOpen() const -> bool;
+
+        void update(float delta_time);
+        void draw() const;
+
+        // Processa events de navegacio. Retorna true si l'event s'ha consumit.
+        // Accepta:
+        //   - SDL_EVENT_KEY_DOWN: UP/DOWN/ENTER/RIGHT/LEFT/BACKSPACE.
+        //   - SDL_EVENT_GAMEPAD_BUTTON_DOWN: DPAD per nav, FIRE = ENTER,
+        //     ACCELERATE = BACK. La resta de botons s'ignoren.
+        //   - SDL_EVENT_GAMEPAD_AXIS_MOTION: stick X/Y amb edge-detect.
+        auto handleEvent(const SDL_Event& event) -> bool;
+
+       private:
+        ServiceMenu(Rendering::Renderer* renderer, SDLManager* sdl, DebugOverlay* debug_overlay);
+
+        // Sub-handlers de handleEvent. Privats, no son part de l'API publica.
+        auto handleKeyDown(const SDL_Event& event) -> bool;
+        auto handleGamepadButton(const SDL_Event& event) -> bool;
+        auto handleGamepadAxis(const SDL_Event& event) -> bool;
+        // Helpers per a cada eix; permeten que handleGamepadAxis es quedi
+        // com a dispatcher i no bote el llindar de complexitat.
+        void processStickX(Sint16 val);
+        void processStickY(Sint16 val);
+        void processTriggerEdge(SDL_JoystickID which, Sint16 val, int virtual_button, bool& held);
+
+        void buildRootPage();
+        [[nodiscard]] auto buildVideoPage() -> Page;
+        [[nodiscard]] auto buildResolutionPage() const -> Page;
+        [[nodiscard]] static auto buildAudioPage() -> Page;
+        [[nodiscard]] auto buildOptionsPage() const -> Page;
+        [[nodiscard]] auto buildSystemPage() -> Page;
+        [[nodiscard]] auto buildControlsPage() -> Page;
+        // Llista de mandos detectats per a un jugador. Cada item assigna el
+        // pad triat (amb swap automatic si l'altre jugador ja el tenia) i
+        // tanca la picker amb popPage. L'ultim item es "SENSE MANDO" per a
+        // desasignar.
+        [[nodiscard]] auto buildPadPickerPage(int player_index) -> Page;
+        // Pagina de confirmacio "ESTAS SEGUR? NO/SI". on_yes s'executa si
+        // l'usuari selecciona SI; el cursor per defecte apunta a NO.
+        void pushConfirmPage(const std::string& title_key, std::function<void()> on_yes);
+        void pushPage(Page page);
+        void popPage();
+        void moveCursor(int direction);
+        void activateCurrent();
+        // RIGHT (direction=+1) / LEFT (direction=-1). Per a TOGGLE/CYCLE/INT_RANGE
+        // crida on_change. Per a SUBMENU/ACTION nomes +1 (entra/activa).
+        void changeValue(int direction);
+
+        // Alçada objectiu de la caixa per a la pagina superior (sense animacio).
+        [[nodiscard]] auto computeTargetHeight() const -> float;
+
+        // Ample objectiu de la caixa per a la pagina superior (sense animacio).
+        // Pren com a base BOX_WIDTH_MIN i s'eixampla si algun text no hi cap.
+        [[nodiscard]] auto computeTargetWidth() const -> float;
+
+        // Y (top) de l'item index dins una caixa col·locada a box_y. Si la
+        // pagina te subtitol, els items es desplacen cap avall.
+        [[nodiscard]] static auto computeItemTopY(float box_y, std::size_t index, bool has_subtitle) -> float;
+
+        Rendering::Renderer* renderer_;
+        SDLManager* sdl_;
+        DebugOverlay* debug_overlay_;
+        Graphics::VectorText text_;
+
+        std::vector<Page> stack_;
+        bool open_ = false;
+        bool closing_ = false;
+        float open_anim_ = 0.0F;   // 0..1 raw (sense easing)
+        float animated_h_ = 0.0F;  // Alçada animada amb smoothing exponencial
+        float animated_w_ = 0.0F;  // Ample animat (eixampla segons contingut)
+
+        // Estat del highlight (rectangle del cursor). Es lerpa cap a l'item
+        // actiu amb ease-out exponencial; quan el cursor "salta" (open o
+        // push/pop de pagina), s'enganxa directament al nou objectiu.
+        float highlight_y_ = 0.0F;
+        float highlight_h_ = 0.0F;
+        bool highlight_snap_ = true;
+
+        // Edge-detect de stick analogic per a navegacio. Una sola activacio
+        // per direccio: cal tornar a centre (sota el llindar) per disparar
+        // una altra. Compartit entre tots els pads — qualsevol jugador pot
+        // navegar el menu.
+        bool stick_left_held_ = false;
+        bool stick_right_held_ = false;
+        bool stick_up_held_ = false;
+        bool stick_down_held_ = false;
+        // Edge-detect dels triggers L2/R2 com a botons virtuals. SDL3 no
+        // emet button events per als triggers; els llegim com a axis i
+        // sintetitzem una pulsacio quan creuen el llindar.
+        bool trigger_l2_held_ = false;
+        bool trigger_r2_held_ = false;
+
+        static std::unique_ptr<ServiceMenu> instance;
+    };
+
+}  // namespace System

source/core/utils/string_utils.hpp

@@ -0,0 +1,23 @@
+// string_utils.hpp - Utilitats genèriques de cadenes
+// © 2026 JailDesigner
+//
+// VectorText només admet ASCII en majúscules; les notificacions, el menú
+// de servei i l'overlay de rebind passen els textos dinàmics per aquest
+// helper abans de pintar-los.
+
+#pragma once
+
+#include <cctype>
+#include <string>
+
+namespace Utils {
+
+    inline auto toUpperAscii(const std::string& s) -> std::string {
+        std::string result = s;
+        for (char& c : result) {
+            c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
+        }
+        return result;
+    }
+
+}  // namespace Utils

source/game/config_yaml.cpp

@@ -5,6 +5,7 @@
 #include <string>
 #include <unordered_map>
 
+#include "core/defaults/audio.hpp"
 #include "core/defaults/rendering.hpp"
 #include "core/defaults/window.hpp"
 #include "external/fkyaml_node.hpp"
@@ -17,9 +18,11 @@ namespace ConfigYaml {
         // Permeten escriure window.width en lloc d'engine_config.window.width.
         Config::WindowConfig& window = engine_config.window;
         Config::RenderingConfig& rendering = engine_config.rendering;
+        Config::AudioConfig& audio = engine_config.audio;
         Config::PlayerBindings& player1 = engine_config.player1;
         Config::PlayerBindings& player2 = engine_config.player2;
         bool& console = engine_config.console;
+        std::string& locale = engine_config.locale;
     }  // namespace
 
     // ========== FUNCIONS AUXILIARS PER CONVERSIÓ DE CONTROLES ==========
@@ -208,6 +211,17 @@ namespace ConfigYaml {
         rendering.render_width = Defaults::Rendering::RENDER_WIDTH_DEFAULT;
         rendering.render_height = Defaults::Rendering::RENDER_HEIGHT_DEFAULT;
 
+        // Audio
+        audio.enabled = Defaults::Audio::ENABLED;
+        audio.volume = Defaults::Audio::VOLUME;
+        audio.music_enabled = Defaults::Audio::MUSIC_ENABLED;
+        audio.music_volume = Defaults::Audio::MUSIC_VOLUME;
+        audio.sound_enabled = Defaults::Audio::SOUND_ENABLED;
+        audio.sound_volume = Defaults::Audio::SOUND_VOLUME;
+
+        // Idioma
+        locale = "ca";
+
         // Version
         version = std::string(Project::VERSION);
     }
@@ -303,6 +317,22 @@ namespace ConfigYaml {
         }
     }
 
+    static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
+        if (!yaml.contains("audio")) {
+            return;
+        }
+        const auto& aud = yaml["audio"];
+
+        auto in_unit_range = [](float v) { return v >= 0.0F && v <= 1.0F; };
+
+        readField(aud, "enabled", audio.enabled, Defaults::Audio::ENABLED);
+        readField(aud, "volume", audio.volume, Defaults::Audio::VOLUME, in_unit_range);
+        readField(aud, "music_enabled", audio.music_enabled, Defaults::Audio::MUSIC_ENABLED);
+        readField(aud, "music_volume", audio.music_volume, Defaults::Audio::MUSIC_VOLUME, in_unit_range);
+        readField(aud, "sound_enabled", audio.sound_enabled, Defaults::Audio::SOUND_ENABLED);
+        readField(aud, "sound_volume", audio.sound_volume, Defaults::Audio::SOUND_VOLUME, in_unit_range);
+    }
+
     // Carregar controls del player 1 desde YAML
     static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
         if (!yaml.contains("player1")) {
@@ -343,12 +373,21 @@ namespace ConfigYaml {
             if (gp.contains("button_shoot")) {
                 player1.gamepad.button_shoot = stringToButton(gp["button_shoot"].get_value<std::string>());
             }
+            if (gp.contains("button_start")) {
+                player1.gamepad.button_start = stringToButton(gp["button_start"].get_value<std::string>());
+            }
+            if (gp.contains("button_menu")) {
+                player1.gamepad.button_menu = stringToButton(gp["button_menu"].get_value<std::string>());
+            }
         }
 
-        // Carregar nom del gamepad
+        // Carregar nom i path del gamepad assignat
         if (p1.contains("gamepad_name")) {
             player1.gamepad_name = p1["gamepad_name"].get_value<std::string>();
         }
+        if (p1.contains("gamepad_path")) {
+            player1.gamepad_path = p1["gamepad_path"].get_value<std::string>();
+        }
     }
 
     // Carregar controls del player 2 desde YAML
@@ -391,12 +430,21 @@ namespace ConfigYaml {
             if (gp.contains("button_shoot")) {
                 player2.gamepad.button_shoot = stringToButton(gp["button_shoot"].get_value<std::string>());
             }
+            if (gp.contains("button_start")) {
+                player2.gamepad.button_start = stringToButton(gp["button_start"].get_value<std::string>());
+            }
+            if (gp.contains("button_menu")) {
+                player2.gamepad.button_menu = stringToButton(gp["button_menu"].get_value<std::string>());
+            }
         }
 
-        // Carregar nom del gamepad
+        // Carregar nom i path del gamepad assignat
         if (p2.contains("gamepad_name")) {
             player2.gamepad_name = p2["gamepad_name"].get_value<std::string>();
         }
+        if (p2.contains("gamepad_path")) {
+            player2.gamepad_path = p2["gamepad_path"].get_value<std::string>();
+        }
     }
 
     // Carregar configuración des del file YAML
@@ -443,9 +491,20 @@ namespace ConfigYaml {
             // Carregar seccions
             loadWindowConfigFromYaml(yaml);
             loadRenderingConfigFromYaml(yaml);
+            loadAudioConfigFromYaml(yaml);
             loadPlayer1ControlsFromYaml(yaml);
             loadPlayer2ControlsFromYaml(yaml);
 
+            // Idioma (opcional; valors admesos: "ca" | "en")
+            if (yaml.contains("locale")) {
+                try {
+                    auto val = yaml["locale"].get_value<std::string>();
+                    locale = (val == "ca" || val == "en") ? val : "ca";
+                } catch (...) {
+                    locale = "ca";
+                }
+            }
+
             if (console) {
                 std::cout << "Config carregada correctament desde: " << config_file_path
                           << '\n';
@@ -465,6 +524,17 @@ namespace ConfigYaml {
         }
     }
 
+    static void saveAudioConfigToYaml(std::ofstream& file) {
+        file << "# AUDIO\n";
+        file << "audio:\n";
+        file << "  enabled: " << (audio.enabled ? "true" : "false") << "   # ON/OFF general\n";
+        file << "  volume: " << audio.volume << "   # Master 0.0-1.0\n";
+        file << "  music_enabled: " << (audio.music_enabled ? "true" : "false") << "\n";
+        file << "  music_volume: " << audio.music_volume << "   # 0.0-1.0\n";
+        file << "  sound_enabled: " << (audio.sound_enabled ? "true" : "false") << "\n";
+        file << "  sound_volume: " << audio.sound_volume << "   # 0.0-1.0\n\n";
+    }
+
     // Guardar controls del player 1 a YAML
     static void savePlayer1ControlsToYaml(std::ofstream& file) {
         file << "# CONTROLS JUGADOR 1\n";
@@ -479,7 +549,10 @@ namespace ConfigYaml {
         file << "    button_right: " << buttonToString(player1.gamepad.button_right) << "\n";
         file << "    button_thrust: " << buttonToString(player1.gamepad.button_thrust) << "\n";
         file << "    button_shoot: " << buttonToString(player1.gamepad.button_shoot) << "\n";
-        file << "  gamepad_name: \"" << player1.gamepad_name << "\"   # Buit = primer disponible\n\n";
+        file << "    button_start: " << buttonToString(player1.gamepad.button_start) << "\n";
+        file << "    button_menu: " << buttonToString(player1.gamepad.button_menu) << "\n";
+        file << "  gamepad_name: \"" << player1.gamepad_name << "\"   # Buit = primer disponible\n";
+        file << "  gamepad_path: \"" << player1.gamepad_path << "\"   # Prioritari sobre name\n\n";
     }
 
     // Guardar controls del player 2 a YAML
@@ -496,7 +569,10 @@ namespace ConfigYaml {
         file << "    button_right: " << buttonToString(player2.gamepad.button_right) << "\n";
         file << "    button_thrust: " << buttonToString(player2.gamepad.button_thrust) << "\n";
         file << "    button_shoot: " << buttonToString(player2.gamepad.button_shoot) << "\n";
-        file << "  gamepad_name: \"" << player2.gamepad_name << "\"   # Buit = segon disponible\n\n";
+        file << "    button_start: " << buttonToString(player2.gamepad.button_start) << "\n";
+        file << "    button_menu: " << buttonToString(player2.gamepad.button_menu) << "\n";
+        file << "  gamepad_name: \"" << player2.gamepad_name << "\"   # Buit = segon disponible\n";
+        file << "  gamepad_path: \"" << player2.gamepad_path << "\"   # Prioritari sobre name\n\n";
     }
 
     // Guardar configuración al file YAML
@@ -532,6 +608,11 @@ namespace ConfigYaml {
         file << "  render_height: " << rendering.render_height
              << "    # Parell amb render_width (720, 900, 1080, 1440, 2160)\n\n";
 
+        file << "# IDIOMA\n";
+        file << "locale: " << locale << "   # ca | en\n\n";
+
+        saveAudioConfigToYaml(file);
+
         // Guardar controls de jugadors
         savePlayer1ControlsToYaml(file);
         savePlayer2ControlsToYaml(file);

source/game/config_yaml.hpp

@@ -3,9 +3,9 @@
 //
 // La configuració runtime viu en Config::EngineConfig (core/config/).
 // Aquest fitxer afegeix una capa de persistència YAML que llegeix i
-// escriu aquesta struct a disc. La connexió amb el Director es fa via
+// escriu aquesta struct a disc. El Director crida ConfigYaml::* directament
-// Config::ConfigPersistence (lambdes a `main.cpp`), mantenint `core/`
+// (init / setConfigFile / loadFromFile / saveToFile): la separació
-// agnòstic respecte d'aquesta capa.
+// core/game queda relaxada al Director, que és EL programa, no part del motor.
 
 #pragma once
 
@@ -28,6 +28,7 @@ namespace ConfigYaml {
                 .key_start = SDL_SCANCODE_2,
             },
             .gamepad_name = "",
+            .gamepad_path = "",
         },
     };
 

source/game/constants.hpp

@@ -7,40 +7,40 @@
 namespace Constants {
     // Límits de objectes
     constexpr int MAX_ORNIS = Defaults::Entities::MAX_ORNIS;
-    constexpr int MAX_BALES = Defaults::Entities::MAX_BALES;
+    constexpr int MAX_BULLETS = Defaults::Entities::MAX_BULLETS;
 
     // Matemàtiques
     constexpr float PI = Defaults::Math::PI;
 
-    // Helpers per comprovar límits de zona
+    // Helpers per comprovar límits de zone
     inline auto isInPlayArea(float x, float y) -> bool {
         const SDL_FPoint POINT = {x, y};
         return SDL_PointInRectFloat(&POINT, &Defaults::Zones::PLAYAREA);
     }
 
     inline void getPlayAreaBounds(float& min_x, float& max_x, float& min_y, float& max_y) {
-        const auto& zona = Defaults::Zones::PLAYAREA;
+        const auto& zone = Defaults::Zones::PLAYAREA;
-        min_x = zona.x;
+        min_x = zone.x;
-        max_x = zona.x + zona.w;
+        max_x = zone.x + zone.w;
-        min_y = zona.y;
+        min_y = zone.y;
-        max_y = zona.y + zona.h;
+        max_y = zone.y + zone.h;
     }
 
-    // Obtenir límits segurs (compensant radi de l'entidad)
+    // Obtenir límits segurs (compensant radius de l'entidad)
-    inline void getSafePlayAreaBounds(float radi, float& min_x, float& max_x, float& min_y, float& max_y) {
+    inline void getSafePlayAreaBounds(float radius, float& min_x, float& max_x, float& min_y, float& max_y) {
-        const auto& zona = Defaults::Zones::PLAYAREA;
+        const auto& zone = Defaults::Zones::PLAYAREA;
-        constexpr float MARGE_SEGURETAT = 10.0F;  // Safety margin
+        constexpr float SAFETY_MARGIN = 10.0F;  // Safety margin
 
-        min_x = zona.x + radi + MARGE_SEGURETAT;
+        min_x = zone.x + radius + SAFETY_MARGIN;
-        max_x = zona.x + zona.w - radi - MARGE_SEGURETAT;
+        max_x = zone.x + zone.w - radius - SAFETY_MARGIN;
-        min_y = zona.y + radi + MARGE_SEGURETAT;
+        min_y = zone.y + radius + SAFETY_MARGIN;
-        max_y = zona.y + zona.h - radi - MARGE_SEGURETAT;
+        max_y = zone.y + zone.h - radius - SAFETY_MARGIN;
     }
 
     // Obtenir centro de l'àrea de juego
-    inline void getPlayAreaCenter(float& centre_x, float& centre_y) {
+    inline void getPlayAreaCenter(float& center_x, float& center_y) {
-        const auto& zona = Defaults::Zones::PLAYAREA;
+        const auto& zone = Defaults::Zones::PLAYAREA;
-        centre_x = zona.x + (zona.w / 2.0F);
+        center_x = zone.x + (zone.w / 2.0F);
-        centre_y = zona.y + (zona.h / 2.0F);
+        center_y = zone.y + (zone.h / 2.0F);
     }
 }  // namespace Constants

source/game/effects/debris.hpp

@@ -39,7 +39,7 @@ namespace Effects {
         // Política: viu sempre durant min_lifetime, després mor quan
         // |velocity| < MIN_SPEED_TO_DIE (definit en Defaults). Així els
         // fragments ràpids no "popen" en moviment.
-        float temps_vida;    // Temps transcorregut (segons)
+        float elapsed_time;  // Temps transcorregut (segons)
         float min_lifetime;  // Temps mínim garantit (segons)
         bool active;         // Està actiu?
 

source/game/effects/debris_manager.cpp

@@ -135,7 +135,7 @@ namespace Effects {
         float speed =
             velocitat_base +
             (((std::rand() / static_cast<float>(RAND_MAX)) * 2.0F - 1.0F) *
-                Defaults::Physics::Debris::VARIACIO_VELOCITAT);
+                Defaults::Physics::Debris::VARIACIO_SPEED);
         debris->velocity.x = (direccio.x * speed) + velocitat_objecte.x;
         debris->velocity.y = (direccio.y * speed) + velocitat_objecte.y;
         debris->acceleration = friction;
@@ -150,7 +150,7 @@ namespace Effects {
 
         // Vida i shrinking — min_lifetime és el temps mínim garantit; després
         // el fragment mor quan |velocity| < MIN_SPEED_TO_DIE.
-        debris->temps_vida = 0.0F;
+        debris->elapsed_time = 0.0F;
         debris->min_lifetime = lifetime;
         debris->factor_shrink = Defaults::Physics::Debris::SHRINK_RATE;
 
@@ -170,16 +170,16 @@ namespace Effects {
 
         // FASE 1: Aplicar herència i variació
         float factor_herencia =
-            Defaults::Physics::Debris::FACTOR_HERENCIA_MIN +
+            Defaults::Physics::Debris::INHERITANCE_FACTOR_MIN +
             ((std::rand() / static_cast<float>(RAND_MAX)) *
-                (Defaults::Physics::Debris::FACTOR_HERENCIA_MAX -
+                (Defaults::Physics::Debris::INHERITANCE_FACTOR_MAX -
-                    Defaults::Physics::Debris::FACTOR_HERENCIA_MIN));
+                    Defaults::Physics::Debris::INHERITANCE_FACTOR_MIN));
         float velocitat_ang_heretada = velocitat_angular * factor_herencia;
         float variacio = ((std::rand() / static_cast<float>(RAND_MAX)) * 0.2F) - 0.1F;
         velocitat_ang_heretada *= (1.0F + variacio);
 
         // FASE 2: Cap a la velocity màxima; l'excés es converteix en tangencial
-        constexpr float CAP = Defaults::Physics::Debris::VELOCITAT_ROT_MAX;
+        constexpr float CAP = Defaults::Physics::Debris::SPEED_ROT_MAX;
         float abs_ang = std::abs(velocitat_ang_heretada);
         float sign_ang = (velocitat_ang_heretada >= 0.0F) ? 1.0F : -1.0F;
 
@@ -213,10 +213,10 @@ namespace Effects {
 
         // Rotación visual aleatòria (factor = 0.0 o sin velocidad angular)
         debris.velocitat_rot_visual =
-            Defaults::Physics::Debris::ROTACIO_MIN +
+            Defaults::Physics::Debris::ROTATION_MIN +
             ((std::rand() / static_cast<float>(RAND_MAX)) *
-                (Defaults::Physics::Debris::ROTACIO_MAX -
+                (Defaults::Physics::Debris::ROTATION_MAX -
-                    Defaults::Physics::Debris::ROTACIO_MIN));
+                    Defaults::Physics::Debris::ROTATION_MIN));
 
         // 50% probabilitat de rotación en sentit contrari
         if (std::rand() % 2 == 0) {
@@ -266,12 +266,12 @@ namespace Effects {
             }
 
             // 1. Actualitzar time de vida
-            debris.temps_vida += delta_time;
+            debris.elapsed_time += delta_time;
 
             // Política de mort: viu sí o sí durant min_lifetime; després mor
             // quan la velocity cau per sota d'un llindar. Així els fragments
             // ràpids no desapareixen en moviment.
-            if (debris.temps_vida >= debris.min_lifetime) {
+            if (debris.elapsed_time >= debris.min_lifetime) {
                 const float SPEED_SQ = (debris.velocity.x * debris.velocity.x) +
                     (debris.velocity.y * debris.velocity.y);
                 if (SPEED_SQ < Defaults::Physics::Debris::MIN_SPEED_TO_DIE_SQ) {
@@ -344,7 +344,7 @@ namespace Effects {
             // 6. Shrink lineal sobre la longitud ORIGINAL (no iteratiu).
             // SHRINK_T va de 0 a 1 al llarg de min_lifetime; després queda
             // a 1 i el shrink_factor manté el valor mínim (1 - factor_shrink).
-            const float SHRINK_T = std::min(debris.temps_vida / debris.min_lifetime, 1.0F);
+            const float SHRINK_T = std::min(debris.elapsed_time / debris.min_lifetime, 1.0F);
             const float SHRINK_FACTOR = std::max(0.0F, 1.0F - (debris.factor_shrink * SHRINK_T));
 
             // 7. Reconstruir p1/p2 des de la geometria autoritaritzada:

source/game/effects/firework.hpp

@@ -16,7 +16,7 @@ namespace Effects {
     //   tail = head − velocity_normalitzada × current_length.
     //
     // Cicle de vida:
-    //   Fase 1 (temps_vida < grow_duration): current_length creix linealment
+    //   Fase 1 (elapsed_time < grow_duration): current_length creix linealment
     //     de 0 a max_length. Brillor al màxim.
     //   Fase 2: current_length = max_length × (speed/initial_speed) i brillor
     //     amb la mateixa proporció. Mor quan length o brightness cauen sota
@@ -30,11 +30,16 @@ namespace Effects {
         float max_length;      // Longitud màxima (final de la fase de creixement)
         float grow_duration;   // Temps de creixement de 0 a max_length (s)
 
-        float temps_vida;     // Acumulador (s)
+        float elapsed_time;   // Acumulador (s)
         float initial_speed;  // Speed inicial per a la proporció de fase 2
 
         float brightness;   // 0..1
         SDL_Color color{};  // alpha==0 → oscilador global
+        // Halo neon (off per defecte). Si glow_color.a > 0, el halo usa
+        // glow_color (línia blanca + halo daurat, p.ex.); si alpha==0, el
+        // halo agafa el color de la línia.
+        bool glow{false};
+        SDL_Color glow_color{};
         bool active;
     };
 

source/game/effects/firework_manager.cpp

@@ -61,18 +61,20 @@ namespace Effects {
         }
     }
 
-    void FireworkManager::spawn(const Vec2& origen,
+    void FireworkManager::spawn(const Vec2& origin,
         SDL_Color color,
         float initial_speed,
         int n_points,
-        float initial_brightness) {
+        float initial_brightness,
+        bool glow,
+        SDL_Color glow_color) {
         if (n_points <= 0) {
             return;
         }
 
         // Notificar als subscriptors (playfield pulses, etc.).
         if (spawn_callback_) {
-            spawn_callback_(origen);
+            spawn_callback_(origin);
         }
 
         const float ANGLE_STEP = 2.0F * Defaults::Math::PI / static_cast<float>(n_points);
@@ -92,7 +94,7 @@ namespace Effects {
             const float SPEED =
                 initial_speed + (randSigned() * Defaults::FX::Firework::SPEED_VARIATION);
 
-            fw->head = origen;
+            fw->head = origin;
             fw->velocity = {.x = std::cos(ANGLE) * SPEED, .y = std::sin(ANGLE) * SPEED};
             fw->acceleration = Defaults::FX::Firework::FRICTION;
 
@@ -100,11 +102,13 @@ namespace Effects {
             fw->max_length = Defaults::FX::Firework::MAX_LENGTH;
             fw->grow_duration = Defaults::FX::Firework::GROW_DURATION;
 
-            fw->temps_vida = 0.0F;
+            fw->elapsed_time = 0.0F;
             fw->initial_speed = SPEED;
 
             fw->brightness = initial_brightness;
             fw->color = color;
+            fw->glow = glow;
+            fw->glow_color = glow_color;
             fw->active = true;
         }
     }
@@ -115,7 +119,7 @@ namespace Effects {
                 continue;
             }
 
-            fw.temps_vida += delta_time;
+            fw.elapsed_time += delta_time;
 
             // 1. Fricció lineal (aplicar en la direcció del movement).
             const float SPEED = std::sqrt(
@@ -140,9 +144,9 @@ namespace Effects {
             bounceOffPlayArea(fw.head, fw.velocity);
 
             // 4. Calcular longitud i brillor segons fase.
-            if (fw.temps_vida < fw.grow_duration) {
+            if (fw.elapsed_time < fw.grow_duration) {
                 // Fase 1: creixement lineal de 0 a max_length.
-                const float T = fw.temps_vida / fw.grow_duration;
+                const float T = fw.elapsed_time / fw.grow_duration;
                 fw.current_length = fw.max_length * T;
                 fw.brightness = Defaults::FX::Firework::INITIAL_BRIGHTNESS;
             } else {
@@ -185,6 +189,17 @@ namespace Effects {
                 .y = fw.head.y - (DIR_Y * fw.current_length),
             };
 
+            if (fw.glow) {
+                Rendering::lineaGlow(renderer_,
+                    static_cast<int>(fw.head.x),
+                    static_cast<int>(fw.head.y),
+                    static_cast<int>(TAIL.x),
+                    static_cast<int>(TAIL.y),
+                    fw.brightness,
+                    0.0F,
+                    fw.color,
+                    fw.glow_color);
+            } else {
                 Rendering::linea(renderer_,
                     static_cast<int>(fw.head.x),
                     static_cast<int>(fw.head.y),
@@ -195,6 +210,7 @@ namespace Effects {
                     fw.color);
             }
         }
+    }
 
     void FireworkManager::reset() {
         for (auto& fw : pool_) {

source/game/effects/firework_manager.hpp

@@ -21,7 +21,7 @@ namespace Effects {
     class FireworkManager {
        public:
         // Notificació opcional cada vegada que es genera un burst.
-        using SpawnCallback = std::function<void(Vec2 origen)>;
+        using SpawnCallback = std::function<void(Vec2 origin)>;
 
         explicit FireworkManager(Rendering::Renderer* renderer);
 
@@ -35,11 +35,15 @@ namespace Effects {
         //   initial_speed: velocitat radial inicial (px/s).
         //   n_points: nombre de línies. Default Defaults::FX::Firework::N_POINTS.
         //   initial_brightness: 0..1.
-        void spawn(const Vec2& origen,
+        //   glow: si true, cada partícula es renderitza amb halo neon.
+        //   glow_color: color del halo. Si alpha==0, agafa el color de la línia.
+        void spawn(const Vec2& origin,
             SDL_Color color = Defaults::FX::Firework::DEFAULT_COLOR,
             float initial_speed = Defaults::FX::Firework::SPEED,
             int n_points = Defaults::FX::Firework::N_POINTS,
-            float initial_brightness = Defaults::FX::Firework::INITIAL_BRIGHTNESS);
+            float initial_brightness = Defaults::FX::Firework::INITIAL_BRIGHTNESS,
+            bool glow = false,
+            SDL_Color glow_color = {0, 0, 0, 0});
 
         void update(float delta_time);
         void draw() const;

source/game/effects/floating_score.hpp

@@ -9,9 +9,9 @@
 
 namespace Effects {
 
-// FloatingScore: text animat que muestra points guanyats
+    // FloatingScore: text animat que muestra points guanyats
-// S'activa cuando es destrueix un enemy i s'esvaeix después de un time
+    // S'activa cuando es destrueix un enemy i s'esvaeix después de un time
-struct FloatingScore {
+    struct FloatingScore {
         // Text a mostrar (e.g., "100", "150", "200")
         std::string text;
 
@@ -22,12 +22,12 @@ struct FloatingScore {
         Vec2 velocity;  // px/s (normalment sin amunt: {0.0f, -30.0f})
 
         // Animación de fade
-        float temps_vida;  // Temps transcorregut (segons)
+        float elapsed_time;  // Temps transcorregut (segons)
-        float temps_max;   // Temps de vida màxim (segons)
+        float max_lifetime;  // Temps de vida màxim (segons)
         float brightness;    // Brillantor calculada (0.0-1.0)
 
         // Estat
         bool active;
-};
+    };
 
 }  // namespace Effects

source/game/effects/floating_score_manager.cpp

@@ -7,15 +7,15 @@
 
 namespace Effects {
 
-FloatingScoreManager::FloatingScoreManager(Rendering::Renderer* renderer)
+    FloatingScoreManager::FloatingScoreManager(Rendering::Renderer* renderer)
         : text_(renderer) {
         // Inicialitzar todos los slots como inactius
         for (auto& pf : pool_) {
             pf.active = false;
         }
-}
+    }
 
-void FloatingScoreManager::crear(int points, const Vec2& position) {
+    void FloatingScoreManager::crear(int points, const Vec2& position) {
         // 1. Trobar slot lliure
         FloatingScore* pf = findFreeSlot();
         if (pf == nullptr) {
@@ -27,13 +27,13 @@ void FloatingScoreManager::crear(int points, const Vec2& position) {
         pf->position = position;
         pf->velocity = {.x = Defaults::FloatingScore::VELOCITY_X,
             .y = Defaults::FloatingScore::VELOCITY_Y};
-    pf->temps_vida = 0.0F;
+        pf->elapsed_time = 0.0F;
-    pf->temps_max = Defaults::FloatingScore::LIFETIME;
+        pf->max_lifetime = Defaults::FloatingScore::LIFETIME;
         pf->brightness = 1.0F;
         pf->active = true;
-}
+    }
 
-void FloatingScoreManager::update(float delta_time) {
+    void FloatingScoreManager::update(float delta_time) {
         for (auto& pf : pool_) {
             if (!pf.active) {
                 continue;
@@ -44,20 +44,20 @@ void FloatingScoreManager::update(float delta_time) {
             pf.position.y += pf.velocity.y * delta_time;
 
             // 2. Actualitzar time de vida
-        pf.temps_vida += delta_time;
+            pf.elapsed_time += delta_time;
 
             // 3. Calcular brightness (fade lineal)
-        float progress = pf.temps_vida / pf.temps_max;  // 0.0 → 1.0
+            float progress = pf.elapsed_time / pf.max_lifetime;  // 0.0 → 1.0
             pf.brightness = 1.0F - progress;                     // 1.0 → 0.0
 
             // 4. Desactivar cuando acaba el time
-        if (pf.temps_vida >= pf.temps_max) {
+            if (pf.elapsed_time >= pf.max_lifetime) {
                 pf.active = false;
             }
         }
-}
+    }
 
-void FloatingScoreManager::draw() {
+    void FloatingScoreManager::draw() {
         for (const auto& pf : pool_) {
             if (!pf.active) {
                 continue;
@@ -69,15 +69,15 @@ void FloatingScoreManager::draw() {
 
             text_.renderCentered(pf.text, pf.position, SCALE, SPACING, pf.brightness);
         }
-}
+    }
 
-void FloatingScoreManager::reset() {
+    void FloatingScoreManager::reset() {
         for (auto& pf : pool_) {
             pf.active = false;
         }
-}
+    }
 
-auto FloatingScoreManager::getActiveCount() const -> int {
+    auto FloatingScoreManager::getActiveCount() const -> int {
         int count = 0;
         for (const auto& pf : pool_) {
             if (pf.active) {
@@ -85,15 +85,15 @@ auto FloatingScoreManager::getActiveCount() const -> int {
             }
         }
         return count;
-}
+    }
 
-auto FloatingScoreManager::findFreeSlot() -> FloatingScore* {
+    auto FloatingScoreManager::findFreeSlot() -> FloatingScore* {
         for (auto& pf : pool_) {
             if (!pf.active) {
                 return &pf;
             }
         }
         return nullptr;  // Pool ple
-}
+    }
 
 }  // namespace Effects

source/game/entities/bullet.cpp

@@ -3,7 +3,6 @@
 
 #include "game/entities/bullet.hpp"
 
-#include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <iostream>
@@ -43,8 +42,8 @@ void Bullet::init() {
     // Inicialment inactiva
     is_active_ = false;
     center_ = {.x = 0.0F, .y = 0.0F};
+    prev_position_ = {.x = 0.0F, .y = 0.0F};
     angle_ = 0.0F;
-    grace_timer_ = 0.0F;
 
     // Reset del cuerpo físico
     body_.position = Vec2{};
@@ -54,18 +53,16 @@ void Bullet::init() {
     body_.clearAccumulators();
 }
 
-void Bullet::disparar(const Vec2& position, float angle, uint8_t owner_id) {
+void Bullet::fire(const Vec2& position, float angle, uint8_t owner_id) {
     // Activar bullet
     is_active_ = true;
 
     // Almacenar propietario (0=P1, 1=P2)
     owner_id_ = owner_id;
 
-    // Activar grace period (prevents instant self-collision)
-    grace_timer_ = Defaults::Game::BULLET_GRACE_PERIOD;
-
     // Posición y orientación iniciales = ship
     center_ = position;
+    prev_position_ = position;  // Al spawn no hi ha moviment encara: swept degenera a punt-cercle
     angle_ = angle;
 
     // Sincronizar el body físico: posición + velocidad cartesiana
@@ -82,37 +79,18 @@ void Bullet::disparar(const Vec2& position, float angle, uint8_t owner_id) {
     Audio::get()->playSound(Defaults::Sound::LASER, Audio::Group::GAME);
 }
 
-void Bullet::update(float delta_time) {
+void Bullet::update(float /*delta_time*/) {
-    if (!is_active_) {
+    // No-op: la desactivació per fora-de-zone viu a
-        return;
+    // Systems::Collision::desactivateOutOfBoundsBullets() perquè així té accés
-    }
+    // al DebrisManager i pot generar el "trencament" visual de la bala alhora.
-
+    // El moviment l'integra PhysicsWorld; postUpdate sincronitza center_ i prev_position_.
-    // Decrementar grace timer
-    if (grace_timer_ > 0.0F) {
-        grace_timer_ -= delta_time;
-        grace_timer_ = std::max(grace_timer_, 0.0F);
-    }
-
-    // El movimiento real lo hace PhysicsWorld::update() (integración).
-    // Aquí solo lógica de estado: detectar salida del PLAYAREA y desactivar.
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::getSafePlayAreaBounds(Defaults::Entities::BULLET_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    if (body_.position.x < min_x || body_.position.x > max_x ||
-        body_.position.y < min_y || body_.position.y > max_y) {
-        desactivar();
-    }
 }
 
 void Bullet::postUpdate(float /*delta_time*/) {
-    // Sincronizar mirror desde body_ tras la integración del world.
+    // Captura la posició al final del frame anterior abans de sobreescriure center_;
+    // així el sistema de col·lisions pot fer swept (segment-vs-cercle) entre prev_position_
+    // i la nova center_, evitant tunneling a velocitats altes.
+    prev_position_ = center_;
     center_ = body_.position;
     // angle_ no cambia (las balas no rotan visualmente).
 }

source/game/entities/bullet.hpp

@@ -17,7 +17,7 @@ class Bullet : public Entities::Entity {
     explicit Bullet(Rendering::Renderer* renderer);
 
     void init() override;
-        void disparar(const Vec2& position, float angle, uint8_t owner_id);
+    void fire(const Vec2& position, float angle, uint8_t owner_id);
     void update(float delta_time) override;
     void postUpdate(float delta_time) override;
     void draw() const override;
@@ -30,19 +30,20 @@ class Bullet : public Entities::Entity {
         return Defaults::Entities::BULLET_RADIUS;
     }
     [[nodiscard]] auto isCollidable() const -> bool override {
-            return is_active_ && grace_timer_ <= 0.0F;
+        return is_active_;
     }
 
     // Getters (API pública sin cambios)
     [[nodiscard]] auto getOwnerId() const -> uint8_t { return owner_id_; }
-        [[nodiscard]] auto getGraceTimer() const -> float { return grace_timer_; }
+    // Posició al final del frame anterior, per a CCD segment-vs-cercle.
+    [[nodiscard]] auto getPrevPosition() const -> const Vec2& { return prev_position_; }
     void desactivar();
 
    private:
     // Miembros específicos de Bullet (heredados: renderer_, shape_, center_, angle_, brightness_, body_).
     // Inicializados en la declaración para que tanto el ctor por defecto como el que toma renderer
-        // dejen el objeto en estado coherente (proyectil inactivo, sin owner, sin grace timer).
+    // dejen el objeto en estado coherente (proyectil inactivo, sin owner).
     bool is_active_{false};
     uint8_t owner_id_{0};   // 0=P1, 1=P2
-        float grace_timer_{0.0F};  // Grace period timer (0.0 = vulnerable)
+    Vec2 prev_position_{};  // Posició al final del frame anterior (per a swept collision)
 };

source/game/entities/enemy.cpp

@@ -8,7 +8,6 @@
 #include <cstdlib>
 #include <iostream>
 
-#include "core/audio/audio.hpp"
 #include "core/defaults.hpp"
 #include "core/entities/entity.hpp"
 #include "core/graphics/shape_loader.hpp"
@@ -42,7 +41,7 @@ namespace {
 Enemy::Enemy(Rendering::Renderer* renderer)
     : Entity(renderer),
 
-      tracking_strength_(Defaults::Enemies::Cuadrado::TRACKING_STRENGTH) {
+      tracking_strength_(Defaults::Enemies::Square::TRACKING_STRENGTH) {
     brightness_ = Defaults::Brightness::ENEMIC;
 
     // Configuración del cuerpo físico — defaults para enemy genérico.
@@ -59,43 +58,43 @@ void Enemy::init(EnemyType type, const Vec2* ship_pos) {
 
     const char* shape_file = nullptr;
     float base_speed = 0.0F;
-    float drotacio_min = 0.0F;
+    float rotation_delta_min = 0.0F;
-    float drotacio_max = 0.0F;
+    float rotation_delta_max = 0.0F;
     float type_mass = Defaults::Enemies::Body::DEFAULT_MASS;
 
     switch (type_) {
         case EnemyType::PENTAGON:
             shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
-            base_speed = Defaults::Enemies::Pentagon::VELOCITAT;
+            base_speed = Defaults::Enemies::Pentagon::SPEED;
-            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
+            rotation_delta_min = Defaults::Enemies::Pentagon::ROTATION_DELTA_MIN;
-            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
+            rotation_delta_max = Defaults::Enemies::Pentagon::ROTATION_DELTA_MAX;
             type_mass = Defaults::Enemies::Pentagon::MASS;
             break;
 
-        case EnemyType::QUADRAT:
+        case EnemyType::SQUARE:
-            shape_file = Defaults::Enemies::Cuadrado::SHAPE_FILE;
+            shape_file = Defaults::Enemies::Square::SHAPE_FILE;
-            base_speed = Defaults::Enemies::Cuadrado::VELOCITAT;
+            base_speed = Defaults::Enemies::Square::SPEED;
-            drotacio_min = Defaults::Enemies::Cuadrado::DROTACIO_MIN;
+            rotation_delta_min = Defaults::Enemies::Square::ROTATION_DELTA_MIN;
-            drotacio_max = Defaults::Enemies::Cuadrado::DROTACIO_MAX;
+            rotation_delta_max = Defaults::Enemies::Square::ROTATION_DELTA_MAX;
-            type_mass = Defaults::Enemies::Cuadrado::MASS;
+            type_mass = Defaults::Enemies::Square::MASS;
             tracking_timer_ = 0.0F;
             break;
 
-        case EnemyType::MOLINILLO:
+        case EnemyType::PINWHEEL:
-            shape_file = Defaults::Enemies::Molinillo::SHAPE_FILE;
+            shape_file = Defaults::Enemies::Pinwheel::SHAPE_FILE;
-            base_speed = Defaults::Enemies::Molinillo::VELOCITAT;
+            base_speed = Defaults::Enemies::Pinwheel::SPEED;
-            drotacio_min = Defaults::Enemies::Molinillo::DROTACIO_MIN;
+            rotation_delta_min = Defaults::Enemies::Pinwheel::ROTATION_DELTA_MIN;
-            drotacio_max = Defaults::Enemies::Molinillo::DROTACIO_MAX;
+            rotation_delta_max = Defaults::Enemies::Pinwheel::ROTATION_DELTA_MAX;
-            type_mass = Defaults::Enemies::Molinillo::MASS;
+            type_mass = Defaults::Enemies::Pinwheel::MASS;
             break;
 
         default:
             std::cerr << "[Enemy] Error: tipo desconocido ("
                       << static_cast<int>(type_) << "), usando PENTAGON\n";
             shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
-            base_speed = Defaults::Enemies::Pentagon::VELOCITAT;
+            base_speed = Defaults::Enemies::Pentagon::SPEED;
-            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
+            rotation_delta_min = Defaults::Enemies::Pentagon::ROTATION_DELTA_MIN;
-            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
+            rotation_delta_max = Defaults::Enemies::Pentagon::ROTATION_DELTA_MAX;
             break;
     }
 
@@ -132,7 +131,7 @@ void Enemy::init(EnemyType type, const Vec2* ship_pos) {
             const int RANGE_Y = static_cast<int>(max_y - min_y);
             center_.x = static_cast<float>((std::rand() % RANGE_X) + static_cast<int>(min_x));
             center_.y = static_cast<float>((std::rand() % RANGE_Y) + static_cast<int>(min_y));
-            std::cout << "[Enemy] Advertencia: spawn sin zona segura tras "
+            std::cout << "[Enemy] Advertencia: spawn sin zone segura tras "
                       << Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS << " intentos\n";
         }
     } else {
@@ -153,28 +152,28 @@ void Enemy::init(EnemyType type, const Vec2* ship_pos) {
     body_.clearAccumulators();
 
     // Rotación visual aleatoria (independiente del body)
-    const float DROTACIO_RANGE = drotacio_max - drotacio_min;
+    const float ROTATION_DELTA_RANGE = rotation_delta_max - rotation_delta_min;
-    drotacio_ = drotacio_min + ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DROTACIO_RANGE);
+    rotation_delta_ = rotation_delta_min + ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * ROTATION_DELTA_RANGE);
-    rotacio_ = 0.0F;
+    rotation_ = 0.0F;
 
     // Estado de animación
-    animacio_ = EnemyAnimation();
+    animation_ = EnemyAnimation();
-    animacio_.drotacio_base = drotacio_;
+    animation_.rotation_delta_base = rotation_delta_;
-    animacio_.drotacio_objetivo = drotacio_;
+    animation_.rotation_delta_target = rotation_delta_;
-    animacio_.drotacio_t = 1.0F;
+    animation_.rotation_delta_t = 1.0F;
 
     // Invulnerabilidad post-spawn
-    timer_invulnerabilitat_ = Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
+    invulnerability_timer_ = Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
     brightness_ = Defaults::Enemies::Spawn::INVULNERABILITY_BRIGHTNESS_START;
 
     // Timer para próximo cambio de dirección (Pentagon)
     direction_change_timer_ = 0.0F;
 
-    esta_ = true;
+    is_active_ = true;
 }
 
 void Enemy::update(float delta_time) {
-    if (!esta_) {
+    if (!is_active_) {
         return;
     }
 
@@ -190,11 +189,11 @@ void Enemy::update(float delta_time) {
     }
 
     // Decremento de invulnerabilidad + LERP de brightness
-    if (timer_invulnerabilitat_ > 0.0F) {
+    if (invulnerability_timer_ > 0.0F) {
-        timer_invulnerabilitat_ -= delta_time;
+        invulnerability_timer_ -= delta_time;
-        timer_invulnerabilitat_ = std::max(timer_invulnerabilitat_, 0.0F);
+        invulnerability_timer_ = std::max(invulnerability_timer_, 0.0F);
 
-        const float T_INV = timer_invulnerabilitat_ / Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
+        const float T_INV = invulnerability_timer_ / Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
         const float T = 1.0F - T_INV;
         const float SMOOTH_T = T * T * (3.0F - (2.0F * T));
         constexpr float START = Defaults::Enemies::Spawn::INVULNERABILITY_BRIGHTNESS_START;
@@ -210,11 +209,11 @@ void Enemy::update(float delta_time) {
             case EnemyType::PENTAGON:
                 behaviorPentagon(delta_time);
                 break;
-            case EnemyType::QUADRAT:
+            case EnemyType::SQUARE:
-                behaviorQuadrat(delta_time);
+                behaviorSquare(delta_time);
                 break;
-            case EnemyType::MOLINILLO:
+            case EnemyType::PINWHEEL:
-                behaviorMolinillo(delta_time);
+                behaviorPinwheel(delta_time);
                 break;
         }
     }
@@ -223,18 +222,18 @@ void Enemy::update(float delta_time) {
     updateAnimation(delta_time);
 
     // Rotación visual (decoración, no afecta movimiento)
-    rotacio_ += drotacio_ * delta_time;
+    rotation_ += rotation_delta_ * delta_time;
 }
 
 void Enemy::postUpdate(float /*delta_time*/) {
     // Sincronizar mirror tras la integración del world.
-    if (esta_) {
+    if (is_active_) {
         center_ = body_.position;
     }
 }
 
 void Enemy::draw() const {
-    if (!esta_ || !shape_) {
+    if (!is_active_ || !shape_) {
         return;
     }
     const float SCALE = computeCurrentScale();
@@ -243,11 +242,11 @@ void Enemy::draw() const {
         case EnemyType::PENTAGON:
             color = Defaults::Palette::PENTAGON;
             break;
-        case EnemyType::QUADRAT:
+        case EnemyType::SQUARE:
-            color = Defaults::Palette::QUADRAT;
+            color = Defaults::Palette::SQUARE;
             break;
-        case EnemyType::MOLINILLO:
+        case EnemyType::PINWHEEL:
-            color = Defaults::Palette::MOLINILLO;
+            color = Defaults::Palette::PINWHEEL;
             break;
     }
 
@@ -261,11 +260,11 @@ void Enemy::draw() const {
         }
     }
 
-    Rendering::renderShape(renderer_, shape_, center_, rotacio_, SCALE, 1.0F, brightness_, color);
+    Rendering::renderShape(renderer_, shape_, center_, rotation_, SCALE, 1.0F, brightness_, color);
 }
 
-void Enemy::destruir() {
+void Enemy::destroy() {
-    esta_ = false;
+    is_active_ = false;
     body_.velocity = Vec2{};
     body_.angular_velocity = 0.0F;
     body_.radius = 0.0F;  // No colisiona mientras está inactivo
@@ -274,10 +273,11 @@ void Enemy::destruir() {
     last_hit_by_ = 0xFF;
 }
 
-void Enemy::herir(uint8_t shooter_id) {
+void Enemy::hurt(uint8_t shooter_id) {
     wounded_timer_ = Defaults::Enemies::Wounded::DURATION;
     last_hit_by_ = shooter_id;
-    Audio::get()->playSound(Defaults::Sound::HIT, Audio::Group::GAME);
+    // El so HIT ara el reprodueix la bala quan es trenca en debris
+    // (Systems::Collision::breakBullet), no l'enemic en entrar a HURT.
 }
 
 void Enemy::applyImpulse(const Vec2& impulse) {
@@ -312,7 +312,7 @@ void Enemy::behaviorPentagon(float delta_time) {
     if (RAND_VAL < Defaults::Enemies::Pentagon::ZIGZAG_PROB_PER_SECOND * delta_time) {
         const float CURRENT_ANGLE = velocityToAngle(body_.velocity);
         const float DELTA = (static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) *
-            Defaults::Enemies::Pentagon::CANVI_ANGLE_MAX;
+            Defaults::Enemies::Pentagon::ANGLE_CHANGE_MAX;
         const float NEW_ANGLE = CURRENT_ANGLE + ((std::rand() % 2 == 0) ? DELTA : -DELTA);
         const float SPEED = body_.velocity.length();
         setVelocityFromAngle(NEW_ANGLE, SPEED);
@@ -320,12 +320,12 @@ void Enemy::behaviorPentagon(float delta_time) {
     }
 }
 
-// QUADRAT: tracking discreto cada TRACKING_INTERVAL. Ajusta dirección
+// SQUARE: tracking discreto cada TRACKING_INTERVAL. Ajusta dirección
 // hacia el ship mezclando con tracking_strength_.
-void Enemy::behaviorQuadrat(float delta_time) {
+void Enemy::behaviorSquare(float delta_time) {
     tracking_timer_ += delta_time;
 
-    if (tracking_timer_ >= Defaults::Enemies::Cuadrado::TRACKING_INTERVAL && ship_position_ != nullptr) {
+    if (tracking_timer_ >= Defaults::Enemies::Square::TRACKING_INTERVAL && ship_position_ != nullptr) {
         tracking_timer_ = 0.0F;
 
         const Vec2 TO_SHIP = *ship_position_ - center_;
@@ -348,89 +348,89 @@ void Enemy::behaviorQuadrat(float delta_time) {
     }
 }
 
-// MOLINILLO: movimiento recto + boost de rotación visual cerca del ship.
+// PINWHEEL: movimiento recto + boost de rotación visual cerca del ship.
 // Sin tracking — solo cambios de dirección raros (igual que Pentagon pero
 // con probabilidad mucho menor).
-void Enemy::behaviorMolinillo(float /*delta_time*/) {
+void Enemy::behaviorPinwheel(float /*delta_time*/) {
     // Boost de rotación visual por proximidad al ship
     if (ship_position_ != nullptr) {
         const Vec2 TO_SHIP = *ship_position_ - center_;
         const float DIST = TO_SHIP.length();
-        if (DIST < Defaults::Enemies::Molinillo::PROXIMITY_DISTANCE) {
+        if (DIST < Defaults::Enemies::Pinwheel::PROXIMITY_DISTANCE) {
-            drotacio_ = animacio_.drotacio_base * Defaults::Enemies::Molinillo::DROTACIO_PROXIMITY_MULTIPLIER;
+            rotation_delta_ = animation_.rotation_delta_base * Defaults::Enemies::Pinwheel::ROTATION_DELTA_PROXIMITY_MULTIPLIER;
         } else {
-            drotacio_ = animacio_.drotacio_base;
+            rotation_delta_ = animation_.rotation_delta_base;
         }
     }
     // Movimiento lineal puro: el world se encarga de integrar y rebotar.
 }
 
 void Enemy::updateAnimation(float delta_time) {
-    updatePalpitation(delta_time);
+    updatePulse(delta_time);
     updateRotationAcceleration(delta_time);
 }
 
-void Enemy::updatePalpitation(float delta_time) {
+void Enemy::updatePulse(float delta_time) {
-    if (animacio_.palpitacio_activa) {
+    if (animation_.pulse_active) {
-        animacio_.palpitacio_fase += 2.0F * Constants::PI * animacio_.palpitacio_frequencia * delta_time;
+        animation_.pulse_phase += 2.0F * Constants::PI * animation_.pulse_frequency * delta_time;
-        animacio_.palpitacio_temps_restant -= delta_time;
+        animation_.pulse_time_remaining -= delta_time;
-        if (animacio_.palpitacio_temps_restant <= 0.0F) {
+        if (animation_.pulse_time_remaining <= 0.0F) {
-            animacio_.palpitacio_activa = false;
+            animation_.pulse_active = false;
         }
     } else {
         const float RAND_VAL = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);
-        const float TRIGGER_PROB = Defaults::Enemies::Animation::PALPITACIO_TRIGGER_PROB * delta_time;
+        const float TRIGGER_PROB = Defaults::Enemies::Animation::PULSE_TRIGGER_PROB * delta_time;
         if (RAND_VAL < TRIGGER_PROB) {
-            animacio_.palpitacio_activa = true;
+            animation_.pulse_active = true;
-            animacio_.palpitacio_fase = 0.0F;
+            animation_.pulse_phase = 0.0F;
 
-            const float FREQ_RANGE = Defaults::Enemies::Animation::PALPITACIO_FREQ_MAX -
+            const float FREQ_RANGE = Defaults::Enemies::Animation::PULSE_FREQ_MAX -
-                Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN;
+                Defaults::Enemies::Animation::PULSE_FREQ_MIN;
-            animacio_.palpitacio_frequencia = Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN +
+            animation_.pulse_frequency = Defaults::Enemies::Animation::PULSE_FREQ_MIN +
                 ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * FREQ_RANGE);
 
-            const float AMP_RANGE = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MAX -
+            const float AMP_RANGE = Defaults::Enemies::Animation::PULSE_AMPLITUD_MAX -
-                Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN;
+                Defaults::Enemies::Animation::PULSE_AMPLITUD_MIN;
-            animacio_.palpitacio_amplitud = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN +
+            animation_.pulse_amplitude = Defaults::Enemies::Animation::PULSE_AMPLITUD_MIN +
                 ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * AMP_RANGE);
 
-            const float DUR_RANGE = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MAX -
+            const float DUR_RANGE = Defaults::Enemies::Animation::PULSE_DURATION_MAX -
-                Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN;
+                Defaults::Enemies::Animation::PULSE_DURATION_MIN;
-            animacio_.palpitacio_temps_restant = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN +
+            animation_.pulse_time_remaining = Defaults::Enemies::Animation::PULSE_DURATION_MIN +
                 ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DUR_RANGE);
         }
     }
 }
 
 void Enemy::updateRotationAcceleration(float delta_time) {
-    if (animacio_.drotacio_t < 1.0F) {
+    if (animation_.rotation_delta_t < 1.0F) {
-        animacio_.drotacio_t += delta_time / animacio_.drotacio_duracio;
+        animation_.rotation_delta_t += delta_time / animation_.rotation_delta_duration;
-        if (animacio_.drotacio_t >= 1.0F) {
+        if (animation_.rotation_delta_t >= 1.0F) {
-            animacio_.drotacio_t = 1.0F;
+            animation_.rotation_delta_t = 1.0F;
-            animacio_.drotacio_base = animacio_.drotacio_objetivo;
+            animation_.rotation_delta_base = animation_.rotation_delta_target;
-            drotacio_ = animacio_.drotacio_base;
+            rotation_delta_ = animation_.rotation_delta_base;
         } else {
-            const float T = animacio_.drotacio_t;
+            const float T = animation_.rotation_delta_t;
             const float SMOOTH_T = T * T * (3.0F - (2.0F * T));
-            const float INITIAL = animacio_.drotacio_base;
+            const float INITIAL = animation_.rotation_delta_base;
-            const float TARGET = animacio_.drotacio_objetivo;
+            const float TARGET = animation_.rotation_delta_target;
-            drotacio_ = INITIAL + ((TARGET - INITIAL) * SMOOTH_T);
+            rotation_delta_ = INITIAL + ((TARGET - INITIAL) * SMOOTH_T);
         }
     } else {
         const float RAND_VAL = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);
-        const float TRIGGER_PROB = Defaults::Enemies::Animation::ROTACIO_ACCEL_TRIGGER_PROB * delta_time;
+        const float TRIGGER_PROB = Defaults::Enemies::Animation::ROTATION_ACCEL_TRIGGER_PROB * delta_time;
         if (RAND_VAL < TRIGGER_PROB) {
-            animacio_.drotacio_t = 0.0F;
+            animation_.rotation_delta_t = 0.0F;
 
-            const float MULT_RANGE = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MAX -
+            const float MULT_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_MULTIPLIER_MAX -
-                Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN;
+                Defaults::Enemies::Animation::ROTATION_ACCEL_MULTIPLIER_MIN;
-            const float MULTIPLIER = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN +
+            const float MULTIPLIER = Defaults::Enemies::Animation::ROTATION_ACCEL_MULTIPLIER_MIN +
                 ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * MULT_RANGE);
-            animacio_.drotacio_objetivo = animacio_.drotacio_base * MULTIPLIER;
+            animation_.rotation_delta_target = animation_.rotation_delta_base * MULTIPLIER;
 
-            const float DUR_RANGE = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MAX -
+            const float DUR_RANGE = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MAX -
-                Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN;
+                Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN;
-            animacio_.drotacio_duracio = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN +
+            animation_.rotation_delta_duration = Defaults::Enemies::Animation::ROTATION_ACCEL_DURATION_MIN +
                 ((static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX)) * DUR_RANGE);
         }
     }
@@ -438,15 +438,15 @@ void Enemy::updateRotationAcceleration(float delta_time) {
 
 auto Enemy::computeCurrentScale() const -> float {
     float scale = 1.0F;
-    if (timer_invulnerabilitat_ > 0.0F) {
+    if (invulnerability_timer_ > 0.0F) {
-        const float T_INV = timer_invulnerabilitat_ / Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
+        const float T_INV = invulnerability_timer_ / Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
         const float T = 1.0F - T_INV;
         const float SMOOTH_T = T * T * (3.0F - (2.0F * T));
         constexpr float START = Defaults::Enemies::Spawn::INVULNERABILITY_SCALE_START;
         constexpr float END = Defaults::Enemies::Spawn::INVULNERABILITY_SCALE_END;
         scale = START + ((END - START) * SMOOTH_T);
-    } else if (animacio_.palpitacio_activa) {
+    } else if (animation_.pulse_active) {
-        scale += animacio_.palpitacio_amplitud * std::sin(animacio_.palpitacio_fase);
+        scale += animation_.pulse_amplitude * std::sin(animation_.pulse_phase);
     }
     return scale;
 }
@@ -454,22 +454,22 @@ auto Enemy::computeCurrentScale() const -> float {
 auto Enemy::getBaseVelocity() const -> float {
     switch (type_) {
         case EnemyType::PENTAGON:
-            return Defaults::Enemies::Pentagon::VELOCITAT;
+            return Defaults::Enemies::Pentagon::SPEED;
-        case EnemyType::QUADRAT:
+        case EnemyType::SQUARE:
-            return Defaults::Enemies::Cuadrado::VELOCITAT;
+            return Defaults::Enemies::Square::SPEED;
-        case EnemyType::MOLINILLO:
+        case EnemyType::PINWHEEL:
-            return Defaults::Enemies::Molinillo::VELOCITAT;
+            return Defaults::Enemies::Pinwheel::SPEED;
         default:
-            return Defaults::Enemies::Pentagon::VELOCITAT;
+            return Defaults::Enemies::Pentagon::SPEED;
     }
 }
 
 auto Enemy::getBaseRotation() const -> float {
-    return animacio_.drotacio_base != 0.0F ? animacio_.drotacio_base : drotacio_;
+    return animation_.rotation_delta_base != 0.0F ? animation_.rotation_delta_base : rotation_delta_;
 }
 
 void Enemy::setTrackingStrength(float strength) {
-    if (type_ == EnemyType::QUADRAT) {
+    if (type_ == EnemyType::SQUARE) {
         tracking_strength_ = strength;
     }
 }

source/game/entities/enemy.hpp

@@ -13,24 +13,24 @@
 // Tipo de enemy
 enum class EnemyType : uint8_t {
     PENTAGON = 0,  // Pentágono esquivador (zigzag)
-    QUADRAT = 1,   // Cuadrado perseguidor (tracks ship)
+    SQUARE = 1,    // Square perseguidor (tracks ship)
-    MOLINILLO = 2  // Molinillo agresivo (rápido, girando)
+    PINWHEEL = 2   // Molinillo agresivo (rápido, girando)
 };
 
 // Estado de animación (palpitación + rotación acelerada)
 struct EnemyAnimation {
     // Palpitación (efecto respiración)
-    bool palpitacio_activa = false;
+    bool pulse_active = false;
-    float palpitacio_fase = 0.0F;
+    float pulse_phase = 0.0F;
-    float palpitacio_frequencia = 2.0F;
+    float pulse_frequency = 2.0F;
-    float palpitacio_amplitud = 0.15F;
+    float pulse_amplitude = 0.15F;
-    float palpitacio_temps_restant = 0.0F;
+    float pulse_time_remaining = 0.0F;
 
     // Aceleración de rotación visual (modulación a largo plazo)
-    float drotacio_base = 0.0F;
+    float rotation_delta_base = 0.0F;
-    float drotacio_objetivo = 0.0F;
+    float rotation_delta_target = 0.0F;
-    float drotacio_t = 0.0F;
+    float rotation_delta_t = 0.0F;
-    float drotacio_duracio = 0.0F;
+    float rotation_delta_duration = 0.0F;
 };
 
 class Enemy : public Entities::Entity {
@@ -46,21 +46,24 @@ class Enemy : public Entities::Entity {
     void draw() const override;
 
     // Override: Interfaz de Entity
-    [[nodiscard]] auto isActive() const -> bool override { return esta_; }
+    [[nodiscard]] auto isActive() const -> bool override { return is_active_; }
 
     // Override: Interfaz de colisión
     [[nodiscard]] auto getCollisionRadius() const -> float override {
         return Defaults::Entities::ENEMY_RADIUS;
     }
+    // Mentre fa spawn (invulnerable) segueix col·lisionant: les bales el
+    // poden abatre i el cos físic rebota amb la nau. El damage a la nau
+    // segueix filtrat per `isInvulnerable()` al detectShipEnemy.
     [[nodiscard]] auto isCollidable() const -> bool override {
-        return esta_ && timer_invulnerabilitat_ <= 0.0F;
+        return is_active_;
     }
 
     // Marcar destruido (desactiva el cuerpo físicamente: radius=0)
-    void destruir();
+    void destroy();
 
     // Getters
-    [[nodiscard]] auto getRotationDelta() const -> float { return drotacio_; }
+    [[nodiscard]] auto getRotationDelta() const -> float { return rotation_delta_; }
     [[nodiscard]] auto getVelocityVector() const -> Vec2 { return body_.velocity; }
 
     // Set ship position reference for tracking behavior
@@ -76,18 +79,18 @@ class Enemy : public Entities::Entity {
     // actual del body_.velocity.
     void setVelocity(float speed);
     void setRotation(float rot) {
-        drotacio_ = rot;
+        rotation_delta_ = rot;
-        animacio_.drotacio_base = rot;
+        animation_.rotation_delta_base = rot;
     }
     void setTrackingStrength(float strength);
 
     // Invulnerabilidad
-    [[nodiscard]] auto isInvulnerable() const -> bool { return timer_invulnerabilitat_ > 0.0F; }
+    [[nodiscard]] auto isInvulnerable() const -> bool { return invulnerability_timer_ > 0.0F; }
-    [[nodiscard]] auto getInvulnerabilityTime() const -> float { return timer_invulnerabilitat_; }
+    [[nodiscard]] auto getInvulnerabilityTime() const -> float { return invulnerability_timer_; }
 
     // Estado "herido": entre primer impacto de bala y explosión diferida.
     // shooter_id: id del jugador que herí; 0xFF = sin atribución (cadena, etc.).
-    void herir(uint8_t shooter_id = 0xFF);
+    void hurt(uint8_t shooter_id = 0xFF);
     [[nodiscard]] auto isWounded() const -> bool { return wounded_timer_ > 0.0F; }
     [[nodiscard]] auto getWoundedTimer() const -> float { return wounded_timer_; }
     [[nodiscard]] auto woundExpiredThisFrame() const -> bool { return wound_expired_this_frame_; }
@@ -101,12 +104,12 @@ class Enemy : public Entities::Entity {
     // Miembros específicos (heredados: renderer_, shape_, center_, angle_, brightness_, body_).
     // Inicializados en la declaración: el ctor por defecto deja al enemy en estado "inactivo
     // como pentágono", coherente con lo que harán init() o el ctor con renderer al activarlo.
-    float drotacio_{0.0F};  // Velocidad angular visual (rad/s) — solo decoración, separada de body_.angular_velocity
+    float rotation_delta_{0.0F};  // Velocidad angular visual (rad/s) — solo decoración, separada de body_.angular_velocity
-    float rotacio_{0.0F};   // Rotación visual acumulada (no afecta movimiento)
+    float rotation_{0.0F};        // Rotación visual acumulada (no afecta movimiento)
-    bool esta_{false};
+    bool is_active_{false};
 
     EnemyType type_{EnemyType::PENTAGON};
-    EnemyAnimation animacio_;
+    EnemyAnimation animation_;
 
     // Comportamiento type-specific
     float tracking_timer_{0.0F};          // Quadrat: tiempo desde último update de dirección
@@ -115,7 +118,7 @@ class Enemy : public Entities::Entity {
     float direction_change_timer_{0.0F};  // Pentagon: tiempo para próximo cambio de dirección
 
     // Invulnerabilidad post-spawn
-    float timer_invulnerabilitat_{0.0F};
+    float invulnerability_timer_{0.0F};
 
     // Estado "herido": timer cuenta atrás; al cruzar 0 se marca expiración.
     float wounded_timer_{0.0F};
@@ -124,11 +127,11 @@ class Enemy : public Entities::Entity {
 
     // Métodos privados
     void updateAnimation(float delta_time);
-    void updatePalpitation(float delta_time);
+    void updatePulse(float delta_time);
     void updateRotationAcceleration(float delta_time);
     void behaviorPentagon(float delta_time);
-    void behaviorQuadrat(float delta_time);
+    void behaviorSquare(float delta_time);
-    void behaviorMolinillo(float delta_time);
+    void behaviorPinwheel(float delta_time);
     [[nodiscard]] auto computeCurrentScale() const -> float;
     // Estático: solo opera sobre ship_pos pasado; no consulta estado del enemy.
     static auto attemptSafeSpawn(const Vec2& ship_pos, float& out_x, float& out_y) -> bool;

source/game/entities/ship.cpp

@@ -10,6 +10,7 @@
 #include <cstdint>
 #include <iostream>
 
+#include "core/audio/audio.hpp"
 #include "core/defaults.hpp"
 #include "core/entities/entity.hpp"
 #include "core/graphics/shape_loader.hpp"
@@ -43,10 +44,10 @@ void Ship::init(const Vec2* spawn_point, bool activar_invulnerabilitat) {
     if (spawn_point != nullptr) {
         center_ = *spawn_point;
     } else {
-        float centre_x;
+        float center_x;
-        float centre_y;
+        float center_y;
-        Constants::getPlayAreaCenter(centre_x, centre_y);
+        Constants::getPlayAreaCenter(center_x, center_y);
-        center_ = {.x = centre_x, .y = centre_y};
+        center_ = {.x = center_x, .y = center_y};
     }
 
     // Reset orientación
@@ -62,6 +63,8 @@ void Ship::init(const Vec2* spawn_point, bool activar_invulnerabilitat) {
     // Activar invulnerabilidad solo si es respawn
     invulnerable_timer_ = activar_invulnerabilitat ? Defaults::Ship::INVULNERABILITY_DURATION : 0.0F;
     is_hit_ = false;
+    hurt_timer_ = 0.0F;
+    touching_enemy_prev_frame_ = false;
 }
 
 void Ship::processInput(float delta_time, uint8_t player_id) {
@@ -115,6 +118,12 @@ void Ship::update(float delta_time) {
         invulnerable_timer_ = std::max(invulnerable_timer_, 0.0F);
     }
 
+    // Decrementar timer d'estat HURT (a 0 → torna a normal sense efecte extern)
+    if (hurt_timer_ > 0.0F) {
+        hurt_timer_ -= delta_time;
+        hurt_timer_ = std::max(hurt_timer_, 0.0F);
+    }
+
     // El movimiento real lo hace PhysicsWorld::update().
     // Aquí solo lógica de estado.
 
@@ -157,5 +166,21 @@ void Ship::draw() const {
     const float VISUAL_PUSH = SPEED / Defaults::Ship::VISUAL_PUSH_DIVISOR;
     const float SCALE = 1.0F + (VISUAL_PUSH / Defaults::Ship::VISUAL_SCALE_DIVISOR);
 
-    Rendering::renderShape(renderer_, shape_, center_, angle_, SCALE, 1.0F, brightness_, Defaults::Palette::SHIP);
+    // Parpelleig daurat mentre està ferida: alterna color normal ↔ color hurt
+    // a Hurt::BLINK_HZ (mateixa estètica que el wounded dels enemics).
+    SDL_Color color = color_normal_;
+    if (hurt_timer_ > 0.0F) {
+        const float CYCLE = 1.0F / Defaults::Ship::Hurt::BLINK_HZ;
+        const float T = std::fmod(hurt_timer_, CYCLE);
+        if (T < (CYCLE / 2.0F)) {
+            color = color_hurt_;
+        }
+    }
+
+    Rendering::renderShape(renderer_, shape_, center_, angle_, SCALE, 1.0F, brightness_, color);
+}
+
+void Ship::hurt() {
+    hurt_timer_ = Defaults::Ship::Hurt::DURATION;
+    Audio::get()->playSound(Defaults::Sound::HURT, Audio::Group::GAME);
 }

source/game/entities/ship.hpp

@@ -53,10 +53,31 @@ class Ship : public Entities::Entity {
         body_.velocity = Vec2{};  // Detener al morir
     }
 
+    // Estat "ferit": primera col·lisió amb enemic dispara HURT; segona durant HURT mata.
+    void hurt();
+    [[nodiscard]] auto isHurt() const -> bool { return hurt_timer_ > 0.0F; }
+    [[nodiscard]] auto getHurtTimer() const -> float { return hurt_timer_; }
+
+    // Edge-trigger del contacte amb enemics: un impacte només compta a la transició
+    // no-tocant → tocant. Sense açò, el contacte continu durant el rebot frame-a-frame
+    // dispararia HURT i mort en frames consecutius.
+    [[nodiscard]] auto wasTouchingEnemyPrevFrame() const -> bool { return touching_enemy_prev_frame_; }
+    void setTouchingEnemyPrevFrame(bool touching) { touching_enemy_prev_frame_ = touching; }
+
    private:
     // Miembros específicos de Ship (heredados: renderer_, shape_, center_, angle_, brightness_, body_).
     // Inicializados en la declaración: el ctor por defecto deja la nave "viva y sin invulnerabilidad",
     // que es el estado coherente al que llevan tanto init() como el ctor con renderer.
     bool is_hit_{false};
     float invulnerable_timer_{0.0F};  // 0.0f = vulnerable, >0.0f = invulnerable
+
+    // Colors de la nau (propietats, prep per migració a YAML).
+    SDL_Color color_normal_{Defaults::Palette::SHIP};
+    SDL_Color color_hurt_{Defaults::Palette::WOUNDED};
+
+    // >0 → estat HURT (parpelleig color_normal_ ↔ color_hurt_).
+    float hurt_timer_{0.0F};
+
+    // Edge-trigger: true si el frame anterior la nau ja estava en contacte amb un enemic.
+    bool touching_enemy_prev_frame_{false};
 };

source/game/scenes/game_scene.cpp

@@ -11,7 +11,9 @@
 
 #include "core/audio/audio.hpp"
 #include "core/input/input.hpp"
+#include "core/locale/locale.hpp"
 #include "core/system/scene_context.hpp"
+#include "core/system/service_menu.hpp"
 #include "game/stage_system/stage_loader.hpp"
 #include "game/systems/collision_system.hpp"
 #include "game/systems/continue_system.hpp"
@@ -30,6 +32,7 @@ GameScene::GameScene(SDLManager& sdl, SceneContext& context)
       floating_score_manager_(sdl.getRenderer()),
       trail_manager_(sdl.getRenderer()),
       text_(sdl.getRenderer()),
+      starfield_parallax_(sdl.getRenderer()),
       playfield_(sdl.getRenderer()),
       border_(sdl.getRenderer()) {
     // Recuperar configuración de match des del context
@@ -37,9 +40,9 @@ GameScene::GameScene(SDLManager& sdl, SceneContext& context)
 
     // Debug output de la configuración
     std::cout << "[GameScene] Configuración de match - P1: "
-              << (match_config_.jugador1_actiu ? "ACTIU" : "INACTIU")
+              << (match_config_.player1_active ? "ACTIU" : "INACTIU")
               << ", P2: "
-              << (match_config_.jugador2_actiu ? "ACTIU" : "INACTIU")
+              << (match_config_.player2_active ? "ACTIU" : "INACTIU")
               << '\n';
 
     // Consumir opciones (preparació per MODE_DEMO futur)
@@ -60,7 +63,7 @@ GameScene::GameScene(SDLManager& sdl, SceneContext& context)
     // Basat en el codi Pascal original: line 376
     std::srand(static_cast<unsigned>(std::time(nullptr)));
 
-    // Configurar el mundo físico con los límites de la zona de juego.
+    // Configurar el mundo físico con los límites de la zone de juego.
     physics_world_.clear();
     physics_world_.setBounds(Defaults::Zones::PLAYAREA);
 
@@ -75,18 +78,18 @@ GameScene::GameScene(SDLManager& sdl, SceneContext& context)
         border_.bumpAt(hit.contact_point, STRENGTH);
     });
 
-    // Fireworks generen un pulse a les línies V i H més properes del playfield.
+    // Fireworks generen una ripple gran al playfield (ona d'aigua centrada al burst).
-    firework_manager_.setSpawnCallback([this](Vec2 origen) {
+    firework_manager_.setSpawnCallback([this](Vec2 origin) {
-        playfield_.notifyFireworkSpawn(origen);
+        playfield_.notifyExplosion(origin);
     });
 
     // Explosions properes a una paret també generen bump (falloff lineal amb la distància).
     debris_manager_.setExplosionCallback([this](Vec2 center) {
-        const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+        const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
-        const float DIST_LEFT = std::abs(center.x - zona.x);
+        const float DIST_LEFT = std::abs(center.x - zone.x);
-        const float DIST_RIGHT = std::abs((zona.x + zona.w) - center.x);
+        const float DIST_RIGHT = std::abs((zone.x + zone.w) - center.x);
-        const float DIST_TOP = std::abs(center.y - zona.y);
+        const float DIST_TOP = std::abs(center.y - zone.y);
-        const float DIST_BOTTOM = std::abs((zona.y + zona.h) - center.y);
+        const float DIST_BOTTOM = std::abs((zone.y + zone.h) - center.y);
         const float MIN_DIST = std::min({DIST_LEFT, DIST_RIGHT, DIST_TOP, DIST_BOTTOM});
         if (MIN_DIST > Defaults::Border::EXPLOSION_FALLOFF_PX) {
             return;
@@ -129,9 +132,9 @@ GameScene::GameScene(SDLManager& sdl, SceneContext& context)
 
     // Inicialitzar naves segons configuración (solo jugadors active)
     for (uint8_t i = 0; i < 2; i++) {
-        bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+        bool player_active = (i == 0) ? match_config_.player1_active : match_config_.player2_active;
 
-        if (jugador_actiu) {
+        if (player_active) {
             // Jugador active: init normalment
             Vec2 spawn_pos = getSpawnPoint(i);
             ships_[i].init(&spawn_pos, false);  // No invulnerability at start
@@ -180,6 +183,13 @@ void GameScene::handleEvent(const SDL_Event& event) {
 }
 
 void GameScene::update(float delta_time) {
+    // Pausa global: mentre el menu de servei esta obert, congelem la lògica
+    // de joc. El draw() segueix executant-se per a mantenir l'escena visible
+    // sota el menu.
+    if (const auto* menu = System::ServiceMenu::get(); menu != nullptr && menu->isOpen()) {
+        return;
+    }
+
     // Orquestador delgado: cada paso vive en su propia función para
     // mantener update() legible y reducir complejidad cognitiva.
     stepPhysics(delta_time);
@@ -213,24 +223,45 @@ void GameScene::stepPhysics(float delta_time) {
         bullet.postUpdate(delta_time);
     }
     trail_manager_.update(delta_time, ships_);
+    // Starfield: world_velocity = -mitjana_de_naus_actives. Si dues naus van en
+    // sentits oposats, es cancel·len → estrelles quietes (cap jugador "guanya").
+    // Si només n'hi ha una activa, segueix la seva velocitat.
+    Vec2 ship_vel_avg{.x = 0.0F, .y = 0.0F};
+    int n_active = 0;
+    for (const auto& ship : ships_) {
+        if (ship.isActive()) {
+            const Vec2 V = ship.getVelocityVector();
+            ship_vel_avg.x += V.x;
+            ship_vel_avg.y += V.y;
+            n_active++;
+        }
+    }
+    if (n_active > 0) {
+        ship_vel_avg.x /= static_cast<float>(n_active);
+        ship_vel_avg.y /= static_cast<float>(n_active);
+    }
+    starfield_parallax_.update(delta_time, Vec2{.x = -ship_vel_avg.x, .y = -ship_vel_avg.y});
     playfield_.update(delta_time);
     border_.update(delta_time);
 
-    // Notificar al playfield que la nau ha passat (per excitar línies properes).
+    // Notificar al playfield que la nau es mou (genera ripples petites a cadència).
-    for (const auto& ship : ships_) {
+    for (std::size_t id = 0; id < ships_.size(); id++) {
-        if (ship.isActive()) {
+        if (ships_[id].isActive()) {
-            playfield_.notifyShipPass(ship.getCenter(), ship.getSpeed());
+            playfield_.notifyShipMoving(static_cast<std::uint8_t>(id),
+                ships_[id].getCenter(),
+                ships_[id].getSpeed(),
+                delta_time);
         }
     }
 }
 
 void GameScene::stepShootingInput() {
     auto* input = Input::get();
-    if (match_config_.jugador1_actiu &&
+    if (match_config_.player1_active &&
         input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
         fireBullet(0);
     }
-    if (match_config_.jugador2_actiu &&
+    if (match_config_.player2_active &&
         input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
         fireBullet(1);
     }
@@ -245,16 +276,16 @@ void GameScene::stepMidGameJoin() {
     // Solo se permite join si hay al menos un jugador vivo (no se puede
     // hacer join en pantalla vacía).
     const bool ALGU_VIU =
-        (match_config_.jugador1_actiu && hit_timer_per_player_[0] != Defaults::Game::HIT_TIMER_INACTIVE_PLAYER) ||
+        (match_config_.player1_active && hit_timer_per_player_[0] != Defaults::Game::HIT_TIMER_INACTIVE_PLAYER) ||
-        (match_config_.jugador2_actiu && hit_timer_per_player_[1] != Defaults::Game::HIT_TIMER_INACTIVE_PLAYER);
+        (match_config_.player2_active && hit_timer_per_player_[1] != Defaults::Game::HIT_TIMER_INACTIVE_PLAYER);
     if (!ALGU_VIU) {
         return;
     }
 
     auto* input = Input::get();
     for (uint8_t pid = 0; pid < 2; pid++) {
-        const bool ACTIU = (pid == 0) ? match_config_.jugador1_actiu
+        const bool ACTIU = (pid == 0) ? match_config_.player1_active
-                                      : match_config_.jugador2_actiu;
+                                      : match_config_.player2_active;
         const bool MUERTO_SIN_VIDAS = hit_timer_per_player_[pid] == Defaults::Game::HIT_TIMER_INACTIVE_PLAYER;
         if (ACTIU && !MUERTO_SIN_VIDAS) {
             continue;  // jugador ya está jugando
@@ -296,6 +327,7 @@ auto GameScene::stepContinueScreen(float delta_time) -> bool {
     for (auto& bullet : bullets_) {
         bullet.update(delta_time);
     }
+    Systems::Collision::desactivateOutOfBoundsBullets(bullets_, debris_manager_);
     debris_manager_.update(delta_time);
     firework_manager_.update(delta_time);
     floating_score_manager_.update(delta_time);
@@ -321,6 +353,7 @@ auto GameScene::stepGameOver(float delta_time) -> bool {
     for (auto& bullet : bullets_) {
         bullet.update(delta_time);
     }
+    Systems::Collision::desactivateOutOfBoundsBullets(bullets_, debris_manager_);
     debris_manager_.update(delta_time);
     firework_manager_.update(delta_time);
     floating_score_manager_.update(delta_time);
@@ -351,8 +384,8 @@ void GameScene::stepDeathSequence(float delta_time) {
 
         // Sin vidas: marcar definitivamente muerto y comprobar transición a CONTINUE.
         hit_timer_per_player_[i] = Defaults::Game::HIT_TIMER_INACTIVE_PLAYER;
-        const bool P1_DEAD = !match_config_.jugador1_actiu || lives_per_player_[0] <= 0;
+        const bool P1_DEAD = !match_config_.player1_active || lives_per_player_[0] <= 0;
-        const bool P2_DEAD = !match_config_.jugador2_actiu || lives_per_player_[1] <= 0;
+        const bool P2_DEAD = !match_config_.player2_active || lives_per_player_[1] <= 0;
         if (P1_DEAD && P2_DEAD) {
             game_over_state_ = GameOverState::CONTINUE;
             continue_counter_ = Defaults::Game::CONTINUE_COUNT_START;
@@ -416,10 +449,10 @@ void GameScene::runStageInitHud(float delta_time) {
         Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
         Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
 
-    if (match_config_.jugador1_actiu && SHIP1_P < 1.0F) {
+    if (match_config_.player1_active && SHIP1_P < 1.0F) {
         ships_[0].setCenter(Systems::InitHud::computeShipPosition(SHIP1_P, getSpawnPoint(0)));
     }
-    if (match_config_.jugador2_actiu && SHIP2_P < 1.0F) {
+    if (match_config_.player2_active && SHIP2_P < 1.0F) {
         ships_[1].setCenter(Systems::InitHud::computeShipPosition(SHIP2_P, getSpawnPoint(1)));
     }
 }
@@ -429,7 +462,7 @@ void GameScene::runStageLevelStart(float delta_time) {
 
     // Ambas naves pueden moverse y disparar durante el intro.
     for (uint8_t i = 0; i < 2; i++) {
-        const bool ACTIU = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+        const bool ACTIU = (i == 0) ? match_config_.player1_active : match_config_.player2_active;
         if (ACTIU && hit_timer_per_player_[i] == 0.0F) {
             ships_[i].processInput(delta_time, i);
             ships_[i].update(delta_time);
@@ -438,6 +471,7 @@ void GameScene::runStageLevelStart(float delta_time) {
     for (auto& bullet : bullets_) {
         bullet.update(delta_time);
     }
+    Systems::Collision::desactivateOutOfBoundsBullets(bullets_, debris_manager_);
     debris_manager_.update(delta_time);
     firework_manager_.update(delta_time);
 }
@@ -456,7 +490,7 @@ void GameScene::runStagePlaying(float delta_time) {
 
     // Gameplay normal: ships activos + entidades + colisiones + efectos.
     for (uint8_t i = 0; i < 2; i++) {
-        const bool ACTIU = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+        const bool ACTIU = (i == 0) ? match_config_.player1_active : match_config_.player2_active;
         if (ACTIU && hit_timer_per_player_[i] == 0.0F) {
             ships_[i].processInput(delta_time, i);
             ships_[i].update(delta_time);
@@ -465,11 +499,15 @@ void GameScene::runStagePlaying(float delta_time) {
     for (auto& enemy : enemies_) {
         enemy.update(delta_time);
     }
+
+    // Col·lisions primer, després desactivació per fora-de-zone: així una bala que
+    // el mateix frame xoca amb un enemic i alhora surt del PLAYAREA es compta com a
+    // impacte abans no se la trenqui per sortir.
+    runCollisionDetections();
     for (auto& bullet : bullets_) {
         bullet.update(delta_time);
     }
-
+    Systems::Collision::desactivateOutOfBoundsBullets(bullets_, debris_manager_);
-    runCollisionDetections();
     debris_manager_.update(delta_time);
     firework_manager_.update(delta_time);
     floating_score_manager_.update(delta_time);
@@ -478,7 +516,7 @@ void GameScene::runStagePlaying(float delta_time) {
 void GameScene::runStageLevelCompleted(float delta_time) {
     stage_manager_->update(delta_time);
     for (uint8_t i = 0; i < 2; i++) {
-        const bool ACTIU = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+        const bool ACTIU = (i == 0) ? match_config_.player1_active : match_config_.player2_active;
         if (ACTIU && hit_timer_per_player_[i] == 0.0F) {
             ships_[i].processInput(delta_time, i);
             ships_[i].update(delta_time);
@@ -487,6 +525,7 @@ void GameScene::runStageLevelCompleted(float delta_time) {
     for (auto& bullet : bullets_) {
         bullet.update(delta_time);
     }
+    Systems::Collision::desactivateOutOfBoundsBullets(bullets_, debris_manager_);
     debris_manager_.update(delta_time);
     firework_manager_.update(delta_time);
     floating_score_manager_.update(delta_time);
@@ -550,14 +589,15 @@ void GameScene::drawBullets() const {
 
 void GameScene::drawActiveShipsAlive() const {
     for (uint8_t i = 0; i < 2; i++) {
-        bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+        bool player_active = (i == 0) ? match_config_.player1_active : match_config_.player2_active;
-        if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
+        if (player_active && hit_timer_per_player_[i] == 0.0F) {
             ships_[i].draw();
         }
     }
 }
 
 void GameScene::drawContinueState() {
+    starfield_parallax_.draw();
     border_.draw();
     drawEnemies();
     drawBullets();
@@ -569,6 +609,7 @@ void GameScene::drawContinueState() {
 }
 
 void GameScene::drawGameOverState() {
+    starfield_parallax_.draw();
     border_.draw();
     drawEnemies();
     drawBullets();
@@ -576,15 +617,15 @@ void GameScene::drawGameOverState() {
     firework_manager_.draw();
     floating_score_manager_.draw();
 
-    const std::string GAME_OVER_TEXT = "GAME OVER";
+    const std::string GAME_OVER_TEXT = Locale::get().text("game_screen.game_over");
     constexpr float SCALE = Defaults::Game::GameOverScreen::TEXT_SCALE;
     constexpr float SPACING = Defaults::Game::GameOverScreen::TEXT_SPACING;
 
     const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-    float centre_x = play_area.x + (play_area.w / 2.0F);
+    float center_x = play_area.x + (play_area.w / 2.0F);
-    float centre_y = play_area.y + (play_area.h / 2.0F);
+    float center_y = play_area.y + (play_area.h / 2.0F);
 
-    text_.renderCentered(GAME_OVER_TEXT, {.x = centre_x, .y = centre_y}, SCALE, SPACING);
+    text_.renderCentered(GAME_OVER_TEXT, {.x = center_x, .y = center_y}, SCALE, SPACING);
 
     drawScoreboard();
 }
@@ -614,6 +655,8 @@ void GameScene::drawInitHudState() {
         Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
         Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
 
+    // Capa de fons més profunda: estrelles 2D (apareixen senceres des del frame 0).
+    starfield_parallax_.draw();
     // Graella de fons al darrere (timer intern propi, cobreix tot l'INIT_HUD).
     playfield_.draw();
 
@@ -629,16 +672,17 @@ void GameScene::drawInitHudState() {
         Systems::InitHud::drawScoreboardAnimated(text_, buildScoreboard(), score_progress);
     }
 
-    if (ship1_progress > 0.0F && match_config_.jugador1_actiu && ships_[0].isActive()) {
+    if (ship1_progress > 0.0F && match_config_.player1_active && ships_[0].isActive()) {
         ships_[0].draw();
     }
 
-    if (ship2_progress > 0.0F && match_config_.jugador2_actiu && ships_[1].isActive()) {
+    if (ship2_progress > 0.0F && match_config_.player2_active && ships_[1].isActive()) {
         ships_[1].draw();
     }
 }
 
 void GameScene::drawLevelStartState() {
+    starfield_parallax_.draw();
     playfield_.draw();
     border_.draw();
     trail_manager_.draw();
@@ -652,6 +696,7 @@ void GameScene::drawLevelStartState() {
 }
 
 void GameScene::drawPlayingState() {
+    starfield_parallax_.draw();
     playfield_.draw();
     border_.draw();
     trail_manager_.draw();
@@ -665,6 +710,7 @@ void GameScene::drawPlayingState() {
 }
 
 void GameScene::drawLevelCompletedState() {
+    starfield_parallax_.draw();
     playfield_.draw();
     border_.draw();
     trail_manager_.draw();
@@ -673,7 +719,7 @@ void GameScene::drawLevelCompletedState() {
     debris_manager_.draw();
     firework_manager_.draw();
     floating_score_manager_.draw();
-    drawStageMessage(StageSystem::Constants::MISSATGE_LEVEL_COMPLETED);
+    drawStageMessage(Locale::get().text("stage.completed"));
     drawScoreboard();
 }
 
@@ -686,30 +732,36 @@ void GameScene::tocado(uint8_t player_id) {
     if (hit_timer_per_player_[player_id] == 0.0F) {
         // *** PHASE 1: TRIGGER DEATH ***
 
+        // Capturar velocitat ABANS del markHit (que la reseteja a zero).
+        // Sense això, els debris no hereten cap inèrcia de la nau.
+        const Vec2 SHIP_VEL_PRE_DEATH = ships_[player_id].getVelocityVector();
+        const Vec2 SHIP_POS = ships_[player_id].getCenter();
+        const float SHIP_ANGLE = ships_[player_id].getAngle();
+        const float SHIP_BRIGHT = ships_[player_id].getBrightness();
+
         // Mark ship as dead (stops rendering and input)
         ships_[player_id].markHit();
 
-        // Create ship explosion
+        const Vec2 INHERITED_VEL = SHIP_VEL_PRE_DEATH *
-        const Vec2& ship_pos = ships_[player_id].getCenter();
+            Defaults::Physics::Debris::SHIP_VELOCITY_INHERITANCE;
-        float ship_angle = ships_[player_id].getAngle();
-        Vec2 vel_nau = ships_[player_id].getVelocityVector();
-        // Reduir la velocity heretada per la ship segons defaults (més realista)
-        constexpr float INHERIT = Defaults::Physics::Debris::SHIP_VELOCITY_INHERITANCE;
-        Vec2 vel_nau_80 = {.x = vel_nau.x * INHERIT, .y = vel_nau.y * INHERIT};
 
+        // Mateixa dispersió i efecte que els debris d'enemic (lifetime,
+        // friction, segment_multiplier alineats); només canvien sound i color.
         debris_manager_.explode(
-            ships_[player_id].getShape(),               // Ship shape (3 lines)
+            ships_[player_id].getShape(),
-            ship_pos,                                   // Center position
+            SHIP_POS,
-            ship_angle,                                 // Ship orientation
+            SHIP_ANGLE,
-            1.0F,                                       // Normal scale
+            1.0F,
-            Defaults::Physics::Debris::VELOCITAT_BASE,  // 80 px/s
+            Defaults::Physics::Debris::SPEED_BASE,
-            ships_[player_id].getBrightness(),          // Heredar brightness
+            SHIP_BRIGHT,
-            vel_nau_80,                                 // Heredar 80% velocity
+            INHERITED_VEL,
-            0.0F,                                       // Nave: trayectorias rectas (sin drotacio)
+            0.0F,  // sense herència angular
-            0.0F,                                       // Sin herencia visual (rotación aleatoria)
+            0.0F,  // sin herencia visual
-            Defaults::Sound::EXPLOSION2,                // Sonido alternativo para la explosión
+            Defaults::Sound::EXPLOSION2,
-            Defaults::Palette::SHIP                     // Debris hereda color de la nave
+            Defaults::Palette::SHIP,
-        );
+            Defaults::Physics::Debris::ENEMY_LIFETIME,
+            Defaults::Physics::Debris::ENEMY_FRICTION,
+            Defaults::Physics::Debris::ENEMY_SEGMENT_MULTIPLIER);
 
         // Start death timer (non-zero to avoid re-triggering)
         hit_timer_per_player_[player_id] = Defaults::Game::HIT_TIMER_TRIGGER_DEATH;
@@ -726,20 +778,20 @@ void GameScene::drawScoreboard() {
     const float SCALE = Defaults::Hud::SCOREBOARD_TEXT_SCALE;
     const float SPACING = Defaults::Hud::SCOREBOARD_TEXT_SPACING;
 
-    // Calcular centro de la zona del marcador
+    // Calcular centro de la zone del marcador
     const SDL_FRect& scoreboard_zone = Defaults::Zones::SCOREBOARD;
-    float centre_x = scoreboard_zone.w / 2.0F;
+    float center_x = scoreboard_zone.w / 2.0F;
-    float centre_y = scoreboard_zone.y + (scoreboard_zone.h / 2.0F);
+    float center_y = scoreboard_zone.y + (scoreboard_zone.h / 2.0F);
 
     // Renderizar centrat
-    text_.renderCentered(text, {.x = centre_x, .y = centre_y}, SCALE, SPACING);
+    text_.renderCentered(text, {.x = center_x, .y = center_y}, SCALE, SPACING);
 }
 
 auto GameScene::buildScoreboard() const -> std::string {
     // Puntuación P1 (6 dígits) - mostrar zeros si inactiu
     std::string score_p1;
     std::string vides_p1;
-    if (match_config_.jugador1_actiu) {
+    if (match_config_.player1_active) {
         score_p1 = std::to_string(score_per_player_[0]);
         score_p1 = std::string(6 - std::min(6, static_cast<int>(score_p1.length())), '0') + score_p1;
         vides_p1 = (lives_per_player_[0] < 10)
@@ -758,7 +810,7 @@ auto GameScene::buildScoreboard() const -> std::string {
     // Puntuación P2 (6 dígits) - mostrar zeros si inactiu
     std::string score_p2;
     std::string vides_p2;
-    if (match_config_.jugador2_actiu) {
+    if (match_config_.player2_active) {
         score_p2 = std::to_string(score_per_player_[1]);
         score_p2 = std::string(6 - std::min(6, static_cast<int>(score_p2.length())), '0') + score_p2;
         vides_p2 = (lives_per_player_[1] < 10)
@@ -771,7 +823,7 @@ auto GameScene::buildScoreboard() const -> std::string {
 
     // Format: "123456 03  LEVEL 01  654321 02"
     // Nota: dos espais entre seccions, mantenir ambdós slots siempre visibles
-    return score_p1 + " " + vides_p1 + "  LEVEL " + stage_str + "  " + score_p2 + " " + vides_p2;
+    return score_p1 + " " + vides_p1 + "  " + Locale::get().text("hud.level") + stage_str + "  " + score_p2 + " " + vides_p2;
 }
 
 // [NEW] Stage system helper methods
@@ -836,9 +888,10 @@ void GameScene::drawStageMessage(const std::string& message) {
     float x = play_area.x + ((play_area.w - full_text_width) / 2.0F);
     float y = play_area.y + (play_area.h * Defaults::Game::STAGE_MESSAGE_Y_RATIO) - (text_height / 2.0F);
 
-    // Render only the partial message (typewriter effect)
+    // Render only the partial message (typewriter effect) amb el color
+    // ambre neon del "PRESS START" del títol — unifica el feel dels missatges.
     Vec2 pos = {.x = x, .y = y};
-    text_.render(partial_message, pos, scale, SPACING);
+    text_.render(partial_message, pos, scale, SPACING, 1.0F, Defaults::Title::Colors::PRESS_START);
 }
 
 // ========================================
@@ -846,7 +899,7 @@ void GameScene::drawStageMessage(const std::string& message) {
 // ========================================
 
 auto GameScene::getSpawnPoint(uint8_t player_id) const -> Vec2 {
-    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+    const SDL_FRect& zone = Defaults::Zones::PLAYAREA;
 
     float x_ratio;
     if (match_config_.isSinglePlayer()) {
@@ -860,8 +913,8 @@ auto GameScene::getSpawnPoint(uint8_t player_id) const -> Vec2 {
     }
 
     return {
-        .x = zona.x + (zona.w * x_ratio),
+        .x = zone.x + (zone.w * x_ratio),
-        .y = zona.y + (zona.h * Defaults::Game::SPAWN_Y_RATIO)};
+        .y = zone.y + (zone.h * Defaults::Game::SPAWN_Y_RATIO)};
 }
 
 void GameScene::fireBullet(uint8_t player_id) {
@@ -883,15 +936,15 @@ void GameScene::fireBullet(uint8_t player_id) {
     float sin_a = std::sin(ship_angle);
     float tip_x = (LOCAL_TIP_X * cos_a) - (LOCAL_TIP_Y * sin_a) + ship_centre.x;
     float tip_y = (LOCAL_TIP_X * sin_a) + (LOCAL_TIP_Y * cos_a) + ship_centre.y;
-    Vec2 posicio_dispar = {.x = tip_x, .y = tip_y};
+    Vec2 fire_position = {.x = tip_x, .y = tip_y};
 
     // Buscar primera bullet inactiva en el pool del player.
-    // El pool global té MAX_BALES slots per jugador (P1=[0..MAX-1], P2=[MAX..2*MAX-1]).
+    // El pool global té MAX_BULLETS slots per jugador (P1=[0..MAX-1], P2=[MAX..2*MAX-1]).
-    constexpr int SLOTS_PER_PLAYER = Defaults::Entities::MAX_BALES;
+    constexpr int SLOTS_PER_PLAYER = Defaults::Entities::MAX_BULLETS;
     const int START_IDX = player_id * SLOTS_PER_PLAYER;
     for (int i = START_IDX; i < START_IDX + SLOTS_PER_PLAYER; i++) {
         if (!bullets_[i].isActive()) {
-            bullets_[i].disparar(posicio_dispar, ship_angle, player_id);
+            bullets_[i].fire(fire_position, ship_angle, player_id);
             break;
         }
     }
@@ -902,14 +955,14 @@ void GameScene::drawContinue() {
     constexpr float SPACING = 4.0F;
 
     // "CONTINUE" text (using constants)
-    const std::string CONTINUE_TEXT = "CONTINUE";
+    const std::string CONTINUE_TEXT = Locale::get().text("game_screen.continue");
     float escala_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_SCALE;
     float y_ratio_continue = Defaults::Game::ContinueScreen::CONTINUE_TEXT_Y_RATIO;
 
-    float centre_x = play_area.x + (play_area.w / 2.0F);
+    float center_x = play_area.x + (play_area.w / 2.0F);
     float centre_y_continue = play_area.y + (play_area.h * y_ratio_continue);
 
-    text_.renderCentered(CONTINUE_TEXT, {.x = centre_x, .y = centre_y_continue}, escala_continue, SPACING);
+    text_.renderCentered(CONTINUE_TEXT, {.x = center_x, .y = centre_y_continue}, escala_continue, SPACING);
 
     // Countdown number (using constants)
     const std::string COUNTER_STR = std::to_string(continue_counter_);
@@ -918,26 +971,29 @@ void GameScene::drawContinue() {
 
     float centre_y_counter = play_area.y + (play_area.h * y_ratio_counter);
 
-    text_.renderCentered(COUNTER_STR, {.x = centre_x, .y = centre_y_counter}, escala_counter, SPACING);
+    text_.renderCentered(COUNTER_STR, {.x = center_x, .y = centre_y_counter}, escala_counter, SPACING);
 
     // "CONTINUES LEFT" (conditional + using constants)
     if (!Defaults::Game::INFINITE_CONTINUES) {
-        const std::string CONTINUES_TEXT = "CONTINUES LEFT: " + std::to_string(Defaults::Game::MAX_CONTINUES - continues_used_);
+        const std::string CONTINUES_TEXT = localeSubstitute(
+            Locale::get().text("game_screen.continues_left"),
+            "{n}",
+            std::to_string(Defaults::Game::MAX_CONTINUES - continues_used_));
         float escala_info = Defaults::Game::ContinueScreen::INFO_TEXT_SCALE;
         float y_ratio_info = Defaults::Game::ContinueScreen::INFO_TEXT_Y_RATIO;
 
         float centre_y_info = play_area.y + (play_area.h * y_ratio_info);
 
-        text_.renderCentered(CONTINUES_TEXT, {.x = centre_x, .y = centre_y_info}, escala_info, SPACING);
+        text_.renderCentered(CONTINUES_TEXT, {.x = center_x, .y = centre_y_info}, escala_info, SPACING);
     }
 }
 
 void GameScene::joinPlayer(uint8_t player_id) {
     // Activate player
     if (player_id == 0) {
-        match_config_.jugador1_actiu = true;
+        match_config_.player1_active = true;
     } else {
-        match_config_.jugador2_actiu = true;
+        match_config_.player2_active = true;
     }
 
     // Reset stats

source/game/scenes/game_scene.hpp

@@ -10,6 +10,7 @@
 
 #include "core/graphics/border.hpp"
 #include "core/graphics/playfield.hpp"
+#include "core/graphics/starfield_parallax.hpp"
 #include "core/graphics/vector_text.hpp"
 #include "core/physics/physics_world.hpp"
 #include "core/rendering/sdl_manager.hpp"
@@ -66,7 +67,7 @@ class GameScene final : public Scene {
     std::array<Enemy, Constants::MAX_ORNIS> enemies_;
     // 6 balas: P1=[0,1,2], P2=[3,4,5]. El cast a size_t evita la
     // widening conversion implícita que detecta clang-tidy.
-    std::array<Bullet, static_cast<std::size_t>(Constants::MAX_BALES) * 2> bullets_;
+    std::array<Bullet, static_cast<std::size_t>(Constants::MAX_BULLETS) * 2> bullets_;
     std::array<float, 2> hit_timer_per_player_;  // Death timers per player (seconds)
 
     // Lives and game over system
@@ -82,6 +83,9 @@ class GameScene final : public Scene {
     // Text vectorial
     Graphics::VectorText text_;
 
+    // Capa més profunda del fons: estrelles 2D amb parallax (estàtiques de moment).
+    Graphics::StarfieldParallax starfield_parallax_;
+
     // Fons del playfield (graella + futures capes)
     Graphics::Playfield playfield_;
 

source/game/scenes/logo_scene.cpp

@@ -20,18 +20,18 @@ using SceneManager::SceneContext;
 using SceneType = SceneContext::SceneType;
 using Option = SceneContext::Option;
 
-// Helper: calcular el progrés individual de una lletra
+// Helper: calcular el progrés individual de una letter
 // en función del progrés global (efecte seqüencial)
-static auto computeLetterProgress(size_t letra_index, size_t num_letras, float global_progress, float threshold) -> float {
+static auto computeLetterProgress(size_t letter_index, size_t num_letters, float global_progress, float threshold) -> float {
-    if (num_letras == 0) {
+    if (num_letters == 0) {
         return 1.0F;
     }
 
-    // Calcular time per lletra
+    // Calcular time per letter
-    float duration_per_letra = 1.0F / static_cast<float>(num_letras);
+    float duration_per_letter = 1.0F / static_cast<float>(num_letters);
-    float step = threshold * duration_per_letra;
+    float step = threshold * duration_per_letter;
-    float start = static_cast<float>(letra_index) * step;
+    float start = static_cast<float>(letter_index) * step;
-    float end = start + duration_per_letra;
+    float end = start + duration_per_letter;
 
     // Interpolar progrés
     if (global_progress < start) {
@@ -47,15 +47,14 @@ LogoScene::LogoScene(SDLManager& sdl, SceneContext& context)
     : sdl_(sdl),
       context_(context),
 
-      debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.getRenderer()))
+      debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.getRenderer())) {
-      {
     std::cout << "SceneType Logo: Inicialitzant...\n";
 
     // Consumir opciones (LOGO no processa opciones actualment)
     auto option = context_.consumeOption();
     (void)option;  // Suprimir warning
 
-    so_reproduit_.fill(false);  // Inicialitzar seguiment de sons
+    sound_played_.fill(false);  // Inicialitzar seguiment de sons
     initLetters();
 }
 
@@ -91,7 +90,7 @@ void LogoScene::initLetters() {
         "logo/letra_s.shp"};
 
     // Pas 1: Carregar todas las formes i calcular amplades
-    float ancho_total = 0.0F;
+    float total_width = 0.0F;
 
     for (const auto& file : archivos) {
         auto shape = ShapeLoader::load(file);
@@ -111,66 +110,66 @@ void LogoScene::initLetters() {
             }
         }
 
-        float ancho_sin_escalar = max_x - min_x;
+        float width_unscaled = max_x - min_x;
 
-        // IMPORTANT: Escalar ancho i offset con ESCALA_FINAL
+        // IMPORTANT: Escalar ancho i offset con FINAL_SCALE
         // per que las posicions finals coincideixin con la mida real de las lletres
-        float ancho = ancho_sin_escalar * ESCALA_FINAL;
+        float width = width_unscaled * FINAL_SCALE;
-        float offset_centre = (shape->getCenter().x - min_x) * ESCALA_FINAL;
+        float center_offset = (shape->getCenter().x - min_x) * FINAL_SCALE;
 
-        lletres_.push_back({shape,
+        letters_.push_back({shape,
             {.x = 0.0F, .y = 0.0F},  // Posición es calcularà después
-            ancho,
+            width,
-            offset_centre});
+            center_offset});
 
-        ancho_total += ancho;
+        total_width += width;
     }
 
     // Pas 2: Añadir espaiat entre lletres
-    ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
+    total_width += LETTER_SPACING * (letters_.size() - 1);
 
     // Pas 3: Calcular posición inicial (centrat horitzontal)
-    constexpr auto PANTALLA_ANCHO = static_cast<float>(Defaults::Game::WIDTH);
+    constexpr auto SCREEN_WIDTH = static_cast<float>(Defaults::Game::WIDTH);
     constexpr auto PANTALLA_ALTO = static_cast<float>(Defaults::Game::HEIGHT);
 
-    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0F;
+    float x_inicial = (SCREEN_WIDTH - total_width) / 2.0F;
     float y_centre = PANTALLA_ALTO / 2.0F;
 
-    // Pas 4: Assignar posicions a cada lletra
+    // Pas 4: Assignar posicions a cada letter
     float x_actual = x_inicial;
 
-    for (auto& lletra : lletres_) {
+    for (auto& letter : letters_) {
         // Posicionar el centro de la shape (shape_centre) en pantalla
-        // Usar offset_centre en lloc de ancho/2 perquè shape_centre
+        // Usar center_offset en lloc de ancho/2 perquè shape_centre
         // pot no estar exactament al mig del bounding box
-        lletra.position.x = x_actual + lletra.offset_centre;
+        letter.position.x = x_actual + letter.center_offset;
-        lletra.position.y = y_centre;
+        letter.position.y = y_centre;
 
-        // Avançar para següent lletra
+        // Avançar para següent letter
-        x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
+        x_actual += letter.width + LETTER_SPACING;
     }
 
-    std::cout << "[LogoScene] " << lletres_.size()
+    std::cout << "[LogoScene] " << letters_.size()
-              << " lletres carregades, ancho total: " << ancho_total << " px\n";
+              << " lletres carregades, ancho total: " << total_width << " px\n";
 }
 
 void LogoScene::changeState(AnimationState nou_estat) {
-    estat_actual_ = nou_estat;
+    current_state_ = nou_estat;
-    temps_estat_actual_ = 0.0F;  // Reset time
+    temps_current_state_ = 0.0F;  // Reset time
 
     // Inicialitzar state de explosión
     if (nou_estat == AnimationState::EXPLOSION) {
-        lletra_explosio_index_ = 0;
+        letter_explosion_index_ = 0;
-        temps_des_ultima_explosio_ = 0.0F;
+        time_since_last_explosion_ = 0.0F;
 
         // Generar ordre aleatori de explosions
-        ordre_explosio_.clear();
+        explosion_order_.clear();
-        for (size_t i = 0; i < lletres_.size(); i++) {
+        for (size_t i = 0; i < letters_.size(); i++) {
-            ordre_explosio_.push_back(i);
+            explosion_order_.push_back(i);
         }
         std::random_device rd;
         std::mt19937 g(rd());
-        std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g);
+        std::shuffle(explosion_order_.begin(), explosion_order_.end(), g);
     } else if (nou_estat == AnimationState::POST_EXPLOSION) {
         Audio::get()->playMusic("title.ogg");
     }
@@ -180,35 +179,35 @@ void LogoScene::changeState(AnimationState nou_estat) {
 }
 
 auto LogoScene::allLettersComplete() const -> bool {
-    // Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0
+    // Cuando global_progress = 1.0, todas las lletres tenen letter_progress = 1.0
-    return temps_estat_actual_ >= DURACIO_ZOOM;
+    return temps_current_state_ >= DURATION_ZOOM;
 }
 
 void LogoScene::updateExplosions(float delta_time) {
-    temps_des_ultima_explosio_ += delta_time;
+    time_since_last_explosion_ += delta_time;
 
-    // Comprovar si es el moment de explode la següent lletra
+    // Comprovar si es el moment de explode la següent letter
-    if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) {
+    if (time_since_last_explosion_ >= DELAY_ENTRE_EXPLOSIONS) {
-        if (lletra_explosio_index_ < lletres_.size()) {
+        if (letter_explosion_index_ < letters_.size()) {
-            // Explotar lletra actual (en ordre aleatori)
+            // Explotar letter actual (en ordre aleatori)
-            size_t index_actual = ordre_explosio_[lletra_explosio_index_];
+            size_t index_actual = explosion_order_[letter_explosion_index_];
-            const auto& lletra = lletres_[index_actual];
+            const auto& letter = letters_[index_actual];
 
             debris_manager_->explode(
-                lletra.shape,           // Forma a explode
+                letter.shape,           // Forma a explode
-                lletra.position,         // Posición
+                letter.position,        // Posición
                 0.0F,                   // Angle (sin rotación)
-                ESCALA_FINAL,           // Escala (lletres a scale final)
+                FINAL_SCALE,            // Escala (lletres a scale final)
-                VELOCITAT_EXPLOSIO,     // Velocidad base
+                SPEED_EXPLOSIO,         // Velocidad base
                 1.0F,                   // Brightness màxim (per defecte)
                 {.x = 0.0F, .y = 0.0F}  // Sin velocity (per defecte)
             );
 
-            std::cout << "[LogoScene] Explota lletra " << lletra_explosio_index_ << "\n";
+            std::cout << "[LogoScene] Explota letter " << letter_explosion_index_ << "\n";
 
-            // Passar a la següent lletra
+            // Passar a la següent letter
-            lletra_explosio_index_++;
+            letter_explosion_index_++;
-            temps_des_ultima_explosio_ = 0.0F;
+            time_since_last_explosion_ = 0.0F;
         } else {
             // Todas las lletres han explotat, transición a POST_EXPLOSION
             changeState(AnimationState::POST_EXPLOSION);
@@ -217,31 +216,31 @@ void LogoScene::updateExplosions(float delta_time) {
 }
 
 void LogoScene::update(float delta_time) {
-    temps_estat_actual_ += delta_time;
+    temps_current_state_ += delta_time;
 
-    switch (estat_actual_) {
+    switch (current_state_) {
         case AnimationState::PRE_ANIMATION:
-            if (temps_estat_actual_ >= DURACIO_PRE) {
+            if (temps_current_state_ >= DURATION_PRE) {
                 changeState(AnimationState::ANIMATION);
             }
             break;
 
         case AnimationState::ANIMATION: {
-            // Reproduir so per cada lletra cuando comença a aparèixer
+            // Reproduir so per cada letter cuando comença a aparèixer
-            float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F);
+            float global_progress = std::min(temps_current_state_ / DURATION_ZOOM, 1.0F);
 
-            for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) {
+            for (size_t i = 0; i < letters_.size() && i < sound_played_.size(); i++) {
-                if (!so_reproduit_[i]) {
+                if (!sound_played_[i]) {
-                    float letra_progress = computeLetterProgress(
+                    float letter_progress = computeLetterProgress(
                         i,
-                        lletres_.size(),
+                        letters_.size(),
                         global_progress,
-                        THRESHOLD_LETRA);
+                        LETTER_THRESHOLD);
 
-                    // Reproduir so cuando la lletra comença a aparèixer (progress > 0)
+                    // Reproduir so cuando la letter comença a aparèixer (progress > 0)
-                    if (letra_progress > 0.0F) {
+                    if (letter_progress > 0.0F) {
                         Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME);
-                        so_reproduit_[i] = true;
+                        sound_played_[i] = true;
                     }
                 }
             }
@@ -253,7 +252,7 @@ void LogoScene::update(float delta_time) {
         }
 
         case AnimationState::POST_ANIMATION:
-            if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
+            if (temps_current_state_ >= DURATION_POST_ANIMATION) {
                 changeState(AnimationState::EXPLOSION);
             }
             break;
@@ -263,7 +262,7 @@ void LogoScene::update(float delta_time) {
             break;
 
         case AnimationState::POST_EXPLOSION:
-            if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
+            if (temps_current_state_ >= DURATION_POST_EXPLOSION) {
                 // Transición a pantalla de título
                 context_.setNextScene(SceneType::TITLE);
             }
@@ -283,47 +282,47 @@ void LogoScene::draw() {
     // Director ha hecho el clear; aquí solo pintamos lo de la escena.
 
     // PRE_ANIMATION: Solo pantalla negra (no se pinta nada).
-    if (estat_actual_ == AnimationState::PRE_ANIMATION) {
+    if (current_state_ == AnimationState::PRE_ANIMATION) {
         return;
     }
 
     // ANIMATION o POST_ANIMATION: Dibuixar lletres con animación
-    if (estat_actual_ == AnimationState::ANIMATION ||
+    if (current_state_ == AnimationState::ANIMATION ||
-        estat_actual_ == AnimationState::POST_ANIMATION) {
+        current_state_ == AnimationState::POST_ANIMATION) {
         float global_progress =
-            (estat_actual_ == AnimationState::ANIMATION)
+            (current_state_ == AnimationState::ANIMATION)
-            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F)
+            ? std::min(temps_current_state_ / DURATION_ZOOM, 1.0F)
             : 1.0F;  // POST: mantenir al 100%
 
-        const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y};
+        const Vec2 ZOOM_ORIGIN = {.x = ZOOM_ORIGIN_X, .y = ZOOM_ORIGIN_Y};
 
-        for (size_t i = 0; i < lletres_.size(); i++) {
+        for (size_t i = 0; i < letters_.size(); i++) {
-            const auto& lletra = lletres_[i];
+            const auto& letter = letters_[i];
 
-            float letra_progress = computeLetterProgress(
+            float letter_progress = computeLetterProgress(
                 i,
-                lletres_.size(),
+                letters_.size(),
                 global_progress,
-                THRESHOLD_LETRA);
+                LETTER_THRESHOLD);
 
-            if (letra_progress <= 0.0F) {
+            if (letter_progress <= 0.0F) {
                 continue;
             }
 
             Vec2 pos_actual;
             pos_actual.x =
-                ORIGEN_ZOOM.x + ((lletra.position.x - ORIGEN_ZOOM.x) * letra_progress);
+                ZOOM_ORIGIN.x + ((letter.position.x - ZOOM_ORIGIN.x) * letter_progress);
             pos_actual.y =
-                ORIGEN_ZOOM.y + ((lletra.position.y - ORIGEN_ZOOM.y) * letra_progress);
+                ZOOM_ORIGIN.y + ((letter.position.y - ZOOM_ORIGIN.y) * letter_progress);
 
-            float t = letra_progress;
+            float t = letter_progress;
             float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
             float current_scale =
-                ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor);
+                INITIAL_SCALE + ((FINAL_SCALE - INITIAL_SCALE) * ease_factor);
 
             Rendering::renderShape(
                 sdl_.getRenderer(),
-                lletra.shape,
+                letter.shape,
                 pos_actual,
                 0.0F,
                 current_scale,
@@ -332,24 +331,24 @@ void LogoScene::draw() {
     }
 
     // EXPLOSION: Dibuixar solo lletres que aún no han explotat
-    if (estat_actual_ == AnimationState::EXPLOSION) {
+    if (current_state_ == AnimationState::EXPLOSION) {
         // Crear conjunt de lletres ya explotades
         std::set<size_t> explotades;
-        for (size_t i = 0; i < lletra_explosio_index_; i++) {
+        for (size_t i = 0; i < letter_explosion_index_; i++) {
-            explotades.insert(ordre_explosio_[i]);
+            explotades.insert(explosion_order_[i]);
         }
 
         // Dibuixar solo lletres que NO han explotat
-        for (size_t i = 0; i < lletres_.size(); i++) {
+        for (size_t i = 0; i < letters_.size(); i++) {
             if (!explotades.contains(i)) {
-                const auto& lletra = lletres_[i];
+                const auto& letter = letters_[i];
 
                 Rendering::renderShape(
                     sdl_.getRenderer(),
-                    lletra.shape,
+                    letter.shape,
-                    lletra.position,
+                    letter.position,
                     0.0F,
-                    ESCALA_FINAL,
+                    FINAL_SCALE,
                     1.0F);
             }
         }

source/game/scenes/logo_scene.hpp

@@ -42,46 +42,46 @@ class LogoScene final : public Scene {
 
     SDLManager& sdl_;
     SceneManager::SceneContext& context_;
-        AnimationState estat_actual_{AnimationState::PRE_ANIMATION};  // Estat actual de la màquina
+    AnimationState current_state_{AnimationState::PRE_ANIMATION};  // Estat actual de la màquina
     float
-            temps_estat_actual_{0.0F};  // Temps en l'state actual (reset en cada transición)
+        temps_current_state_{0.0F};  // Temps en l'state actual (reset en cada transición)
 
     // Gestor de fragments de explosions
     std::unique_ptr<Effects::DebrisManager> debris_manager_;
 
     // Seguiment de explosions seqüencials
-        size_t lletra_explosio_index_{0};        // Índex de la següent lletra a explode
+    size_t letter_explosion_index_{0};       // Índex de la següent letter a explode
-        float temps_des_ultima_explosio_{0.0F};     // Temps desde l'última explosión
+    float time_since_last_explosion_{0.0F};  // Temps desde l'última explosión
-        std::vector<size_t> ordre_explosio_;  // Ordre aleatori de índexs de lletres
+    std::vector<size_t> explosion_order_;    // Ordre aleatori de índexs de lletres
 
-        // Estructura para cada lletra del logo
+    // Estructura para cada letter del logo
-        struct LetraLogo {
+    struct LogoLetter {
         std::shared_ptr<Graphics::Shape> shape;
         Vec2 position;        // Posición final en pantalla
-                float ancho;          // Ancho del bounding box
+        float width;          // Ancho del bounding box
-                float offset_centre;  // Distancia de min_x a shape_centre.x
+        float center_offset;  // Distancia de min_x a shape_centre.x
     };
 
-        std::vector<LetraLogo> lletres_;  // 9 lletres: J-A-I-L-G-A-M-E-S
+    std::vector<LogoLetter> letters_;  // 9 lletres: J-A-I-L-G-A-M-E-S
 
     // Seguiment de sons de lletres (evitar reproduccions repetides)
-        std::array<bool, 9> so_reproduit_;  // Track si cada lletra ya ha reproduit el so
+    std::array<bool, 9> sound_played_;  // Track si cada letter ya ha reproduit el so
 
     // Constants de animación
-        static constexpr float DURACIO_PRE = 1.5F;             // Duració PRE_ANIMATION (pantalla negra)
+    static constexpr float DURATION_PRE = 1.5F;             // Duració PRE_ANIMATION (pantalla negra)
-        static constexpr float DURACIO_ZOOM = 4.0F;            // Duració del zoom (segons)
+    static constexpr float DURATION_ZOOM = 4.0F;            // Duració del zoom (segons)
-        static constexpr float DURACIO_POST_ANIMATION = 3.0F;  // Duració POST_ANIMATION (logo complet)
+    static constexpr float DURATION_POST_ANIMATION = 3.0F;  // Duració POST_ANIMATION (logo complet)
-        static constexpr float DURACIO_POST_EXPLOSION = 3.0F;  // Duració POST_EXPLOSION (espera final)
+    static constexpr float DURATION_POST_EXPLOSION = 3.0F;  // Duració POST_EXPLOSION (espera final)
     static constexpr float DELAY_ENTRE_EXPLOSIONS = 0.1F;   // Temps entre explosions de lletres
-        static constexpr float VELOCITAT_EXPLOSIO = 240.0F;    // Velocidad base fragments (px/s)
+    static constexpr float SPEED_EXPLOSIO = 240.0F;         // Velocidad base fragments (px/s)
-        static constexpr float ESCALA_INICIAL = 0.1F;          // Escala inicial (10%)
+    static constexpr float INITIAL_SCALE = 0.1F;            // Escala inicial (10%)
-        static constexpr float ESCALA_FINAL = 0.8F;            // Escala final (80%)
+    static constexpr float FINAL_SCALE = 0.8F;              // Escala final (80%)
-        static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;    // Espaiat entre lletres
+    static constexpr float LETTER_SPACING = 10.0F;          // Espaiat entre lletres
 
     // Constants de animación seqüencial
-        static constexpr float THRESHOLD_LETRA = 0.6F;                         // Umbral per activar següent lletra (0.0-1.0)
+    static constexpr float LETTER_THRESHOLD = 0.6F;                        // Umbral per activar següent letter (0.0-1.0)
-        static constexpr float ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5F;   // Vec2 inicial X del zoom
+    static constexpr float ZOOM_ORIGIN_X = Defaults::Game::WIDTH * 0.5F;   // Vec2 inicial X del zoom
-        static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F;  // Vec2 inicial Y del zoom
+    static constexpr float ZOOM_ORIGIN_Y = Defaults::Game::HEIGHT * 0.4F;  // Vec2 inicial Y del zoom
 
     // Métodos privats
     void initLetters();