diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8777d7c..bdb14ab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -135,6 +135,46 @@ add_custom_command(
 add_custom_target(resource_pack ALL DEPENDS ${RESOURCE_PACK})
 add_dependencies(${PROJECT_NAME} resource_pack)
 
+# --- COMPILACIÓ DE SHADERS GLSL → SPIR-V ---
+# Compila tots els shaders .glsl a SPIR-V (Vulkan/Linux/Windows).
+# macOS necessitarà MSL en el futur (Metal) — es generen amb spirv-cross
+# o glslang amb target distint en una etapa posterior.
+# Sortida: build/shaders/*.spv
+find_program(GLSLC_EXE NAMES glslc HINTS ${Vulkan_GLSLC_EXECUTABLE})
+if(GLSLC_EXE)
+    file(GLOB SHADER_SOURCES CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/shaders/*.glsl")
+    set(COMPILED_SHADERS "")
+    foreach(SHADER ${SHADER_SOURCES})
+        get_filename_component(SHADER_NAME ${SHADER} NAME)
+        # Detectar stage del nom: line.vert.glsl → vert, line.frag.glsl → frag
+        if(SHADER_NAME MATCHES "\\.vert\\.glsl$")
+            set(SHADER_STAGE "vert")
+            string(REPLACE ".glsl" ".spv" SPV_NAME ${SHADER_NAME})
+        elseif(SHADER_NAME MATCHES "\\.frag\\.glsl$")
+            set(SHADER_STAGE "frag")
+            string(REPLACE ".glsl" ".spv" SPV_NAME ${SHADER_NAME})
+        else()
+            message(WARNING "Shader sense stage detectat: ${SHADER_NAME} (esperat .vert.glsl o .frag.glsl)")
+            continue()
+        endif()
+        set(SPV_OUTPUT "${CMAKE_BINARY_DIR}/shaders/${SPV_NAME}")
+        add_custom_command(
+            OUTPUT ${SPV_OUTPUT}
+            COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/shaders"
+            COMMAND ${GLSLC_EXE} -fshader-stage=${SHADER_STAGE} -O ${SHADER} -o ${SPV_OUTPUT}
+            DEPENDS ${SHADER}
+            COMMENT "Compilant shader ${SHADER_NAME} → ${SPV_NAME}"
+            VERBATIM
+        )
+        list(APPEND COMPILED_SHADERS ${SPV_OUTPUT})
+    endforeach()
+    add_custom_target(shaders ALL DEPENDS ${COMPILED_SHADERS})
+    add_dependencies(${PROJECT_NAME} shaders)
+    message(STATUS "Shaders trobats: ${SHADER_SOURCES}")
+else()
+    message(FATAL_ERROR "glslc no trobat: instal·la 'shaderc' o 'vulkan-sdk' per compilar shaders SPIR-V")
+endif()
+
 # --- STATIC ANALYSIS / FORMAT TARGETS ---
 find_program(CLANG_TIDY_EXE NAMES clang-tidy)
 find_program(CLANG_FORMAT_EXE NAMES clang-format)
diff --git a/MIGRATION_PLAN.md b/MIGRATION_PLAN.md
new file mode 100644
index 0000000..2f92025
--- /dev/null
+++ b/MIGRATION_PLAN.md
@@ -0,0 +1,140 @@
+# Plan de migración Orni Attack → SDL3 GPU + física vectorial
+
+Documento maestro de la rama `rewrite/physics-gpu`. Resumen del progreso y
+qué queda. Si pierdes el contexto de la sesión, **léeme primero**.
+
+## Visión
+
+Modernizar la base técnica del juego antes de tunear jugabilidad:
+1. Limpiar legacy (polares, mezcla catalán/inglés, header guards).
+2. Adoptar formato 16:9 (1280×720).
+3. Importar subsistemas robustos de AEEA (audio, *input deferido*).
+4. Implementar física vectorial 2D con rigid bodies + colisiones elásticas.
+5. **Migrar renderizado a SDL3 GPU sin fallback** ([memoria: project-no-sdl-fallback](./.claude/projects/-home-sergio-gitea-orni-attack/memory/project_no_sdl_fallback.md)).
+6. Postprocesado y color.
+
+El tuning de feeling se hace al final, post-GPU.
+
+## Estado actual
+
+Rama de trabajo: **`rewrite/physics-gpu`** (pusheada a Gitea).
+Tag de seguridad: **`beta-3.0`** (snapshot de `main` antes de empezar).
+
+| Fase | Estado | Commits |
+|---|---|---|
+| 0 — Limpieza de código muerto (primitives, polígonos, Bresenham, polares) | ✅ | `6cf990b` |
+| 1a — `Punt → Vec2` con operadores modernos | ✅ | `cd38101` |
+| 1b — Renames de entidades + métodos virtuales a camelBack | ✅ | `ae5cc1c` |
+| 1c — Renames de escenas | ✅ | `5871d29` |
+| 1d — Renames effects/stage_system/locales | ✅ | `7ee359b` |
+| 1e — Pragma once + locales restantes + comentarios castellano | ✅ | `bf83f16` |
+| (fix) — clave YAML `quadrat → cuadrado` post-sweep | ✅ | `56533ca` |
+| 2 — Cambio a 1280×720 (16:9) | ✅ | `a4f6a55` |
+| 3 — Import del subsistema de Audio desde AEEA | ✅ | `ed98ef6` |
+| **4** — Input parcial AEEA | ⏭️ **saltado** (decisión usuario) | — |
+| 5 — Infraestructura física (`RigidBody`, `PhysicsWorld`) | ✅ | `0fd9360` |
+| 6a+b — `body_` en Entity + `world_` en GameScene | ✅ | `0574077` |
+| 6c — Migrar Ship | ✅ | `2fe22ff` |
+| 6d — Migrar Enemy | ✅ | `27242f5` |
+| 6e — Migrar Bullet | ✅ | `9993b2d` |
+| 7a — Infra GPU (shaders + wrappers, runtime dormido) | ✅ | `ba6fd00` |
+| 7b+c — Swap atómico a SDL3 GPU + line_renderer al pipeline | ✅ | `fa7da4c` |
+| 7d — Validación visual del usuario en hardware Vulkan | ✅ | — |
+| 9a — Extraer `Systems::Collision` | ✅ | `896a899` |
+| 9b — Extraer `Systems::ContinueScreen` | ✅ | `816bc02` |
+| 9c — Extraer `Systems::InitHud` | ✅ | `a4942fc` |
+| 9d — Descomponer `GameScene::update` (339→18 LOC) | ✅ | `808abb2` |
+| **8 — Postprocesado + paleta de colores por entidad** | 🔲 **siguiente** | — |
+| 10 — Tuning final de masa/restitución/damping | 🔲 | — |
+| Mac/Metal — shaders MSL en build | 🔲 | — |
+| 8 — Postprocesado, color, paleta por tipo | 🔲 | — |
+| 9 — Refactor de GameScene (2.877 LOC → módulos) | 🔲 | — |
+| 10 — Tuning final de masa/restitución/damping | 🔲 | — |
+
+## Lo que queda inmediato (Fase 8 — postprocesado + paleta de colores)
+
+Fase 7 y Fase 9 cerradas. Validación visual SDL3 GPU OK (`Backend GPU: vulkan`).
+`GameScene.cpp` 1429 → 1015 LOC; `update()` 339 → 18 LOC, complexity baja a
+< 10 por sub-paso. Tres sistemas extraídos a `source/game/systems/`:
+- `Systems::Collision` (~210 LOC propios)
+- `Systems::ContinueScreen` (~160 LOC propios)
+- `Systems::InitHud` (~155 LOC propios)
+
+**Fase 8 — siguientes pasos**:
+1. Color por entidad (paleta semántica): naves blancas, balas verdes,
+   pentagons azules, quadrats rojos, molinillos magenta, debris hereda
+   color del padre. Hoy todo se pinta con el color global del oscilador
+   (`g_current_line_color`). Hay que pasar el color al `pushLine` desde
+   las entidades (cada entity expone un `getColor()`).
+2. Postprocesado básico:
+   - Bloom/glow: render-to-texture al swapchain real con fragment shader
+     que aplique kernel separable de blur sobre los píxeles iluminados.
+     Requiere un pipeline extra y un par de texturas off-screen.
+   - Opcional: scanlines o leve aberración cromática para feel CRT.
+
+**Fase 10** (tras 8): tuning de mass/restitution/damping con feedback
+visual de los colores.
+
+**Mac/Metal**: cuando vayamos a release de macOS, añadir compilación
+de los shaders también a MSL (con `spirv-cross` o `glslangValidator`).
+
+## Memoria del proyecto
+
+Las preferencias y decisiones persistentes están en:
+`~/.claude/projects/-home-sergio-gitea-orni-attack/memory/MEMORY.md` y los
+archivos enlazados desde ahí. Léelos al empezar sesión nueva.
+
+Resumen:
+- **No fallback a SDL_Renderer** en Fase 7 — solo GPU o falla.
+- **Naming**: `.clang-tidy` exige `CamelCase` tipos, `camelBack` métodos,
+  `lower_case_` miembros privados, `UPPER_CASE` constantes.
+- **Costuras del título tras 16:9** son tuning artístico, no bug, post-Fase 10.
+- **Push automático** tras cada commit en `rewrite/physics-gpu`.
+- **Smoke test xvfb** (`timeout 5 xvfb-run -a ./build/orni 2>&1 | head -40`)
+  tras builds importantes para validar arranque.
+
+## Convenciones técnicas
+
+- **Lenguaje código**: inglés. **Lenguaje comentarios**: castellano. **Strings
+  de UI**: valenciano (preservados).
+- **Coordenadas**: cartesianas (`Vec2`). Polares prohibidas (legacy).
+- **Resolución lógica**: 1280×720. Constantes en `core/defaults.hpp`.
+- **Audio**: import de AEEA. API: `Audio::get()->playSound/playMusic` con
+  crossfade y efectos.
+- **Física**: `Physics::RigidBody` en `core/physics/rigid_body.hpp`,
+  `Physics::PhysicsWorld` en `core/physics/physics_world.hpp/.cpp`.
+  Entity tiene `body_` como member. Flujo tri-fase por frame en
+  `GameScene::update`:
+  1. `physics_world_.update(dt)` — integrar y resolver
+  2. `entity.postUpdate(dt)` — sincronizar mirror (center_, angle_)
+  3. Lógica del juego (input, AI, etc.) — aplica fuerzas/cambia velocity
+
+## Cómo reanudar tras compactación
+
+1. Lee este archivo.
+2. Lee `MEMORY.md` (memorias persistentes).
+3. `git log --oneline -20` para ver últimos commits.
+4. `git status` para ver si hay trabajo en curso sin commitear.
+5. Si la fase actual estaba a medias: continúa donde se quedó (este archivo
+   indica en qué fase estamos).
+6. Tras cada commit, push automático: `git push origin rewrite/physics-gpu`.
+
+## Configuración física actual (Fase 6e)
+
+| Entidad | mass | radius (world) | restitution | linear_damping | angular_damping |
+|---|---|---|---|---|---|
+| Ship | 10.0 | 12 | 0.6 | 1.5 | 0.0 |
+| Enemy Pentagon | 5.0 | 20 | 1.0 | 0.0 | 0.0 |
+| Enemy Quadrat | 8.0 | 20 | 1.0 | 0.0 | 0.0 |
+| Enemy Molinillo | 4.0 | 20 | 1.0 | 0.0 | 0.0 |
+| Bullet | 0.5 | **0** (cinemática) | 0 | 0 | 0 |
+| Wall (PLAYAREA bounds) | ∞ (estático) | — | — | — | — |
+
+Nota: Bullet usa `radius=0` en el body físico para que no participe en las
+colisiones del world (ni body-body ni bounds). El radio de gameplay
+(`Defaults::Entities::BULLET_RADIUS = 3`) lo expone vía `getCollisionRadius()`
+y lo consumen `check_collision` y la detección de salida del PLAYAREA en
+`Bullet::update`.
+
+Las paredes son implícitas: `physics_world_.setBounds(PLAYAREA)` en
+`GameScene::init`. No son `RigidBody` separados, sino un AABB que rebota.
diff --git a/data/config/postfx.yaml b/data/config/postfx.yaml
new file mode 100644
index 0000000..812cf01
--- /dev/null
+++ b/data/config/postfx.yaml
@@ -0,0 +1,34 @@
+# postfx.yaml - Parámetros del shader de postprocesado
+#
+# Este archivo configura el pase final del renderer (bloom + flicker +
+# background pulse). Se carga al iniciar el juego desde resources.pack.
+# Si falta o tiene errores, se usan los valores por defecto de
+# Defaults::PostFx (defaults.hpp).
+#
+# Tip de tuning:
+#   - Para más "neón vector", sube bloom.intensity y bloom.radius_px.
+#   - Para más "CRT viejo", sube flicker.amplitude (riesgo de mareo si >0.3).
+#   - Background es muy sutil; pasa los componentes G a 0.15-0.20 para
+#     un fondo verde-tenue más marcado.
+
+# Bloom / glow: desenfoque gaussiano de las regiones brillantes.
+bloom:
+  enabled: true
+  intensity: 0.6        # 0..2 — cuanto del bloom se suma a la imagen
+  threshold: 0.30       # 0..1 — luminancia mínima que aporta al bloom
+  radius_px: 2.0        # radio del kernel en píxeles lógicos (1..8 razonable)
+
+# Flicker: modulación global de brillo (efecto fósforo CRT).
+# Sustituye a la antigua oscilación CPU del ColorOscillator.
+flicker:
+  enabled: true
+  amplitude: 0.10       # 0..1 — profundidad del flicker
+  frequency_hz: 6.0     # Hz — velocidad de la pulsación
+
+# Background pulse: color de fondo oscilante (suma aditiva).
+# RGB en [0..255]; el shader normaliza a [0..1].
+background:
+  enabled: true
+  color_min: [0, 5, 0]      # negro casi puro
+  color_max: [0, 15, 0]     # verde muy tenue
+  pulse_frequency_hz: 6.0   # Hz — sincronizado con flicker por defecto
diff --git a/data/shapes/bullet.shp b/data/shapes/bullet.shp
index 1b3a353..ad9d4e2 100644
--- a/data/shapes/bullet.shp
+++ b/data/shapes/bullet.shp
@@ -1,23 +1,7 @@
-# bullet.shp - Projectil (petit pentàgon)
-# © 1999 Visente i Sergi (versió Pascal)
-# © 2025 Port a C++20 amb SDL3
+# bullet.shp - Projectil (octàgon, radi=3)
 
 name: bullet
 scale: 1.0
 center: 0, 0
 
-# Cercle (octàgon regular radi=3)
-# 8 punts equidistants (45° entre ells) per aproximar un cercle
-# Començant a angle=-90° (amunt), rotant sentit horari
-#
-# Conversió polar→cartesià (radi=3, SDL: Y creix cap avall):
-#   angle=-90°:  (0.00, -3.00)
-#   angle=-45°:  (2.12, -2.12)
-#   angle=0°:    (3.00, 0.00)
-#   angle=45°:   (2.12, 2.12)
-#   angle=90°:   (0.00, 3.00)
-#   angle=135°:  (-2.12, 2.12)
-#   angle=180°:  (-3.00, 0.00)
-#   angle=225°:  (-2.12, -2.12)
-
 polyline: 0,-3  2.12,-2.12  3,0  2.12,2.12  0,3  -2.12,2.12  -3,0  -2.12,-2.12  0,-3
diff --git a/data/shapes/enemy_pentagon.shp b/data/shapes/enemy_pentagon.shp
index 8771dc2..23c84c9 100644
--- a/data/shapes/enemy_pentagon.shp
+++ b/data/shapes/enemy_pentagon.shp
@@ -1,21 +1,7 @@
-# enemy_pentagon.shp - ORNI enemic (pentàgon regular)
-# © 1999 Visente i Sergi (versió Pascal)
-# © 2025 Port a C++20 amb SDL3
+# enemy_pentagon.shp - ORNI enemic (pentàgon regular, radi=20)
 
 name: enemy_pentagon
 scale: 1.0
 center: 0, 0
 
-# Pentàgon regular radi=20
-# 5 punts equidistants al voltant d'un cercle (72° entre ells)
-# Començant a angle=-90° (amunt), rotant sentit antihorari
-#
-# Angles: -90°, -18°, 54°, 126°, 198°
-# Conversió polar→cartesià (SDL: Y creix cap avall):
-#   angle=-90°: (0.00, -20.00)
-#   angle=-18°: (19.02, -6.18)
-#   angle=54°:  (11.76, 16.18)
-#   angle=126°: (-11.76, 16.18)
-#   angle=198°: (-19.02, -6.18)
-
 polyline: 0,-20  19.02,-6.18  11.76,16.18  -11.76,16.18  -19.02,-6.18  0,-20
diff --git a/data/shapes/enemy_square.shp b/data/shapes/enemy_square.shp
index 2d6f16c..3c17405 100644
--- a/data/shapes/enemy_square.shp
+++ b/data/shapes/enemy_square.shp
@@ -1,19 +1,7 @@
-# enemy_square.shp - ORNI enemic (quadrat regular)
-# © 2025 Port a C++20 amb SDL3
+# enemy_square.shp - ORNI enemic (quadrat regular, radi=20)
 
 name: enemy_square
 scale: 1.0
 center: 0, 0
 
-# Quadrat regular radi=20 (circumscrit)
-# 4 punts equidistants al voltant d'un cercle (90° entre ells)
-# Començant a angle=-90° (amunt), rotant sentit horari
-#
-# Angles: -90°, 0°, 90°, 180°
-# Conversió polar→cartesià (SDL: Y creix cap avall):
-#   angle=-90°: (0.00, -20.00)
-#   angle=0°:   (20.00, 0.00)
-#   angle=90°:  (0.00, 20.00)
-#   angle=180°: (-20.00, 0.00)
-
 polyline: 0,-20  20,0  0,20  -20,0  0,-20
diff --git a/data/shapes/ship.shp b/data/shapes/ship.shp
index f4f683e..aebcbe7 100644
--- a/data/shapes/ship.shp
+++ b/data/shapes/ship.shp
@@ -1,24 +1,8 @@
-# ship.shp - Nau del jugador 1 (triangle amb base còncava - punta de fletxa)
-# © 1999 Visente i Sergi (versió Pascal)
-# © 2025 Port a C++20 amb SDL3
+# ship.shp - Nau del jugador 1
+# Triangle amb base còncava (punta de fletxa)
 
 name: ship
 scale: 1.0
 center: 0, 0
 
-# Triangle amb base còncava tipus "punta de fletxa"
-# Punts originals (polar):
-#   p1: r=12, angle=270° (3π/2) → punta amunt
-#   p2: r=12, angle=45° (π/4) → base dreta-darrere
-#   p3: r=12, angle=135° (3π/4) → base esquerra-darrere
-#
-# MODIFICACIÓ: afegit p4 al mig de la base, desplaçat cap al centre
-#   p4: (0, 4) → punt central de la base, cap endins
-#
-# Conversió polar→cartesià (angle-90° perquè origen visual és amunt):
-#   p1: (0, -12) → punta
-#   p2: (8.49, 8.49) → base dreta
-#   p4: (0, 4) → base centre (cap endins)
-#   p3: (-8.49, 8.49) → base esquerra
-
 polyline: 0,-12  8.49,8.49  0,4  -8.49,8.49  0,-12
diff --git a/data/shapes/ship2.shp b/data/shapes/ship2.shp
index 9d6280c..4bf35d3 100644
--- a/data/shapes/ship2.shp
+++ b/data/shapes/ship2.shp
@@ -1,30 +1,11 @@
-# ship2.shp - Nau del jugador 2 (triangle amb circulito central)
-# © 1999 Visente i Sergi (versió Pascal)
-# © 2025 Port a C++20 amb SDL3
+# ship2.shp - Nau del jugador 2
+# Triangle amb cercle central (distintiu visual)
 
 name: ship2
 scale: 1.0
 center: 0, 0
 
-# Triangle amb base còncava tipus "punta de fletxa"
-# (Mateix que ship.shp)
-# Punts originals (polar):
-#   p1: r=12, angle=270° (3π/2) → punta amunt
-#   p2: r=12, angle=45° (π/4) → base dreta-darrere
-#   p3: r=12, angle=135° (3π/4) → base esquerra-darrere
-#
-# MODIFICACIÓ: afegit p4 al mig de la base, desplaçat cap al centre
-#   p4: (0, 4) → punt central de la base, cap endins
-#
-# Conversió polar→cartesià (angle-90° perquè origen visual és amunt):
-#   p1: (0, -12) → punta
-#   p2: (8.49, 8.49) → base dreta
-#   p4: (0, 4) → base centre (cap endins)
-#   p3: (-8.49, 8.49) → base esquerra
-
-#polyline: 0,-12  8.49,8.49  0,4  -8.49,8.49  0,-12
 polyline: 0,-12  8.49,8.49  -8.49,8.49  0,-12
 
-# Circulito central (octàgon r=2.5)
-# Distintiu visual del jugador 2
+# Octàgon central (radi=2.5)
 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
diff --git a/data/stages/stages.yaml b/data/stages/stages.yaml
index e6a24ac..b1bb66c 100644
--- a/data/stages/stages.yaml
+++ b/data/stages/stages.yaml
@@ -16,7 +16,7 @@ stages:
       spawn_interval: 3.0
     enemy_distribution:
       pentagon: 100
-      quadrat: 0
+      cuadrado: 0
       molinillo: 0
     difficulty_multipliers:
       speed_multiplier: 0.7
@@ -32,7 +32,7 @@ stages:
       spawn_interval: 2.5
     enemy_distribution:
       pentagon: 70
-      quadrat: 30
+      cuadrado: 30
       molinillo: 0
     difficulty_multipliers:
       speed_multiplier: 0.85
@@ -48,7 +48,7 @@ stages:
       spawn_interval: 2.0
     enemy_distribution:
       pentagon: 50
-      quadrat: 30
+      cuadrado: 30
       molinillo: 20
     difficulty_multipliers:
       speed_multiplier: 1.0
@@ -64,7 +64,7 @@ stages:
       spawn_interval: 1.8
     enemy_distribution:
       pentagon: 40
-      quadrat: 35
+      cuadrado: 35
       molinillo: 25
     difficulty_multipliers:
       speed_multiplier: 1.1
@@ -80,7 +80,7 @@ stages:
       spawn_interval: 1.5
     enemy_distribution:
       pentagon: 35
-      quadrat: 35
+      cuadrado: 35
       molinillo: 30
     difficulty_multipliers:
       speed_multiplier: 1.2
@@ -96,7 +96,7 @@ stages:
       spawn_interval: 1.3
     enemy_distribution:
       pentagon: 30
-      quadrat: 30
+      cuadrado: 30
       molinillo: 40
     difficulty_multipliers:
       speed_multiplier: 1.3
@@ -112,7 +112,7 @@ stages:
       spawn_interval: 1.0
     enemy_distribution:
       pentagon: 25
-      quadrat: 30
+      cuadrado: 30
       molinillo: 45
     difficulty_multipliers:
       speed_multiplier: 1.4
@@ -128,7 +128,7 @@ stages:
       spawn_interval: 0.8
     enemy_distribution:
       pentagon: 20
-      quadrat: 30
+      cuadrado: 30
       molinillo: 50
     difficulty_multipliers:
       speed_multiplier: 1.5
@@ -144,7 +144,7 @@ stages:
       spawn_interval: 0.6
     enemy_distribution:
       pentagon: 15
-      quadrat: 25
+      cuadrado: 25
       molinillo: 60
     difficulty_multipliers:
       speed_multiplier: 1.6
@@ -160,7 +160,7 @@ stages:
       spawn_interval: 0.5
     enemy_distribution:
       pentagon: 10
-      quadrat: 20
+      cuadrado: 20
       molinillo: 70
     difficulty_multipliers:
       speed_multiplier: 1.8
diff --git a/shaders/line.frag.glsl b/shaders/line.frag.glsl
new file mode 100644
index 0000000..086e216
--- /dev/null
+++ b/shaders/line.frag.glsl
@@ -0,0 +1,12 @@
+#version 450
+
+// Fragment shader para líneas vectoriales.
+// Pinta el color interpolado per-vertex que viene del vertex shader.
+// (Postprocesado / bloom / glow son responsabilidad de la Fase 8.)
+
+layout(location = 0) in vec4 frag_color;
+layout(location = 0) out vec4 out_color;
+
+void main() {
+    out_color = frag_color;
+}
diff --git a/shaders/line.vert.glsl b/shaders/line.vert.glsl
new file mode 100644
index 0000000..247d3ff
--- /dev/null
+++ b/shaders/line.vert.glsl
@@ -0,0 +1,29 @@
+#version 450
+
+// Vertex shader para líneas vectoriales.
+// Las líneas se proveen ya extrudidas en CPU como quads (2 triángulos por línea)
+// con grosor configurable. El vertex shader solo:
+//   1. Transforma de píxeles lógicos (0..viewport_size) a clip-space (-1..+1).
+//   2. Pasa el color RGBA al fragment shader.
+//
+// Slot de uniform buffer 0 (vertex): viewport size para la transformación.
+// Convención SDL_gpu: SDL_PushGPUVertexUniformData(cmd, 0, &ubo, sizeof(ubo)).
+
+layout(set = 1, binding = 0) uniform UBO {
+    vec2 viewport_size;  // ancho y alto en píxeles lógicos (ej. 1280, 720)
+    vec2 _padding;       // alineamiento a 16 bytes
+} ubo;
+
+layout(location = 0) in vec2 in_position;  // píxeles lógicos
+layout(location = 1) in vec4 in_color;     // RGBA 0..1
+
+layout(location = 0) out vec4 frag_color;
+
+void main() {
+    // Píxeles lógicos -> NDC (-1..+1)
+    vec2 ndc = (in_position / ubo.viewport_size) * 2.0 - 1.0;
+    // Y flip: SDL screen-Y va hacia abajo, clip-Y hacia arriba.
+    ndc.y = -ndc.y;
+    gl_Position = vec4(ndc, 0.0, 1.0);
+    frag_color = in_color;
+}
diff --git a/shaders/postfx.frag.glsl b/shaders/postfx.frag.glsl
new file mode 100644
index 0000000..eccd236
--- /dev/null
+++ b/shaders/postfx.frag.glsl
@@ -0,0 +1,82 @@
+#version 450
+
+// Fragment shader del pase de postprocesado.
+// Lee la textura offscreen (escena vectorial sobre fondo negro) y produce
+// el fragmento final aplicando:
+//   1. Bloom kernel 5×5 con high-pass (solo los brillos por encima de
+//      threshold contribuyen).
+//   2. Flicker: multiplicador global de brillo modulado por tiempo
+//      (sustituye al oscilador CPU del legacy).
+//   3. Background pulse: color de fondo que oscila entre min y max y se
+//      suma a la imagen (las líneas brillan por encima).
+//
+// Resource sets (SDL_gpu):
+//   set=2, binding=0 → sampler2D (escena offscreen)
+//   set=3, binding=0 → uniform buffer (parámetros del postpro)
+
+layout(set = 2, binding = 0) uniform sampler2D scene;
+
+layout(set = 3, binding = 0) uniform PostFxUBO {
+    float time;
+    float bloom_intensity;
+    float bloom_threshold;
+    float bloom_radius_px;
+
+    float flicker_amplitude;
+    float flicker_frequency_hz;
+    float background_pulse_freq_hz;
+    float _pad_a;
+
+    vec4 background_min;   // RGB en [0..1], A=1
+    vec4 background_max;   // RGB en [0..1], A=1
+
+    vec2 texel_size;       // 1.0 / texture_size
+    vec2 _pad_b;
+} ubo;
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 frag;
+
+const float TAU = 6.28318530718;
+
+void main() {
+    // === BLOOM ===
+    // Kernel 5×5 con muestreo radial y high-pass por luminancia (max RGB).
+    // Pesos gaussianos: w = exp(-(dx²+dy²) / 4).
+    vec3 src = texture(scene, v_uv).rgb;
+    vec3 bloom = vec3(0.0);
+    float total_weight = 0.0;
+    for (int dy = -2; dy <= 2; ++dy) {
+        for (int dx = -2; dx <= 2; ++dx) {
+            vec2 offset = vec2(float(dx), float(dy)) * ubo.texel_size * ubo.bloom_radius_px;
+            vec3 c = texture(scene, v_uv + offset).rgb;
+            float luma = max(c.r, max(c.g, c.b));
+            float high_pass = max(0.0, luma - ubo.bloom_threshold);
+            float w = exp(-(float(dx * dx + dy * dy)) / 4.0);
+            bloom += c * high_pass * w;
+            total_weight += w;
+        }
+    }
+    if (total_weight > 0.0) {
+        bloom /= total_weight;
+    }
+    bloom *= ubo.bloom_intensity;
+
+    // === FLICKER ===
+    // Multiplicador global de brillo. Oscila entre (1.0 - amplitude) y 1.0.
+    // amplitude=0 → sin flicker; amplitude=1 → pulsa entre apagado y máximo.
+    float pulse = (sin(ubo.time * ubo.flicker_frequency_hz * TAU) * 0.5) + 0.5;
+    float flicker = 1.0 - (ubo.flicker_amplitude * (1.0 - pulse));
+
+    // === BACKGROUND PULSE ===
+    // Suma de color de fondo oscilante. min..max se interpolan con sin(t).
+    float bg_pulse = (sin(ubo.time * ubo.background_pulse_freq_hz * TAU) * 0.5) + 0.5;
+    vec3 background = mix(ubo.background_min.rgb, ubo.background_max.rgb, bg_pulse);
+
+    // === COMPOSICIÓN ===
+    // El offscreen viene con clear=black, por lo que solo las líneas y el
+    // bloom aportan luz. Sumamos el fondo y luego multiplicamos por flicker
+    // para que el pulso afecte a todo (líneas + bloom + bg).
+    vec3 lines_and_glow = (src + bloom) * flicker;
+    frag = vec4(background + lines_and_glow, 1.0);
+}
diff --git a/shaders/postfx.vert.glsl b/shaders/postfx.vert.glsl
new file mode 100644
index 0000000..70ac360
--- /dev/null
+++ b/shaders/postfx.vert.glsl
@@ -0,0 +1,28 @@
+#version 450
+
+// Vertex shader del pase de postprocesado.
+// Emite un solo triángulo que cubre toda la pantalla (técnica del "fullscreen
+// triangle"): tres vértices en (-1,-1), (3,-1), (-1,3) → la región visible
+// [-1..1]² queda completamente cubierta y el clip recorta el resto. No hace
+// falta vertex buffer; el draw es DrawPrimitives(vertex_count=3).
+
+layout(location = 0) out vec2 v_uv;
+
+void main() {
+    vec2 positions[3] = vec2[3](
+        vec2(-1.0, -1.0),
+        vec2( 3.0, -1.0),
+        vec2(-1.0,  3.0)
+    );
+    // UV.y invertida para compensar la diferencia entre la convención de
+    // clip-space del line shader (ndc.y flipeado, GL-style) y la convención
+    // de muestreo de SDL_gpu/Vulkan (origen de textura en top-left). Sin esta
+    // inversión, el offscreen se ve cabeza-abajo en el composite.
+    vec2 uvs[3] = vec2[3](
+        vec2(0.0, 1.0),
+        vec2(2.0, 1.0),
+        vec2(0.0, -1.0)
+    );
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    v_uv = uvs[gl_VertexIndex];
+}
diff --git a/source/core/audio/audio.cpp b/source/core/audio/audio.cpp
index be1eac7..8bb79d0 100644
--- a/source/core/audio/audio.cpp
+++ b/source/core/audio/audio.cpp
@@ -1,183 +1,291 @@
-#include "audio.hpp"
+#include "core/audio/audio.hpp"
 
-#include <SDL3/SDL.h>  // Para SDL_LogInfo, SDL_LogCategory, SDL_G...
+#include <SDL3/SDL.h>  // Para SDL_GetError, SDL_Init
 
 #include <algorithm>  // Para clamp
-#include <iostream>   // Para std::cout
+#include <cstdio>     // Para std::fprintf
 
-// Implementación de stb_vorbis (debe estar ANTES de incluir jail_audio.hpp)
-// clang-format off
-#undef STB_VORBIS_HEADER_ONLY
-#include "external/stb_vorbis.h"
-// clang-format on
+#include "core/audio/audio_adapter.hpp"         // Para AudioResource::getMusic/getSound
+#include "core/audio/jail_audio.hpp"            // Para Ja::* (motor jailgames)
+#include "core/audio/sound_effects_config.hpp"  // Para SoundEffectsConfig
+#include "core/defaults.hpp"                    // Para Defaults::Audio::FREQUENCY
 
-#include "core/audio/audio_cache.hpp"  // Para AudioCache
-#include "core/audio/jail_audio.hpp"   // Para JA_FadeOutMusic, JA_Init, JA_PauseM...
-#include "game/options.hpp"            // Para AudioOptions, audio, MusicOptions
+// Invariant compile-time: tots los valors d'Audio::Group han de cabre als slots
+// de volum per grup que manté l'engine. Si s'afegeix una nueva entrada a Group
+// y no s'incrementa Ja::MAX_GROUPS, este assert falla antes de compilar.
+static_assert(static_cast<int>(Audio::Group::INTERFACE) < Ja::MAX_GROUPS,
+    "Audio::Group té més entrades que slots té Ja::MAX_GROUPS");
 
 // Singleton
-Audio* Audio::instance = nullptr;
+std::unique_ptr<Audio> Audio::instance;
 
-// Inicializa la instancia única del singleton
-void Audio::init() { Audio::instance = new Audio(); }
+// Inicialitza la instància única del singleton con la configuración rebuda
+void Audio::init(const Config& config) { Audio::instance = std::unique_ptr<Audio>(new Audio(config)); }
 
-// Libera la instancia
-void Audio::destroy() { delete Audio::instance; }
+// Allibera la instància
+void Audio::destroy() { Audio::instance.reset(); }
 
-// Obtiene la instancia
-auto Audio::get() -> Audio* { return Audio::instance; }
+// Obté la instància
+auto Audio::get() -> Audio* { return Audio::instance.get(); }
 
 // Constructor
-Audio::Audio() { initSDLAudio(); }
+Audio::Audio(const Config& config)
+    : config_(config) { initSDLAudio(); }
 
-// Destructor
-Audio::~Audio() {
-    JA_Quit();
-}
+// Destructor: engine_ es std::unique_ptr, el seu dtor tanca el device SDL i
+// desregistra Ja::Engine::active_. Cap crida explícita necessària.
+Audio::~Audio() = default;
 
-// Método principal
+// Método principal: l'estat de la música el manté el motor (única font de
+// veritat), per tant no cal sin sincronització aquí.
 void Audio::update() {
-    JA_Update();
+    if (instance && instance->engine_) { instance->engine_->update(); }
 }
 
-// Reproduce la música
-void Audio::playMusic(const std::string& name, const int loop) {
-    bool new_loop = (loop != 0);
+// Reprodueix la música per nom (amb crossfade opcional)
+void Audio::playMusic(const std::string& name, const int loop, const int crossfade_ms) {
+    const bool NEW_LOOP = (loop != 0);
 
-    // Si ya está sonando exactamente la misma pista y mismo modo loop, no hacemos nada
-    if (music_.state == MusicState::PLAYING && music_.name == name && music_.loop == new_loop) {
+    // Si ya sona exactament la misma pista i mismo mode loop, no fem res
+    if (getMusicState() == MusicState::PLAYING && music_.name == name && music_.loop == NEW_LOOP) {
         return;
     }
 
-    // Intentar obtener recurso; si falla, no tocar estado
-    auto* resource = AudioCache::getMusic(name);
-    if (resource == nullptr) {
-        // manejo de error opcional
-        return;
-    }
+    if (!music_enabled_) { return; }
 
-    // Si hay algo reproduciéndose, detenerlo primero (si el backend lo requiere)
-    if (music_.state == MusicState::PLAYING) {
-        JA_StopMusic();  // sustituir por la función de stop real del API si tiene otro nombre
-    }
+    auto* resource = AudioResource::getMusic(name);
+    if (resource == nullptr) { return; }
 
-    // Llamada al motor para reproducir la nueva pista
-    JA_PlayMusic(resource, loop);
-
-    // Actualizar estado y metadatos después de iniciar con éxito
+    playMusicInternal(resource, loop, crossfade_ms);
     music_.name = name;
-    music_.loop = new_loop;
-    music_.state = MusicState::PLAYING;
 }
 
-// Pausa la música
+// 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; }
+
+    playMusicInternal(music, loop, crossfade_ms);
+    // Si el Ja::Music es va crear con filename (loadMusic con 3 arguments), el
+    // recuperem porque getCurrentMusicName() no menteixi. Si no, music_.name
+    // queda buit — el contracte d'este overload no garanteix el nom.
+    music_.name = music->filename;
+}
+
+// Camí comú dels dos overloads: fa el dispatch crossfade vs stop+play i
+// actualitza el loop cachejat. Els callers s'encarreguen del gating
+// (music_enabled_, nullptr, same-track early return) y del nom. 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) {
+        engine_->crossfadeMusic(music, crossfade_ms, loop);
+    } else {
+        if (CURRENTLY_PLAYING) {
+            engine_->stopMusic();
+        }
+        engine_->playMusic(music, loop);
+    }
+
+    music_.loop = (loop != 0);
+}
+
+// Pausa la música (l'estat el transiciona Engine::pauseMusic)
 void Audio::pauseMusic() {
-    if (music_enabled_ && music_.state == MusicState::PLAYING) {
-        JA_PauseMusic();
-        music_.state = MusicState::PAUSED;
+    if (music_enabled_ && getMusicState() == MusicState::PLAYING) {
+        engine_->pauseMusic();
     }
 }
 
-// Continua la música pausada
+// Continua la música pausada (l'estat el transiciona Engine::resumeMusic)
 void Audio::resumeMusic() {
-    if (music_enabled_ && music_.state == MusicState::PAUSED) {
-        JA_ResumeMusic();
-        music_.state = MusicState::PLAYING;
+    if (music_enabled_ && getMusicState() == MusicState::PAUSED) {
+        engine_->resumeMusic();
     }
 }
 
-// Detiene la música
+// Atura la música (l'estat el transiciona Engine::stopMusic)
 void Audio::stopMusic() {
     if (music_enabled_) {
-        JA_StopMusic();
-        music_.state = MusicState::STOPPED;
+        engine_->stopMusic();
     }
 }
 
-// Reproduce un sonido por nombre
-void Audio::playSound(const std::string& name, Group group) const {
+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_) {
-        JA_PlaySound(AudioCache::getSound(name), 0, static_cast<int>(group));
+        engine_->playSound(AudioResource::getSound(name), 0, static_cast<int>(group));
     }
 }
 
-// Reproduce un sonido por puntero directo
-void Audio::playSound(JA_Sound_t* sound, Group group) const {
+// Reprodueix un so per punter directe
+void Audio::playSound(Ja::Sound* sound, Group group) {
+    if (sound_enabled_ && sound != nullptr) {
+        engine_->playSound(sound, 0, static_cast<int>(group));
+    }
+}
+
+// Variant con velocitat (i to) escalats. Apliquem el ratio al canal
+// just retornat per `playSound`: así el `SDL_AudioStream` recent creat
+// processa tot el sample con el ratio des del primer pull del callback.
+// 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));
+    if (CH >= 0 && speed != 1.0F) {
+        engine_->setChannelSpeed(CH, speed);
+    }
+}
+
+// Reprodueix un so processat per un eco definit a sounds.yaml. Si el preset no
+// 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; }
+
+    const auto* params = SoundEffectsConfig::get().findEcho(preset_name);
+    if (params == nullptr) {
+        std::fprintf(stderr, "Audio: preset d'eco '%s' desconegut — so '%s' es reprodueix sec\n", preset_name.c_str(), name.c_str());
+        engine_->playSound(sound, 0, static_cast<int>(group));
+        return;
+    }
+
+    if (engine_->playSoundWithEcho(sound, *params, static_cast<int>(group)) < 0) {
+        engine_->playSound(sound, 0, static_cast<int>(group));
+    }
+}
+
+// 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; }
+
+    const auto* params = SoundEffectsConfig::get().findReverb(preset_name);
+    if (params == nullptr) {
+        std::fprintf(stderr, "Audio: preset de reverb '%s' desconegut — so '%s' es reprodueix sec\n", preset_name.c_str(), name.c_str());
+        engine_->playSound(sound, 0, static_cast<int>(group));
+        return;
+    }
+
+    if (engine_->playSoundWithReverb(sound, *params, static_cast<int>(group)) < 0) {
+        engine_->playSound(sound, 0, static_cast<int>(group));
+    }
+}
+
+// Atura tots los sons
+void Audio::stopAllSounds() {
     if (sound_enabled_) {
-        JA_PlaySound(sound, 0, static_cast<int>(group));
+        engine_->stopChannel(-1);
     }
 }
 
-// Detiene todos los sonidos
-void Audio::stopAllSounds() const {
-    if (sound_enabled_) {
-        JA_StopChannel(-1);
+// Fa una fosa de sortida de la música
+void Audio::fadeOutMusic(int milliseconds) {
+    if (music_enabled_ && getMusicState() == MusicState::PLAYING) {
+        engine_->fadeOutMusic(milliseconds);
     }
 }
 
-// Realiza un fundido de salida de la música
-void Audio::fadeOutMusic(int milliseconds) const {
-    if (music_enabled_ && getRealMusicState() == MusicState::PLAYING) {
-        JA_FadeOutMusic(milliseconds);
-    }
+// Registra un callback que el motor dispararà cuando la pista actual acabi de
+// drenar (times == 0 + stream buit). S'executa al mismo thread que
+// Audio::update (render loop); los consumidors no poden fer I/O blocant.
+void Audio::setOnMusicEnded(std::function<void()> callback) {
+    if (engine_) { engine_->setOnMusicEnded(std::move(callback)); }
 }
 
-// Consulta directamente el estado real de la música en jailaudio
-auto Audio::getRealMusicState() -> MusicState {
-    JA_Music_state ja_state = JA_GetMusicState();
-    switch (ja_state) {
-        case JA_MUSIC_PLAYING:
+// Resol el nom contra el cache de recursos i retorna la duración pre-calculada
+// al `loadMusic`. 0 si la pista no existeix — así el caller pot decidir
+// fallback (p. ex. usar un timeout fix) sin haver de propagar errors.
+auto Audio::getMusicDurationMs(const std::string& name) -> int {
+    auto* music = AudioResource::getMusic(name);
+    return (music != nullptr) ? music->duration_ms : 0;
+}
+
+// Consulta directament l'estat a Ja y el projecta al subconjunt d'estats que
+// exposa Audio (INVALID/DISABLED de Ja col·lapsen a STOPPED — la capa d'usuari
+// solo vol saber si está sonant, pausat o parat).
+auto Audio::getMusicState() -> MusicState {
+    if (!instance || !instance->engine_) { return MusicState::STOPPED; }
+    switch (instance->engine_->getMusicState()) {
+        case Ja::MusicState::PLAYING:
             return MusicState::PLAYING;
-        case JA_MUSIC_PAUSED:
+        case Ja::MusicState::PAUSED:
             return MusicState::PAUSED;
-        case JA_MUSIC_STOPPED:
-        case JA_MUSIC_INVALID:
-        case JA_MUSIC_DISABLED:
+        case Ja::MusicState::STOPPED:
+        case Ja::MusicState::INVALID:
         default:
             return MusicState::STOPPED;
     }
 }
 
-// Establece el volumen de los sonidos
-void Audio::setSoundVolume(float sound_volume, Group group) const {
-    if (sound_enabled_) {
-        sound_volume = std::clamp(sound_volume, MIN_VOLUME, MAX_VOLUME);
-        const float CONVERTED_VOLUME = sound_volume * Options::audio.volume;
-        JA_SetSoundVolume(CONVERTED_VOLUME, static_cast<int>(group));
-    }
+// Aplica el gate master (enabled_) + el gate del canal (sound/music_enabled_)
+// i retorna el volum escalat pel master config_.volume. 0 si algun gate está
+// tancat. Así los dos setters comparteixen la misma política.
+auto Audio::effectiveVolume(float volume, bool channel_enabled) const -> float {
+    volume = std::clamp(volume, MIN_VOLUME, MAX_VOLUME);
+    return (enabled_ && channel_enabled) ? volume * config_.volume : 0.0F;
 }
 
-// Establece el volumen de la música
-void Audio::setMusicVolume(float music_volume) const {
-    if (music_enabled_) {
-        music_volume = std::clamp(music_volume, MIN_VOLUME, MAX_VOLUME);
-        const float CONVERTED_VOLUME = music_volume * Options::audio.volume;
-        JA_SetMusicVolume(CONVERTED_VOLUME);
-    }
+// Estableix el volum dels sons (float 0.0..1.0)
+void Audio::setSoundVolume(float sound_volume, Group group) {
+    engine_->setSoundVolume(effectiveVolume(sound_volume, sound_enabled_), static_cast<int>(group));
 }
 
-// Aplica la configuración
-void Audio::applySettings() {
-    enable(Options::audio.enabled);
+// Estableix el volum de la música (float 0.0..1.0)
+void Audio::setMusicVolume(float music_volume) {
+    engine_->setMusicVolume(effectiveVolume(music_volume, music_enabled_));
 }
 
-// Establecer estado general
+// Aplica una nueva configuración (substitueix la config cachejada i reaplica enables/volums)
+void Audio::applySettings(const Config& config) {
+    config_ = config;
+    sound_enabled_ = config_.sound_enabled;
+    music_enabled_ = config_.music_enabled;
+    enable(config_.enabled);
+}
+
+// Estableix l'estat general
 void Audio::enable(bool value) {
     enabled_ = value;
 
-    setSoundVolume(enabled_ ? Options::audio.sound.volume : MIN_VOLUME);
-    setMusicVolume(enabled_ ? Options::audio.music.volume : MIN_VOLUME);
+    setSoundVolume(enabled_ ? config_.sound_volume : MIN_VOLUME);
+    setMusicVolume(enabled_ ? config_.music_volume : MIN_VOLUME);
 }
 
-// Inicializa SDL Audio
+// Estableix l'estat dels sons i reaplica el volum porque los canals actius
+// responguin a l'instant (evita que el toggle solo surti efecte al pròxim
+// setSoundVolume explícit).
+void Audio::enableSound(bool value) {
+    sound_enabled_ = value;
+    setSoundVolume(config_.sound_volume);
+}
+
+// Estableix l'estat de la música i reaplica el volum per la misma raó.
+void Audio::enableMusic(bool value) {
+    music_enabled_ = value;
+    setMusicVolume(config_.music_volume);
+}
+
+// Inicialitza SDL Audio y el motor Ja::Engine owned.
 void Audio::initSDLAudio() {
     if (!SDL_Init(SDL_INIT_AUDIO)) {
-        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_AUDIO could not initialize! SDL Error: %s", SDL_GetError());
-    } else {
-        JA_Init(FREQUENCY, SDL_AUDIO_S16LE, 2);
-        enable(Options::audio.enabled);
-
-        std::cout << "\n** AUDIO SYSTEM **\n";
-        std::cout << "Audio system initialized successfully\n";
+        std::fprintf(stderr, "Audio: SDL_AUDIO could not initialize! SDL Error: %s\n", SDL_GetError());
+        return;
     }
-}
\ No newline at end of file
+    engine_ = std::make_unique<Ja::Engine>(Defaults::Audio::FREQUENCY, Defaults::Audio::FORMAT, Defaults::Audio::CHANNELS);
+    sound_enabled_ = config_.sound_enabled;
+    music_enabled_ = config_.music_enabled;
+    enable(config_.enabled);
+}
diff --git a/source/core/audio/audio.hpp b/source/core/audio/audio.hpp
index 16ff733..957b383 100644
--- a/source/core/audio/audio.hpp
+++ b/source/core/audio/audio.hpp
@@ -1,97 +1,163 @@
 #pragma once
 
-#include <string>   // Para string
-#include <utility>  // Para move
+#include <cmath>       // Para std::lround
+#include <cstdint>     // Para int8_t, uint8_t
+#include <functional>  // Para std::function
+#include <memory>      // Para std::unique_ptr
+#include <string>      // Para string
+#include <utility>     // Para move
 
-// --- Clase Audio: gestor de audio (singleton) ---
+// Forward-declares per no incloure core/audio/jail_audio.hpp al header. Els
+// tres símbols (Music/Sound para el punter que exposa la API i Engine per al
+// std::unique_ptr<Engine> membre) s'usen solo per punter al header, así que
+// el forward-decl basta. El ~Audio() en .cpp veu la definició completa i
+// instancia correctament el dtor de l'unique_ptr.
+namespace Ja {
+    class Engine;
+    struct Music;
+    struct Sound;
+}  // namespace Ja
+
+// --- Clase Audio: gestor d'àudio (singleton) ---
+// Port del subsistema d'àudio del projecte ../aee, desacoblat d'Options:
+// la configuración entra per la struct Audio::Config a init()/applySettings(),
+// en lloc de llegir directament Options::audio. Això deixa audio.cpp independent
+// del layout d'Options i permet substituir la font de configuración.
+//
+// Els volums es manegen internament como a float 0.0–1.0; la capa de
+// presentació (menús, notificacions) usa las helpers toPercent/fromPercent
+// per mostrar 0–100 a l'usuari.
 class Audio {
-    public:
-        // --- Enums ---
-        enum class Group : int {
-            ALL = -1,      // Todos los grupos
-            GAME = 0,      // Sonidos del juego
-            INTERFACE = 1  // Sonidos de la interfaz
-        };
+   public:
+    // --- Configuración injectada (Options la construeix via buildAudioConfig) ---
+    struct Config {
+        bool enabled{true};
+        float volume{1.0F};  // Master 0..1
+        bool music_enabled{true};
+        float music_volume{0.8F};
+        bool sound_enabled{true};
+        float sound_volume{1.0F};
+    };
 
-        enum class MusicState {
-            PLAYING,  // Reproduciendo música
-            PAUSED,   // Música pausada
-            STOPPED,  // Música detenida
-        };
+    // --- Enums ---
+    enum class Group : std::int8_t {
+        ALL = -1,      // Tots los grups
+        GAME = 0,      // Sons del joc
+        INTERFACE = 1  // Sons de la interfície
+    };
 
-        // --- Constantes ---
-        static constexpr float MAX_VOLUME = 1.0F;  // Volumen máximo
-        static constexpr float MIN_VOLUME = 0.0F;  // Volumen mínimo
-        static constexpr int FREQUENCY = 48000;    // Frecuencia de audio
+    enum class MusicState : std::uint8_t {
+        PLAYING,  // Reproduint música
+        PAUSED,   // Música pausada
+        STOPPED,  // Música aturada
+    };
 
-        // --- Singleton ---
-        static void init();                               // Inicializa el objeto Audio
-        static void destroy();                            // Libera el objeto Audio
-        static auto get() -> Audio*;                      // Obtiene el puntero al objeto Audio
-        Audio(const Audio&) = delete;                     // Evitar copia
-        auto operator=(const Audio&) -> Audio& = delete;  // Evitar asignación
+    // --- Constants ---
+    static constexpr float MAX_VOLUME = 1.0F;  // Volum màxim (float 0..1)
+    static constexpr float MIN_VOLUME = 0.0F;  // Volum mínim (float 0..1)
 
-        static void update();  // Actualización del sistema de audio
+    // --- Singleton ---
+    static void init(const Config& config);  // Inicialitza con la configuración rebuda
+    static void destroy();                   // Allibera l'objecte Audio
+    static auto get() -> Audio*;             // Obté el punter a l'objecte Audio
+    ~Audio();                                // Destructor (públic para std::unique_ptr)
+    Audio(const Audio&) = delete;            // Evitar còpia
+    Audio(Audio&&) = delete;
+    auto operator=(const Audio&) -> Audio& = delete;  // Evitar assignació
+    auto operator=(Audio&&) -> Audio& = delete;
 
-        // --- Control de música ---
-        void playMusic(const std::string& name, int loop = -1);  // Reproducir música en bucle
-        void pauseMusic();                                       // Pausar reproducción de música
-        void resumeMusic();                                      // Continua la música pausada
-        void stopMusic();                                        // Detener completamente la música
-        void fadeOutMusic(int milliseconds) const;               // Fundido de salida de la música
+    static void update();  // Actualització del sistema d'àudio
 
-        // --- Control de sonidos ---
-        void playSound(const std::string& name, Group group = Group::GAME) const;   // Reproducir sonido puntual por nombre
-        void playSound(struct JA_Sound_t* sound, Group group = Group::GAME) const;  // Reproducir sonido puntual por puntero
-        void stopAllSounds() const;                                                 // Detener todos los sonidos
+    // --- Control de música ---
+    void playMusic(const std::string& name, int loop = -1, int crossfade_ms = 0);  // Reproduir música per nom (amb crossfade opcional)
+    void playMusic(Ja::Music* music, int loop = -1, int crossfade_ms = 0);         // Reproduir música per punter (amb crossfade opcional)
+    void pauseMusic();                                                             // Pausar la reproducció de música
+    void resumeMusic();                                                            // Continua la música pausada
+    void stopMusic();                                                              // Aturar completament la música
+    void fadeOutMusic(int milliseconds);                                           // Fosa de sortida de la música (muta globals de Ja)
+    void setOnMusicEnded(std::function<void()> callback);                          // Callback disparat cuando la pista actual acaba de drenar (CONV-03)
+    // Multiplicador de velocitat de la música actual. 1.0 = normal,
+    // 1.5 = un 50% més ràpid (efecte "chipmunk" — también puja el to).
+    // Es reseteja a 1.0 implícitament a cada `playMusic`. No-op si no
+    // hay música activa.
+    void setMusicSpeed(float ratio);
 
-        // --- Control de volumen ---
-        void setSoundVolume(float volume, Group group = Group::ALL) const;  // Ajustar volumen de efectos
-        void setMusicVolume(float volume) const;                            // Ajustar volumen de música
+    // --- Control de sons ---
+    void playSound(const std::string& name, Group group = Group::GAME);  // Reproduir so puntual per nom (muta globals de Ja)
+    void playSound(Ja::Sound* sound, Group group = Group::GAME);         // Reproduir so puntual per punter (muta globals de Ja)
+    // Reprodueix un so con la velocitat (i to) escalats per `speed`:
+    // 1.0 = normal, 0.95 ≈ -5% (més greu i lent), 1.05 ≈ +5% (més
+    // agut i ràpid). Mateixa semàntica que `setMusicSpeed`. Útil per a
+    // variacions subtils que eviten la fatiga d'escoltar el mismo
+    // sample idèntic (p.ex. obertures de sarcòfag, picks d'ítems).
+    void playSound(const std::string& name, Group group, float speed);
+    // Reprodueix un so processat per un efecte definit a data/config/sounds.yaml
+    // (preset_name busca a SoundEffectsConfig). Si el preset no existeix
+    // o el motor está al sin de canals con efecte, fa fallback a playSound
+    // sec — l'usuari sent el so igualment, sin la cua.
+    void playSoundWithEcho(const std::string& name, const std::string& preset_name, Group group = Group::GAME);
+    void playSoundWithReverb(const std::string& name, const std::string& preset_name, Group group = Group::GAME);
+    void stopAllSounds();  // Aturar tots los sons (muta globals de Ja)
 
-        // --- Configuración general ---
-        void enable(bool value);                        // Establecer estado general
-        void toggleEnabled() { enabled_ = !enabled_; }  // Alternar estado general
-        void applySettings();                           // Aplica la configuración
+    // --- 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
 
-        // --- Configuración de sonidos ---
-        void enableSound() { sound_enabled_ = true; }             // Habilitar sonidos
-        void disableSound() { sound_enabled_ = false; }           // Deshabilitar sonidos
-        void enableSound(bool value) { sound_enabled_ = value; }  // Establecer estado de sonidos
-        void toggleSound() { sound_enabled_ = !sound_enabled_; }  // Alternar estado de sonidos
+    // --- Helpers de conversió para la capa de presentació ---
+    // UI (menús, notificacions) manega enters 0..100; internament viu float 0..1.
+    // No són constexpr porque std::lround no ho es en C++20; s'usen en runtime.
+    static auto toPercent(float volume) -> int {
+        return static_cast<int>(std::lround(volume * 100.0F));
+    }
+    static auto fromPercent(int percent) -> float {
+        return static_cast<float>(percent) / 100.0F;
+    }
 
-        // --- Configuración de música ---
-        void enableMusic() { music_enabled_ = true; }             // Habilitar música
-        void disableMusic() { music_enabled_ = false; }           // Deshabilitar música
-        void enableMusic(bool value) { music_enabled_ = value; }  // Establecer estado de música
-        void toggleMusic() { music_enabled_ = !music_enabled_; }  // Alternar estado de música
+    // --- Configuración general ---
+    void enable(bool value);                     // Estableix l'estat general (reaplica volums)
+    void toggleEnabled() { enable(!enabled_); }  // Alterna l'estat general (reaplica volums)
+    void applySettings(const Config& config);    // Aplica una nueva configuración
 
-        // --- Consultas de estado ---
-        [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }
-        [[nodiscard]] auto isSoundEnabled() const -> bool { return sound_enabled_; }
-        [[nodiscard]] auto isMusicEnabled() const -> bool { return music_enabled_; }
-        [[nodiscard]] auto getMusicState() const -> MusicState { return music_.state; }
-        [[nodiscard]] static auto getRealMusicState() -> MusicState;
-        [[nodiscard]] auto getCurrentMusicName() const -> const std::string& { return music_.name; }
+    // --- Configuración de sons ---
+    void enableSound(bool value);                         // Estableix l'estat dels sons (reaplica volum)
+    void toggleSound() { enableSound(!sound_enabled_); }  // Alterna l'estat dels sons (reaplica volum)
 
-    private:
-        // --- Tipos anidados ---
-        struct Music {
-                MusicState state{MusicState::STOPPED};  // Estado actual de la música
-                std::string name;                       // Última pista de música reproducida
-                bool loop{false};                       // Indica si se reproduce en bucle
-        };
+    // --- Configuración de música ---
+    void enableMusic(bool value);                         // Estableix l'estat de la música (reaplica volum)
+    void toggleMusic() { enableMusic(!music_enabled_); }  // Alterna l'estat de la música (reaplica volum)
 
-        // --- Métodos ---
-        Audio();              // Constructor privado
-        ~Audio();             // Destructor privado
-        void initSDLAudio();  // Inicializa SDL Audio
+    // --- Consultes d'estat ---
+    [[nodiscard]] auto isEnabled() const -> bool { return enabled_; }
+    [[nodiscard]] auto isSoundEnabled() const -> bool { return sound_enabled_; }
+    [[nodiscard]] auto isMusicEnabled() const -> bool { return music_enabled_; }
+    [[nodiscard]] static auto getMusicState() -> MusicState;  // Estat real consultat a Ja::
+    [[nodiscard]] auto getCurrentMusicName() const -> const std::string& { return music_.name; }
+    // Duración de la pista resolta per nom (mil·lisegons). 0 si la pista no
+    // existeix al cache de recursos o si el seu header OGG no permet
+    // calcular-la. Pensat para clients que necessiten un timeline
+    // determinista (p. ex. RoomFsm) sin dependre de callbacks de fi.
+    [[nodiscard]] static auto getMusicDurationMs(const std::string& name) -> int;
 
-        // --- Variables miembro ---
-        static Audio* instance;  // Instancia única de Audio
+   private:
+    // --- Tipus anidats ---
+    struct Music {
+        std::string name;  // Última pista de música reproduïda (buida si es va passar per punter sin filename)
+        bool loop{false};  // Si el play actual es en bucle
+    };
 
-        Music music_;               // Estado de la música
-        bool enabled_{true};        // Estado general del audio
-        bool sound_enabled_{true};  // Estado de los efectos de sonido
-        bool music_enabled_{true};  // Estado de la música
-};
\ No newline at end of file
+    // --- Mètodes ---
+    explicit Audio(const Config& config);                                                   // Constructor privat: rep la config
+    void initSDLAudio();                                                                    // Inicialitza SDL Audio
+    void playMusicInternal(Ja::Music* music, int loop, int crossfade_ms);                   // Camí comú dels dos overloads de playMusic
+    [[nodiscard]] auto effectiveVolume(float volume, bool channel_enabled) const -> float;  // Gate master+channel: 0 si algun está off, clamp 0..1 altrament
+
+    // --- Variables membre ---
+    static std::unique_ptr<Audio> instance;  // Instància única d'Audio
+
+    std::unique_ptr<Ja::Engine> engine_;  // Motor de baix nivell (owned); viu mentre Audio viu.
+    Config config_{};                     // Configuración injectada (volums, enables)
+    Music music_;                         // Estat de la música (nom + loop cachejats)
+    bool enabled_{true};                  // Estat general de l'àudio
+    bool sound_enabled_{true};            // Estat dels efectes de so
+    bool music_enabled_{true};            // Estat de la música
+};
diff --git a/source/core/audio/audio_adapter.cpp b/source/core/audio/audio_adapter.cpp
new file mode 100644
index 0000000..e67d744
--- /dev/null
+++ b/source/core/audio/audio_adapter.cpp
@@ -0,0 +1,99 @@
+// audio_adapter.cpp - Implementación de AudioResource para orni_attack
+// © 2025 Orni Attack
+//
+// Implementa AudioResource::getMusic / getSound delegando a
+// Resource::Helper::loadFile (que abstrae el resources.pack y el fallback
+// a filesystem). Cache local de Ja::Music* / Ja::Sound* con lazy load:
+// cada recurso se carga la primera vez que se pide y se mantiene vivo
+// hasta el shutdown.
+
+#include "core/audio/audio_adapter.hpp"
+
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "core/audio/jail_audio.hpp"
+#include "core/resources/resource_helper.hpp"
+
+namespace {
+
+// Cachés locales: indexados por nombre lógico ("title.ogg", "effects/laser_shoot.wav", etc.)
+// Mantienen ownership con unique_ptr; se liberan al salir del programa.
+std::unordered_map<std::string, std::unique_ptr<Ja::Music>>& musicCache() {
+    static std::unordered_map<std::string, std::unique_ptr<Ja::Music>> cache;
+    return cache;
+}
+
+std::unordered_map<std::string, std::unique_ptr<Ja::Sound>>& soundCache() {
+    static std::unordered_map<std::string, std::unique_ptr<Ja::Sound>> cache;
+    return cache;
+}
+
+// Normaliza el nombre añadiendo la subcarpeta correspondiente si no la trae:
+//   "title.ogg"            -> "music/title.ogg"
+//   "music/title.ogg"      -> "music/title.ogg"
+//   "effects/laser.wav"    -> "sounds/effects/laser.wav"
+std::string normalizeMusicPath(const std::string& name) {
+    return (name.rfind("music/", 0) == 0) ? name : "music/" + name;
+}
+
+std::string normalizeSoundPath(const std::string& name) {
+    return (name.rfind("sounds/", 0) == 0) ? name : "sounds/" + name;
+}
+
+}  // namespace
+
+namespace AudioResource {
+
+auto getMusic(const std::string& name) -> Ja::Music* {
+    auto& cache = musicCache();
+    if (auto it = cache.find(name); it != cache.end()) {
+        return it->second.get();
+    }
+
+    const std::string path = normalizeMusicPath(name);
+    auto bytes = Resource::Helper::loadFile(path);
+    if (bytes.empty()) {
+        std::cerr << "[AudioResource] no se ha podido cargar música: " << path << "\n";
+        return nullptr;
+    }
+
+    Ja::Music* raw = Ja::loadMusic(bytes.data(), static_cast<std::uint32_t>(bytes.size()), name.c_str());
+    if (raw == nullptr) {
+        std::cerr << "[AudioResource] decodificación de música falló: " << path << "\n";
+        return nullptr;
+    }
+
+    cache.emplace(name, std::unique_ptr<Ja::Music>(raw));
+    std::cout << "[AudioResource] música cargada: " << path << "\n";
+    return raw;
+}
+
+auto getSound(const std::string& name) -> Ja::Sound* {
+    auto& cache = soundCache();
+    if (auto it = cache.find(name); it != cache.end()) {
+        return it->second.get();
+    }
+
+    const std::string path = normalizeSoundPath(name);
+    auto bytes = Resource::Helper::loadFile(path);
+    if (bytes.empty()) {
+        std::cerr << "[AudioResource] no se ha podido cargar sonido: " << path << "\n";
+        return nullptr;
+    }
+
+    Ja::Sound* raw = Ja::loadSound(bytes.data(), static_cast<std::uint32_t>(bytes.size()));
+    if (raw == nullptr) {
+        std::cerr << "[AudioResource] decodificación de sonido falló: " << path << "\n";
+        return nullptr;
+    }
+
+    cache.emplace(name, std::unique_ptr<Ja::Sound>(raw));
+    std::cout << "[AudioResource] sonido cargado: " << path << "\n";
+    return raw;
+}
+
+}  // namespace AudioResource
diff --git a/source/core/audio/audio_adapter.hpp b/source/core/audio/audio_adapter.hpp
new file mode 100644
index 0000000..1afccfc
--- /dev/null
+++ b/source/core/audio/audio_adapter.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+// --- Audio Resource Adapter ---
+// Este archivo exposa una interfície comuna a Audio per obtenir Ja::Music* /
+// Ja::Sound* per nom. Cada projecte la implementa en audio_adapter.cpp delegant
+// al seu singleton de recursos (Resource::Cache::get(), ...). Así audio.hpp
+// i audio.cpp es poden compartir entre projectes.
+
+#include <string>  // Para string
+
+namespace Ja {
+    struct Music;
+    struct Sound;
+}  // namespace Ja
+
+namespace AudioResource {
+    auto getMusic(const std::string& name) -> Ja::Music*;
+    auto getSound(const std::string& name) -> Ja::Sound*;
+}  // namespace AudioResource
diff --git a/source/core/audio/audio_cache.cpp b/source/core/audio/audio_cache.cpp
deleted file mode 100644
index f3b671e..0000000
--- a/source/core/audio/audio_cache.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-// audio_cache.cpp - Implementació del caché de sons i música
-// © 2025 Port a C++20 amb SDL3
-
-#include "core/audio/audio_cache.hpp"
-
-#include <iostream>
-
-#include "core/resources/resource_helper.hpp"
-
-// Inicialització de variables estàtiques
-std::unordered_map<std::string, JA_Sound_t*> AudioCache::sounds_;
-std::unordered_map<std::string, JA_Music_t*> AudioCache::musics_;
-std::string AudioCache::sounds_base_path_ = "data/sounds/";
-std::string AudioCache::music_base_path_ = "data/music/";
-
-JA_Sound_t* AudioCache::getSound(const std::string& name) {
-    // Cache hit
-    auto it = sounds_.find(name);
-    if (it != sounds_.end()) {
-        std::cout << "[AudioCache] Sound cache hit: " << name << std::endl;
-        return it->second;
-    }
-
-    // Normalize path: "laser_shoot.wav" → "sounds/laser_shoot.wav"
-    std::string normalized = name;
-    if (normalized.find("sounds/") != 0) {
-        normalized = "sounds/" + normalized;
-    }
-
-    // Load from resource system
-    std::vector<uint8_t> data = Resource::Helper::loadFile(normalized);
-    if (data.empty()) {
-        std::cerr << "[AudioCache] Error: no s'ha pogut carregar " << normalized << std::endl;
-        return nullptr;
-    }
-
-    // Load sound from memory
-    JA_Sound_t* sound = JA_LoadSound(data.data(), static_cast<uint32_t>(data.size()));
-    if (sound == nullptr) {
-        std::cerr << "[AudioCache] Error: no s'ha pogut decodificar " << normalized
-                  << std::endl;
-        return nullptr;
-    }
-
-    std::cout << "[AudioCache] Sound loaded: " << normalized << std::endl;
-    sounds_[name] = sound;
-    return sound;
-}
-
-JA_Music_t* AudioCache::getMusic(const std::string& name) {
-    // Cache hit
-    auto it = musics_.find(name);
-    if (it != musics_.end()) {
-        std::cout << "[AudioCache] Music cache hit: " << name << std::endl;
-        return it->second;
-    }
-
-    // Normalize path: "title.ogg" → "music/title.ogg"
-    std::string normalized = name;
-    if (normalized.find("music/") != 0) {
-        normalized = "music/" + normalized;
-    }
-
-    // Load from resource system
-    std::vector<uint8_t> data = Resource::Helper::loadFile(normalized);
-    if (data.empty()) {
-        std::cerr << "[AudioCache] Error: no s'ha pogut carregar " << normalized << std::endl;
-        return nullptr;
-    }
-
-    // Load music from memory
-    JA_Music_t* music = JA_LoadMusic(data.data(), static_cast<uint32_t>(data.size()));
-    if (music == nullptr) {
-        std::cerr << "[AudioCache] Error: no s'ha pogut decodificar " << normalized
-                  << std::endl;
-        return nullptr;
-    }
-
-    std::cout << "[AudioCache] Music loaded: " << normalized << std::endl;
-    musics_[name] = music;
-    return music;
-}
-
-void AudioCache::clear() {
-    std::cout << "[AudioCache] Clearing cache (" << sounds_.size() << " sounds, "
-              << musics_.size() << " music)" << std::endl;
-
-    // Liberar memoria de sonidos
-    for (auto& [name, sound] : sounds_) {
-        if (sound && sound->buffer) {
-            SDL_free(sound->buffer);
-        }
-        delete sound;
-    }
-    sounds_.clear();
-
-    // Liberar memoria de música
-    for (auto& [name, music] : musics_) {
-        if (music && music->buffer) {
-            SDL_free(music->buffer);
-        }
-        if (music && music->filename) {
-            free(music->filename);
-        }
-        delete music;
-    }
-    musics_.clear();
-}
-
-size_t AudioCache::getSoundCacheSize() { return sounds_.size(); }
-
-size_t AudioCache::getMusicCacheSize() { return musics_.size(); }
-
-std::string AudioCache::resolveSoundPath(const std::string& name) {
-    // Si es un path absoluto (comienza con '/'), usarlo directamente
-    if (!name.empty() && name[0] == '/') {
-        return name;
-    }
-
-    // Si ya contiene el prefix base_path, usarlo directamente
-    if (name.find(sounds_base_path_) == 0) {
-        return name;
-    }
-
-    // Caso contrario, añadir base_path
-    return sounds_base_path_ + name;
-}
-
-std::string AudioCache::resolveMusicPath(const std::string& name) {
-    // Si es un path absoluto (comienza con '/'), usarlo directamente
-    if (!name.empty() && name[0] == '/') {
-        return name;
-    }
-
-    // Si ya contiene el prefix base_path, usarlo directamente
-    if (name.find(music_base_path_) == 0) {
-        return name;
-    }
-
-    // Caso contrario, añadir base_path
-    return music_base_path_ + name;
-}
diff --git a/source/core/audio/audio_cache.hpp b/source/core/audio/audio_cache.hpp
deleted file mode 100644
index b209952..0000000
--- a/source/core/audio/audio_cache.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// audio_cache.hpp - Caché simplificado de sonidos y música
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-
-#include <string>
-#include <unordered_map>
-
-#include "core/audio/jail_audio.hpp"
-
-// Caché estático de sonidos y música
-// Patrón inspirado en Graphics::ShapeLoader
-class AudioCache {
-    public:
-        // No instanciable (todo estático)
-        AudioCache() = delete;
-
-        // Obtener sonido (carga bajo demanda)
-        // Retorna puntero (nullptr si error)
-        static JA_Sound_t* getSound(const std::string& name);
-
-        // Obtener música (carga bajo demanda)
-        // Retorna puntero (nullptr si error)
-        static JA_Music_t* getMusic(const std::string& name);
-
-        // Limpiar caché (útil para debug/recarga)
-        static void clear();
-
-        // Estadísticas (debug)
-        static size_t getSoundCacheSize();
-        static size_t getMusicCacheSize();
-
-    private:
-        static std::unordered_map<std::string, JA_Sound_t*> sounds_;
-        static std::unordered_map<std::string, JA_Music_t*> musics_;
-        static std::string sounds_base_path_;  // "data/sounds/"
-        static std::string music_base_path_;   // "data/music/"
-
-        // Helpers privados
-        static std::string resolveSoundPath(const std::string& name);
-        static std::string resolveMusicPath(const std::string& name);
-};
diff --git a/source/core/audio/audio_effects.cpp b/source/core/audio/audio_effects.cpp
new file mode 100644
index 0000000..b012c88
--- /dev/null
+++ b/source/core/audio/audio_effects.cpp
@@ -0,0 +1,251 @@
+#include "core/audio/audio_effects.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include <iostream>
+
+#include "core/audio/jail_audio.hpp"
+
+namespace AudioEffects {
+
+    namespace {
+
+        // --- Caps de cua ---
+        constexpr float ECHO_TAIL_MS = 800.0F;
+        constexpr float REVERB_TAIL_MS = 1500.0F;
+
+        // --- Constants Freeverb ---
+        // Delays de comb i allpass tunats para 44.1 kHz; los reescalem per
+        // freqüència real de la font.
+        constexpr int COMB_REFERENCE_RATE = 44100;
+        constexpr std::array<int, 8> COMB_DELAYS_L = {1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617};
+        constexpr std::array<int, 4> ALLPASS_DELAYS_L = {556, 441, 341, 225};
+        constexpr int STEREO_SPREAD = 23;
+
+        // Mapeig de Schroeder/Dattorro/Freeverb estàndard.
+        constexpr float FIXED_GAIN = 0.015F;
+        constexpr float SCALE_ROOM = 0.28F;
+        constexpr float OFFSET_ROOM = 0.7F;
+        constexpr float SCALE_DAMP = 0.4F;
+
+        // --- Decodificació a float -1..1 ---
+        // Suporta U8/S16, mono/estèreo. Mono es duplica a L i R (la cadena
+        // d'efectes treballa siempre con dos canals per simplicitat).
+        auto decodeToStereoFloat(const Ja::Sound& src, std::vector<float>& left, std::vector<float>& right) -> bool {
+            const auto& spec = src.spec;
+            const Uint8* buf = src.buffer.get();
+            if (buf == nullptr || src.length == 0) { return false; }
+
+            int bytes_per_sample = 0;
+            if (spec.format == SDL_AUDIO_S16) {
+                bytes_per_sample = 2;
+            } else if (spec.format == SDL_AUDIO_U8) {
+                bytes_per_sample = 1;
+            } else {
+                std::cerr << "[AudioEffects] formato de sonido no soportado (solo U8 o S16)\n";
+                return false;
+            }
+            if (spec.channels < 1 || spec.channels > 2) {
+                std::cerr << "[AudioEffects] el sonido debe ser mono o estéreo\n";
+                return false;
+            }
+
+            const std::size_t TOTAL_FRAMES = src.length / static_cast<std::size_t>(bytes_per_sample * spec.channels);
+            left.resize(TOTAL_FRAMES);
+            right.resize(TOTAL_FRAMES);
+
+            for (std::size_t i = 0; i < TOTAL_FRAMES; ++i) {
+                float sample_l = 0.0F;
+                float sample_r = 0.0F;
+                if (spec.format == SDL_AUDIO_S16) {
+                    const auto* p = reinterpret_cast<const std::int16_t*>(buf + (i * spec.channels * 2));
+                    sample_l = static_cast<float>(p[0]) / 32768.0F;
+                    sample_r = (spec.channels == 2) ? static_cast<float>(p[1]) / 32768.0F : sample_l;
+                } else {  // U8
+                    const Uint8* p = buf + (i * spec.channels);
+                    sample_l = (static_cast<float>(p[0]) - 128.0F) / 128.0F;
+                    sample_r = (spec.channels == 2) ? (static_cast<float>(p[1]) - 128.0F) / 128.0F : sample_l;
+                }
+                left[i] = sample_l;
+                right[i] = sample_r;
+            }
+            return true;
+        }
+
+        // Empaqueta dos canals float (-1..1) a S16 entrellaçat.
+        void encodeStereoS16(const std::vector<float>& left, const std::vector<float>& right, std::vector<std::uint8_t>& out) {
+            const std::size_t LEN = left.size();
+            out.resize(LEN * 2 * sizeof(std::int16_t));
+            auto* dst = reinterpret_cast<std::int16_t*>(out.data());
+            for (std::size_t i = 0; i < LEN; ++i) {
+                const float L = std::clamp(left[i], -1.0F, 1.0F);
+                const float R = std::clamp(right[i], -1.0F, 1.0F);
+                dst[(i * 2) + 0] = static_cast<std::int16_t>(std::lround(L * 32767.0F));
+                dst[(i * 2) + 1] = static_cast<std::int16_t>(std::lround(R * 32767.0F));
+            }
+        }
+
+        // Reescala un delay de la taula de Freeverb para la freqüència real.
+        auto scaledDelay(int reference_delay, int rate) -> int {
+            const long SCALED = std::lround(static_cast<double>(reference_delay) * static_cast<double>(rate) / static_cast<double>(COMB_REFERENCE_RATE));
+            return std::max(1, static_cast<int>(SCALED));
+        }
+
+        // --- Filtres bàsics ---
+        struct Comb {
+            std::vector<float> buf;
+            std::size_t idx{0};
+            float feedback{0.0F};
+            float damp1{0.0F};
+            float damp2{1.0F};
+            float store{0.0F};
+
+            void init(int delay, float fb, float damping) {
+                buf.assign(static_cast<std::size_t>(delay), 0.0F);
+                idx = 0;
+                feedback = fb;
+                damp1 = damping;
+                damp2 = 1.0F - damping;
+                store = 0.0F;
+            }
+            auto tick(float in) -> float {
+                const float OUT = buf[idx];
+                store = (OUT * damp2) + (store * damp1);
+                buf[idx] = in + (store * feedback);
+                idx = (idx + 1) % buf.size();
+                return OUT;
+            }
+        };
+
+        struct Allpass {
+            std::vector<float> buf;
+            std::size_t idx{0};
+
+            void init(int delay) {
+                buf.assign(static_cast<std::size_t>(delay), 0.0F);
+                idx = 0;
+            }
+            auto tick(float in) -> float {
+                const float BUFOUT = buf[idx];
+                const float OUT = -in + BUFOUT;
+                buf[idx] = in + (BUFOUT * 0.5F);
+                idx = (idx + 1) % buf.size();
+                return OUT;
+            }
+        };
+
+    }  // namespace
+
+    auto applyEcho(const Ja::Sound& src, const Ja::EchoParams& params) -> std::optional<ProcessedSound> {
+        std::vector<float> left;
+        std::vector<float> right;
+        if (!decodeToStereoFloat(src, left, right)) { return std::nullopt; }
+
+        const int RATE = src.spec.freq;
+        const int DELAY_SAMPLES = std::max(1, static_cast<int>(std::lround(params.delay_ms * 0.001F * static_cast<float>(RATE))));
+        const auto TAIL_SAMPLES = static_cast<std::size_t>(std::lround(ECHO_TAIL_MS * 0.001F * static_cast<float>(RATE)));
+
+        const float FEEDBACK = std::clamp(params.feedback, 0.0F, 0.95F);
+        const float WET = std::clamp(params.wet, 0.0F, 1.0F);
+        const float DRY = 1.0F - WET;
+
+        const std::size_t INPUT_LEN = left.size();
+        const std::size_t TOTAL_LEN = INPUT_LEN + TAIL_SAMPLES;
+
+        std::vector<float> ring_l(static_cast<std::size_t>(DELAY_SAMPLES), 0.0F);
+        std::vector<float> ring_r(static_cast<std::size_t>(DELAY_SAMPLES), 0.0F);
+        std::size_t cursor = 0;
+
+        std::vector<float> out_l(TOTAL_LEN);
+        std::vector<float> out_r(TOTAL_LEN);
+
+        for (std::size_t i = 0; i < TOTAL_LEN; ++i) {
+            const float IN_L = (i < INPUT_LEN) ? left[i] : 0.0F;
+            const float IN_R = (i < INPUT_LEN) ? right[i] : 0.0F;
+
+            const float DELAYED_L = ring_l[cursor];
+            const float DELAYED_R = ring_r[cursor];
+
+            out_l[i] = (DRY * IN_L) + (WET * DELAYED_L);
+            out_r[i] = (DRY * IN_R) + (WET * DELAYED_R);
+
+            ring_l[cursor] = IN_L + (DELAYED_L * FEEDBACK);
+            ring_r[cursor] = IN_R + (DELAYED_R * FEEDBACK);
+            cursor = (cursor + 1) % static_cast<std::size_t>(DELAY_SAMPLES);
+        }
+
+        ProcessedSound result;
+        result.spec = SDL_AudioSpec{.format = SDL_AUDIO_S16, .channels = 2, .freq = RATE};
+        encodeStereoS16(out_l, out_r, result.bytes);
+        return result;
+    }
+
+    auto applyReverb(const Ja::Sound& src, const Ja::ReverbParams& params) -> std::optional<ProcessedSound> {
+        std::vector<float> left;
+        std::vector<float> right;
+        if (!decodeToStereoFloat(src, left, right)) { return std::nullopt; }
+
+        const int RATE = src.spec.freq;
+        const auto TAIL_SAMPLES = static_cast<std::size_t>(std::lround(REVERB_TAIL_MS * 0.001F * static_cast<float>(RATE)));
+
+        const float ROOM_SIZE = std::clamp(params.room_size, 0.0F, 1.0F);
+        const float DAMPING = std::clamp(params.damping, 0.0F, 1.0F);
+        const float WET = std::clamp(params.wet, 0.0F, 1.0F);
+        const float DRY = 1.0F - WET;
+
+        const float FEEDBACK = (ROOM_SIZE * SCALE_ROOM) + OFFSET_ROOM;  // 0.7..0.98
+        const float DAMP1 = DAMPING * SCALE_DAMP;                       // 0..0.4
+
+        // Inicialitza los 8 comb filters per cada canal i los 4 allpass.
+        std::array<Comb, 8> comb_l;
+        std::array<Comb, 8> comb_r;
+        for (std::size_t i = 0; i < COMB_DELAYS_L.size(); ++i) {
+            comb_l[i].init(scaledDelay(COMB_DELAYS_L[i], RATE), FEEDBACK, DAMP1);
+            comb_r[i].init(scaledDelay(COMB_DELAYS_L[i] + STEREO_SPREAD, RATE), FEEDBACK, DAMP1);
+        }
+        std::array<Allpass, 4> allpass_l;
+        std::array<Allpass, 4> allpass_r;
+        for (std::size_t i = 0; i < ALLPASS_DELAYS_L.size(); ++i) {
+            allpass_l[i].init(scaledDelay(ALLPASS_DELAYS_L[i], RATE));
+            allpass_r[i].init(scaledDelay(ALLPASS_DELAYS_L[i] + STEREO_SPREAD, RATE));
+        }
+
+        const std::size_t INPUT_LEN = left.size();
+        const std::size_t TOTAL_LEN = INPUT_LEN + TAIL_SAMPLES;
+        std::vector<float> out_l(TOTAL_LEN);
+        std::vector<float> out_r(TOTAL_LEN);
+
+        for (std::size_t i = 0; i < TOTAL_LEN; ++i) {
+            const float IN_L = (i < INPUT_LEN) ? left[i] : 0.0F;
+            const float IN_R = (i < INPUT_LEN) ? right[i] : 0.0F;
+            const float MONO_INPUT = (IN_L + IN_R) * FIXED_GAIN;
+
+            // 8 comb filters en paral·lel, sumats.
+            float wet_l = 0.0F;
+            float wet_r = 0.0F;
+            for (std::size_t k = 0; k < comb_l.size(); ++k) {
+                wet_l += comb_l[k].tick(MONO_INPUT);
+                wet_r += comb_r[k].tick(MONO_INPUT);
+            }
+            // 4 allpass en sèrie.
+            for (std::size_t k = 0; k < allpass_l.size(); ++k) {
+                wet_l = allpass_l[k].tick(wet_l);
+                wet_r = allpass_r[k].tick(wet_r);
+            }
+
+            out_l[i] = (DRY * IN_L) + (WET * wet_l);
+            out_r[i] = (DRY * IN_R) + (WET * wet_r);
+        }
+
+        ProcessedSound result;
+        result.spec = SDL_AudioSpec{.format = SDL_AUDIO_S16, .channels = 2, .freq = RATE};
+        encodeStereoS16(out_l, out_r, result.bytes);
+        return result;
+    }
+
+}  // namespace AudioEffects
diff --git a/source/core/audio/audio_effects.hpp b/source/core/audio/audio_effects.hpp
new file mode 100644
index 0000000..6204405
--- /dev/null
+++ b/source/core/audio/audio_effects.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+// Forward-declaració per no incloure jail_audio.hpp (cicle d'inclusió: este
+// header viu sota los params declarats a jail_audio.hpp, i alhora jail_audio
+// usa applyEcho/applyReverb).
+namespace Ja {
+    struct Sound;
+    struct EchoParams;
+    struct ReverbParams;
+}  // namespace Ja
+
+// Processadors d'efectes para sons puntuals. Reben un Ja::Sound (qualsevol
+// format suportat pel decodificador WAV: U8/S16, mono o estèreo) i tornen un
+// buffer PCM en S16 + el seu spec, llest per empenyer a un SDL_AudioStream.
+//
+// El buffer de sortida inclou la cua (decay) generada per l'efecte: per al
+// reverb, hasta a 1500 ms; para l'eco, hasta a 800 ms. Aquests caps eviten
+// allargar indefinidament la reproducció cuando los parámetros reinjecten mucho.
+//
+// Si el format del so d'origen no es pot processar, retornen std::nullopt
+// (el caller ha de fer fallback a reproducció seca).
+namespace AudioEffects {
+
+    struct ProcessedSound {
+        std::vector<std::uint8_t> bytes;  // PCM S16 entrellaçat (LRLRLR... si stereo)
+        SDL_AudioSpec spec;               // Format/canals/freqüència del buffer
+    };
+
+    [[nodiscard]] auto applyEcho(const Ja::Sound& src, const Ja::EchoParams& params) -> std::optional<ProcessedSound>;
+    [[nodiscard]] auto applyReverb(const Ja::Sound& src, const Ja::ReverbParams& params) -> std::optional<ProcessedSound>;
+
+}  // namespace AudioEffects
diff --git a/source/core/audio/jail_audio.cpp b/source/core/audio/jail_audio.cpp
new file mode 100644
index 0000000..8e50358
--- /dev/null
+++ b/source/core/audio/jail_audio.cpp
@@ -0,0 +1,645 @@
+#include "core/audio/jail_audio.hpp"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "core/audio/audio_effects.hpp"
+
+// Solo declaracions de stb_vorbis: STB_VORBIS_HEADER_ONLY omet el bloc
+// d'implementació. Les definicions las aporta source/external/stb_vorbis_impl.cpp
+// (TU aïllat porque clang-analyzer no dispari fals positius al nostre codi).
+#define STB_VORBIS_HEADER_ONLY
+// clang-format off
+// NOLINTNEXTLINE(bugprone-suspicious-include) -- stb_vorbis es single-file: la macro de dalt limita este TU a solo-declaracions; la implementació viu a external/stb_vorbis_impl.cpp.
+#include "external/stb_vorbis.c"
+// clang-format on
+
+namespace Ja {
+
+    // --- Streaming internals (file-scope constants) ---
+    namespace {
+        // Bytes-per-sample per canal (siempre s16)
+        constexpr int MUSIC_BYTES_PER_SAMPLE = 2;
+        // Quants shorts decodifiquem per crida a get_samples_short_interleaved.
+        // 8192 shorts = 4096 samples/channel en estèreo ≈ 85ms de so a 48kHz.
+        constexpr int MUSIC_CHUNK_SHORTS = 8192;
+        // Umbral d'audio per davant del cursor de reproducció. Mantenim ≥ 0.5 s a
+        // l'SDL_AudioStream per absorbir jitter de frame i evitar underruns.
+        constexpr float MUSIC_LOW_WATER_SECONDS = 0.5F;
+    }  // namespace
+
+    // --- Engine::active_ storage ---
+    Engine* Engine::active_ = nullptr;
+
+    auto Engine::active() noexcept -> Engine* { return active_; }
+
+    // --- Ctor/Dtor ---
+
+    Engine::Engine(const int freq, const SDL_AudioFormat format, const int num_channels) {
+        assert(active_ == nullptr && "Ja::Engine: més d'una instància activa no está suportat");
+        active_ = this;
+
+        audio_spec_ = {.format = format, .channels = num_channels, .freq = freq};
+        sdl_audio_device_ = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &audio_spec_);
+        if (sdl_audio_device_ == 0) { std::fprintf(stderr, "Ja::Engine: Failed to initialize SDL audio!\n"); }
+        for (auto& channel : channels_) { channel.state = ChannelState::FREE; }
+    }
+
+    Engine::~Engine() {
+        if (outgoing_music_.stream != nullptr) {
+            SDL_DestroyAudioStream(outgoing_music_.stream);
+            outgoing_music_.stream = nullptr;
+        }
+        if (sdl_audio_device_ != 0) { SDL_CloseAudioDevice(sdl_audio_device_); }
+        sdl_audio_device_ = 0;
+
+        if (active_ == this) { active_ = nullptr; }
+    }
+
+    // --- Helpers stateless (no toquen membres d'Engine) ---
+    namespace {
+
+        auto feedMusicChunk(Music* music) -> int {
+            if (music == nullptr || music->vorbis == nullptr || music->stream == nullptr) { return 0; }
+
+            short chunk[MUSIC_CHUNK_SHORTS];
+            const int NUM_CHANNELS = music->spec.channels;
+            const int SAMPLES_PER_CHANNEL = stb_vorbis_get_samples_short_interleaved(
+                music->vorbis,
+                NUM_CHANNELS,
+                static_cast<short*>(chunk),
+                MUSIC_CHUNK_SHORTS);
+            if (SAMPLES_PER_CHANNEL <= 0) { return 0; }
+
+            const int BYTES = SAMPLES_PER_CHANNEL * NUM_CHANNELS * MUSIC_BYTES_PER_SAMPLE;
+            SDL_PutAudioStreamData(music->stream, static_cast<const void*>(chunk), BYTES);
+            return SAMPLES_PER_CHANNEL;
+        }
+
+        void pumpMusic(Music* music) {
+            if (music == nullptr || music->vorbis == nullptr || music->stream == nullptr) { return; }
+
+            const int BYTES_PER_SECOND = music->spec.freq * music->spec.channels * MUSIC_BYTES_PER_SAMPLE;
+            const int LOW_WATER_BYTES = static_cast<int>(MUSIC_LOW_WATER_SECONDS * static_cast<float>(BYTES_PER_SECOND));
+
+            while (SDL_GetAudioStreamAvailable(music->stream) < LOW_WATER_BYTES) {
+                const int DECODED = feedMusicChunk(music);
+                if (DECODED > 0) { continue; }
+
+                // EOF: si queden loops, rebobinar; si no, tallar y deixar drenar.
+                if (music->times != 0) {
+                    stb_vorbis_seek_start(music->vorbis);
+                    if (music->times > 0) { music->times--; }
+                } else {
+                    break;
+                }
+            }
+        }
+
+        void preFillOutgoing(Music* music, const int duration_ms) {
+            if (music == nullptr || music->vorbis == nullptr || music->stream == nullptr) { return; }
+
+            const int BYTES_PER_SECOND = music->spec.freq * music->spec.channels * MUSIC_BYTES_PER_SAMPLE;
+            const int NEEDED_BYTES = static_cast<int>((static_cast<std::int64_t>(duration_ms) * BYTES_PER_SECOND) / 1000);
+
+            while (SDL_GetAudioStreamAvailable(music->stream) < NEEDED_BYTES) {
+                const int DECODED = feedMusicChunk(music);
+                if (DECODED <= 0) { break; }
+            }
+        }
+
+        // Retorna el progrés lineal [0..1] d'un fade. 1.0 vol dir completat. Única
+        // font de la corba del fade: si es vol canviar a logarítmica/quadràtica,
+        // s'edita aquí i afecta fade-in i fade-out alhora.
+        auto fadeProgress(const FadeState& fade) -> float {
+            if (fade.duration_ms <= 0) { return 1.0F; }
+            const Uint64 ELAPSED = SDL_GetTicks() - fade.start_time;
+            if (ELAPSED >= static_cast<Uint64>(fade.duration_ms)) { return 1.0F; }
+            return static_cast<float>(ELAPSED) / static_cast<float>(fade.duration_ms);
+        }
+
+    }  // namespace
+
+    void Engine::updateOutgoingFade() {
+        if (outgoing_music_.stream == nullptr || !outgoing_music_.fade.active) { return; }
+
+        // Mentre la fosa está activa, mantenim el stream con una reserva
+        // de samples per davant del cursor (mismo patró que pumpMusic
+        // para el current_music_). Así el stream no es buida ni cuando SDL
+        // drena més ràpid del previst en haver sounds bound a la misma
+        // device. Si l'OGG arriba a EOF, rebobina (la fosa pot ser més
+        // llarga que la pista).
+        if (outgoing_music_.music != nullptr && outgoing_music_.music->vorbis != nullptr) {
+            const Music& music = *outgoing_music_.music;
+            const int BYTES_PER_SECOND = music.spec.freq * music.spec.channels * MUSIC_BYTES_PER_SAMPLE;
+            const int LOW_WATER = static_cast<int>(MUSIC_LOW_WATER_SECONDS * static_cast<float>(BYTES_PER_SECOND));
+            while (SDL_GetAudioStreamAvailable(outgoing_music_.stream) < LOW_WATER) {
+                short chunk[MUSIC_CHUNK_SHORTS];
+                const int SAMPLES = stb_vorbis_get_samples_short_interleaved(
+                    music.vorbis,
+                    music.spec.channels,
+                    static_cast<short*>(chunk),
+                    MUSIC_CHUNK_SHORTS);
+                if (SAMPLES <= 0) {
+                    stb_vorbis_seek_start(music.vorbis);
+                    continue;
+                }
+                const int BYTES = SAMPLES * music.spec.channels * MUSIC_BYTES_PER_SAMPLE;
+                SDL_PutAudioStreamData(outgoing_music_.stream, static_cast<const void*>(chunk), BYTES);
+            }
+        }
+
+        const float PROGRESS = fadeProgress(outgoing_music_.fade);
+        if (PROGRESS >= 1.0F) {
+            SDL_DestroyAudioStream(outgoing_music_.stream);
+            outgoing_music_.stream = nullptr;
+            outgoing_music_.fade.active = false;
+            // Deixem el Vorbis del Music original en un estat conegut per
+            // a la pròxima reproducció. (playMusic también fa seek_start,
+            // pero fer-ho ací evita estats intermedis si algú consulta.)
+            if (outgoing_music_.music != nullptr && outgoing_music_.music->vorbis != nullptr) {
+                stb_vorbis_seek_start(outgoing_music_.music->vorbis);
+            }
+            outgoing_music_.music = nullptr;
+        } else {
+            SDL_SetAudioStreamGain(outgoing_music_.stream, outgoing_music_.fade.initial_volume * (1.0F - PROGRESS));
+        }
+    }
+
+    void Engine::updateIncomingFade() {
+        if (!incoming_fade_.active) { return; }
+
+        const float PROGRESS = fadeProgress(incoming_fade_);
+        if (PROGRESS >= 1.0F) {
+            incoming_fade_.active = false;
+            SDL_SetAudioStreamGain(current_music_->stream, music_volume_);
+        } else {
+            SDL_SetAudioStreamGain(current_music_->stream, music_volume_ * PROGRESS);
+        }
+    }
+
+    void Engine::updateCurrentMusic() {
+        if (current_music_ == nullptr || current_music_->state != MusicState::PLAYING) { return; }
+
+        updateIncomingFade();
+
+        pumpMusic(current_music_);
+        if (current_music_->times == 0 && SDL_GetAudioStreamAvailable(current_music_->stream) == 0) {
+            // La pista ha acabat de drenar naturalment. L'aturem primer (deixa
+            // l'engine en estat consistent) i entonces invoquem el callback;
+            // así un eventual playMusic des del callback comença net.
+            stopMusic();
+            if (on_music_ended_) { on_music_ended_(); }
+        }
+    }
+
+    void Engine::updateSoundChannels() {
+        for (int i = 0; i < MAX_SIMULTANEOUS_CHANNELS; ++i) {
+            if (channels_[i].state != ChannelState::PLAYING) { continue; }
+
+            if (channels_[i].times != 0) {
+                if (static_cast<Uint32>(SDL_GetAudioStreamAvailable(channels_[i].stream)) < (channels_[i].sound->length / 2)) {
+                    SDL_PutAudioStreamData(channels_[i].stream, channels_[i].sound->buffer.get(), channels_[i].sound->length);
+                    if (channels_[i].times > 0) { channels_[i].times--; }
+                }
+            } else if (SDL_GetAudioStreamAvailable(channels_[i].stream) == 0) {
+                stopChannel(i);
+            }
+        }
+    }
+
+    void Engine::stealCurrentIntoOutgoing(const int duration_ms) {
+        if (outgoing_music_.stream != nullptr) {
+            SDL_DestroyAudioStream(outgoing_music_.stream);
+            outgoing_music_.stream = nullptr;
+            outgoing_music_.fade.active = false;
+        }
+
+        if (current_music_ == nullptr || current_music_->state != MusicState::PLAYING || current_music_->stream == nullptr) {
+            return;
+        }
+
+        preFillOutgoing(current_music_, duration_ms);
+
+        outgoing_music_.stream = current_music_->stream;
+        // Guardem la referència al Music porque updateOutgoingFade puga
+        // seguir bombant Vorbis sin al stream durante tota la fosa. NO fem
+        // seek_start ací: la decompressió ha de continuar des d'on estava
+        // porque el so siga continu. El seek_start es farà cuando la fosa
+        // acabe (o cuando playMusic la interrompi via stopMusic).
+        outgoing_music_.music = current_music_;
+        outgoing_music_.fade = {
+            .active = true,
+            .start_time = SDL_GetTicks(),
+            .duration_ms = duration_ms,
+            .initial_volume = music_volume_,
+        };
+        current_music_->stream = nullptr;
+        current_music_->state = MusicState::STOPPED;
+    }
+
+    template <typename Fn>
+    void Engine::forEachTargetChannel(const int channel, Fn&& fn) {
+        if (channel == -1) {
+            for (auto& ch : channels_) { fn(ch); }
+        } else if (channel >= 0 && channel < MAX_SIMULTANEOUS_CHANNELS) {
+            fn(channels_[channel]);
+        }
+    }
+
+    // --- Engine public API ---
+
+    void Engine::update() {
+        updateOutgoingFade();
+        updateCurrentMusic();
+        updateSoundChannels();
+    }
+
+    void Engine::playMusic(Music* music, const int loop) {
+        if (music == nullptr || music->vorbis == nullptr) { return; }
+
+        stopMusic();
+
+        current_music_ = music;
+        current_music_->state = MusicState::PLAYING;
+        current_music_->times = loop;
+
+        stb_vorbis_seek_start(current_music_->vorbis);
+
+        current_music_->stream = SDL_CreateAudioStream(&current_music_->spec, &audio_spec_);
+        if (current_music_->stream == nullptr) {
+            std::fprintf(stderr, "Ja::Engine::playMusic: Failed to create audio stream!\n");
+            current_music_->state = MusicState::STOPPED;
+            return;
+        }
+        SDL_SetAudioStreamGain(current_music_->stream, music_volume_);
+
+        pumpMusic(current_music_);
+
+        if (!SDL_BindAudioStream(sdl_audio_device_, current_music_->stream)) {
+            std::fprintf(stderr, "Ja::Engine::playMusic: SDL_BindAudioStream failed!\n");
+        }
+    }
+
+    void Engine::setMusicSpeed(float ratio) {
+        if (current_music_ == nullptr || current_music_->stream == nullptr) { return; }
+        SDL_SetAudioStreamFrequencyRatio(current_music_->stream, ratio);
+    }
+
+    void Engine::pauseMusic() {
+        if (current_music_ == nullptr || current_music_->state != MusicState::PLAYING) { return; }
+
+        current_music_->state = MusicState::PAUSED;
+        SDL_UnbindAudioStream(current_music_->stream);
+    }
+
+    void Engine::resumeMusic() {
+        if (current_music_ == nullptr || current_music_->state != MusicState::PAUSED) { return; }
+
+        current_music_->state = MusicState::PLAYING;
+        SDL_BindAudioStream(sdl_audio_device_, current_music_->stream);
+    }
+
+    void Engine::stopMusic() {
+        if (outgoing_music_.stream != nullptr) {
+            SDL_DestroyAudioStream(outgoing_music_.stream);
+            outgoing_music_.stream = nullptr;
+            outgoing_music_.fade.active = false;
+            if (outgoing_music_.music != nullptr && outgoing_music_.music->vorbis != nullptr) {
+                stb_vorbis_seek_start(outgoing_music_.music->vorbis);
+            }
+            outgoing_music_.music = nullptr;
+        }
+        incoming_fade_.active = false;
+
+        if (current_music_ == nullptr || current_music_->state == MusicState::INVALID || current_music_->state == MusicState::STOPPED) { return; }
+
+        current_music_->state = MusicState::STOPPED;
+        if (current_music_->stream != nullptr) {
+            SDL_DestroyAudioStream(current_music_->stream);
+            current_music_->stream = nullptr;
+        }
+        if (current_music_->vorbis != nullptr) {
+            stb_vorbis_seek_start(current_music_->vorbis);
+        }
+    }
+
+    void Engine::fadeOutMusic(const int milliseconds) {
+        if (current_music_ == nullptr || current_music_->state != MusicState::PLAYING) { return; }
+
+        stealCurrentIntoOutgoing(milliseconds);
+        incoming_fade_.active = false;
+    }
+
+    void Engine::crossfadeMusic(Music* music, const int crossfade_ms, const int loop) {
+        if (music == nullptr || music->vorbis == nullptr) { return; }
+
+        stealCurrentIntoOutgoing(crossfade_ms);
+
+        current_music_ = music;
+        current_music_->state = MusicState::PLAYING;
+        current_music_->times = loop;
+
+        stb_vorbis_seek_start(current_music_->vorbis);
+        current_music_->stream = SDL_CreateAudioStream(&current_music_->spec, &audio_spec_);
+        if (current_music_->stream == nullptr) {
+            std::fprintf(stderr, "Ja::Engine::crossfadeMusic: Failed to create audio stream!\n");
+            current_music_->state = MusicState::STOPPED;
+            return;
+        }
+        SDL_SetAudioStreamGain(current_music_->stream, 0.0F);
+        pumpMusic(current_music_);
+        SDL_BindAudioStream(sdl_audio_device_, current_music_->stream);
+
+        incoming_fade_ = {
+            .active = true,
+            .start_time = SDL_GetTicks(),
+            .duration_ms = crossfade_ms,
+            .initial_volume = 0.0F,
+        };
+    }
+
+    auto Engine::getMusicState() const -> MusicState {
+        if (current_music_ == nullptr) { return MusicState::INVALID; }
+        return current_music_->state;
+    }
+
+    auto Engine::setMusicVolume(float volume) -> float {
+        music_volume_ = SDL_clamp(volume, 0.0F, 1.0F);
+        if (current_music_ != nullptr && current_music_->stream != nullptr) {
+            SDL_SetAudioStreamGain(current_music_->stream, music_volume_);
+        }
+        return music_volume_;
+    }
+
+    void Engine::setOnMusicEnded(std::function<void()> callback) {
+        on_music_ended_ = std::move(callback);
+    }
+
+    void Engine::onMusicDeleted(const Music* music) {
+        if (music == nullptr) { return; }
+        if (current_music_ == music) {
+            stopMusic();
+            current_music_ = nullptr;
+        }
+    }
+
+    // --- Sound ---
+
+    auto Engine::playSound(Sound* sound, const int loop, const int group) -> int {
+        if (sound == nullptr) { return -1; }
+
+        int channel = 0;
+        while (channel < MAX_SIMULTANEOUS_CHANNELS && channels_[channel].state != ChannelState::FREE) { channel++; }
+        if (channel == MAX_SIMULTANEOUS_CHANNELS) {
+            // No hay canal libre, reemplazamos el primero
+            channel = 0;
+        }
+
+        return playSoundOnChannel(sound, channel, loop, group);
+    }
+
+    auto Engine::playSoundOnChannel(Sound* sound, const int channel, const int loop, const int group) -> int {
+        if (sound == nullptr) { return -1; }
+        if (channel < 0 || channel >= MAX_SIMULTANEOUS_CHANNELS) { return -1; }
+
+        stopChannel(channel);
+
+        channels_[channel].sound = sound;
+        channels_[channel].times = loop;
+        channels_[channel].pos = 0;
+        channels_[channel].group = group;
+        channels_[channel].state = ChannelState::PLAYING;
+        channels_[channel].stream = SDL_CreateAudioStream(&channels_[channel].sound->spec, &audio_spec_);
+
+        if (channels_[channel].stream == nullptr) {
+            std::fprintf(stderr, "Ja::Engine::playSoundOnChannel: Failed to create audio stream!\n");
+            channels_[channel].state = ChannelState::FREE;
+            return -1;
+        }
+
+        SDL_PutAudioStreamData(channels_[channel].stream, channels_[channel].sound->buffer.get(), channels_[channel].sound->length);
+        SDL_SetAudioStreamGain(channels_[channel].stream, sound_volume_[group]);
+        SDL_BindAudioStream(sdl_audio_device_, channels_[channel].stream);
+
+        return channel;
+    }
+
+    void Engine::setChannelSpeed(const int channel, const float ratio) {
+        if (channel < 0 || channel >= MAX_SIMULTANEOUS_CHANNELS) { return; }
+        if (channels_[channel].stream == nullptr) { return; }
+        SDL_SetAudioStreamFrequencyRatio(channels_[channel].stream, ratio);
+    }
+
+    void Engine::pauseChannel(const int channel) {
+        forEachTargetChannel(channel, [](Channel& ch) {
+            if (ch.state == ChannelState::PLAYING) {
+                ch.state = ChannelState::PAUSED;
+                SDL_UnbindAudioStream(ch.stream);
+            }
+        });
+    }
+
+    void Engine::resumeChannel(const int channel) {
+        const SDL_AudioDeviceID DEVICE = sdl_audio_device_;
+        forEachTargetChannel(channel, [DEVICE](Channel& ch) {
+            if (ch.state == ChannelState::PAUSED) {
+                ch.state = ChannelState::PLAYING;
+                SDL_BindAudioStream(DEVICE, ch.stream);
+            }
+        });
+    }
+
+    void Engine::stopChannel(const int channel) {
+        forEachTargetChannel(channel, [this](Channel& ch) {
+            if (ch.state != ChannelState::FREE) {
+                if (ch.stream != nullptr) { SDL_DestroyAudioStream(ch.stream); }
+                ch.stream = nullptr;
+                ch.state = ChannelState::FREE;
+                ch.pos = 0;
+                ch.sound = nullptr;
+                if (ch.has_effect) {
+                    ch.has_effect = false;
+                    if (effect_channels_active_ > 0) { --effect_channels_active_; }
+                }
+            }
+        });
+    }
+
+    auto Engine::setSoundVolume(float volume, const int group) -> float {
+        const float V = SDL_clamp(volume, 0.0F, 1.0F);
+
+        if (group == -1) {
+            std::ranges::fill(sound_volume_, V);
+        } else if (group >= 0 && group < MAX_GROUPS) {
+            sound_volume_[group] = V;
+        } else {
+            return V;
+        }
+
+        for (auto& ch : channels_) {
+            if ((ch.state == ChannelState::PLAYING) || (ch.state == ChannelState::PAUSED)) {
+                if (group == -1 || ch.group == group) {
+                    if (ch.stream != nullptr) {
+                        SDL_SetAudioStreamGain(ch.stream, sound_volume_[ch.group]);
+                    }
+                }
+            }
+        }
+        return V;
+    }
+
+    void Engine::onSoundDeleted(const Sound* sound) {
+        if (sound == nullptr) { return; }
+        for (int i = 0; i < MAX_SIMULTANEOUS_CHANNELS; ++i) {
+            if (channels_[i].sound == sound) { stopChannel(i); }
+        }
+    }
+
+    auto Engine::playProcessedOnFreeChannel(const std::vector<std::uint8_t>& bytes, const SDL_AudioSpec& spec, const int group) -> int {
+        // El sin de canals con efecte es valida antes de reservar slot —
+        // así evitem crear y destruir un stream solo per descartar el play.
+        if (effect_channels_active_ >= MAX_EFFECT_CHANNELS) { return -1; }
+
+        int channel = 0;
+        while (channel < MAX_SIMULTANEOUS_CHANNELS && channels_[channel].state != ChannelState::FREE) { ++channel; }
+        if (channel == MAX_SIMULTANEOUS_CHANNELS) { channel = 0; }
+
+        stopChannel(channel);
+
+        // El stream es crea contra l'spec del buffer processat (S16, ...)
+        // porque SDL faci el resampling sin a audio_spec_ del device.
+        channels_[channel].stream = SDL_CreateAudioStream(&spec, &audio_spec_);
+        if (channels_[channel].stream == nullptr) {
+            std::fprintf(stderr, "Ja::Engine::playProcessedOnFreeChannel: Failed to create audio stream!\n");
+            return -1;
+        }
+
+        channels_[channel].sound = nullptr;  // El buffer no es propietat de sin Ja::Sound.
+        channels_[channel].times = 0;
+        channels_[channel].pos = 0;
+        const int CLAMPED_GROUP = (group >= 0 && group < MAX_GROUPS) ? group : 0;
+        channels_[channel].group = CLAMPED_GROUP;
+        channels_[channel].state = ChannelState::PLAYING;
+        channels_[channel].has_effect = true;
+        ++effect_channels_active_;
+
+        SDL_PutAudioStreamData(channels_[channel].stream, bytes.data(), static_cast<int>(bytes.size()));
+        SDL_SetAudioStreamGain(channels_[channel].stream, sound_volume_[CLAMPED_GROUP]);
+        SDL_BindAudioStream(sdl_audio_device_, channels_[channel].stream);
+
+        return channel;
+    }
+
+    auto Engine::playSoundWithEcho(const Sound* sound, const EchoParams& params, const int group) -> int {
+        if (sound == nullptr) { return -1; }
+        auto processed = AudioEffects::applyEcho(*sound, params);
+        if (!processed) { return -1; }
+        return playProcessedOnFreeChannel(processed->bytes, processed->spec, group);
+    }
+
+    auto Engine::playSoundWithReverb(const Sound* sound, const ReverbParams& params, const int group) -> int {
+        if (sound == nullptr) { return -1; }
+        auto processed = AudioEffects::applyReverb(*sound, params);
+        if (!processed) { return -1; }
+        return playProcessedOnFreeChannel(processed->bytes, processed->spec, group);
+    }
+
+    // --- Factories y destructors (permanents) ---
+
+    auto loadMusic(const Uint8* buffer, Uint32 length) -> Music* {
+        if (buffer == nullptr || length == 0) { return nullptr; }
+
+        // Allocem el Music primer per aprofitar el seu `std::vector<Uint8>`
+        // como a propietari del OGG comprimit. stb_vorbis guarda un punter
+        // persistent al buffer; como que ací no el resize'jem, el .data() es
+        // estable durante tot el cicle de vida del music.
+        auto music = std::make_unique<Music>();
+        music->ogg_data.assign(buffer, buffer + length);
+
+        int vorbis_error = 0;
+        music->vorbis = stb_vorbis_open_memory(music->ogg_data.data(),
+            static_cast<int>(length),
+            &vorbis_error,
+            nullptr);
+        if (music->vorbis == nullptr) {
+            std::fprintf(stderr, "Ja::loadMusic: stb_vorbis_open_memory failed (error %d)\n", vorbis_error);
+            return nullptr;
+        }
+
+        const stb_vorbis_info INFO = stb_vorbis_get_info(music->vorbis);
+        music->spec.channels = static_cast<int>(INFO.channels);
+        music->spec.freq = static_cast<int>(INFO.sample_rate);
+        music->spec.format = SDL_AUDIO_S16;
+        // Pre-cálculo de la duración en ms a partir del header. stb_vorbis ya
+        // ha decodificat la informació necessària a `stb_vorbis_open_memory`;
+        // esta consulta no descodifica àudio, solo llig el comptador
+        // de samples. Si el sample_rate fos 0 (header malmès) deixem
+        // duration_ms a 0.
+        if (INFO.sample_rate > 0) {
+            const auto SAMPLES = stb_vorbis_stream_length_in_samples(music->vorbis);
+            music->duration_ms = static_cast<int>((static_cast<std::uint64_t>(SAMPLES) * 1000ULL) / INFO.sample_rate);
+        }
+        music->state = MusicState::STOPPED;
+
+        return music.release();
+    }
+
+    // Overload con filename. Resource::Cache l'usa per registrar el path dins
+    // del propi Ja::Music (camp `filename`); la capa Audio l'usa per recuperar
+    // el nom después d'un playMusic(Ja::Music*, ...) — veure PATCH-02.
+    auto loadMusic(const Uint8* buffer, Uint32 length, const char* filename) -> Music* {
+        Music* music = loadMusic(buffer, length);
+        if (music != nullptr && filename != nullptr) { music->filename = filename; }
+        return music;
+    }
+
+    void deleteMusic(Music* music) {
+        if (music == nullptr) { return; }
+        // Notifiquem el motor actiu porque pari la pista si es la current_music.
+        // Si no hay motor (shutdown-order invertit), passem: los recursos
+        // propis del Music es lliberen igualment a sota.
+        if (Engine* eng = Engine::active()) { eng->onMusicDeleted(music); }
+
+        if (music->stream != nullptr) { SDL_DestroyAudioStream(music->stream); }
+        if (music->vorbis != nullptr) { stb_vorbis_close(music->vorbis); }
+        delete music;
+    }
+
+    auto loadSound(std::uint8_t* buffer, std::uint32_t size) -> Sound* {
+        auto sound = std::make_unique<Sound>();
+        Uint8* raw = nullptr;
+        if (!SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size), true, &sound->spec, &raw, &sound->length)) {
+            std::fprintf(stderr, "Ja::loadSound: Failed to load WAV from memory: %s\n", SDL_GetError());
+            return nullptr;
+        }
+        sound->buffer.reset(raw);  // adopta el SDL_malloc'd buffer
+        return sound.release();
+    }
+
+    void deleteSound(Sound* sound) {
+        if (sound == nullptr) { return; }
+        if (Engine* eng = Engine::active()) { eng->onSoundDeleted(sound); }
+        // buffer es destrueix automàticament via RAII (SdlFreeDeleter).
+        delete sound;
+    }
+
+}  // namespace Ja
+
+// --- stb_vorbis macro leak cleanup ---
+// stb_vorbis.c filtra noms curts (L, C, R i PLAYBACK_*) al TU que el compila.
+// Xocarien con parámetros de plantilla d'altres headers si estas definicions
+// s'escapessin. Els netegem al final del TU per tancar la porta.
+// clang-format off
+#undef L
+#undef C
+#undef R
+#undef PLAYBACK_MONO
+#undef PLAYBACK_LEFT
+#undef PLAYBACK_RIGHT
+// clang-format on
diff --git a/source/core/audio/jail_audio.hpp b/source/core/audio/jail_audio.hpp
index 582094a..e46c542 100644
--- a/source/core/audio/jail_audio.hpp
+++ b/source/core/audio/jail_audio.hpp
@@ -2,481 +2,257 @@
 
 // --- Includes ---
 #include <SDL3/SDL.h>
-#include <stdint.h>  // Para uint32_t, uint8_t
-#include <stdio.h>   // Para NULL, fseek, printf, fclose, fopen, fread, ftell, FILE, SEEK_END, SEEK_SET
-#include <stdlib.h>  // Para free, malloc
-#include <string.h>  // Para strcpy, strlen
 
-#define STB_VORBIS_HEADER_ONLY
-#include "external/stb_vorbis.h"  // Para stb_vorbis_decode_memory
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
 
-// --- Public Enums ---
-enum JA_Channel_state { JA_CHANNEL_INVALID,
-    JA_CHANNEL_FREE,
-    JA_CHANNEL_PLAYING,
-    JA_CHANNEL_PAUSED,
-    JA_SOUND_DISABLED };
-enum JA_Music_state { JA_MUSIC_INVALID,
-    JA_MUSIC_PLAYING,
-    JA_MUSIC_PAUSED,
-    JA_MUSIC_STOPPED,
-    JA_MUSIC_DISABLED };
+// Forward-declaració del decoder de vorbis. La implementació viu a
+// jail_audio.cpp (únic TU que compila external/stb_vorbis.c). Qualsevol caller
+// solo necessita `stb_vorbis*` per punter — nunca per valor — así que el
+// forward decl n'hay prou i evita arrossegar el .c a tots los TU.
+// NOLINTNEXTLINE(readability-identifier-naming) — nom imposat per l'API de stb_vorbis
+struct stb_vorbis;
 
-// --- Struct Definitions ---
-#define JA_MAX_SIMULTANEOUS_CHANNELS 20
-#define JA_MAX_GROUPS 2
-
-struct JA_Sound_t {
-        SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
-        Uint32 length{0};
-        Uint8* buffer{NULL};
+// Deleter stateless para buffers reservats con `SDL_malloc` / `SDL_LoadWAV*`.
+// Compatible con `std::unique_ptr<Uint8[], SdlFreeDeleter>` — zero size overhead
+// gràcies a EBO, igual que un unique_ptr con default_delete.
+struct SdlFreeDeleter {
+    void operator()(Uint8* p) const noexcept {
+        if (p != nullptr) { SDL_free(p); }
+    }
 };
 
-struct JA_Channel_t {
-        JA_Sound_t* sound{nullptr};
+// Motor de baix nivell d'àudio del projecte jailgames: streaming OGG
+// (stb_vorbis) + N canals d'efectes (SDL3 audio). No depèn d'Options ni de sin
+// singleton del joc; solo de SDL3 i stb_vorbis. La capa superior (Audio) li
+// passa recursos pel punter i fa el bookkeeping d'usuari.
+namespace Ja {
+
+    // --- Public Enums ---
+    enum class ChannelState : std::uint8_t {
+        FREE,
+        PLAYING,
+        PAUSED,
+    };
+
+    enum class MusicState : std::uint8_t {
+        INVALID,  // Music carregat pero nunca play-ejat
+        PLAYING,
+        PAUSED,
+        STOPPED,
+    };
+
+    // --- Constants ---
+    inline constexpr int MAX_SIMULTANEOUS_CHANNELS = 20;
+    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
+    // cauen al camí sec — l'usuari sent el so igualment, sin la cua.
+    inline constexpr int MAX_EFFECT_CHANNELS = 4;
+
+    // --- Paràmetres d'efectes ---
+    // Els camps los fixa el caller (Audio) llegint sounds.yaml; el motor solo
+    // los passa a AudioEffects::applyEcho/applyReverb. Els defaults són
+    // sensats pero los presets los sobreescriuen.
+    struct EchoParams {
+        float delay_ms{220.0F};  // Temps hasta al primer rebot.
+        float feedback{0.45F};   // Reinjecció (0..0.95).
+        float wet{0.35F};        // Mescla humida (0..1).
+    };
+
+    struct ReverbParams {
+        float room_size{0.7F};  // Tamaño percebuda (0..1).
+        float damping{0.5F};    // Atenuació d'aguts per rebot (0..1).
+        float wet{0.4F};        // Mescla humida (0..1).
+    };
+
+    // Spec de fallback del dispositiu. S'aplica antes que l'Engine s'iniciï i
+    // como a valor inicial de Sound/Music. L'spec real d'ús l'imposa el ctor
+    // d'Engine, alimentat des de Defaults::Audio via Audio.
+    inline constexpr SDL_AudioSpec DEFAULT_SPEC{SDL_AUDIO_S16, 2, 48000};
+
+    // --- Struct Definitions ---
+    struct Sound {
+        SDL_AudioSpec spec{DEFAULT_SPEC};
+        Uint32 length{0};
+        // Buffer descomprimit (PCM) propietat del sound. Reservat per SDL_LoadWAV
+        // via SDL_malloc; el deleter `SdlFreeDeleter` allibera con SDL_free.
+        std::unique_ptr<Uint8[], SdlFreeDeleter> buffer;
+    };
+
+    // L'ordre (punters primer, ints después, enum de 8 bits al final) minimitza
+    // el padding a 64-bit (evita avisos de clang-analyzer-optin.performance.Padding).
+    struct Channel {
+        Sound* sound{nullptr};
+        SDL_AudioStream* stream{nullptr};
         int pos{0};
         int times{0};
         int group{0};
+        ChannelState state{ChannelState::FREE};
+        // Marca si este canal va arrencar con so processat per un efecte.
+        // El motor compta canals actius con efecte per fer complir
+        // MAX_EFFECT_CHANNELS i alliberar el comptador en parar.
+        bool has_effect{false};
+    };
+
+    struct Music {
+        SDL_AudioSpec spec{DEFAULT_SPEC};
+
+        // OGG comprimit en memòria. Propietat nostra; es copia des del buffer
+        // d'entrada una sola vegada en loadMusic i es descomprimix en chunks
+        // per streaming. Como que stb_vorbis guarda un punter persistent al
+        // `.data()` d'este vector, no el podem resize'jar un cop establert
+        // (una reallocation invalidaria el punter que el decoder conserva).
+        std::vector<Uint8> ogg_data;
+        stb_vorbis* vorbis{nullptr};  // handle del decoder, viu tot el cicle del Music
+
+        std::string filename;
+
+        int times{0};  // loops restants (-1 = infinit, 0 = un sol play)
+        // Duración total de la pista en mil·lisegons, mesurada via
+        // `stb_vorbis_stream_length_in_samples / sample_rate` al
+        // `loadMusic`. 0 si el cálculo no es possible (header malmès).
+        // L'usen consumidors que necessiten un timeline pre-calculat —
+        // p. ex. la FSM de sala — sin dependre de callbacks de fi.
+        int duration_ms{0};
         SDL_AudioStream* stream{nullptr};
-        JA_Channel_state state{JA_CHANNEL_FREE};
-};
+        MusicState state{MusicState::INVALID};
+    };
 
-struct JA_Music_t {
-        SDL_AudioSpec spec{SDL_AUDIO_S16, 2, 48000};
-        Uint32 length{0};
-        Uint8* buffer{nullptr};
-        char* filename{nullptr};
+    struct FadeState {
+        bool active{false};
+        Uint64 start_time{0};
+        int duration_ms{0};
+        float initial_volume{0.0F};
+    };
 
-        int pos{0};
-        int times{0};
+    struct OutgoingMusic {
         SDL_AudioStream* stream{nullptr};
-        JA_Music_state state{JA_MUSIC_INVALID};
-};
-
-// --- Internal Global State ---
-// Marcado 'inline' (C++17) para asegurar una única instancia.
-
-inline JA_Music_t* current_music{nullptr};
-inline JA_Channel_t channels[JA_MAX_SIMULTANEOUS_CHANNELS];
-
-inline SDL_AudioSpec JA_audioSpec{SDL_AUDIO_S16, 2, 48000};
-inline float JA_musicVolume{1.0F};
-inline float JA_soundVolume[JA_MAX_GROUPS];
-inline bool JA_musicEnabled{true};
-inline bool JA_soundEnabled{true};
-inline SDL_AudioDeviceID sdlAudioDevice{0};
-
-inline bool fading{false};
-inline int fade_start_time{0};
-inline int fade_duration{0};
-inline float fade_initial_volume{0.0F};  // Corregido de 'int' a 'float'
-
-// --- Forward Declarations ---
-inline void JA_StopMusic();
-inline void JA_StopChannel(const int channel);
-inline int JA_PlaySoundOnChannel(JA_Sound_t* sound, const int channel, const int loop = 0, const int group = 0);
-
-// --- Core Functions ---
-
-inline void JA_Update() {
-    if (JA_musicEnabled && current_music && current_music->state == JA_MUSIC_PLAYING) {
-        if (fading) {
-            int time = SDL_GetTicks();
-            if (time > (fade_start_time + fade_duration)) {
-                fading = false;
-                JA_StopMusic();
-                return;
-            } else {
-                const int time_passed = time - fade_start_time;
-                const float percent = (float)time_passed / (float)fade_duration;
-                SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume * (1.0 - percent));
-            }
-        }
-
-        if (current_music->times != 0) {
-            if ((Uint32)SDL_GetAudioStreamAvailable(current_music->stream) < (current_music->length / 2)) {
-                SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length);
-            }
-            if (current_music->times > 0) current_music->times--;
-        } else {
-            if (SDL_GetAudioStreamAvailable(current_music->stream) == 0) JA_StopMusic();
-        }
-    }
-
-    if (JA_soundEnabled) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i)
-            if (channels[i].state == JA_CHANNEL_PLAYING) {
-                if (channels[i].times != 0) {
-                    if ((Uint32)SDL_GetAudioStreamAvailable(channels[i].stream) < (channels[i].sound->length / 2)) {
-                        SDL_PutAudioStreamData(channels[i].stream, channels[i].sound->buffer, channels[i].sound->length);
-                        if (channels[i].times > 0) channels[i].times--;
-                    }
-                } else {
-                    if (SDL_GetAudioStreamAvailable(channels[i].stream) == 0) JA_StopChannel(i);
-                }
-            }
-    }
-}
-
-inline void JA_Init(const int freq, const SDL_AudioFormat format, const int num_channels) {
-#ifdef _DEBUG
-    SDL_SetLogPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_DEBUG);
-#endif
-
-    JA_audioSpec = {format, num_channels, freq};
-    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);  // Corregido: !sdlAudioDevice -> sdlAudioDevice
-    sdlAudioDevice = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &JA_audioSpec);
-    if (sdlAudioDevice == 0) SDL_Log("Failed to initialize SDL audio!");
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; ++i) channels[i].state = JA_CHANNEL_FREE;
-    for (int i = 0; i < JA_MAX_GROUPS; ++i) JA_soundVolume[i] = 0.5F;
-}
-
-inline void JA_Quit() {
-    if (sdlAudioDevice) SDL_CloseAudioDevice(sdlAudioDevice);  // Corregido: !sdlAudioDevice -> sdlAudioDevice
-    sdlAudioDevice = 0;
-}
-
-// --- Music Functions ---
-
-inline JA_Music_t* JA_LoadMusic(const Uint8* buffer, Uint32 length) {
-    JA_Music_t* music = new JA_Music_t();
-
-    int chan, samplerate;
-    short* output;
-    music->length = stb_vorbis_decode_memory(buffer, length, &chan, &samplerate, &output) * chan * 2;
-
-    music->spec.channels = chan;
-    music->spec.freq = samplerate;
-    music->spec.format = SDL_AUDIO_S16;
-    music->buffer = static_cast<Uint8*>(SDL_malloc(music->length));
-    SDL_memcpy(music->buffer, output, music->length);
-    free(output);
-    music->pos = 0;
-    music->state = JA_MUSIC_STOPPED;
-
-    return music;
-}
-
-inline JA_Music_t* JA_LoadMusic(const char* filename) {
-    // [RZC 28/08/22] Carreguem primer el arxiu en memòria i després el descomprimim. Es algo més rapid.
-    FILE* f = fopen(filename, "rb");
-    if (!f) return NULL;  // Añadida comprobación de apertura
-    fseek(f, 0, SEEK_END);
-    long fsize = ftell(f);
-    fseek(f, 0, SEEK_SET);
-    auto* buffer = static_cast<Uint8*>(malloc(fsize + 1));
-    if (!buffer) {  // Añadida comprobación de malloc
-        fclose(f);
-        return NULL;
-    }
-    if (fread(buffer, fsize, 1, f) != 1) {
-        fclose(f);
-        free(buffer);
-        return NULL;
-    }
-    fclose(f);
-
-    JA_Music_t* music = JA_LoadMusic(buffer, fsize);
-    if (music) {  // Comprobar que JA_LoadMusic tuvo éxito
-        music->filename = static_cast<char*>(malloc(strlen(filename) + 1));
-        if (music->filename) {
-            strcpy(music->filename, filename);
-        }
-    }
-
-    free(buffer);
-
-    return music;
-}
-
-inline void JA_PlayMusic(JA_Music_t* music, const int loop = -1) {
-    if (!JA_musicEnabled || !music) return;  // Añadida comprobación de music
-
-    JA_StopMusic();
-
-    current_music = music;
-    current_music->pos = 0;
-    current_music->state = JA_MUSIC_PLAYING;
-    current_music->times = loop;
-
-    current_music->stream = SDL_CreateAudioStream(&current_music->spec, &JA_audioSpec);
-    if (!current_music->stream) {  // Comprobar creación de stream
-        SDL_Log("Failed to create audio stream!");
-        current_music->state = JA_MUSIC_STOPPED;
-        return;
-    }
-    if (!SDL_PutAudioStreamData(current_music->stream, current_music->buffer, current_music->length)) printf("[ERROR] SDL_PutAudioStreamData failed!\n");
-    SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
-    if (!SDL_BindAudioStream(sdlAudioDevice, current_music->stream)) printf("[ERROR] SDL_BindAudioStream failed!\n");
-}
-
-inline char* JA_GetMusicFilename(const JA_Music_t* music = nullptr) {
-    if (!music) music = current_music;
-    if (!music) return nullptr;  // Añadida comprobación
-    return music->filename;
-}
-
-inline void JA_PauseMusic() {
-    if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state != JA_MUSIC_PLAYING) return;  // Comprobación mejorada
-
-    current_music->state = JA_MUSIC_PAUSED;
-    SDL_UnbindAudioStream(current_music->stream);
-}
-
-inline void JA_ResumeMusic() {
-    if (!JA_musicEnabled) return;
-    if (!current_music || current_music->state != JA_MUSIC_PAUSED) return;  // Comprobación mejorada
-
-    current_music->state = JA_MUSIC_PLAYING;
-    SDL_BindAudioStream(sdlAudioDevice, current_music->stream);
-}
-
-inline void JA_StopMusic() {
-    if (!current_music || current_music->state == JA_MUSIC_INVALID || current_music->state == JA_MUSIC_STOPPED) return;
-
-    current_music->pos = 0;
-    current_music->state = JA_MUSIC_STOPPED;
-    if (current_music->stream) {
-        SDL_DestroyAudioStream(current_music->stream);
-        current_music->stream = nullptr;
-    }
-    // No liberamos filename aquí, se debería liberar en JA_DeleteMusic
-}
-
-inline void JA_FadeOutMusic(const int milliseconds) {
-    if (!JA_musicEnabled) return;
-    if (current_music == NULL || current_music->state == JA_MUSIC_INVALID) return;
-
-    fading = true;
-    fade_start_time = SDL_GetTicks();
-    fade_duration = milliseconds;
-    fade_initial_volume = JA_musicVolume;
-}
-
-inline JA_Music_state JA_GetMusicState() {
-    if (!JA_musicEnabled) return JA_MUSIC_DISABLED;
-    if (!current_music) return JA_MUSIC_INVALID;
-
-    return current_music->state;
-}
-
-inline void JA_DeleteMusic(JA_Music_t* music) {
-    if (!music) return;
-    if (current_music == music) {
-        JA_StopMusic();
-        current_music = nullptr;
-    }
-    SDL_free(music->buffer);
-    if (music->stream) SDL_DestroyAudioStream(music->stream);
-    free(music->filename);  // filename se libera aquí
-    delete music;
-}
-
-inline float JA_SetMusicVolume(float volume) {
-    JA_musicVolume = SDL_clamp(volume, 0.0F, 1.0F);
-    if (current_music && current_music->stream) {
-        SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
-    }
-    return JA_musicVolume;
-}
-
-inline void JA_SetMusicPosition(float value) {
-    if (!current_music) return;
-    current_music->pos = value * current_music->spec.freq;
-    // Nota: Esta implementación de 'pos' no parece usarse en JA_Update para
-    // el streaming. El streaming siempre parece empezar desde el principio.
-}
-
-inline float JA_GetMusicPosition() {
-    if (!current_music) return 0;
-    return float(current_music->pos) / float(current_music->spec.freq);
-    // Nota: Ver `JA_SetMusicPosition`
-}
-
-inline void JA_EnableMusic(const bool value) {
-    if (!value && current_music && (current_music->state == JA_MUSIC_PLAYING)) JA_StopMusic();
-
-    JA_musicEnabled = value;
-}
-
-// --- Sound Functions ---
-
-inline JA_Sound_t* JA_NewSound(Uint8* buffer, Uint32 length) {
-    JA_Sound_t* sound = new JA_Sound_t();
-    sound->buffer = buffer;
-    sound->length = length;
-    // Nota: spec se queda con los valores por defecto.
-    return sound;
-}
-
-inline JA_Sound_t* JA_LoadSound(uint8_t* buffer, uint32_t size) {
-    JA_Sound_t* sound = new JA_Sound_t();
-    if (!SDL_LoadWAV_IO(SDL_IOFromMem(buffer, size), 1, &sound->spec, &sound->buffer, &sound->length)) {
-        SDL_Log("Failed to load WAV from memory: %s", SDL_GetError());
-        delete sound;
-        return nullptr;
-    }
-    return sound;
-}
-
-inline JA_Sound_t* JA_LoadSound(const char* filename) {
-    JA_Sound_t* sound = new JA_Sound_t();
-    if (!SDL_LoadWAV(filename, &sound->spec, &sound->buffer, &sound->length)) {
-        SDL_Log("Failed to load WAV file: %s", SDL_GetError());
-        delete sound;
-        return nullptr;
-    }
-    return sound;
-}
-
-inline int JA_PlaySound(JA_Sound_t* sound, const int loop = 0, const int group = 0) {
-    if (!JA_soundEnabled || !sound) return -1;
-
-    int channel = 0;
-    while (channel < JA_MAX_SIMULTANEOUS_CHANNELS && channels[channel].state != JA_CHANNEL_FREE) { channel++; }
-    if (channel == JA_MAX_SIMULTANEOUS_CHANNELS) {
-        // No hay canal libre, reemplazamos el primero
-        channel = 0;
-    }
-
-    return JA_PlaySoundOnChannel(sound, channel, loop, group);
-}
-
-inline int JA_PlaySoundOnChannel(JA_Sound_t* sound, const int channel, const int loop, const int group) {
-    if (!JA_soundEnabled || !sound) return -1;
-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return -1;
-
-    JA_StopChannel(channel);  // Detiene y limpia el canal si estaba en uso
-
-    channels[channel].sound = sound;
-    channels[channel].times = loop;
-    channels[channel].pos = 0;
-    channels[channel].group = group;  // Asignar grupo
-    channels[channel].state = JA_CHANNEL_PLAYING;
-    channels[channel].stream = SDL_CreateAudioStream(&channels[channel].sound->spec, &JA_audioSpec);
-
-    if (!channels[channel].stream) {
-        SDL_Log("Failed to create audio stream for sound!");
-        channels[channel].state = JA_CHANNEL_FREE;
-        return -1;
-    }
-
-    SDL_PutAudioStreamData(channels[channel].stream, channels[channel].sound->buffer, channels[channel].sound->length);
-    SDL_SetAudioStreamGain(channels[channel].stream, JA_soundVolume[group]);
-    SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
-
-    return channel;
-}
-
-inline void JA_DeleteSound(JA_Sound_t* sound) {
-    if (!sound) return;
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        if (channels[i].sound == sound) JA_StopChannel(i);
-    }
-    SDL_free(sound->buffer);
-    delete sound;
-}
-
-inline void JA_PauseChannel(const int channel) {
-    if (!JA_soundEnabled) return;
-
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
-            if (channels[i].state == JA_CHANNEL_PLAYING) {
-                channels[i].state = JA_CHANNEL_PAUSED;
-                SDL_UnbindAudioStream(channels[i].stream);
-            }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PLAYING) {
-            channels[channel].state = JA_CHANNEL_PAUSED;
-            SDL_UnbindAudioStream(channels[channel].stream);
-        }
-    }
-}
-
-inline void JA_ResumeChannel(const int channel) {
-    if (!JA_soundEnabled) return;
-
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++)
-            if (channels[i].state == JA_CHANNEL_PAUSED) {
-                channels[i].state = JA_CHANNEL_PLAYING;
-                SDL_BindAudioStream(sdlAudioDevice, channels[i].stream);
-            }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state == JA_CHANNEL_PAUSED) {
-            channels[channel].state = JA_CHANNEL_PLAYING;
-            SDL_BindAudioStream(sdlAudioDevice, channels[channel].stream);
-        }
-    }
-}
-
-inline void JA_StopChannel(const int channel) {
-    if (channel == -1) {
-        for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-            if (channels[i].state != JA_CHANNEL_FREE) {
-                if (channels[i].stream) SDL_DestroyAudioStream(channels[i].stream);
-                channels[i].stream = nullptr;
-                channels[i].state = JA_CHANNEL_FREE;
-                channels[i].pos = 0;
-                channels[i].sound = NULL;
-            }
-        }
-    } else if (channel >= 0 && channel < JA_MAX_SIMULTANEOUS_CHANNELS) {
-        if (channels[channel].state != JA_CHANNEL_FREE) {
-            if (channels[channel].stream) SDL_DestroyAudioStream(channels[channel].stream);
-            channels[channel].stream = nullptr;
-            channels[channel].state = JA_CHANNEL_FREE;
-            channels[channel].pos = 0;
-            channels[channel].sound = NULL;
-        }
-    }
-}
-
-inline JA_Channel_state JA_GetChannelState(const int channel) {
-    if (!JA_soundEnabled) return JA_SOUND_DISABLED;
-    if (channel < 0 || channel >= JA_MAX_SIMULTANEOUS_CHANNELS) return JA_CHANNEL_INVALID;
-
-    return channels[channel].state;
-}
-
-inline float JA_SetSoundVolume(float volume, const int group = -1)  // -1 para todos los grupos
-{
-    const float v = SDL_clamp(volume, 0.0F, 1.0F);
-
-    if (group == -1) {
-        for (int i = 0; i < JA_MAX_GROUPS; ++i) {
-            JA_soundVolume[i] = v;
-        }
-    } else if (group >= 0 && group < JA_MAX_GROUPS) {
-        JA_soundVolume[group] = v;
-    } else {
-        return v;  // Grupo inválido
-    }
-
-    // Aplicar volumen a canales activos
-    for (int i = 0; i < JA_MAX_SIMULTANEOUS_CHANNELS; i++) {
-        if ((channels[i].state == JA_CHANNEL_PLAYING) || (channels[i].state == JA_CHANNEL_PAUSED)) {
-            if (group == -1 || channels[i].group == group) {
-                if (channels[i].stream) {
-                    SDL_SetAudioStreamGain(channels[i].stream, JA_soundVolume[channels[i].group]);
-                }
-            }
-        }
-    }
-    return v;
-}
-
-inline void JA_EnableSound(const bool value) {
-    if (!value) {
-        JA_StopChannel(-1);  // Detener todos los canales
-    }
-    JA_soundEnabled = value;
-}
-
-inline float JA_SetVolume(float volume) {
-    float v = JA_SetMusicVolume(volume);
-    JA_SetSoundVolume(v, -1);  // Aplicar a todos los grupos de sonido
-    return v;
-}
\ No newline at end of file
+        // Referència al Music original porque updateOutgoingFade puga
+        // continuar descomprimint des de Vorbis sin al stream durante
+        // tota la fosa. Sense això, solo tenim el pre-fill puntual i
+        // SDL drena el stream més ràpid del previst cuando hay sounds
+        // bound a la misma device (~2x), buidant-lo a meitat del
+        // fade i sentint-se como un tall sec.
+        Music* music{nullptr};
+        FadeState fade;
+    };
+
+    // --- Engine ---
+    // Encapsula tot l'estat que antes vivia como a globals inline. Un sol Engine
+    // viu per procés (enforceat via assert al ctor contra `active_`). El ctor
+    // obre el device SDL; el dtor el tanca (RAII). Els deleters
+    // `Ja::deleteMusic`/`Ja::deleteSound` accedeixen al motor actiu via
+    // `Engine::active()` per parar canals antes d'alliberar.
+    class Engine {
+       public:
+        Engine(int freq, SDL_AudioFormat format, int num_channels);
+        ~Engine();
+        Engine(const Engine&) = delete;
+        auto operator=(const Engine&) -> Engine& = delete;
+        Engine(Engine&&) = delete;
+        auto operator=(Engine&&) -> Engine& = delete;
+
+        // Retorna el motor actiu o nullptr si sin ha estat construït. L'usen
+        // los deleters de recursos porque no los arriba sin referència directa.
+        [[nodiscard]] static auto active() noexcept -> Engine*;
+
+        void update();
+
+        // --- Música ---
+        void playMusic(Music* music, int loop = -1);
+        void pauseMusic();
+        void resumeMusic();
+        void stopMusic();
+        void fadeOutMusic(int milliseconds);
+        void crossfadeMusic(Music* music, int crossfade_ms, int loop = -1);
+        [[nodiscard]] auto getMusicState() const -> MusicState;
+        auto setMusicVolume(float volume) -> float;
+        // Multiplicador de velocitat de reproducció de la música actual
+        // via `SDL_SetAudioStreamFrequencyRatio`. 1.0 = normal, 2.0 =
+        // doble velocitat. Cal saber que también puja el to (efecte
+        // "chipmunk") — es el comportament arcade clàssic dels comptes
+        // enrere. Cada `playMusic` crea un stream nuevo con ratio 1.0,
+        // así que un canvi de track reseteja la velocitat
+        // implícitament. No-op si no hay música activa.
+        void setMusicSpeed(float ratio);
+        // Registra un callback que es disparà cuando la música actual acabi de
+        // drenar naturalment (times == 0 + stream buit). Es crida DESPRÉS de
+        // stopMusic, así que el callback pot invocar playMusic sin córrer.
+        // S'executa al mismo thread que Engine::update (render loop); no fer
+        // operacions blocants.
+        void setOnMusicEnded(std::function<void()> callback);
+        // Notifica al motor que un Music s'está destruint: si es el current_music
+        // s'atura antes que los seus recursos (stream/vorbis) deixin de ser vàlids.
+        void onMusicDeleted(const Music* music);
+
+        // --- So ---
+        auto playSound(Sound* sound, int loop = 0, int group = 0) -> int;
+        auto playSoundOnChannel(Sound* sound, int channel, int loop = 0, int group = 0) -> int;
+        // Ajusta la velocitat de reproducció d'un canal actiu via
+        // `SDL_SetAudioStreamFrequencyRatio`. 1.0 = normal. Igual que a
+        // `setMusicSpeed`, puja/baixa el to junt con la velocitat
+        // (efecte "chipmunk"); para SFX curts arcade es el que volem.
+        // No-op si el canal no está actiu. Cridar-lo just después de
+        // `playSound`/`playSoundOnChannel` porque el ratio cobreixi
+        // tota la reproducció.
+        void setChannelSpeed(int channel, float ratio);
+        // Reproducció con so processat per un efecte. Retorna el canal
+        // assignat o -1 si no queden slots d'efecte (MAX_EFFECT_CHANNELS).
+        // El sound original solo s'usa per consultar el spec/buffer; el
+        // canal manipula el buffer ya processat (no reapunta a `sound`).
+        auto playSoundWithEcho(const Sound* sound, const EchoParams& params, int group = 0) -> int;
+        auto playSoundWithReverb(const Sound* sound, const ReverbParams& params, int group = 0) -> int;
+        void pauseChannel(int channel);
+        void resumeChannel(int channel);
+        void stopChannel(int channel);
+        auto setSoundVolume(float volume, int group = -1) -> float;
+        // Notifica al motor que un Sound s'está destruint: los canals que el
+        // referenciïn es paren antes d'alliberar el buffer.
+        void onSoundDeleted(const Sound* sound);
+
+       private:
+        void stealCurrentIntoOutgoing(int duration_ms);
+        void updateOutgoingFade();
+        void updateIncomingFade();
+        void updateCurrentMusic();
+        void updateSoundChannels();
+        // Empenta un buffer ya processat (S16) a un canal lliure y el deixa
+        // sonar sin bucle. Camí comú dels dos overloads playSoundWith*.
+        // Retorna el canal o -1 si no queden slots.
+        auto playProcessedOnFreeChannel(const std::vector<std::uint8_t>& bytes, const SDL_AudioSpec& spec, int group) -> int;
+
+        template <typename Fn>
+        void forEachTargetChannel(int channel, Fn&& fn);
+
+        Music* current_music_{nullptr};
+        Channel channels_[MAX_SIMULTANEOUS_CHANNELS]{};
+        SDL_AudioSpec audio_spec_{DEFAULT_SPEC};
+        float music_volume_{1.0F};
+        float sound_volume_[MAX_GROUPS]{};
+        SDL_AudioDeviceID sdl_audio_device_{0};
+        OutgoingMusic outgoing_music_;
+        FadeState incoming_fade_;
+        std::function<void()> on_music_ended_;
+        // Comptador derivat de Channel::has_effect — evita haver-lo de
+        // recalcular cada vegada que algú demana un play con efecte.
+        int effect_channels_active_{0};
+
+        // NOLINTNEXTLINE(readability-identifier-naming) — convenció projecte: private static con sufix _
+        static Engine* active_;
+    };
+
+    // --- Factories y destructors (permanents) ---
+    // No depenen de l'estat del motor: loadMusic/loadSound solo construeixen
+    // objectes, deleteMusic/deleteSound consulten Engine::active() per parar
+    // canals antes d'alliberar (si el motor aún viu).
+    [[nodiscard]] auto loadMusic(const Uint8* buffer, Uint32 length) -> Music*;
+    [[nodiscard]] auto loadMusic(const Uint8* buffer, Uint32 length, const char* filename) -> Music*;
+    void deleteMusic(Music* music);
+    [[nodiscard]] auto loadSound(std::uint8_t* buffer, std::uint32_t size) -> Sound*;
+    void deleteSound(Sound* sound);
+
+}  // namespace Ja
diff --git a/source/core/audio/sound_effects_config.cpp b/source/core/audio/sound_effects_config.cpp
new file mode 100644
index 0000000..b8da792
--- /dev/null
+++ b/source/core/audio/sound_effects_config.cpp
@@ -0,0 +1,80 @@
+#include "core/audio/sound_effects_config.hpp"
+
+#include <string>
+
+#include <iostream>
+
+#include "core/resources/resource_helper.hpp"
+#include "external/fkyaml_node.hpp"
+
+namespace {
+
+    // Lector de camp con fallback: deixa el destí intacte si la clau no
+    // existeix (los defaults dels Ja::*Params s'inicialitzen al ctor del
+    // struct, así que el comportament es "preset parcial = preset complet
+    // con defaults per als camps que falten").
+    template <typename T>
+    void readField(const fkyaml::node& node, const char* key, T& dst) {
+        if (node.contains(key)) { dst = node[key].get_value<T>(); }
+    }
+
+}  // namespace
+
+auto SoundEffectsConfig::get() -> SoundEffectsConfig& {
+    static SoundEffectsConfig instance_;
+    return instance_;
+}
+
+void SoundEffectsConfig::load(const std::string& file_path) {
+    auto bytes = Resource::Helper::loadFile(file_path);
+    if (bytes.empty()) {
+        std::cerr << "[SoundEffectsConfig] no se ha podido abrir " << file_path
+                  << " — sin presets de efecto disponibles\n";
+        return;
+    }
+
+    try {
+        const auto* begin = reinterpret_cast<const char*>(bytes.data());
+        const auto* end = begin + bytes.size();
+        auto yaml = fkyaml::node::deserialize(begin, end);
+
+        if (yaml.contains("echo") && yaml["echo"].is_mapping()) {
+            for (auto it = yaml["echo"].begin(); it != yaml["echo"].end(); ++it) {
+                const auto NAME = it.key().get_value<std::string>();
+                const auto& node = it.value();
+                Ja::EchoParams params{};
+                readField(node, "delay_ms", params.delay_ms);
+                readField(node, "feedback", params.feedback);
+                readField(node, "wet", params.wet);
+                echoes_[NAME] = params;
+            }
+        }
+
+        if (yaml.contains("reverb") && yaml["reverb"].is_mapping()) {
+            for (auto it = yaml["reverb"].begin(); it != yaml["reverb"].end(); ++it) {
+                const auto NAME = it.key().get_value<std::string>();
+                const auto& node = it.value();
+                Ja::ReverbParams params{};
+                readField(node, "room_size", params.room_size);
+                readField(node, "damping", params.damping);
+                readField(node, "wet", params.wet);
+                reverbs_[NAME] = params;
+            }
+        }
+
+        std::cout << "[SoundEffectsConfig] " << echoes_.size() << " preset(s) de echo y "
+                  << reverbs_.size() << " de reverb desde " << file_path << "\n";
+    } catch (const std::exception& e) {
+        std::cerr << "[SoundEffectsConfig] error parseando " << file_path << ": " << e.what() << "\n";
+    }
+}
+
+auto SoundEffectsConfig::findEcho(const std::string& name) const -> const Ja::EchoParams* {
+    const auto IT = echoes_.find(name);
+    return (IT == echoes_.end()) ? nullptr : &IT->second;
+}
+
+auto SoundEffectsConfig::findReverb(const std::string& name) const -> const Ja::ReverbParams* {
+    const auto IT = reverbs_.find(name);
+    return (IT == reverbs_.end()) ? nullptr : &IT->second;
+}
diff --git a/source/core/audio/sound_effects_config.hpp b/source/core/audio/sound_effects_config.hpp
new file mode 100644
index 0000000..0b46015
--- /dev/null
+++ b/source/core/audio/sound_effects_config.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+#include "core/audio/jail_audio.hpp"  // Para Ja::EchoParams / Ja::ReverbParams
+
+// Catàleg de presets d'efectes carregat des de data/config/sounds.yaml. La capa
+// Audio (playSoundWithEcho/playSoundWithReverb) hi accedeix per nom: si el
+// preset no existeix, el so es reprodueix sec con un avís a stderr.
+//
+// Patró Meyers idèntic a UiConfig/Locale: un sol load() a l'arrencada, sense
+// hot-reload. Si el archivo no existeix, el catàleg queda buit (sin preset
+// disponible) i tots los playSoundWith* es comporten como playSound dry.
+class SoundEffectsConfig {
+   public:
+    static auto get() -> SoundEffectsConfig&;
+
+    SoundEffectsConfig(const SoundEffectsConfig&) = delete;
+    SoundEffectsConfig(SoundEffectsConfig&&) = delete;
+    auto operator=(const SoundEffectsConfig&) -> SoundEffectsConfig& = delete;
+    auto operator=(SoundEffectsConfig&&) -> SoundEffectsConfig& = delete;
+
+    void load(const std::string& file_path);
+
+    // Retorna nullptr si el preset no existeix.
+    [[nodiscard]] auto findEcho(const std::string& name) const -> const Ja::EchoParams*;
+    [[nodiscard]] auto findReverb(const std::string& name) const -> const Ja::ReverbParams*;
+
+   private:
+    SoundEffectsConfig() = default;
+    ~SoundEffectsConfig() = default;
+
+    std::unordered_map<std::string, Ja::EchoParams> echoes_;
+    std::unordered_map<std::string, Ja::ReverbParams> reverbs_;
+};
diff --git a/source/core/config/postfx_config.cpp b/source/core/config/postfx_config.cpp
new file mode 100644
index 0000000..c83bde7
--- /dev/null
+++ b/source/core/config/postfx_config.cpp
@@ -0,0 +1,108 @@
+// postfx_config.cpp - Implementación del cargador de YAML del postpro.
+
+#include "core/config/postfx_config.hpp"
+
+#include <iostream>
+
+#include "core/resources/resource_helper.hpp"
+#include "external/fkyaml_node.hpp"
+
+namespace Config::PostFx {
+
+namespace {
+
+// Helper: lee `key` en `node` solo si existe; deja `dst` intacto en caso
+// contrario. Así, un YAML parcial sigue funcionando con los defaults del
+// struct para los campos que falten.
+template <typename T>
+void readField(const fkyaml::node& node, const char* key, T& dst) {
+    if (node.contains(key)) {
+        dst = node[key].get_value<T>();
+    }
+}
+
+// Lee un array RGB [r, g, b] (0..255) y lo normaliza a [0..1] sobre tres
+// destinos floats. Si la clave no existe o no es secuencia de 3, deja los
+// destinos como están.
+void readRgb255(const fkyaml::node& node, const char* key,
+                float& dst_r, float& dst_g, float& dst_b) {
+    if (!node.contains(key)) {
+        return;
+    }
+    const auto& arr = node[key];
+    if (!arr.is_sequence() || arr.size() < 3) {
+        return;
+    }
+    try {
+        const auto R = arr[0].get_value<int>();
+        const auto G = arr[1].get_value<int>();
+        const auto B = arr[2].get_value<int>();
+        dst_r = static_cast<float>(R) / 255.0F;
+        dst_g = static_cast<float>(G) / 255.0F;
+        dst_b = static_cast<float>(B) / 255.0F;
+    } catch (...) {
+        // Mantiene los defaults si algún elemento no es entero.
+    }
+}
+
+}  // namespace
+
+auto load(const std::string& path) -> Rendering::GPU::PostFxParams {
+    Rendering::GPU::PostFxParams params{};  // valores por defecto del struct
+
+    auto bytes = Resource::Helper::loadFile(path);
+    if (bytes.empty()) {
+        std::cerr << "[PostFxConfig] No se pudo cargar " << path
+                  << " — usando defaults built-in\n";
+        return params;
+    }
+
+    try {
+        const auto* begin = reinterpret_cast<const char*>(bytes.data());
+        const auto* end = begin + bytes.size();
+        auto yaml = fkyaml::node::deserialize(begin, end);
+
+        if (yaml.contains("bloom") && yaml["bloom"].is_mapping()) {
+            const auto& node = yaml["bloom"];
+            readField(node, "enabled", params.bloom_enabled);
+            readField(node, "intensity", params.bloom_intensity);
+            readField(node, "threshold", params.bloom_threshold);
+            readField(node, "radius_px", params.bloom_radius_px);
+        }
+
+        if (yaml.contains("flicker") && yaml["flicker"].is_mapping()) {
+            const auto& node = yaml["flicker"];
+            readField(node, "enabled", params.flicker_enabled);
+            readField(node, "amplitude", params.flicker_amplitude);
+            readField(node, "frequency_hz", params.flicker_frequency_hz);
+        }
+
+        if (yaml.contains("background") && yaml["background"].is_mapping()) {
+            const auto& node = yaml["background"];
+            readField(node, "enabled", params.background_enabled);
+            readRgb255(node, "color_min",
+                       params.background_min_r,
+                       params.background_min_g,
+                       params.background_min_b);
+            readRgb255(node, "color_max",
+                       params.background_max_r,
+                       params.background_max_g,
+                       params.background_max_b);
+            readField(node, "pulse_frequency_hz", params.background_pulse_freq_hz);
+        }
+
+        std::cout << "[PostFxConfig] Cargado " << path
+                  << " (bloom=" << (params.bloom_enabled ? "on" : "off")
+                  << " intensity=" << params.bloom_intensity
+                  << ", flicker=" << (params.flicker_enabled ? "on" : "off")
+                  << " amp=" << params.flicker_amplitude
+                  << ", bg=" << (params.background_enabled ? "on" : "off")
+                  << ")\n";
+    } catch (const fkyaml::exception& e) {
+        std::cerr << "[PostFxConfig] Error parseando " << path << ": " << e.what()
+                  << " — usando defaults built-in\n";
+    }
+    return params;
+}
+
+}  // namespace Config::PostFx
diff --git a/source/core/config/postfx_config.hpp b/source/core/config/postfx_config.hpp
new file mode 100644
index 0000000..7e1f41b
--- /dev/null
+++ b/source/core/config/postfx_config.hpp
@@ -0,0 +1,21 @@
+// postfx_config.hpp - Carga de los parámetros del shader de postpro desde YAML.
+// © 2025 Orni Attack
+//
+// Lee `config/postfx.yaml` (dentro de resources.pack) y devuelve un struct
+// PostFxParams listo para pasar a GpuFrameRenderer::setPostFx(). Si el YAML
+// no existe o falla el parser, retorna los defaults built-in.
+
+#pragma once
+
+#include <string>
+
+#include "core/rendering/gpu/gpu_frame_renderer.hpp"
+
+namespace Config::PostFx {
+
+// Carga desde el resource pack. Path relativo dentro del pack (p.ej.
+// "config/postfx.yaml"). Si falla, devuelve un PostFxParams construido por
+// defecto (valores embebidos en el struct).
+[[nodiscard]] auto load(const std::string& path) -> Rendering::GPU::PostFxParams;
+
+}  // namespace Config::PostFx
diff --git a/source/core/defaults.hpp b/source/core/defaults.hpp
index 7f04d7a..da5552a 100644
--- a/source/core/defaults.hpp
+++ b/source/core/defaults.hpp
@@ -8,38 +8,38 @@
 namespace Defaults {
 // Configuración de ventana
 namespace Window {
-constexpr int WIDTH = 640;
-constexpr int HEIGHT = 480;
-constexpr int MIN_WIDTH = 320;  // Mínimo: mitad del original
-constexpr int MIN_HEIGHT = 240;
+constexpr int WIDTH = 1280;
+constexpr int HEIGHT = 720;
+constexpr int MIN_WIDTH = 640;   // Mínimo: mitad del baseline (16:9)
+constexpr int MIN_HEIGHT = 360;
 // Zoom system
-constexpr float BASE_ZOOM = 1.0F;       // 640x480 baseline
-constexpr float MIN_ZOOM = 0.5F;        // 320x240 minimum
+constexpr float BASE_ZOOM = 1.0F;       // 1280x720 baseline (16:9)
+constexpr float MIN_ZOOM = 0.5F;        // 640x360 minimum
 constexpr float ZOOM_INCREMENT = 0.1F;  // 10% steps (F1/F2)
-constexpr bool FULLSCREEN = true;       // Pantalla completa activadapor defecto
+constexpr bool FULLSCREEN = true;       // Pantalla completa activada por defecto
 }  // namespace Window
 
-// Dimensions base del joc (coordenades lògiques)
+// Dimensiones base del juego (coordenadas lógicas, 16:9)
 namespace Game {
-constexpr int WIDTH = 640;
-constexpr int HEIGHT = 480;
+constexpr int WIDTH = 1280;
+constexpr int HEIGHT = 720;
 }  // namespace Game
 
-// Zones del joc (SDL_FRect amb càlculs automàtics basat en percentatges)
+// Zones del juego (SDL_FRect con cálculos automáticos basat en porcentajes)
 namespace Zones {
 // --- CONFIGURACIÓ DE PORCENTATGES ---
-// Totes les zones definides com a percentatges de Game::WIDTH (640) i Game::HEIGHT (480)
+// Todas las zones definides como a porcentajes de Game::WIDTH (640) i Game::HEIGHT (480)
 
-// Percentatges d'alçada (divisió vertical)
+// Percentatges de height (divisió vertical)
 constexpr float SCOREBOARD_TOP_HEIGHT_PERCENT = 0.02F;     // 10% superior
 constexpr float MAIN_PLAYAREA_HEIGHT_PERCENT = 0.88F;      // 80% central
 constexpr float SCOREBOARD_BOTTOM_HEIGHT_PERCENT = 0.10F;  // 10% inferior
 
-// Padding horizontal per a PLAYAREA (dins de MAIN_PLAYAREA)
+// Padding horizontal para PLAYAREA (dentro de MAIN_PLAYAREA)
 constexpr float PLAYAREA_PADDING_HORIZONTAL_PERCENT = 0.015F;  // 5% a cada costat
 
 // --- CÀLCULS AUTOMÀTICS DE PÍXELS ---
-// Càlculs automàtics a partir dels percentatges
+// Cálculos automáticos a partir dels porcentajes
 
 // Alçades
 constexpr float SCOREBOARD_TOP_H = Game::HEIGHT * SCOREBOARD_TOP_HEIGHT_PERCENT;
@@ -56,44 +56,44 @@ constexpr float PLAYAREA_PADDING_H = Game::WIDTH * PLAYAREA_PADDING_HORIZONTAL_P
 
 // --- ZONES FINALS (SDL_FRect) ---
 
-// Marcador superior (reservat per a futur ús)
-// Ocupa: 10% superior (0-48px)
+// Marcador superior (reservado para futuro uso)
+// Ocupa el 2% superior
 constexpr SDL_FRect SCOREBOARD_TOP = {
     0.0F,                             // x = 0.0
     SCOREBOARD_TOP_Y,                 // y = 0.0
-    static_cast<float>(Game::WIDTH),  // w = 640.0
-    SCOREBOARD_TOP_H                  // h = 48.0
+    static_cast<float>(Game::WIDTH),  // ancho completo
+    SCOREBOARD_TOP_H                  // alto
 };
 
-// Àrea de joc principal (contenidor del 80% central, sense padding)
-// Ocupa: 10-90% (48-432px), ample complet
+// Área de juego principal (contenedor del 80% central, sin padding)
+// Ocupa el 88% central, ancho completo
 constexpr SDL_FRect MAIN_PLAYAREA = {
     0.0F,                             // x = 0.0
-    MAIN_PLAYAREA_Y,                  // y = 48.0
-    static_cast<float>(Game::WIDTH),  // w = 640.0
-    MAIN_PLAYAREA_H                   // h = 384.0
+    MAIN_PLAYAREA_Y,                  // debajo del scoreboard superior
+    static_cast<float>(Game::WIDTH),  // ancho completo
+    MAIN_PLAYAREA_H                   // alto
 };
 
-// Zona de joc real (amb padding horizontal del 5%)
-// Ocupa: dins de MAIN_PLAYAREA, amb marges laterals
-// S'utilitza per a límits del joc, col·lisions, spawn
+// Zona de juego real (con padding horizontal del 5%)
+// Ocupa: dentro de MAIN_PLAYAREA, con márgenes laterales
+// Se utiliza para límites del juego, colisiones, spawn
 constexpr SDL_FRect PLAYAREA = {
-    PLAYAREA_PADDING_H,                         // x = 32.0
-    MAIN_PLAYAREA_Y,                            // y = 48.0 (igual que MAIN_PLAYAREA)
-    Game::WIDTH - (2.0F * PLAYAREA_PADDING_H),  // w = 576.0
-    MAIN_PLAYAREA_H                             // h = 384.0 (igual que MAIN_PLAYAREA)
+    PLAYAREA_PADDING_H,                         // padding horizontal
+    MAIN_PLAYAREA_Y,                            // debajo del scoreboard superior (igual que MAIN_PLAYAREA)
+    Game::WIDTH - (2.0F * PLAYAREA_PADDING_H),  // ancho con padding
+    MAIN_PLAYAREA_H                             // alto (igual que MAIN_PLAYAREA)
 };
 
 // Marcador inferior (marcador actual)
-// Ocupa: 10% inferior (432-480px)
+// Ocupa el 10% inferior
 constexpr SDL_FRect SCOREBOARD = {
     0.0F,                             // x = 0.0
-    SCOREBOARD_BOTTOM_Y,              // y = 432.0
-    static_cast<float>(Game::WIDTH),  // w = 640.0
-    SCOREBOARD_BOTTOM_H               // h = 48.0
+    SCOREBOARD_BOTTOM_Y,              // fondo
+    static_cast<float>(Game::WIDTH),  // ancho completo
+    SCOREBOARD_BOTTOM_H               // alto
 };
 
-// Padding horizontal del marcador (per alinear zones esquerra/dreta amb PLAYAREA)
+// Padding horizontal del marcador (para alinear zonas izquierda/derecha con PLAYAREA)
 constexpr float SCOREBOARD_PADDING_H = 0.0F;  // Game::WIDTH * 0.015f;
 }  // namespace Zones
 
@@ -101,14 +101,24 @@ constexpr float SCOREBOARD_PADDING_H = 0.0F;  // Game::WIDTH * 0.015f;
 namespace Entities {
 constexpr int MAX_ORNIS = 15;
 constexpr int MAX_BALES = 3;
-constexpr int MAX_IPUNTS = 30;
 
 constexpr float SHIP_RADIUS = 12.0F;
 constexpr float ENEMY_RADIUS = 20.0F;
 constexpr float BULLET_RADIUS = 3.0F;
 }  // namespace Entities
 
-// Ship (nave del jugador)
+// Paleta semántica por tipo de entidad. Si una entity declara color, lo
+// pasa al pipeline con alpha=255 (sentinela "color válido"); si no, se
+// usa el color global del oscilador (g_current_line_color).
+namespace Palette {
+constexpr SDL_Color SHIP        = {.r = 255, .g = 255, .b = 255, .a = 255};  // Blanco neutro
+constexpr SDL_Color BULLET      = {.r = 120, .g = 255, .b = 140, .a = 255};  // Verde laser
+constexpr SDL_Color PENTAGON    = {.r = 120, .g = 170, .b = 255, .a = 255};  // Azul "esquivador"
+constexpr SDL_Color QUADRAT     = {.r = 255, .g = 110, .b = 110, .a = 255};  // Rojo "tank"
+constexpr SDL_Color MOLINILLO   = {.r = 255, .g = 130, .b = 255, .a = 255};  // Magenta agresivo
+}  // namespace Palette
+
+// Ship (nave del player)
 namespace Ship {
 // Invulnerabilidad post-respawn
 constexpr float INVULNERABILITY_DURATION = 3.0F;  // Segundos de invulnerabilidad
@@ -144,7 +154,7 @@ constexpr float LEVEL_COMPLETED_TYPING_RATIO = 0.0F;  // 0.0 = sin typewriter (d
 constexpr float INIT_HUD_DURATION = 3.0F;  // Duración total del estado
 
 // Ratios de animación (inicio y fin como porcentajes del tiempo total)
-// RECT (rectángulo de marges)
+// RECT (rectángulo de márgenes)
 constexpr float INIT_HUD_RECT_RATIO_INIT = 0.30F;
 constexpr float INIT_HUD_RECT_RATIO_END = 0.85F;
 
@@ -152,11 +162,11 @@ constexpr float INIT_HUD_RECT_RATIO_END = 0.85F;
 constexpr float INIT_HUD_SCORE_RATIO_INIT = 0.60F;
 constexpr float INIT_HUD_SCORE_RATIO_END = 0.90F;
 
-// SHIP1 (nave jugador 1)
+// SHIP1 (nave player 1)
 constexpr float INIT_HUD_SHIP1_RATIO_INIT = 0.0F;
 constexpr float INIT_HUD_SHIP1_RATIO_END = 1.0F;
 
-// SHIP2 (nave jugador 2)
+// SHIP2 (nave player 2)
 constexpr float INIT_HUD_SHIP2_RATIO_INIT = 0.20F;
 constexpr float INIT_HUD_SHIP2_RATIO_END = 1.0F;
 
@@ -212,21 +222,21 @@ constexpr float VELOCITY_SCALE = 20.0F;  // factor conversión frame→tiempo
 
 // Explosions (debris physics)
 namespace Debris {
-constexpr float VELOCITAT_BASE = 80.0F;      // Velocitat inicial (px/s)
+constexpr float VELOCITAT_BASE = 80.0F;      // Velocidad inicial (px/s)
 constexpr float VARIACIO_VELOCITAT = 40.0F;  // ±variació aleatòria (px/s)
 constexpr float ACCELERACIO = -60.0F;        // Fricció/desacceleració (px/s²)
-constexpr float ROTACIO_MIN = 0.1F;          // Rotació mínima (rad/s ~5.7°/s)
-constexpr float ROTACIO_MAX = 0.3F;          // Rotació màxima (rad/s ~17.2°/s)
+constexpr float ROTACIO_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 TEMPS_VIDA = 2.0F;           // Duració màxima (segons) - enemy/bullet debris
 constexpr float TEMPS_VIDA_NAU = 3.0F;       // Ship debris lifetime (matches DEATH_DURATION)
 constexpr float SHRINK_RATE = 0.5F;          // Reducció de mida (factor/s)
 
-// Herència de velocitat angular (trayectorias curvas)
+// Herència de velocity angular (trayectorias curvas)
 constexpr float FACTOR_HERENCIA_MIN = 0.7F;  // Mínimo 70% del drotacio heredat
 constexpr float FACTOR_HERENCIA_MAX = 1.0F;  // Màxim 100% del drotacio heredat
 constexpr float FRICCIO_ANGULAR = 0.5F;      // Desacceleració angular (rad/s²)
 
-// Angular velocity cap for trajectory inheritance
+// 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)
@@ -238,59 +248,46 @@ namespace Math {
 constexpr float PI = std::numbers::pi_v<float>;
 }  // namespace Math
 
-// Colores (oscilación para efecto CRT)
-namespace Color {
-// Frecuencia de oscilación
-constexpr float FREQUENCY = 6.0F;  // 1 Hz (1 ciclo/segundo)
+// La antigua oscilación CPU (namespace Color) se ha migrado al shader de
+// postpro. Los parámetros de flicker / background pulse viven ahora en
+// data/config/postfx.yaml y se aplican en shaders/postfx.frag.glsl.
 
-// Color de líneas (efecto fósforo verde CRT)
-constexpr uint8_t LINE_MIN_R = 100;  // Verde oscuro
-constexpr uint8_t LINE_MIN_G = 200;
-constexpr uint8_t LINE_MIN_B = 100;
-
-constexpr uint8_t LINE_MAX_R = 100;  // Verde brillante
-constexpr uint8_t LINE_MAX_G = 255;
-constexpr uint8_t LINE_MAX_B = 100;
-
-// Color de fondo (pulso sutil verde oscuro)
-constexpr uint8_t BACKGROUND_MIN_R = 0;  // Negro
-constexpr uint8_t BACKGROUND_MIN_G = 5;
-constexpr uint8_t BACKGROUND_MIN_B = 0;
-
-constexpr uint8_t BACKGROUND_MAX_R = 0;  // Verde muy oscuro
-constexpr uint8_t BACKGROUND_MAX_G = 15;
-constexpr uint8_t BACKGROUND_MAX_B = 0;
-}  // namespace Color
-
-// Brillantor (control de intensitat per cada tipus d'entitat)
+// Brillantor (control de intensitat per cada type de entidad)
 namespace Brightness {
-// Brillantor estàtica per entitats de joc (0.0-1.0)
-constexpr float NAU = 1.0F;     // Màxima visibilitat (jugador)
+// Brillantor estàtica per entidades de juego (0.0-1.0)
+constexpr float NAU = 1.0F;     // Màxima visibilitat (player)
 constexpr float ENEMIC = 0.7F;  // 30% més tènue (destaca menys)
 constexpr float BALA = 1.0F;    // Brillo a tope (màxima visibilitat)
 
-// Starfield: gradient segons distància al centre
-// distancia_centre: 0.0 (centre) → 1.0 (vora pantalla)
+// Starfield: gradient segons distancia al centro
+// distancia_centre: 0.0 (centro) → 1.0 (vora pantalla)
 // brightness = MIN + (MAX - MIN) * distancia_centre
-constexpr float STARFIELD_MIN = 0.3F;  // Estrelles llunyanes (prop del centre)
+constexpr float STARFIELD_MIN = 0.3F;  // Estrelles llunyanes (prop del centro)
 constexpr float STARFIELD_MAX = 0.8F;  // Estrelles properes (vora pantalla)
 }  // namespace Brightness
 
-// Renderització (V-Sync i altres opcions de render)
+// Renderització (V-Sync i altres opciones de render)
 namespace Rendering {
 constexpr int VSYNC_DEFAULT = 1;  // 0=disabled, 1=enabled
 }  // namespace Rendering
 
-// Audio (sistema de so i música)
+// Audio (sistema de sonido y música) — usado por Audio::Config en init()
 namespace Audio {
-constexpr float VOLUME = 1.0F;  // Volumen maestro (0.0 a 1.0)
-constexpr bool ENABLED = true;  // Audio habilitado por defecto
+constexpr bool ENABLED = true;        // Audio habilitado por defecto
+constexpr float VOLUME = 1.0F;        // Volumen maestro (0..1)
+constexpr bool MUSIC_ENABLED = true;  // Música habilitada
+constexpr float MUSIC_VOLUME = 0.8F;  // Volumen música (0..1)
+constexpr bool SOUND_ENABLED = true;  // Efectos habilitados
+constexpr float SOUND_VOLUME = 1.0F;  // Volumen efectos (0..1)
+constexpr float VOLUME_STEP = 0.05F;  // Paso UI (5%)
+constexpr int FREQUENCY = 48000;      // Frecuencia de muestreo (Hz)
+constexpr int CROSSFADE_MS = 1500;    // Crossfade por defecto entre pistas (ms)
+constexpr SDL_AudioFormat FORMAT = SDL_AUDIO_S16;  // PCM 16-bit signed nativo
+constexpr int CHANNELS = 2;           // Estéreo
 }  // namespace Audio
 
 // Música (pistas de fondo)
 namespace Music {
-constexpr float VOLUME = 0.8F;                    // Volumen música
-constexpr bool ENABLED = true;                    // Música habilitada
 constexpr const char* GAME_TRACK = "game.ogg";    // Pista de juego
 constexpr const char* TITLE_TRACK = "title.ogg";  // Pista de titulo
 constexpr int FADE_DURATION_MS = 1000;            // Fade out duration
@@ -298,8 +295,6 @@ constexpr int FADE_DURATION_MS = 1000;            // Fade out duration
 
 // Efectes de so (sons puntuals)
 namespace Sound {
-constexpr float VOLUME = 1.0F;                                               // Volumen efectos
-constexpr bool ENABLED = true;                                               // Sonidos habilitados
 constexpr const char* CONTINUE = "effects/continue.wav";                     // Cuenta atras
 constexpr const char* EXPLOSION = "effects/explosion.wav";                   // Explosión
 constexpr const char* EXPLOSION2 = "effects/explosion2.wav";                 // Explosión alternativa
@@ -307,7 +302,7 @@ constexpr const char* FRIENDLY_FIRE_HIT = "effects/friendly_fire.wav";       //
 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
-constexpr const char* START = "effects/start.wav";                           // El jugador pulsa START
+constexpr const char* START = "effects/start.wav";                           // El player pulsa START
 constexpr const char* GOOD_JOB_COMMANDER = "voices/good_job_commander.wav";  // Voz: "Good job, commander"
 }  // namespace Sound
 
@@ -328,7 +323,7 @@ constexpr SDL_Keycode SHOOT = SDLK_LSHIFT;
 }  // namespace P2
 }  // namespace Controls
 
-// Enemy type configuration (tipus d'enemics)
+// Enemy type configuration (type de enemigos)
 namespace Enemies {
 // Pentagon (esquivador - zigzag evasion)
 namespace Pentagon {
@@ -340,15 +335,15 @@ constexpr float DROTACIO_MAX = 3.75F;      // Max visual rotation (rad/s) [+50%]
 constexpr const char* SHAPE_FILE = "enemy_pentagon.shp";
 }  // namespace Pentagon
 
-// Quadrat (perseguidor - tracks player)
-namespace Quadrat {
+// Cuadrado (perseguidor - tracks player)
+namespace Cuadrado {
 constexpr float VELOCITAT = 40.0F;         // px/s (medium speed)
 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 DROTACIO_MAX = 1.5F;       // [+50%]
 constexpr const char* SHAPE_FILE = "enemy_square.shp";
-}  // namespace Quadrat
+}  // namespace Cuadrado
 
 // Molinillo (agressiu - fast straight lines, proximity spin-up)
 namespace Molinillo {
@@ -396,54 +391,54 @@ constexpr float INVULNERABILITY_SCALE_START = 0.0F;       // Invisible
 constexpr float INVULNERABILITY_SCALE_END = 1.0F;         // Full size
 }  // namespace Spawn
 
-// Scoring system (puntuació per tipus d'enemic)
+// Scoring system (puntuación per type de enemy)
 namespace Scoring {
-constexpr int PENTAGON_SCORE = 100;   // Pentàgon (esquivador, 35 px/s)
-constexpr int QUADRAT_SCORE = 150;    // Quadrat (perseguidor, 40 px/s)
+constexpr int PENTAGON_SCORE = 100;   // Pentágono (esquivador, 35 px/s)
+constexpr int QUADRAT_SCORE = 150;    // Cuadrado (perseguidor, 40 px/s)
 constexpr int MOLINILLO_SCORE = 200;  // Molinillo (agressiu, 50 px/s)
 }  // namespace Scoring
 
 }  // namespace Enemies
 
-// Title scene ship animations (naus 3D flotants a l'escena de títol)
+// Title scene ship animations (naves 3D flotantes a l'escena de título)
 namespace Title {
 namespace Ships {
 // ============================================================
 // PARÀMETRES BASE (ajustar aquí per experimentar)
 // ============================================================
 
-// 1. Escala global de les naus
+// 1. Escala global de las naves
 constexpr float SHIP_BASE_SCALE = 2.5F;  // Multiplicador (1.0 = mida original del .shp)
 
 // 2. Altura vertical (cercanía al centro)
 // Ratio Y desde el centro de la pantalla (0.0 = centro, 1.0 = bottom de pantalla)
 constexpr float TARGET_Y_RATIO = 0.15625F;
 
-// 3. Radio orbital (distancia radial desde centro en coordenadas polares)
-constexpr float CLOCK_RADIUS = 150.0F;  // Distància des del centre
+// 3. Radio orbital (distance radial desde centro en coordenadas polares)
+constexpr float CLOCK_RADIUS = 150.0F;  // Distancia des del centro
 
 // 4. Ángulos de posición (clock positions en coordenadas polares)
-// En coordenades de pantalla: 0° = dreta, 90° = baix, 180° = esquerra, 270° = dalt
+// En coordenadas de pantalla: 0° = derecha, 90° = baix, 180° = izquierda, 270° = dalt
 constexpr float CLOCK_8_ANGLE = 150.0F * Math::PI / 180.0F;  // 8 o'clock (bottom-left)
 constexpr float CLOCK_4_ANGLE = 30.0F * Math::PI / 180.0F;   // 4 o'clock (bottom-right)
 
-// 5. Radio máximo de la forma de la nave (para calcular offset automáticamente)
+// 5. Radio máximo de la shape de la nave (para calcular offset automáticamente)
 constexpr float SHIP_MAX_RADIUS = 30.0F;  // Radi del cercle circumscrit a ship_starfield.shp
 
 // 6. Margen de seguridad para offset de entrada
 constexpr float ENTRY_OFFSET_MARGIN = 227.5F;  // Para offset total de ~340px (ajustado)
 
 // ============================================================
-// VALORS DERIVATS (calculats automàticament - NO modificar)
+// VALORS DERIVATS (calculats automáticoament - NO modificar)
 // ============================================================
 
-// Centre de la pantalla (punt de referència)
-constexpr float CENTER_X = Game::WIDTH / 2.0F;   // 320.0f
-constexpr float CENTER_Y = Game::HEIGHT / 2.0F;  // 240.0f
+// Centro de la pantalla (point de referència)
+constexpr float CENTER_X = Game::WIDTH / 2.0F;   // auto-derivado de Game::WIDTH
+constexpr float CENTER_Y = Game::HEIGHT / 2.0F;  // auto-derivado de Game::HEIGHT
 
-// Posicions target (calculades dinàmicament des dels paràmetres base)
-// Nota: std::cos/sin no són constexpr en C++20, però funcionen en runtime
-// Les funcions inline són optimitzades pel compilador (zero overhead)
+// Posicions target (calculades dinàmicament des dels parámetros base)
+// Nota: std::cos/sin no són constexpr en C++20, pero funcionen en runtime
+// Les funciones inline són optimitzades por el compilador (zero overhead)
 inline float P1_TARGET_X() {
     return CENTER_X + (CLOCK_RADIUS * std::cos(CLOCK_8_ANGLE));
 }
@@ -457,27 +452,27 @@ inline float P2_TARGET_Y() {
     return CENTER_Y + ((Game::HEIGHT / 2.0F) * TARGET_Y_RATIO);
 }
 
-// Escales d'animació (relatives a SHIP_BASE_SCALE)
-constexpr float ENTRY_SCALE_START = 1.5F * SHIP_BASE_SCALE;  // Entrada: 50% més gran
-constexpr float FLOATING_SCALE = 1.0F * SHIP_BASE_SCALE;     // Flotant: escala base
+// Escales de animación (relatives a SHIP_BASE_SCALE)
+constexpr float ENTRY_SCALE_START = 1.5F * SHIP_BASE_SCALE;  // Entrada: 50% més grande
+constexpr float FLOATING_SCALE = 1.0F * SHIP_BASE_SCALE;     // Flotante: scale base
 
-// Offset d'entrada (ajustat automàticament a l'escala)
-// Fórmula: (radi màxim de la nau * escala d'entrada) + marge
+// Offset de entrada (ajustat automáticoament a l'scale)
+// Fórmula: (radi màxim de la ship * scale de entrada) + margen
 constexpr float ENTRY_OFFSET = (SHIP_MAX_RADIUS * ENTRY_SCALE_START) + ENTRY_OFFSET_MARGIN;
 
-// Punt de fuga (centre per a l'animació de sortida)
-constexpr float VANISHING_POINT_X = CENTER_X;  // 320.0f
-constexpr float VANISHING_POINT_Y = CENTER_Y;  // 240.0f
+// Vec2 de fuga (centro para l'animación de salida)
+constexpr float VANISHING_POINT_X = CENTER_X;  // auto-derivado de Game::WIDTH
+constexpr float VANISHING_POINT_Y = CENTER_Y;  // auto-derivado de Game::HEIGHT
 
 // ============================================================
 // ANIMACIONS (durades, oscil·lacions, delays)
 // ============================================================
 
-// Durades d'animació
+// Durades de animación
 constexpr float ENTRY_DURATION = 2.0F;  // Entrada (segons)
-constexpr float EXIT_DURATION = 1.0F;   // Sortida (segons)
+constexpr float EXIT_DURATION = 1.0F;   // Salida (segons)
 
-// Flotació (oscil·lació reduïda i diferenciada per nau)
+// Flotació (oscil·lació reduïda y diferenciada per ship)
 constexpr float FLOAT_AMPLITUDE_X = 4.0F;  // Amplitud X (píxels)
 constexpr float FLOAT_AMPLITUDE_Y = 2.5F;  // Amplitud Y (píxels)
 
@@ -486,21 +481,21 @@ constexpr float FLOAT_FREQUENCY_X_BASE = 0.5F;  // Hz
 constexpr float FLOAT_FREQUENCY_Y_BASE = 0.7F;  // Hz
 constexpr float FLOAT_PHASE_OFFSET = 1.57F;     // π/2 (90°)
 
-// Delays d'entrada (per a entrada escalonada)
+// Delays de entrada (per a entrada escalonada)
 constexpr float P1_ENTRY_DELAY = 0.0F;  // P1 entra immediatament
-constexpr float P2_ENTRY_DELAY = 0.5F;  // P2 entra 0.5s després
+constexpr float P2_ENTRY_DELAY = 0.5F;  // P2 entra 0.5s después
 
-// Delay global abans d'iniciar l'animació d'entrada al estat MAIN
-constexpr float ENTRANCE_DELAY = 5.0F;  // Temps d'espera abans que les naus entrin
+// 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 per a cada nau (variació sutil ±12%)
+// 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
 
 }  // namespace Ships
 
 namespace Layout {
-// Posicions verticals (anclatges des del TOP de pantalla lògica, 0.0-1.0)
+// Posicions verticals (anclatges des del TOP de pantalla lógica, 0.0-1.0)
 constexpr float LOGO_POS = 0.20F;         // Logo "ORNI"
 constexpr float PRESS_START_POS = 0.75F;  // "PRESS START TO PLAY"
 constexpr float COPYRIGHT1_POS = 0.90F;   // Primera línia copyright
@@ -509,21 +504,21 @@ constexpr float COPYRIGHT1_POS = 0.90F;   // Primera línia copyright
 constexpr float LOGO_LINE_SPACING = 0.02F;      // Entre "ORNI" i "ATTACK!" (10px)
 constexpr float COPYRIGHT_LINE_SPACING = 0.0F;  // Entre línies copyright (5px)
 
-// Factors d'escala
+// Factors de scale
 constexpr float LOGO_SCALE = 0.6F;         // Escala "ORNI ATTACK!"
 constexpr float PRESS_START_SCALE = 1.0F;  // Escala "PRESS START TO PLAY"
 constexpr float COPYRIGHT_SCALE = 0.5F;    // Escala copyright
 
-// Espaiat entre caràcters (usat per VectorText)
+// Espaiat entre caràcters (usado per VectorText)
 constexpr float TEXT_SPACING = 2.0F;
 }  // namespace Layout
 }  // namespace Title
 
-// Floating score numbers (números flotants de puntuació)
+// Floating score numbers (números flotantes de puntuación)
 namespace FloatingScore {
 constexpr float LIFETIME = 2.0F;      // Duració màxima (segons)
-constexpr float VELOCITY_Y = -30.0F;  // Velocitat vertical (px/s, negatiu = amunt)
-constexpr float VELOCITY_X = 0.0F;    // Velocitat horizontal (px/s)
+constexpr float VELOCITY_Y = -30.0F;  // Velocidad vertical (px/s, negatiu = amunt)
+constexpr float VELOCITY_X = 0.0F;    // Velocidad horizontal (px/s)
 constexpr float SCALE = 0.45F;        // Escala del text (0.6 = 60% del marcador)
 constexpr float SPACING = 0.0F;       // Espaiat entre caràcters
 constexpr int MAX_CONCURRENT = 15;    // Pool size (= MAX_ORNIS)
diff --git a/source/core/entities/entitat.hpp b/source/core/entities/entitat.hpp
deleted file mode 100644
index 1210d32..0000000
--- a/source/core/entities/entitat.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-// entitat.hpp - Classe base abstracta per a totes les entitats del joc
-// © 2025 Orni Attack - Arquitectura d'entitats
-
-#pragma once
-
-#include <SDL3/SDL.h>
-
-#include <memory>
-
-#include "core/graphics/shape.hpp"
-#include "core/types.hpp"
-
-namespace Entities {
-
-class Entitat {
-    public:
-        virtual ~Entitat() = default;
-
-        // Interfície principal (virtual pur)
-        virtual void inicialitzar() = 0;
-        virtual void actualitzar(float delta_time) = 0;
-        virtual void dibuixar() const = 0;
-        [[nodiscard]] virtual bool esta_actiu() const = 0;
-
-        // Interfície de col·lisió (override opcional)
-        [[nodiscard]] virtual float get_collision_radius() const { return 0.0F; }
-        [[nodiscard]] virtual bool es_collidable() const { return false; }
-
-        // Getters comuns (inline, sense overhead)
-        [[nodiscard]] const Punt& get_centre() const { return centre_; }
-        [[nodiscard]] float get_angle() const { return angle_; }
-        [[nodiscard]] float get_brightness() const { return brightness_; }
-        [[nodiscard]] const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
-
-    protected:
-        // Estat comú (accés directe, sense overhead)
-        SDL_Renderer* renderer_;
-        std::shared_ptr<Graphics::Shape> forma_;
-        Punt centre_;
-        float angle_{0.0F};
-        float brightness_{1.0F};
-
-        // Constructor protegit (classe abstracta)
-        Entitat(SDL_Renderer* renderer = nullptr)
-            : renderer_(renderer),
-              centre_({.x = 0.0F, .y = 0.0F}) {}
-};
-
-}  // namespace Entities
diff --git a/source/core/entities/entity.hpp b/source/core/entities/entity.hpp
new file mode 100644
index 0000000..47d3d13
--- /dev/null
+++ b/source/core/entities/entity.hpp
@@ -0,0 +1,72 @@
+// entity.hpp - Clase base abstracta para todas las entidades del juego
+// © 2025 Orni Attack - Arquitectura de entidades
+//
+// Cada Entity incluye un Physics::RigidBody como member. Las entidades que
+// se simulen físicamente lo configuran en init() y registran en el
+// PhysicsWorld del GameScene. Las que no, ignoran el body (queda con
+// defaults inocuos: mass=1, radius=0).
+//
+// Flujo por frame (gestionado por GameScene):
+//   1. entity.update(dt)        — aplicar fuerzas, decidir lógica
+//   2. world.update(dt)         — integrar bodies, resolver colisiones
+//   3. entity.postUpdate(dt)    — sincronizar mirror (center_, angle_)
+
+#pragma once
+
+#include <memory>
+
+#include "core/graphics/shape.hpp"
+#include "core/physics/rigid_body.hpp"
+#include "core/rendering/render_context.hpp"
+#include "core/types.hpp"
+
+namespace Entities {
+
+class Entity {
+    public:
+        virtual ~Entity() = default;
+
+        // Interfaz principal (virtual pur)
+        virtual void init() = 0;
+        virtual void update(float delta_time) = 0;
+        virtual void draw() const = 0;
+        [[nodiscard]] virtual bool isActive() const = 0;
+
+        // Sincronización post-física (override opcional).
+        // Llamado por GameScene tras world.update(). Default: no-op.
+        virtual void postUpdate(float /*delta_time*/) {}
+
+        // Interfaz de colisión (override opcional)
+        [[nodiscard]] virtual float getCollisionRadius() const { return 0.0F; }
+        [[nodiscard]] virtual bool isCollidable() const { return false; }
+
+        // Getters comunes (inline, sin overhead)
+        [[nodiscard]] const Vec2& getCenter() const { return center_; }
+        [[nodiscard]] float getAngle() const { return angle_; }
+        [[nodiscard]] float getBrightness() const { return brightness_; }
+        [[nodiscard]] const std::shared_ptr<Graphics::Shape>& getShape() const { return shape_; }
+
+        // Acceso al cuerpo físico (Fase 6+). El PhysicsWorld lo registra
+        // por puntero; la entidad lo configura en init().
+        [[nodiscard]] auto getBody() -> Physics::RigidBody& { return body_; }
+        [[nodiscard]] auto getBody() const -> const Physics::RigidBody& { return body_; }
+
+    protected:
+        // Estado común (acceso directo, sin overhead)
+        Rendering::Renderer* renderer_;
+        std::shared_ptr<Graphics::Shape> shape_;
+        Vec2 center_;
+        float angle_{0.0F};
+        float brightness_{1.0F};
+
+        // Cuerpo físico (Fase 6). Las entidades que se mueven por
+        // física actualizan center_/angle_ en postUpdate() desde body_.
+        Physics::RigidBody body_;
+
+        // Constructor protegido (clase abstracta)
+        Entity(Rendering::Renderer* renderer = nullptr)
+            : renderer_(renderer),
+              center_({.x = 0.0F, .y = 0.0F}) {}
+};
+
+}  // namespace Entities
diff --git a/source/core/graphics/shape.cpp b/source/core/graphics/shape.cpp
index dc218bb..a647864 100644
--- a/source/core/graphics/shape.cpp
+++ b/source/core/graphics/shape.cpp
@@ -1,5 +1,5 @@
 // shape.cpp - Implementació del sistema de formes vectorials
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #include "core/graphics/shape.hpp"
 
@@ -11,31 +11,31 @@
 namespace Graphics {
 
 Shape::Shape(const std::string& filepath)
-    : centre_({.x = 0.0F, .y = 0.0F}),
+    : center_({.x = 0.0F, .y = 0.0F}),
       escala_defecte_(1.0F),
       nom_("unnamed") {
-    carregar(filepath);
+    load(filepath);
 }
 
-bool Shape::carregar(const std::string& filepath) {
-    // Llegir fitxer
+bool Shape::load(const std::string& filepath) {
+    // Llegir file
     std::ifstream file(filepath);
     if (!file.is_open()) {
         std::cerr << "[Shape] Error: no es pot obrir " << filepath << '\n';
         return false;
     }
 
-    // Llegir tot el contingut
+    // Llegir todo el contingut
     std::stringstream buffer;
     buffer << file.rdbuf();
     std::string contingut = buffer.str();
     file.close();
 
     // Parsejar
-    return parsejar_fitxer(contingut);
+    return parseFile(contingut);
 }
 
-bool Shape::parsejar_fitxer(const std::string& contingut) {
+bool Shape::parseFile(const std::string& contingut) {
     std::istringstream iss(contingut);
     std::string line;
 
@@ -55,7 +55,7 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
             try {
                 escala_defecte_ = std::stof(extract_value(line));
             } catch (...) {
-                std::cerr << "[Shape] Warning: escala invàlida, usant 1.0" << '\n';
+                std::cerr << "[Shape] Warning: scale invàlida, usant 1.0" << '\n';
                 escala_defecte_ = 1.0F;
             }
         } else if (starts_with(line, "center:")) {
@@ -65,7 +65,7 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
             if (points.size() >= 2) {
                 primitives_.push_back({PrimitiveType::POLYLINE, points});
             } else {
-                std::cerr << "[Shape] Warning: polyline amb menys de 2 punts ignorada"
+                std::cerr << "[Shape] Warning: polyline con menys de 2 points ignorada"
                           << '\n';
             }
         } else if (starts_with(line, "line:")) {
@@ -73,7 +73,7 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
             if (points.size() == 2) {
                 primitives_.push_back({PrimitiveType::LINE, points});
             } else {
-                std::cerr << "[Shape] Warning: line ha de tenir exactament 2 punts"
+                std::cerr << "[Shape] Warning: line ha de tenir exactament 2 points"
                           << '\n';
             }
         }
@@ -81,7 +81,7 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
     }
 
     if (primitives_.empty()) {
-        std::cerr << "[Shape] Error: cap primitiva carregada" << '\n';
+        std::cerr << "[Shape] Error: sin primitiva carregada" << '\n';
         return false;
     }
 
@@ -124,18 +124,18 @@ void Shape::parse_center(const std::string& value) {
     size_t comma = val.find(',');
     if (comma != std::string::npos) {
         try {
-            centre_.x = std::stof(trim(val.substr(0, comma)));
-            centre_.y = std::stof(trim(val.substr(comma + 1)));
+            center_.x = std::stof(trim(val.substr(0, comma)));
+            center_.y = std::stof(trim(val.substr(comma + 1)));
         } catch (...) {
-            std::cerr << "[Shape] Warning: centre invàlid, usant (0,0)" << '\n';
-            centre_ = {.x = 0.0F, .y = 0.0F};
+            std::cerr << "[Shape] Warning: centro invàlid, usant (0,0)" << '\n';
+            center_ = {.x = 0.0F, .y = 0.0F};
         }
     }
 }
 
 // Helper: parse points "x1,y1  x2,y2  x3,y3"
-std::vector<Punt> Shape::parse_points(const std::string& str) const {
-    std::vector<Punt> points;
+std::vector<Vec2> Shape::parse_points(const std::string& str) const {
+    std::vector<Vec2> points;
     std::istringstream iss(trim(str));
     std::string pair;
 
@@ -147,7 +147,7 @@ std::vector<Punt> Shape::parse_points(const std::string& str) const {
                 float y = std::stof(pair.substr(comma + 1));
                 points.push_back({x, y});
             } catch (...) {
-                std::cerr << "[Shape] Warning: punt invàlid ignorat: " << pair
+                std::cerr << "[Shape] Warning: point invàlid ignorat: " << pair
                           << '\n';
             }
         }
diff --git a/source/core/graphics/shape.hpp b/source/core/graphics/shape.hpp
index 4f13f36..7836328 100644
--- a/source/core/graphics/shape.hpp
+++ b/source/core/graphics/shape.hpp
@@ -1,5 +1,5 @@
 // shape.hpp - Sistema de formes vectorials
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
 
@@ -10,38 +10,38 @@
 
 namespace Graphics {
 
-// Tipus de primitiva dins d'una forma
+// Tipo de primitiva dins de una shape
 enum class PrimitiveType {
-    POLYLINE,  // Seqüència de punts connectats
-    LINE       // Línia individual (2 punts)
+    POLYLINE,  // Secuencia de points connectats
+    LINE       // Línia individual (2 points)
 };
 
 // Primitiva individual (polyline o line)
 struct ShapePrimitive {
         PrimitiveType type;
-        std::vector<Punt> points;  // 2+ punts per polyline, exactament 2 per line
+        std::vector<Vec2> points;  // 2+ points per polyline, exactament 2 per line
 };
 
-// Classe Shape - representa una forma vectorial carregada des de .shp
+// Clase Shape - representa una shape vectorial carregada desde .shp
 class Shape {
     public:
         // Constructors
         Shape() = default;
         explicit Shape(const std::string& filepath);
 
-        // Carregar forma des de fitxer .shp
-        bool carregar(const std::string& filepath);
+        // Carregar shape desde file .shp
+        bool load(const std::string& filepath);
 
-        // Parsejar forma des de buffer de memòria (per al sistema de recursos)
-        bool parsejar_fitxer(const std::string& contingut);
+        // Parsejar shape desde buffer de memòria (per al sistema de recursos)
+        bool parseFile(const std::string& contingut);
 
         // Getters
         [[nodiscard]] const std::vector<ShapePrimitive>& get_primitives() const {
             return primitives_;
         }
-        [[nodiscard]] const Punt& get_centre() const { return centre_; }
+        [[nodiscard]] const Vec2& getCenter() const { return center_; }
         [[nodiscard]] float get_escala_defecte() const { return escala_defecte_; }
-        [[nodiscard]] bool es_valida() const { return !primitives_.empty(); }
+        [[nodiscard]] bool isValid() const { return !primitives_.empty(); }
 
         // Info de depuració
         [[nodiscard]] std::string get_nom() const { return nom_; }
@@ -49,16 +49,16 @@ class Shape {
 
     private:
         std::vector<ShapePrimitive> primitives_;
-        Punt centre_;           // Centre/origen de la forma
+        Vec2 center_;           // Centro/origin de la shape
         float escala_defecte_;  // Escala per defecte (normalment 1.0)
-        std::string nom_;       // Nom de la forma (per depuració)
+        std::string nom_;       // Nom de la shape (per depuració)
 
         // Helpers privats per parsejar
         [[nodiscard]] std::string trim(const std::string& str) const;
         [[nodiscard]] bool starts_with(const std::string& str, const std::string& prefix) const;
         [[nodiscard]] std::string extract_value(const std::string& line) const;
         void parse_center(const std::string& value);
-        [[nodiscard]] std::vector<Punt> parse_points(const std::string& str) const;
+        [[nodiscard]] std::vector<Vec2> parse_points(const std::string& str) const;
 };
 
 }  // namespace Graphics
diff --git a/source/core/graphics/shape_loader.cpp b/source/core/graphics/shape_loader.cpp
index 99a7f5d..27f74e2 100644
--- a/source/core/graphics/shape_loader.cpp
+++ b/source/core/graphics/shape_loader.cpp
@@ -1,5 +1,5 @@
-// shape_loader.cpp - Implementació del carregador amb caché
-// © 2025 Port a C++20 amb SDL3
+// shape_loader.cpp - Implementació del carregador con caché
+// © 2025 Port a C++20 con SDL3
 
 #include "core/graphics/shape_loader.hpp"
 
@@ -9,7 +9,7 @@
 
 namespace Graphics {
 
-// Inicialització de variables estàtiques
+// Inicialización de variables estàtiques
 std::unordered_map<std::string, std::shared_ptr<Shape>> ShapeLoader::cache_;
 std::string ShapeLoader::base_path_ = "data/shapes/";
 
@@ -32,7 +32,7 @@ std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
     // Load from resource system
     std::vector<uint8_t> data = Resource::Helper::loadFile(normalized);
     if (data.empty()) {
-        std::cerr << "[ShapeLoader] Error: no s'ha pogut carregar " << normalized
+        std::cerr << "[ShapeLoader] Error: no s'ha pogut load " << normalized
                   << '\n';
         return nullptr;
     }
@@ -40,15 +40,15 @@ std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
     // Convert bytes to string and parse
     std::string file_content(data.begin(), data.end());
     auto shape = std::make_shared<Shape>();
-    if (!shape->parsejar_fitxer(file_content)) {
+    if (!shape->parseFile(file_content)) {
         std::cerr << "[ShapeLoader] Error: no s'ha pogut parsejar " << normalized
                   << '\n';
         return nullptr;
     }
 
     // Verify shape is valid
-    if (!shape->es_valida()) {
-        std::cerr << "[ShapeLoader] Error: forma invàlida " << normalized << '\n';
+    if (!shape->isValid()) {
+        std::cerr << "[ShapeLoader] Error: shape invàlida " << normalized << '\n';
         return nullptr;
     }
 
@@ -69,17 +69,17 @@ void ShapeLoader::clear_cache() {
 size_t ShapeLoader::get_cache_size() { return cache_.size(); }
 
 std::string ShapeLoader::resolve_path(const std::string& filename) {
-    // Si és un path absolut (comença amb '/'), usar-lo directament
+    // Si es un path absolut (comença con '/'), usar-lo directament
     if (!filename.empty() && filename[0] == '/') {
         return filename;
     }
 
-    // Si ja conté el prefix base_path, usar-lo directament
+    // Si ya conté el prefix base_path, usar-lo directament
     if (filename.starts_with(base_path_)) {
         return filename;
     }
 
-    // Altrament, afegir base_path (ara suporta subdirectoris)
+    // Altrament, añadir base_path (ara suporta subdirectoris)
     return base_path_ + filename;
 }
 
diff --git a/source/core/graphics/shape_loader.hpp b/source/core/graphics/shape_loader.hpp
index d606c0a..9f14c4c 100644
--- a/source/core/graphics/shape_loader.hpp
+++ b/source/core/graphics/shape_loader.hpp
@@ -1,5 +1,5 @@
-// shape_loader.hpp - Carregador estàtic de formes amb caché
-// © 2025 Port a C++20 amb SDL3
+// shape_loader.hpp - Carregador estàtic de formes con caché
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
 
@@ -11,13 +11,13 @@
 
 namespace Graphics {
 
-// Carregador estàtic de formes amb caché
+// Carregador estàtic de formes con caché
 class ShapeLoader {
     public:
         // No instanciable (tot estàtic)
         ShapeLoader() = delete;
 
-        // Carregar forma des de fitxer (amb caché)
+        // Carregar shape desde file (con caché)
         // Retorna punter compartit (nullptr si error)
         // Exemple: load("ship.shp") → busca a "data/shapes/ship.shp"
         static std::shared_ptr<Shape> load(const std::string& filename);
diff --git a/source/core/graphics/starfield.cpp b/source/core/graphics/starfield.cpp
index 945171f..632fa91 100644
--- a/source/core/graphics/starfield.cpp
+++ b/source/core/graphics/starfield.cpp
@@ -1,4 +1,4 @@
-// starfield.cpp - Implementació del sistema d'estrelles de fons
+// starfield.cpp - Implementació del sistema de estrelles de fons
 // © 2025 Orni Attack
 
 #include "core/graphics/starfield.hpp"
@@ -14,38 +14,38 @@
 namespace Graphics {
 
 // Constructor
-Starfield::Starfield(SDL_Renderer* renderer,
-    const Punt& punt_fuga,
+Starfield::Starfield(Rendering::Renderer* renderer,
+    const Vec2& punt_fuga,
     const SDL_FRect& area,
     int densitat)
     : renderer_(renderer),
       punt_fuga_(punt_fuga),
       area_(area),
       densitat_(densitat) {
-    // Carregar forma d'estrella amb ShapeLoader
+    // Carregar shape de estrella con ShapeLoader
     shape_estrella_ = ShapeLoader::load("star.shp");
 
-    if (!shape_estrella_ || !shape_estrella_->es_valida()) {
-        std::cerr << "ERROR: No s'ha pogut carregar star.shp" << '\n';
+    if (!shape_estrella_ || !shape_estrella_->isValid()) {
+        std::cerr << "ERROR: No s'ha pogut load star.shp" << '\n';
         return;
     }
 
-    // Configurar 3 capes amb diferents velocitats i escales
-    // Capa 0: Fons llunyà (lenta, petita)
+    // Configurar 3 capes con diferents velocitats i escales
+    // Capa 0: Fons llunyà (lenta, pequeña)
     capes_.push_back({20.0F, 0.3F, 0.8F, densitat / 3});
 
     // Capa 1: Profunditat mitjana
     capes_.push_back({40.0F, 0.5F, 1.2F, densitat / 3});
 
-    // Capa 2: Primer pla (ràpida, gran)
+    // Capa 2: Primer pla (ràpida, grande)
     capes_.push_back({80.0F, 0.8F, 2.0F, densitat / 3});
 
-    // Calcular radi màxim (distància del centre al racó més llunyà)
+    // 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 amb posicions distribuïdes (pre-omplir pantalla)
+    // 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++) {
@@ -55,55 +55,55 @@ Starfield::Starfield(SDL_Renderer* renderer,
             // Angle aleatori
             estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0F * Defaults::Math::PI;
 
-            // Distància aleatòria (0.0 a 1.0) per omplir tota la pantalla
+            // Distancia aleatòria (0.0 a 1.0) per omplir toda la pantalla
             estrella.distancia_centre = static_cast<float>(rand()) / RAND_MAX;
 
-            // Calcular posició des de la distància
+            // Calcular posición desde la distancia
             float radi = estrella.distancia_centre * radi_max_;
-            estrella.posicio.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
-            estrella.posicio.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
+            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 (nova o regenerada)
+// Inicialitzar una estrella (nueva o regenerada)
 void Starfield::inicialitzar_estrella(Estrella& estrella) const {
-    // Angle aleatori des del punt de fuga cap a fora
+    // Angle aleatori des del point de fuga hacia fuera
     estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0F * Defaults::Math::PI;
 
-    // Distància inicial petita (5% del radi màxim) - neix prop del centre
+    // Distancia inicial pequeña (5% del radi màxim) - neix prop del centro
     estrella.distancia_centre = 0.05F;
 
-    // Posició inicial: molt prop del punt de fuga
+    // Posición inicial: mucho prop del point de fuga
     float radi = estrella.distancia_centre * radi_max_;
-    estrella.posicio.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
-    estrella.posicio.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
+    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à fora de l'àrea
+// Verificar si una estrella está fuera de l'àrea
 bool Starfield::fora_area(const Estrella& estrella) const {
-    return (estrella.posicio.x < area_.x ||
-        estrella.posicio.x > area_.x + area_.w ||
-        estrella.posicio.y < area_.y ||
-        estrella.posicio.y > area_.y + area_.h);
+    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 escala dinàmica segons distància del centre
+// Calcular scale dinàmica segons distancia del centro
 float Starfield::calcular_escala(const Estrella& estrella) const {
     const CapaConfig& capa = capes_[estrella.capa];
 
-    // Interpolació lineal basada en distància del centre
-    // distancia_centre: 0.0 (centre) → 1.0 (vora)
+    // 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 distància del centre
+// Calcular brightness dinàmica segons distancia del centro
 float Starfield::calcular_brightness(const Estrella& estrella) const {
     // Interpolació lineal: estrelles properes (vora) més brillants
-    // distancia_centre: 0.0 (centre, llunyanes) → 1.0 (vora, properes)
+    // 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);
@@ -112,23 +112,23 @@ float Starfield::calcular_brightness(const Estrella& estrella) const {
     return std::min(1.0F, brightness_base * multiplicador_brightness_);
 }
 
-// Actualitzar posicions de les estrelles
-void Starfield::actualitzar(float delta_time) {
+// Actualitzar posicions de las estrelles
+void Starfield::update(float delta_time) {
     for (auto& estrella : estrelles_) {
-        // Obtenir configuració de la capa
+        // Obtenir configuración de la capa
         const CapaConfig& capa = capes_[estrella.capa];
 
-        // Moure cap a fora des del centre
-        float velocitat = capa.velocitat_base;
-        float dx = velocitat * std::cos(estrella.angle) * delta_time;
-        float dy = velocitat * std::sin(estrella.angle) * delta_time;
+        // 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.posicio.x += dx;
-        estrella.posicio.y += dy;
+        estrella.position.x += dx;
+        estrella.position.y += dy;
 
-        // Actualitzar distància del centre
-        float dx_centre = estrella.posicio.x - punt_fuga_.x;
-        float dy_centre = estrella.posicio.y - punt_fuga_.y;
+        // 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_;
 
@@ -144,26 +144,25 @@ void Starfield::set_brightness(float multiplier) {
     multiplicador_brightness_ = std::max(0.0F, multiplier);  // Evitar valors negatius
 }
 
-// Dibuixar totes les estrelles
-void Starfield::dibuixar() {
-    if (!shape_estrella_->es_valida()) {
+// Dibuixar todas las estrelles
+void Starfield::draw() {
+    if (!shape_estrella_->isValid()) {
         return;
     }
 
     for (const auto& estrella : estrelles_) {
-        // Calcular escala i brightness dinàmicament
-        float escala = calcular_escala(estrella);
+        // Calcular scale i brightness dinàmicament
+        float scale = calcular_escala(estrella);
         float brightness = calcular_brightness(estrella);
 
-        // Renderitzar estrella sense rotació
+        // Renderizar estrella sin rotación
         Rendering::render_shape(
             renderer_,
             shape_estrella_,
-            estrella.posicio,
-            0.0F,       // angle (les estrelles no giren)
-            escala,     // escala dinàmica
-            true,       // dibuixar
-            1.0F,       // progress (sempre visible)
+            estrella.position,
+            0.0F,       // angle (las estrelles no giren)
+            scale,     // scale dinàmica
+            1.0F,       // progress (siempre visible)
             brightness  // brightness dinàmica
         );
     }
diff --git a/source/core/graphics/starfield.hpp b/source/core/graphics/starfield.hpp
index b74d2b1..30ae441 100644
--- a/source/core/graphics/starfield.hpp
+++ b/source/core/graphics/starfield.hpp
@@ -1,8 +1,10 @@
-// starfield.hpp - Sistema d'estrelles de fons amb efecte de profunditat
+// starfield.hpp - Sistema de estrelles de fons con efecte de profunditat
 // © 2025 Orni Attack
 
 #pragma once
 
+#include "core/rendering/render_context.hpp"
+
 #include <SDL3/SDL.h>
 
 #include <memory>
@@ -13,70 +15,70 @@
 
 namespace Graphics {
 
-// Configuració per cada capa de profunditat
+// Configuración per cada capa de profunditat
 struct CapaConfig {
-        float velocitat_base;  // Velocitat base d'aquesta capa (px/s)
-        float escala_min;      // Escala mínima prop del centre
+        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 d'estrelles en aquesta capa
+        int num_estrelles;     // Nombre de estrelles en esta capa
 };
 
-// Classe Starfield - camp d'estrelles animat amb efecte de profunditat
+// Clase Starfield - camp de estrelles animat con efecte de profunditat
 class Starfield {
     public:
         // Constructor
         // - renderer: SDL renderer
-        // - punt_fuga: punt d'origen/fuga des d'on surten les estrelles
-        // - area: rectangle on actuen les estrelles (SDL_FRect)
-        // - densitat: nombre total d'estrelles (es divideix entre capes)
-        Starfield(SDL_Renderer* renderer,
-            const Punt& punt_fuga,
+        // - 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 les estrelles
-        void actualitzar(float delta_time);
+        // Actualitzar posicions de las estrelles
+        void update(float delta_time);
 
-        // Dibuixar totes les estrelles
-        void dibuixar();
+        // Dibuixar todas las estrelles
+        void draw();
 
-        // Setters per ajustar paràmetres en temps real
-        void set_punt_fuga(const Punt& punt) { punt_fuga_ = punt; }
+        // Setters per ajustar parámetros en time real
+        void set_punt_fuga(const Vec2& point) { punt_fuga_ = point; }
         void set_brightness(float multiplier);
 
     private:
         // Estructura interna per cada estrella
         struct Estrella {
-                Punt posicio;            // Posició actual
-                float angle;             // Angle de moviment (radians)
-                float distancia_centre;  // Distància normalitzada del centre (0.0-1.0)
+                Vec2 position;            // Posición actual
+                float angle;             // Angle de movement (radians)
+                float distancia_centre;  // Distancia normalitzada del centro (0.0-1.0)
                 int capa;                // Índex de capa (0=lluny, 1=mitjà, 2=prop)
         };
 
-        // Inicialitzar una estrella (nova o regenerada)
+        // Inicialitzar una estrella (nueva o regenerada)
         void inicialitzar_estrella(Estrella& estrella) const;
 
-        // Verificar si una estrella està fora de l'àrea
+        // Verificar si una estrella está fuera de l'àrea
         [[nodiscard]] bool fora_area(const Estrella& estrella) const;
 
-        // Calcular escala dinàmica segons distància del centre
+        // Calcular scale dinàmica segons distancia del centro
         [[nodiscard]] float calcular_escala(const Estrella& estrella) const;
 
-        // Calcular brightness dinàmica segons distància del centre
+        // Calcular brightness dinàmica segons distancia del centro
         [[nodiscard]] float calcular_brightness(const Estrella& estrella) const;
 
         // Dades
         std::vector<Estrella> estrelles_;
-        std::vector<CapaConfig> capes_;  // Configuració de les 3 capes
+        std::vector<CapaConfig> capes_;  // Configuración de las 3 capes
         std::shared_ptr<Shape> shape_estrella_;
-        SDL_Renderer* renderer_;
+        Rendering::Renderer* renderer_;
 
-        // Configuració
-        Punt punt_fuga_;                        // Punt d'origen de les estrelles
+        // Configuración
+        Vec2 punt_fuga_;                        // Vec2 de origin de las estrelles
         SDL_FRect area_;                        // Àrea activa
-        float radi_max_;                        // Distància màxima del centre al límit de pantalla
-        int densitat_;                          // Nombre total d'estrelles
-        float multiplicador_brightness_{1.0F};  // Multiplicador de brillantor (1.0 = default)
+        float radi_max_;                        // Distancia màxima del centro al límit de pantalla
+        int densitat_;                          // Nombre total de estrelles
+        float multiplicador_brightness_{1.0F};  // Multiplicador de brightness (1.0 = default)
 };
 
 }  // namespace Graphics
diff --git a/source/core/graphics/vector_text.cpp b/source/core/graphics/vector_text.cpp
index 80ce303..9c283c6 100644
--- a/source/core/graphics/vector_text.cpp
+++ b/source/core/graphics/vector_text.cpp
@@ -1,5 +1,5 @@
 // vector_text.cpp - Implementació del sistema de text vectorial
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 // Test pre-commit hook
 
 #include "core/graphics/vector_text.hpp"
@@ -11,11 +11,11 @@
 
 namespace Graphics {
 
-// Constants per a mides base dels caràcters
+// Constants para mides base dels caràcters
 constexpr float char_width = 20.0F;   // Amplada base del caràcter
 constexpr float char_height = 40.0F;  // Altura base del caràcter
 
-VectorText::VectorText(SDL_Renderer* renderer)
+VectorText::VectorText(Rendering::Renderer* renderer)
     : renderer_(renderer) {
     load_charset();
 }
@@ -26,10 +26,10 @@ void VectorText::load_charset() {
         std::string filename = get_shape_filename(c);
         auto shape = ShapeLoader::load(filename);
 
-        if (shape && shape->es_valida()) {
+        if (shape && shape->isValid()) {
             chars_[c] = shape;
         } else {
-            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+            std::cerr << "[VectorText] Warning: no s'ha pogut load " << filename
                       << '\n';
         }
     }
@@ -39,10 +39,10 @@ void VectorText::load_charset() {
         std::string filename = get_shape_filename(c);
         auto shape = ShapeLoader::load(filename);
 
-        if (shape && shape->es_valida()) {
+        if (shape && shape->isValid()) {
             chars_[c] = shape;
         } else {
-            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+            std::cerr << "[VectorText] Warning: no s'ha pogut load " << filename
                       << '\n';
         }
     }
@@ -54,25 +54,25 @@ void VectorText::load_charset() {
         std::string filename = get_shape_filename(c);
         auto shape = ShapeLoader::load(filename);
 
-        if (shape && shape->es_valida()) {
+        if (shape && shape->isValid()) {
             chars_[c] = shape;
         } else {
-            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+            std::cerr << "[VectorText] Warning: no s'ha pogut load " << filename
                       << '\n';
         }
     }
 
     // Cargar símbolo de copyright (©) - UTF-8 U+00A9
-    // Usem el segon byte (0xA9) com a key interna
+    // Usem el segon byte (0xA9) como a key interna
     {
         char c = '\xA9';  // 169 decimal
         std::string filename = "font/char_copyright.shp";
         auto shape = ShapeLoader::load(filename);
 
-        if (shape && shape->es_valida()) {
+        if (shape && shape->isValid()) {
             chars_[c] = shape;
         } else {
-            std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
+            std::cerr << "[VectorText] Warning: no s'ha pogut load " << filename
                       << '\n';
         }
     }
@@ -82,7 +82,7 @@ void VectorText::load_charset() {
 }
 
 std::string VectorText::get_shape_filename(char c) const {
-    // Mapeo carácter → nombre de archivo (amb prefix "font/")
+    // Mapeo carácter → nombre de archivo (con prefix "font/")
     switch (c) {
         case '0':
         case '1':
@@ -168,7 +168,7 @@ std::string VectorText::get_shape_filename(char c) const {
         case '?':
             return "font/char_question.shp";
         case ' ':
-            return "";  // Espai es maneja sense carregar shape
+            return "";  // Espai es maneja sin load shape
 
         case '\xA9':  // Copyright symbol (©) - UTF-8 U+00A9
             return "font/char_copyright.shp";
@@ -182,23 +182,23 @@ bool VectorText::is_supported(char c) const {
     return chars_.contains(c);
 }
 
-void VectorText::render(const std::string& text, const Punt& posicio, float escala, float spacing, float brightness) const {
+void VectorText::render(const std::string& text, const Vec2& position, float scale, float spacing, float brightness) const {
     if (renderer_ == nullptr) {
         return;
     }
 
-    // Ancho de un carácter base (20 px a escala 1.0)
-    const float char_width_scaled = char_width * escala;
+    // Ancho de un carácter base (20 px a scale 1.0)
+    const float char_width_scaled = char_width * scale;
 
     // Spacing escalado
-    const float spacing_scaled = spacing * escala;
+    const float spacing_scaled = spacing * scale;
 
     // Altura de un carácter escalado (necesario para ajustar Y)
-    const float char_height_scaled = char_height * escala;
+    const float char_height_scaled = char_height * scale;
 
     // Posición X del borde izquierdo del carácter actual
     // (se ajustará +char_width/2 para obtener el centro al renderizar)
-    float current_x = posicio.x;
+    float current_x = position.x;
 
     // Iterar sobre cada byte del string (con detecció UTF-8)
     for (size_t i = 0; i < text.length(); i++) {
@@ -207,7 +207,7 @@ void VectorText::render(const std::string& text, const Punt& posicio, float esca
         // Detectar copyright UTF-8 (0xC2 0xA9)
         if (c == 0xC2 && i + 1 < text.length() &&
             static_cast<unsigned char>(text[i + 1]) == 0xA9) {
-            c = 0xA9;  // Usar segon byte com a key
+            c = 0xA9;  // Usar segon byte como a key
             i++;       // Saltar el següent byte
         }
 
@@ -221,10 +221,10 @@ void VectorText::render(const std::string& text, const Punt& posicio, float esca
         auto it = chars_.find(c);
         if (it != chars_.end()) {
             // Renderizar carácter
-            // Ajustar X e Y para que posicio represente esquina superior izquierda
+            // 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)
-            Punt char_pos = {.x = current_x + (char_width_scaled / 2.0F), .y = posicio.y + (char_height_scaled / 2.0F)};
-            Rendering::render_shape(renderer_, it->second, char_pos, 0.0F, escala, true, 1.0F, brightness);
+            Vec2 char_pos = {.x = current_x + (char_width_scaled / 2.0F), .y = position.y + (char_height_scaled / 2.0F)};
+            Rendering::render_shape(renderer_, it->second, char_pos, 0.0F, scale, 1.0F, brightness);
 
             // Avanzar posición
             current_x += char_width_scaled + spacing_scaled;
@@ -237,28 +237,28 @@ void VectorText::render(const std::string& text, const Punt& posicio, float esca
     }
 }
 
-void VectorText::render_centered(const std::string& text, const Punt& centre_punt, float escala, float spacing, float brightness) const {
+void VectorText::renderCentered(const std::string& text, const Vec2& centre_punt, float scale, float spacing, float brightness) const {
     // Calcular dimensions del text
-    float text_width = get_text_width(text, escala, spacing);
-    float text_height = get_text_height(escala);
+    float text_width = get_text_width(text, scale, spacing);
+    float text_height = get_text_height(scale);
 
-    // Calcular posició de l'esquina superior esquerra
-    // restant la meitat de les dimensions del punt central
-    Punt posicio_esquerra = {
+    // Calcular posición de l'esquina superior izquierda
+    // restant la meitat de las dimensions del point central
+    Vec2 posicio_esquerra = {
         .x = centre_punt.x - (text_width / 2.0F),
         .y = centre_punt.y - (text_height / 2.0F)};
 
-    // Delegar al mètode render() existent
-    render(text, posicio_esquerra, escala, spacing, brightness);
+    // Delegar al método render() existent
+    render(text, posicio_esquerra, scale, spacing, brightness);
 }
 
-float VectorText::get_text_width(const std::string& text, float escala, float spacing) const {
+float VectorText::get_text_width(const std::string& text, float scale, float spacing) const {
     if (text.empty()) {
         return 0.0F;
     }
 
-    const float char_width_scaled = char_width * escala;
-    const float spacing_scaled = spacing * escala;
+    const float char_width_scaled = char_width * scale;
+    const float spacing_scaled = spacing * scale;
 
     // Contar caracteres visuals (no bytes) - manejar UTF-8
     size_t visual_chars = 0;
@@ -279,8 +279,8 @@ float VectorText::get_text_width(const std::string& text, float escala, float sp
     return (visual_chars * char_width_scaled) + ((visual_chars - 1) * spacing_scaled);
 }
 
-float VectorText::get_text_height(float escala) const {
-    return char_height * escala;
+float VectorText::get_text_height(float scale) const {
+    return char_height * scale;
 }
 
 }  // namespace Graphics
diff --git a/source/core/graphics/vector_text.hpp b/source/core/graphics/vector_text.hpp
index eacddb4..6352f7b 100644
--- a/source/core/graphics/vector_text.hpp
+++ b/source/core/graphics/vector_text.hpp
@@ -1,8 +1,10 @@
 // vector_text.hpp - Sistema de texto vectorial con display de 7-segmentos
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
 
+#include "core/rendering/render_context.hpp"
+
 #include <SDL3/SDL.h>
 
 #include <memory>
@@ -16,36 +18,36 @@ namespace Graphics {
 
 class VectorText {
     public:
-        VectorText(SDL_Renderer* renderer);
+        VectorText(Rendering::Renderer* renderer);
 
         // Renderizar string completo
         // - text: cadena a renderizar (soporta: A-Z, a-z, 0-9, '.', ',', '-', ':',
         // '!', '?', ' ')
-        // - posicio: posición inicial (esquina superior izquierda)
-        // - escala: factor de escala (1.0 = 20×40 px por carácter)
-        // - spacing: espacio entre caracteres en píxeles (a escala 1.0)
-        // - brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
-        void render(const std::string& text, const Punt& posicio, float escala = 1.0F, float spacing = 2.0F, float brightness = 1.0F) const;
+        // - 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)
+        // - brightness: factor de brightness (0.0-1.0, default 1.0 = màxima brightness)
+        void render(const std::string& text, const Vec2& position, float scale = 1.0F, float spacing = 2.0F, float brightness = 1.0F) const;
 
         // Renderizar string centrado en un punto
         // - text: cadena a renderizar
         // - centre_punt: punto central del texto (no esquina superior izquierda)
-        // - escala: factor de escala (1.0 = 20×40 px por carácter)
-        // - spacing: espacio entre caracteres en píxeles (a escala 1.0)
-        // - brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
-        void render_centered(const std::string& text, const Punt& centre_punt, float escala = 1.0F, float spacing = 2.0F, float brightness = 1.0F) const;
+        // - 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)
+        void renderCentered(const std::string& text, const Vec2& centre_punt, float scale = 1.0F, float spacing = 2.0F, float brightness = 1.0F) const;
 
         // Calcular ancho total de un string (útil para centrado)
-        [[nodiscard]] float get_text_width(const std::string& text, float escala = 1.0F, float spacing = 2.0F) const;
+        [[nodiscard]] float get_text_width(const std::string& text, float scale = 1.0F, float spacing = 2.0F) const;
 
         // Calcular altura del texto (útil para centrado vertical)
-        [[nodiscard]] float get_text_height(float escala = 1.0F) const;
+        [[nodiscard]] float get_text_height(float scale = 1.0F) const;
 
         // Verificar si un carácter está soportado
         [[nodiscard]] bool is_supported(char c) const;
 
     private:
-        SDL_Renderer* renderer_;
+        Rendering::Renderer* renderer_;
         std::unordered_map<char, std::shared_ptr<Shape>> chars_;
 
         void load_charset();
diff --git a/source/core/input/input.cpp b/source/core/input/input.cpp
index f89f3f7..7ed92f1 100644
--- a/source/core/input/input.cpp
+++ b/source/core/input/input.cpp
@@ -30,7 +30,7 @@ Input::Input(std::string game_controller_db_path)
     // Inicializar bindings del teclado (valores por defecto)
     // Estos serán sobrescritos por applyPlayer1BindingsFromOptions()
     keyboard_.bindings = {
-        // Movimiento del jugador
+        // Movimiento del player
         {Action::LEFT, KeyState{.scancode = SDL_SCANCODE_LEFT}},
         {Action::RIGHT, KeyState{.scancode = SDL_SCANCODE_RIGHT}},
         {Action::THRUST, KeyState{.scancode = SDL_SCANCODE_UP}},
@@ -188,7 +188,7 @@ auto Input::checkAnyButton(bool repeat) -> bool {
     return false;
 }
 
-// Comprueba si algún jugador (P1 o P2) presionó alguna acción de una lista
+// Comprueba si algún player (P1 o P2) presionó alguna acción de una lista
 auto Input::checkAnyPlayerAction(const std::span<const InputAction>& actions, bool repeat) -> bool {
     for (const auto& action : actions) {
         if (checkActionPlayer1(action, repeat) || checkActionPlayer2(action, repeat)) {
@@ -388,14 +388,14 @@ void Input::update() {
         binding.second.is_held = key_is_down_now;
     }
 
-    // Actualizar bindings de jugador 1
+    // Actualizar bindings de player 1
     for (auto& binding : player1_keyboard_bindings_) {
         bool key_is_down_now = key_states[binding.second.scancode];
         binding.second.just_pressed = key_is_down_now && !binding.second.is_held;
         binding.second.is_held = key_is_down_now;
     }
 
-    // Actualizar bindings de jugador 2
+    // Actualizar bindings de player 2
     for (auto& binding : player2_keyboard_bindings_) {
         bool key_is_down_now = key_states[binding.second.scancode];
         binding.second.just_pressed = key_is_down_now && !binding.second.is_held;
@@ -493,7 +493,7 @@ auto Input::findAvailableGamepadByName(const std::string& gamepad_name) -> std::
 
 // ========== MÉTODOS ESPECÍFICOS POR JUGADOR (ORNI) ==========
 
-// Aplica configuración de controles del jugador 1
+// Aplica configuración de controles del player 1
 void Input::applyPlayer1BindingsFromOptions() {
     // 1. Aplicar bindings de teclado (NO usar bindKey, llenar mapa específico)
     player1_keyboard_bindings_[Action::LEFT].scancode = Options::player1.keyboard.key_left;
@@ -527,7 +527,7 @@ void Input::applyPlayer1BindingsFromOptions() {
     player1_gamepad_ = gamepad;
 }
 
-// Aplica configuración de controles del jugador 2
+// Aplica configuración de controles del player 2
 void Input::applyPlayer2BindingsFromOptions() {
     // 1. Aplicar bindings de teclado (mapa específico de P2, no sobrescribe P1)
     player2_keyboard_bindings_[Action::LEFT].scancode = Options::player2.keyboard.key_left;
@@ -561,7 +561,7 @@ void Input::applyPlayer2BindingsFromOptions() {
     player2_gamepad_ = gamepad;
 }
 
-// Consulta de input para jugador 1
+// Consulta de input para player 1
 auto Input::checkActionPlayer1(Action action, bool repeat) -> bool {
     // Comprobar teclado con el mapa específico de P1
     bool keyboard_active = false;
@@ -583,7 +583,7 @@ auto Input::checkActionPlayer1(Action action, bool repeat) -> bool {
     return keyboard_active || gamepad_active;
 }
 
-// Consulta de input para jugador 2
+// Consulta de input para player 2
 auto Input::checkActionPlayer2(Action action, bool repeat) -> bool {
     // Comprobar teclado con el mapa específico de P2
     bool keyboard_active = false;
diff --git a/source/core/input/input.hpp b/source/core/input/input.hpp
index 9e70746..d6b8384 100644
--- a/source/core/input/input.hpp
+++ b/source/core/input/input.hpp
@@ -58,7 +58,7 @@ class Input {
                       name(std::string(SDL_GetGamepadName(gamepad))),
                       path(std::string(SDL_GetGamepadPath(pad))),
                       bindings{
-                          // Movimiento y acciones del jugador
+                          // Movimiento y acciones del player
                           {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)}},
@@ -92,7 +92,7 @@ class Input {
         void applyKeyboardBindingsFromOptions();
         void applyGamepadBindingsFromOptions();
 
-        // Configuración por jugador (Orni - dos jugadores)
+        // Configuración por player (Orni - dos jugadores)
         void applyPlayer1BindingsFromOptions();
         void applyPlayer2BindingsFromOptions();
 
@@ -105,7 +105,7 @@ class Input {
         auto checkAnyButton(bool repeat = DO_NOT_ALLOW_REPEAT) -> bool;
         void resetInputStates();
 
-        // Consulta por jugador (Orni - dos jugadores)
+        // Consulta por player (Orni - dos jugadores)
         auto checkActionPlayer1(Action action, bool repeat = true) -> bool;
         auto checkActionPlayer2(Action action, bool repeat = true) -> bool;
 
@@ -152,11 +152,11 @@ class Input {
         Keyboard keyboard_{};                // Estado del teclado (solo acciones globales)
         std::string gamepad_mappings_file_;  // Ruta al archivo de mappings
 
-        // Referencias cacheadas a gamepads por jugador (Orni)
+        // Referencias cacheadas a gamepads por player (Orni)
         std::shared_ptr<Gamepad> player1_gamepad_;
         std::shared_ptr<Gamepad> player2_gamepad_;
 
-        // Mapas de bindings separados por jugador (Orni - dos jugadores)
+        // Mapas de bindings separados por player (Orni - dos jugadores)
         std::unordered_map<Action, KeyState> player1_keyboard_bindings_;
         std::unordered_map<Action, KeyState> player2_keyboard_bindings_;
 };
\ No newline at end of file
diff --git a/source/core/input/input_types.hpp b/source/core/input/input_types.hpp
index 603de00..c032638 100644
--- a/source/core/input/input_types.hpp
+++ b/source/core/input/input_types.hpp
@@ -13,7 +13,7 @@ enum class InputAction : int {  // Acciones de entrada posibles en el juego
     RIGHT,   // Rotar derecha
     THRUST,  // Acelerar
     SHOOT,   // Disparar
-    START,   // Empezar partida
+    START,   // Empezar match
 
     // Inputs de sistema (globales)
     WINDOW_INC_ZOOM,    // F2
diff --git a/source/core/input/mouse.cpp b/source/core/input/mouse.cpp
index d47740c..239264e 100644
--- a/source/core/input/mouse.cpp
+++ b/source/core/input/mouse.cpp
@@ -12,19 +12,19 @@ bool cursor_visible = false;      // Estado del cursor (inicia ocult)
 // SDLManager controla esto mediante llamadas a setForceHidden().
 bool force_hidden = false;
 
-// Temps d'inicialització per ignorar esdeveniments fantasma de SDL
+// Temps de inicialización per ignorar esdeveniments fantasma de SDL
 Uint32 initialization_time = 0;
 constexpr Uint32 IGNORE_MOTION_DURATION = 1000;  // Ignorar primers 1000ms
 
 void forceHide() {
-    // Forçar ocultació sincronitzant estat SDL i estat intern
-    std::cout << "[Mouse::forceHide] Ocultant cursor i sincronitzant estat. cursor_visible=" << cursor_visible
+    // Forçar ocultació sincronitzant state SDL i state intern
+    std::cout << "[Mouse::forceHide] Ocultant cursor i sincronitzant state. cursor_visible=" << cursor_visible
               << " -> false" << '\n';
     SDL_HideCursor();
     cursor_visible = false;
     last_mouse_move_time = 0;
-    initialization_time = SDL_GetTicks();  // Marcar temps per ignorar esdeveniments inicials
-    std::cout << "[Mouse::forceHide] Ignorant moviments durant " << IGNORE_MOTION_DURATION << "ms" << '\n';
+    initialization_time = SDL_GetTicks();  // Marcar time per ignorar esdeveniments inicials
+    std::cout << "[Mouse::forceHide] Ignorant moviments durante " << IGNORE_MOTION_DURATION << "ms" << '\n';
 }
 
 void setForceHidden(bool force) {
@@ -56,16 +56,16 @@ void handleEvent(const SDL_Event& event) {
     if (event.type == SDL_EVENT_MOUSE_MOTION) {
         Uint32 current_time = SDL_GetTicks();
 
-        // Ignorar esdeveniments fantasma de SDL durant el període inicial
+        // Ignorar esdeveniments fantasma de SDL durante el període inicial
         if (initialization_time > 0 && (current_time - initialization_time < IGNORE_MOTION_DURATION)) {
-            std::cout << "[Mouse::handleEvent] Ignorant moviment fantasma de SDL. time=" << current_time
-                      << " (inicialització fa " << (current_time - initialization_time) << "ms)" << '\n';
+            std::cout << "[Mouse::handleEvent] Ignorant movement fantasma de SDL. time=" << current_time
+                      << " (inicialización hace " << (current_time - initialization_time) << "ms)" << '\n';
             return;
         }
 
         last_mouse_move_time = current_time;
         if (!cursor_visible) {
-            std::cout << "[Mouse::handleEvent] Mostrant cursor per moviment REAL. time=" << last_mouse_move_time << '\n';
+            std::cout << "[Mouse::handleEvent] Mostrant cursor per movement REAL. time=" << last_mouse_move_time << '\n';
             SDL_ShowCursor();
             cursor_visible = true;
         }
diff --git a/source/core/input/mouse.hpp b/source/core/input/mouse.hpp
index d3bad75..7233c47 100644
--- a/source/core/input/mouse.hpp
+++ b/source/core/input/mouse.hpp
@@ -7,7 +7,7 @@ extern Uint32 cursor_hide_time;      // Tiempo en milisegundos para ocultar el c
 extern Uint32 last_mouse_move_time;  // Última vez que el ratón se movió
 extern bool cursor_visible;          // Estado del cursor
 
-void forceHide();  // Forçar ocultació del cursor (sincronitza estat intern)
+void forceHide();  // Forçar ocultació del cursor (sincronitza state intern)
 void handleEvent(const SDL_Event& event);
 void updateCursorVisibility();
 
diff --git a/source/core/math/easing.hpp b/source/core/math/easing.hpp
index 1b6d239..5c135b2 100644
--- a/source/core/math/easing.hpp
+++ b/source/core/math/easing.hpp
@@ -1,4 +1,4 @@
-// easing.hpp - Funcions d'interpolació i easing
+// easing.hpp - Funciones de interpolació i easing
 // © 2025 Orni Attack
 
 #pragma once
@@ -7,21 +7,21 @@ namespace Easing {
 
 // Ease-out quadratic: empieza rápido, desacelera suavemente
 // t = progreso normalizado [0.0 - 1.0]
-// retorna valor interpolado [0.0 - 1.0]
+// retorna value interpolado [0.0 - 1.0]
 inline float ease_out_quad(float t) {
     return 1.0F - ((1.0F - t) * (1.0F - t));
 }
 
 // Ease-in quadratic: empieza lento, acelera
 // t = progreso normalizado [0.0 - 1.0]
-// retorna valor interpolado [0.0 - 1.0]
+// retorna value interpolado [0.0 - 1.0]
 inline float ease_in_quad(float t) {
     return t * t;
 }
 
 // Ease-in-out quadratic: acelera al inicio, desacelera al final
 // t = progreso normalizado [0.0 - 1.0]
-// retorna valor interpolado [0.0 - 1.0]
+// retorna value interpolado [0.0 - 1.0]
 inline float ease_in_out_quad(float t) {
     return (t < 0.5F)
         ? 2.0F * t * t
@@ -30,7 +30,7 @@ inline float ease_in_out_quad(float t) {
 
 // Ease-out cubic: desaceleración más suave que quadratic
 // t = progreso normalizado [0.0 - 1.0]
-// retorna valor interpolado [0.0 - 1.0]
+// retorna value interpolado [0.0 - 1.0]
 inline float ease_out_cubic(float t) {
     float t1 = 1.0F - t;
     return 1.0F - (t1 * t1 * t1);
diff --git a/source/core/physics/collision.hpp b/source/core/physics/collision.hpp
index 4bc73af..4152d20 100644
--- a/source/core/physics/collision.hpp
+++ b/source/core/physics/collision.hpp
@@ -1,27 +1,27 @@
-// collision.hpp - Utilitats de detecció de col·lisions
+// collision.hpp - Utilitats de detecció de colisiones
 // © 2025 Orni Attack - Sistema de física
 
 #pragma once
 
-#include "core/entities/entitat.hpp"
+#include "core/entities/entity.hpp"
 #include "core/types.hpp"
 
 namespace Physics {
 
-// Comprovació genèrica de col·lisió entre dues entitats
-inline bool check_collision(const Entities::Entitat& a, const Entities::Entitat& b, float amplifier = 1.0F) {
+// Comprobación genèrica de colisión entre dues entidades
+inline bool check_collision(const Entities::Entity& a, const Entities::Entity& b, float amplifier = 1.0F) {
     // Comprovar si ambdós són col·lisionables
-    if (!a.es_collidable() || !b.es_collidable()) {
+    if (!a.isCollidable() || !b.isCollidable()) {
         return false;
     }
 
-    // Calcular radi combinat (amb amplificador per hitbox generós)
-    float suma_radis = (a.get_collision_radius() + b.get_collision_radius()) * amplifier;
+    // Calcular radi combinat (con amplificador per hitbox generós)
+    float suma_radis = (a.getCollisionRadius() + b.getCollisionRadius()) * amplifier;
     float suma_radis_sq = suma_radis * suma_radis;
 
-    // Comprovació distància al quadrat (sense sqrt)
-    const Punt& pos_a = a.get_centre();
-    const Punt& pos_b = b.get_centre();
+    // Comprobación distancia al cuadrado (sin sqrt)
+    const Vec2& pos_a = a.getCenter();
+    const Vec2& pos_b = b.getCenter();
     float dx = pos_a.x - pos_b.x;
     float dy = pos_a.y - pos_b.y;
     float dist_sq = (dx * dx) + (dy * dy);
diff --git a/source/core/physics/physics_world.cpp b/source/core/physics/physics_world.cpp
new file mode 100644
index 0000000..3d1e7a5
--- /dev/null
+++ b/source/core/physics/physics_world.cpp
@@ -0,0 +1,178 @@
+// physics_world.cpp - Implementación del mundo físico
+// © 2025 Orni Attack
+
+#include "core/physics/physics_world.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+#include "core/physics/rigid_body.hpp"
+
+namespace Physics {
+
+void PhysicsWorld::addBody(RigidBody* body) {
+    if (body == nullptr) {
+        return;
+    }
+    if (std::ranges::find(bodies_, body) == bodies_.end()) {
+        bodies_.push_back(body);
+    }
+}
+
+void PhysicsWorld::removeBody(RigidBody* body) {
+    std::erase(bodies_, body);
+}
+
+void PhysicsWorld::update(float dt) {
+    integrate(dt);
+    if (has_bounds_) {
+        resolveBoundsCollisions();
+    }
+    resolveBodyCollisions();
+}
+
+// Integración semi-implícita de Euler:
+//   v(t+dt) = v(t) + (F/m) * dt
+//   x(t+dt) = x(t) + v(t+dt) * dt
+// Más estable que Euler explícito para juegos. Damping exponencial.
+void PhysicsWorld::integrate(float dt) {
+    for (auto* body : bodies_) {
+        if (body == nullptr || body->isStatic()) {
+            continue;
+        }
+
+        // Aplicar fuerzas acumuladas → aceleración
+        const Vec2 acceleration = body->force_accumulator * body->inverse_mass;
+        body->velocity += acceleration * dt;
+
+        // Damping exponencial: equivalente a v *= exp(-damping * dt)
+        // Aproximación lineal cuando damping*dt es pequeño.
+        if (body->linear_damping > 0.0F) {
+            const float DAMP = std::exp(-body->linear_damping * dt);
+            body->velocity *= DAMP;
+        }
+        if (body->angular_damping > 0.0F) {
+            const float DAMP = std::exp(-body->angular_damping * dt);
+            body->angular_velocity *= DAMP;
+        }
+
+        // Actualizar posición y rotación
+        body->position += body->velocity * dt;
+        body->angle += body->angular_velocity * dt;
+
+        body->clearAccumulators();
+    }
+}
+
+// Rebote contra los 4 bordes del rectángulo bounds_.
+// Refleja la componente normal de la velocidad por la restitución.
+void PhysicsWorld::resolveBoundsCollisions() {
+    const float MIN_X = bounds_.x;
+    const float MAX_X = bounds_.x + bounds_.w;
+    const float MIN_Y = bounds_.y;
+    const float MAX_Y = bounds_.y + bounds_.h;
+
+    for (auto* body : bodies_) {
+        if (body == nullptr || body->isStatic()) {
+            continue;
+        }
+        const float R = body->radius;
+
+        // Pared izquierda
+        if (body->position.x - R < MIN_X) {
+            body->position.x = MIN_X + R;
+            if (body->velocity.x < 0.0F) {
+                body->velocity.x = -body->velocity.x * body->restitution;
+            }
+        }
+        // Pared derecha
+        if (body->position.x + R > MAX_X) {
+            body->position.x = MAX_X - R;
+            if (body->velocity.x > 0.0F) {
+                body->velocity.x = -body->velocity.x * body->restitution;
+            }
+        }
+        // Pared superior
+        if (body->position.y - R < MIN_Y) {
+            body->position.y = MIN_Y + R;
+            if (body->velocity.y < 0.0F) {
+                body->velocity.y = -body->velocity.y * body->restitution;
+            }
+        }
+        // Pared inferior
+        if (body->position.y + R > MAX_Y) {
+            body->position.y = MAX_Y - R;
+            if (body->velocity.y > 0.0F) {
+                body->velocity.y = -body->velocity.y * body->restitution;
+            }
+        }
+    }
+}
+
+// Colisiones cuerpo-cuerpo: O(n²) círculo-círculo + resolución por impulso.
+// Para 15 enemigos + 6 balas + 2 naves = ~23 cuerpos → 253 pares. Sobra.
+//
+// Fórmula del impulso elástico (referencia: Chris Hecker / Box2D):
+//   j = -(1 + e) * (v_rel · n) / (1/m_a + 1/m_b)
+// donde n es la normal del contacto (de a hacia b) y v_rel = v_a - v_b.
+void PhysicsWorld::resolveBodyCollisions() {
+    const std::size_t COUNT = bodies_.size();
+    for (std::size_t i = 0; i < COUNT; ++i) {
+        for (std::size_t j = i + 1; j < COUNT; ++j) {
+            auto* a = bodies_[i];
+            auto* b = bodies_[j];
+            if (a == nullptr || b == nullptr) {
+                continue;
+            }
+            // Dos cuerpos estáticos no necesitan resolución
+            if (a->isStatic() && b->isStatic()) {
+                continue;
+            }
+
+            const Vec2 DELTA = b->position - a->position;
+            const float DIST_SQ = DELTA.lengthSquared();
+            const float SUM_R = a->radius + b->radius;
+            if (DIST_SQ > SUM_R * SUM_R || DIST_SQ <= 0.0F) {
+                continue;
+            }
+
+            const float DIST = std::sqrt(DIST_SQ);
+            const Vec2 NORMAL = DELTA / DIST;  // de A hacia B
+
+            // Corrección posicional (resolver penetración)
+            const float PENETRATION = SUM_R - DIST;
+            const float TOTAL_INV_MASS = a->inverse_mass + b->inverse_mass;
+            if (TOTAL_INV_MASS > 0.0F) {
+                const Vec2 CORRECTION = NORMAL * (PENETRATION / TOTAL_INV_MASS);
+                if (!a->isStatic()) {
+                    a->position -= CORRECTION * a->inverse_mass;
+                }
+                if (!b->isStatic()) {
+                    b->position += CORRECTION * b->inverse_mass;
+                }
+            }
+
+            // Velocidad relativa proyectada sobre la normal
+            const Vec2 V_REL = b->velocity - a->velocity;
+            const float VEL_ALONG_NORMAL = V_REL.dot(NORMAL);
+            // Si se están separando, no aplicar impulso
+            if (VEL_ALONG_NORMAL > 0.0F) {
+                continue;
+            }
+
+            // Restitución promedio (Box2D usa max; promedio es más permisivo)
+            const float E = (a->restitution + b->restitution) * 0.5F;
+            const float J = -(1.0F + E) * VEL_ALONG_NORMAL / TOTAL_INV_MASS;
+            const Vec2 IMPULSE = NORMAL * J;
+
+            if (!a->isStatic()) {
+                a->velocity -= IMPULSE * a->inverse_mass;
+            }
+            if (!b->isStatic()) {
+                b->velocity += IMPULSE * b->inverse_mass;
+            }
+        }
+    }
+}
+
+}  // namespace Physics
diff --git a/source/core/physics/physics_world.hpp b/source/core/physics/physics_world.hpp
new file mode 100644
index 0000000..28314f8
--- /dev/null
+++ b/source/core/physics/physics_world.hpp
@@ -0,0 +1,64 @@
+// physics_world.hpp - Mundo físico 2D
+// © 2025 Orni Attack
+//
+// Gestiona un conjunto de RigidBody, integra sus movimientos y detecta
+// colisiones por frame. Diseño minimalista para arcade: broadphase trivial
+// O(n²) suficiente para <50 cuerpos (15 enemigos + balas + paredes).
+//
+// Los RigidBody viven en las entidades (las entidades poseen sus bodies);
+// PhysicsWorld solo guarda punteros no-owning. La entidad es responsable
+// de añadir/quitar su body del mundo en init/destroy.
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <vector>
+
+namespace Physics {
+
+struct RigidBody;
+
+class PhysicsWorld {
+    public:
+        PhysicsWorld() = default;
+
+        // Añade un cuerpo al mundo (no toma ownership).
+        void addBody(RigidBody* body);
+
+        // Elimina un cuerpo. No-op si no está registrado.
+        void removeBody(RigidBody* body);
+
+        // Vacía la lista (no destruye los cuerpos).
+        void clear() { bodies_.clear(); }
+
+        // Define los límites del mundo (paredes implícitas). Pasa un rect
+        // PLAYAREA para que los cuerpos reboten contra los bordes según su
+        // restitution. Vacío = sin paredes.
+        void setBounds(const SDL_FRect& bounds) {
+            bounds_ = bounds;
+            has_bounds_ = true;
+        }
+        void clearBounds() { has_bounds_ = false; }
+
+        // Avanza la simulación dt segundos:
+        //   1. Integra cada cuerpo (semi-implicit Euler + damping)
+        //   2. Resuelve colisiones contra los bounds (si configurados)
+        //   3. Resuelve colisiones cuerpo-cuerpo (impulsos elásticos)
+        void update(float dt);
+
+        // Consultas
+        [[nodiscard]] auto getBodyCount() const -> std::size_t { return bodies_.size(); }
+        [[nodiscard]] auto getBodies() const -> const std::vector<RigidBody*>& { return bodies_; }
+
+    private:
+        std::vector<RigidBody*> bodies_;
+        SDL_FRect bounds_{0.0F, 0.0F, 0.0F, 0.0F};
+        bool has_bounds_{false};
+
+        void integrate(float dt);
+        void resolveBoundsCollisions();
+        void resolveBodyCollisions();
+};
+
+}  // namespace Physics
diff --git a/source/core/physics/rigid_body.hpp b/source/core/physics/rigid_body.hpp
new file mode 100644
index 0000000..c90b840
--- /dev/null
+++ b/source/core/physics/rigid_body.hpp
@@ -0,0 +1,75 @@
+// rigid_body.hpp - Cuerpo rígido 2D para el sistema de física
+// © 2025 Orni Attack
+//
+// Estructura POD-like que encapsula el estado físico de una entidad:
+// posición, velocidad lineal/angular, masa, restitución y damping.
+// El integrador es semi-implícito de Euler (estable para juegos arcade).
+//
+// Convenciones:
+//   - position: coordenadas lógicas (px), donde la entidad está en el mundo
+//   - angle:    radianes; 0 apunta hacia arriba (eje Y negativo en SDL)
+//   - velocity: px/s en cartesianas (NO polares — adiós a cos/sin por entidad)
+//   - mass = 0 (inverse_mass = 0) representa un cuerpo estático (masa infinita)
+//   - restitution 0 = inelástico, 1 = elástico perfecto
+//   - linear_damping en s⁻¹ (fricción exponencial: v *= exp(-damping * dt))
+
+#pragma once
+
+#include "core/types.hpp"
+
+namespace Physics {
+
+struct RigidBody {
+        // --- Estado cinemático ---
+        Vec2 position{};                // Posición del centro (px)
+        Vec2 velocity{};                // Velocidad lineal (px/s)
+        float angle{0.0F};              // Orientación (rad)
+        float angular_velocity{0.0F};   // Velocidad angular (rad/s)
+
+        // --- Propiedades físicas ---
+        float mass{1.0F};               // Masa (kg, escala libre)
+        float inverse_mass{1.0F};       // 1/mass cacheado (0 = estático)
+        float restitution{0.5F};        // Elasticidad (0..1)
+        float linear_damping{0.0F};     // Fricción lineal (s⁻¹)
+        float angular_damping{0.0F};    // Fricción angular (s⁻¹)
+        float radius{0.0F};             // Radio de colisión (círculo)
+
+        // --- Fuerzas acumuladas (reseteadas tras cada integrate) ---
+        Vec2 force_accumulator{};
+        float torque_accumulator{0.0F};
+
+        // Configura la masa y precalcula inverse_mass.
+        // mass <= 0 marca el cuerpo como estático (inmovible por impulsos).
+        void setMass(float new_mass) {
+            mass = new_mass;
+            inverse_mass = (new_mass > 0.0F) ? 1.0F / new_mass : 0.0F;
+        }
+
+        // Marca el cuerpo como estático (paredes, obstáculos fijos).
+        void setStatic() {
+            mass = 0.0F;
+            inverse_mass = 0.0F;
+            velocity = Vec2{};
+            angular_velocity = 0.0F;
+        }
+
+        [[nodiscard]] auto isStatic() const -> bool { return inverse_mass == 0.0F; }
+
+        // Aplica una fuerza instantánea (acumulada para el siguiente integrate).
+        void applyForce(const Vec2& force) { force_accumulator += force; }
+
+        // Aplica un impulso (cambio inmediato de velocidad: Δv = J / m).
+        void applyImpulse(const Vec2& impulse) {
+            if (!isStatic()) {
+                velocity += impulse * inverse_mass;
+            }
+        }
+
+        // Resetea los acumuladores tras la integración.
+        void clearAccumulators() {
+            force_accumulator = Vec2{};
+            torque_accumulator = 0.0F;
+        }
+};
+
+}  // namespace Physics
diff --git a/source/core/rendering/color_oscillator.cpp b/source/core/rendering/color_oscillator.cpp
deleted file mode 100644
index ca1df1a..0000000
--- a/source/core/rendering/color_oscillator.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-// color_oscillator.cpp - Implementació d'oscil·lació de color
-// © 2025 Port a C++20 amb SDL3
-
-#include "core/rendering/color_oscillator.hpp"
-
-#include <cmath>
-
-#include "core/defaults.hpp"
-
-namespace Rendering {
-
-ColorOscillator::ColorOscillator()
-    : accumulated_time_(0.0F) {
-    // Inicialitzar amb el color mínim
-    current_line_color_ = {.r = Defaults::Color::LINE_MIN_R,
-        .g = Defaults::Color::LINE_MIN_G,
-        .b = Defaults::Color::LINE_MIN_B,
-        .a = 255};
-    current_background_color_ = {.r = Defaults::Color::BACKGROUND_MIN_R,
-        .g = Defaults::Color::BACKGROUND_MIN_G,
-        .b = Defaults::Color::BACKGROUND_MIN_B,
-        .a = 255};
-}
-
-void ColorOscillator::update(float delta_time) {
-    accumulated_time_ += delta_time;
-
-    float factor =
-        calculateOscillationFactor(accumulated_time_, Defaults::Color::FREQUENCY);
-
-    // Interpolar colors de línies
-    SDL_Color line_min = {Defaults::Color::LINE_MIN_R,
-        Defaults::Color::LINE_MIN_G,
-        Defaults::Color::LINE_MIN_B,
-        255};
-    SDL_Color line_max = {Defaults::Color::LINE_MAX_R,
-        Defaults::Color::LINE_MAX_G,
-        Defaults::Color::LINE_MAX_B,
-        255};
-    current_line_color_ = interpolateColor(line_min, line_max, factor);
-
-    // Interpolar colors de fons
-    SDL_Color bg_min = {Defaults::Color::BACKGROUND_MIN_R,
-        Defaults::Color::BACKGROUND_MIN_G,
-        Defaults::Color::BACKGROUND_MIN_B,
-        255};
-    SDL_Color bg_max = {Defaults::Color::BACKGROUND_MAX_R,
-        Defaults::Color::BACKGROUND_MAX_G,
-        Defaults::Color::BACKGROUND_MAX_B,
-        255};
-    current_background_color_ = interpolateColor(bg_min, bg_max, factor);
-}
-
-float ColorOscillator::calculateOscillationFactor(float time, float frequency) {
-    // Oscil·lació senoïdal: sin(t * freq * 2π)
-    // Mapejar de [-1, 1] a [0, 1]
-    float radians = time * frequency * 2.0F * Defaults::Math::PI;
-    return (std::sin(radians) + 1.0F) / 2.0F;
-}
-
-SDL_Color ColorOscillator::interpolateColor(SDL_Color min, SDL_Color max, float factor) {
-    return {static_cast<uint8_t>(min.r + ((max.r - min.r) * factor)),
-        static_cast<uint8_t>(min.g + ((max.g - min.g) * factor)),
-        static_cast<uint8_t>(min.b + ((max.b - min.b) * factor)),
-        255};
-}
-
-}  // namespace Rendering
diff --git a/source/core/rendering/color_oscillator.hpp b/source/core/rendering/color_oscillator.hpp
deleted file mode 100644
index d2a6bc1..0000000
--- a/source/core/rendering/color_oscillator.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// color_oscillator.hpp - Sistema d'oscil·lació de color per efecte CRT
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-#include <SDL3/SDL.h>
-
-namespace Rendering {
-
-class ColorOscillator {
-    public:
-        ColorOscillator();
-
-        void update(float delta_time);
-
-        [[nodiscard]] SDL_Color getCurrentLineColor() const { return current_line_color_; }
-        [[nodiscard]] SDL_Color getCurrentBackgroundColor() const {
-            return current_background_color_;
-        }
-
-    private:
-        float accumulated_time_;
-        SDL_Color current_line_color_;
-        SDL_Color current_background_color_;
-
-        static float calculateOscillationFactor(float time, float frequency);
-        static SDL_Color interpolateColor(SDL_Color min, SDL_Color max, float factor);
-};
-
-}  // namespace Rendering
diff --git a/source/core/rendering/coordinate_transform.cpp b/source/core/rendering/coordinate_transform.cpp
index 4ed2314..1e1f58d 100644
--- a/source/core/rendering/coordinate_transform.cpp
+++ b/source/core/rendering/coordinate_transform.cpp
@@ -1,11 +1,11 @@
-// coordinate_transform.cpp - Inicialització de variables globals
-// © 2025 Port a C++20 amb SDL3
+// coordinate_transform.cpp - Inicialización de variables globals
+// © 2025 Port a C++20 con SDL3
 
 #include "core/rendering/coordinate_transform.hpp"
 
 namespace Rendering {
 
-// Factor d'escala global (inicialitzat a 1.0 per defecte)
+// Factor de scale global (inicialitzat a 1.0 per defecte)
 float g_current_scale_factor = 1.0F;
 
 }  // namespace Rendering
diff --git a/source/core/rendering/coordinate_transform.hpp b/source/core/rendering/coordinate_transform.hpp
index 7bd859f..724e7c0 100644
--- a/source/core/rendering/coordinate_transform.hpp
+++ b/source/core/rendering/coordinate_transform.hpp
@@ -1,5 +1,5 @@
 // coordinate_transform.hpp - Transformació de coordenades lògiques a físiques
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
 
@@ -7,10 +7,10 @@
 
 namespace Rendering {
 
-// Factor d'escala global (actualitzat cada frame per SDLManager)
+// Factor de scale global (actualitzat cada frame per SDLManager)
 extern float g_current_scale_factor;
 
-// Transforma coordenada lògica a física amb arrodoniment
+// Transforma coordenada lógica a física con arrodoniment
 inline int transform_x(int logical_x, float scale) {
     return static_cast<int>(std::round(logical_x * scale));
 }
@@ -19,7 +19,7 @@ inline int transform_y(int logical_y, float scale) {
     return static_cast<int>(std::round(logical_y * scale));
 }
 
-// Variant que usa el factor d'escala global
+// Variant que usa el factor de scale global
 inline int transform_x(int logical_x) {
     return transform_x(logical_x, g_current_scale_factor);
 }
diff --git a/source/core/rendering/gpu/gpu_device.cpp b/source/core/rendering/gpu/gpu_device.cpp
new file mode 100644
index 0000000..c5a1260
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_device.cpp
@@ -0,0 +1,105 @@
+// gpu_device.cpp - Implementación del wrapper de SDL_GPUDevice
+
+#include "core/rendering/gpu/gpu_device.hpp"
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "core/utils/path_utils.hpp"
+
+namespace Rendering::GPU {
+
+GpuDevice::~GpuDevice() { destroy(); }
+
+auto GpuDevice::init(SDL_Window* window) -> bool {
+    window_ = window;
+
+    // Solicitar backends en orden de preferencia: Vulkan (Linux/Windows),
+    // Metal (macOS). Sin DirectX según decisión de proyecto.
+    // SDL_GPU_SHADERFORMAT_SPIRV: shaders compilados con glslc.
+    // SDL_GPU_SHADERFORMAT_MSL: pendiente para macOS (Fase futura).
+    constexpr SDL_GPUShaderFormat SHADER_FORMATS =
+        SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_MSL;
+
+    device_ = SDL_CreateGPUDevice(SHADER_FORMATS, /*debug=*/true, /*name=*/nullptr);
+    if (device_ == nullptr) {
+        std::cerr << "[GpuDevice] SDL_CreateGPUDevice falló: " << SDL_GetError() << '\n';
+        return false;
+    }
+
+    const char* driver = SDL_GetGPUDeviceDriver(device_);
+    std::cout << "[GpuDevice] Backend GPU: " << (driver != nullptr ? driver : "?") << '\n';
+
+    if (!SDL_ClaimWindowForGPUDevice(device_, window_)) {
+        std::cerr << "[GpuDevice] SDL_ClaimWindowForGPUDevice falló: " << SDL_GetError() << '\n';
+        SDL_DestroyGPUDevice(device_);
+        device_ = nullptr;
+        return false;
+    }
+
+    swapchain_format_ = SDL_GetGPUSwapchainTextureFormat(device_, window_);
+    return true;
+}
+
+void GpuDevice::destroy() {
+    if (device_ != nullptr) {
+        if (window_ != nullptr) {
+            SDL_ReleaseWindowFromGPUDevice(device_, window_);
+        }
+        SDL_DestroyGPUDevice(device_);
+        device_ = nullptr;
+    }
+    window_ = nullptr;
+    swapchain_format_ = SDL_GPU_TEXTUREFORMAT_INVALID;
+}
+
+auto GpuDevice::loadShader(const std::string& spv_filename,
+                           SDL_GPUShaderStage stage,
+                           uint32_t num_uniform_buffers,
+                           uint32_t num_samplers) const -> SDL_GPUShader* {
+    if (device_ == nullptr) {
+        return nullptr;
+    }
+
+    // Los .spv viven en build/shaders/ junto al binario.
+    const std::string PATH = Utils::getExecutableDirectory() + "/shaders/" + spv_filename;
+
+    std::ifstream file(PATH, std::ios::binary | std::ios::ate);
+    if (!file.is_open()) {
+        std::cerr << "[GpuDevice] No s'ha pogut obrir el shader: " << PATH << '\n';
+        return nullptr;
+    }
+    const std::streamsize SIZE = file.tellg();
+    file.seekg(0, std::ios::beg);
+    std::vector<uint8_t> buffer(static_cast<size_t>(SIZE));
+    if (!file.read(reinterpret_cast<char*>(buffer.data()), SIZE)) {
+        std::cerr << "[GpuDevice] Error llegint shader: " << PATH << '\n';
+        return nullptr;
+    }
+
+    SDL_GPUShaderCreateInfo info{};
+    info.code = buffer.data();
+    info.code_size = buffer.size();
+    info.entrypoint = "main";
+    info.format = SDL_GPU_SHADERFORMAT_SPIRV;
+    info.stage = stage;
+    info.num_uniform_buffers = num_uniform_buffers;
+    info.num_samplers = num_samplers;
+    info.num_storage_buffers = 0;
+    info.num_storage_textures = 0;
+
+    SDL_GPUShader* shader = SDL_CreateGPUShader(device_, &info);
+    if (shader == nullptr) {
+        std::cerr << "[GpuDevice] SDL_CreateGPUShader (" << spv_filename << "): " << SDL_GetError() << '\n';
+    }
+    return shader;
+}
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_device.hpp b/source/core/rendering/gpu/gpu_device.hpp
new file mode 100644
index 0000000..6e5b828
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_device.hpp
@@ -0,0 +1,59 @@
+// gpu_device.hpp - Wrapper de SDL_GPUDevice
+// © 2025 Orni Attack
+//
+// Ownership del SDL_GPUDevice y del claim del window. Backend preferido:
+// Vulkan (Linux, Windows) y Metal (macOS). Sin DirectX.
+//
+// Uso:
+//   GpuDevice device;
+//   if (!device.init(window)) return -1;       // claim del window
+//   ... renderer setup ...
+//   device.destroy();                          // unclaim + destroy device
+
+#pragma once
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <string>
+
+namespace Rendering::GPU {
+
+class GpuDevice {
+    public:
+        GpuDevice() = default;
+        ~GpuDevice();
+
+        // No copia / move (RAII propietario del device).
+        GpuDevice(const GpuDevice&) = delete;
+        auto operator=(const GpuDevice&) -> GpuDevice& = delete;
+        GpuDevice(GpuDevice&&) = delete;
+        auto operator=(GpuDevice&&) -> GpuDevice& = delete;
+
+        // Crea el device y claim el window. Devuelve false si no hay backend
+        // soportado o si el driver no permite el claim.
+        [[nodiscard]] auto init(SDL_Window* window) -> bool;
+        void destroy();
+
+        // Carga un shader SPIR-V desde build/shaders/{name}.spv. Devuelve un
+        // SDL_GPUShader* del que ahora es responsable el caller (libera con
+        // SDL_ReleaseGPUShader). Retorna nullptr si falla.
+        //
+        // num_uniform_buffers: nº de uniform buffers que usa el shader (slot 0..N-1).
+        // num_samplers: nº de samplers (combined image+sampler) usados por el shader.
+        [[nodiscard]] auto loadShader(const std::string& spv_filename,
+                                      SDL_GPUShaderStage stage,
+                                      uint32_t num_uniform_buffers,
+                                      uint32_t num_samplers = 0) const -> SDL_GPUShader*;
+
+        [[nodiscard]] auto get() const -> SDL_GPUDevice* { return device_; }
+        [[nodiscard]] auto window() const -> SDL_Window* { return window_; }
+        [[nodiscard]] auto swapchainFormat() const -> SDL_GPUTextureFormat { return swapchain_format_; }
+
+    private:
+        SDL_GPUDevice* device_{nullptr};
+        SDL_Window* window_{nullptr};
+        SDL_GPUTextureFormat swapchain_format_{SDL_GPU_TEXTUREFORMAT_INVALID};
+};
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_frame_renderer.cpp b/source/core/rendering/gpu/gpu_frame_renderer.cpp
new file mode 100644
index 0000000..dcbac0e
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_frame_renderer.cpp
@@ -0,0 +1,400 @@
+// gpu_frame_renderer.cpp - Implementación del FrameRenderer con offscreen + postpro
+
+#include "core/rendering/gpu/gpu_frame_renderer.hpp"
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <iostream>
+
+namespace Rendering::GPU {
+
+GpuFrameRenderer::~GpuFrameRenderer() { destroy(); }
+
+auto GpuFrameRenderer::init(SDL_Window* window, float logical_w, float logical_h) -> bool {
+    logical_w_ = logical_w;
+    logical_h_ = logical_h;
+
+    if (!device_.init(window)) {
+        return false;
+    }
+    // Pipeline de líneas: escribe sobre el offscreen (formato fijo).
+    if (!line_pipeline_.init(device_, offscreen_format_)) {
+        device_.destroy();
+        return false;
+    }
+    // Pipeline de postpro: escribe sobre swapchain (formato del swapchain).
+    if (!postfx_pipeline_.init(device_, device_.swapchainFormat())) {
+        line_pipeline_.destroy();
+        device_.destroy();
+        return false;
+    }
+    if (!createOffscreen()) {
+        postfx_pipeline_.destroy();
+        line_pipeline_.destroy();
+        device_.destroy();
+        return false;
+    }
+    return true;
+}
+
+auto GpuFrameRenderer::createOffscreen() -> bool {
+    SDL_GPUDevice* dev = device_.get();
+    if (dev == nullptr) {
+        return false;
+    }
+
+    // Textura offscreen del tamaño lógico del juego, COLOR_TARGET + SAMPLER.
+    SDL_GPUTextureCreateInfo tex_info{};
+    tex_info.type = SDL_GPU_TEXTURETYPE_2D;
+    tex_info.format = offscreen_format_;
+    tex_info.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER;
+    tex_info.width = static_cast<uint32_t>(logical_w_);
+    tex_info.height = static_cast<uint32_t>(logical_h_);
+    tex_info.layer_count_or_depth = 1;
+    tex_info.num_levels = 1;
+    tex_info.sample_count = SDL_GPU_SAMPLECOUNT_1;
+    offscreen_texture_ = SDL_CreateGPUTexture(dev, &tex_info);
+    if (offscreen_texture_ == nullptr) {
+        std::cerr << "[GpuFrameRenderer] SDL_CreateGPUTexture (offscreen): "
+                  << SDL_GetError() << '\n';
+        return false;
+    }
+
+    // Sampler lineal con clamp-to-edge (evita sangrado en los bordes del bloom).
+    SDL_GPUSamplerCreateInfo sampler_info{};
+    sampler_info.min_filter = SDL_GPU_FILTER_LINEAR;
+    sampler_info.mag_filter = SDL_GPU_FILTER_LINEAR;
+    sampler_info.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_LINEAR;
+    sampler_info.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    sampler_info.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    sampler_info.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    linear_sampler_ = SDL_CreateGPUSampler(dev, &sampler_info);
+    if (linear_sampler_ == nullptr) {
+        std::cerr << "[GpuFrameRenderer] SDL_CreateGPUSampler: "
+                  << SDL_GetError() << '\n';
+        return false;
+    }
+    return true;
+}
+
+void GpuFrameRenderer::destroyOffscreen() {
+    SDL_GPUDevice* dev = device_.get();
+    if (dev == nullptr) {
+        offscreen_texture_ = nullptr;
+        linear_sampler_ = nullptr;
+        return;
+    }
+    if (offscreen_texture_ != nullptr) {
+        SDL_ReleaseGPUTexture(dev, offscreen_texture_);
+        offscreen_texture_ = nullptr;
+    }
+    if (linear_sampler_ != nullptr) {
+        SDL_ReleaseGPUSampler(dev, linear_sampler_);
+        linear_sampler_ = nullptr;
+    }
+}
+
+void GpuFrameRenderer::destroy() {
+    destroyOffscreen();
+    postfx_pipeline_.destroy();
+    line_pipeline_.destroy();
+    device_.destroy();
+    vertices_.clear();
+    indices_.clear();
+}
+
+auto GpuFrameRenderer::beginFrame(float clear_r, float clear_g, float clear_b) -> bool {
+    // Los clear_* se ignoran: el fondo lo pinta el postpro. Mantenemos la
+    // firma para no romper el SDLManager.
+    (void)clear_r;
+    (void)clear_g;
+    (void)clear_b;
+
+    SDL_GPUDevice* dev = device_.get();
+    if (dev == nullptr) {
+        return false;
+    }
+
+    cmd_buffer_ = SDL_AcquireGPUCommandBuffer(dev);
+    if (cmd_buffer_ == nullptr) {
+        std::cerr << "[GpuFrameRenderer] SDL_AcquireGPUCommandBuffer: " << SDL_GetError() << '\n';
+        return false;
+    }
+
+    if (!SDL_WaitAndAcquireGPUSwapchainTexture(cmd_buffer_, device_.window(),
+                                               &swapchain_texture_, nullptr, nullptr)) {
+        std::cerr << "[GpuFrameRenderer] WaitAndAcquire: " << SDL_GetError() << '\n';
+        SDL_SubmitGPUCommandBuffer(cmd_buffer_);
+        cmd_buffer_ = nullptr;
+        return false;
+    }
+
+    if (swapchain_texture_ == nullptr) {
+        // Ventana minimizada o swapchain no disponible: solo submit y salir.
+        SDL_SubmitGPUCommandBuffer(cmd_buffer_);
+        cmd_buffer_ = nullptr;
+        return false;
+    }
+
+    // Abrir render pass sobre OFFSCREEN con clear a negro.
+    SDL_GPUColorTargetInfo color_target{};
+    color_target.texture = offscreen_texture_;
+    color_target.clear_color = SDL_FColor{.r = 0.0F, .g = 0.0F, .b = 0.0F, .a = 1.0F};
+    color_target.load_op = SDL_GPU_LOADOP_CLEAR;
+    color_target.store_op = SDL_GPU_STOREOP_STORE;
+    color_target.cycle = false;
+
+    render_pass_ = SDL_BeginGPURenderPass(cmd_buffer_, &color_target, 1, nullptr);
+    if (render_pass_ == nullptr) {
+        std::cerr << "[GpuFrameRenderer] SDL_BeginGPURenderPass (offscreen): "
+                  << SDL_GetError() << '\n';
+        SDL_SubmitGPUCommandBuffer(cmd_buffer_);
+        cmd_buffer_ = nullptr;
+        return false;
+    }
+    // Sin SetGPUViewport: el offscreen se llena entero a tamaño lógico.
+
+    vertices_.clear();
+    indices_.clear();
+    return true;
+}
+
+void GpuFrameRenderer::setViewport(float x, float y, float w, float h) {
+    viewport_x_ = x;
+    viewport_y_ = y;
+    viewport_w_ = w;
+    viewport_h_ = h;
+    // El viewport solo se aplica en el pase final (composite). Si estamos
+    // ya dentro del composite, lo aplicaríamos inmediatamente, pero la API
+    // está pensada para llamarse antes de endFrame/al cambiar de ventana.
+}
+
+void GpuFrameRenderer::setVSync(bool enabled) {
+    SDL_GPUDevice* dev = device_.get();
+    if (dev == nullptr || device_.window() == nullptr) {
+        return;
+    }
+    const SDL_GPUPresentMode MODE = enabled
+        ? SDL_GPU_PRESENTMODE_VSYNC
+        : SDL_GPU_PRESENTMODE_IMMEDIATE;
+    if (!SDL_SetGPUSwapchainParameters(dev, device_.window(),
+                                       SDL_GPU_SWAPCHAINCOMPOSITION_SDR, MODE)) {
+        std::cerr << "[GpuFrameRenderer] SDL_SetGPUSwapchainParameters: " << SDL_GetError() << '\n';
+    }
+}
+
+void GpuFrameRenderer::applyFinalViewport() {
+    if (render_pass_ == nullptr) {
+        return;
+    }
+    if (viewport_w_ <= 0.0F || viewport_h_ <= 0.0F) {
+        return;
+    }
+    SDL_GPUViewport vp{};
+    vp.x = viewport_x_;
+    vp.y = viewport_y_;
+    vp.w = viewport_w_;
+    vp.h = viewport_h_;
+    vp.min_depth = 0.0F;
+    vp.max_depth = 1.0F;
+    SDL_SetGPUViewport(render_pass_, &vp);
+}
+
+void GpuFrameRenderer::pushLine(float x1, float y1, float x2, float y2, float thickness,
+                                float r, float g, float b, float a) {
+    const float DX = x2 - x1;
+    const float DY = y2 - y1;
+    const float LEN = std::sqrt((DX * DX) + (DY * DY));
+    if (LEN < 1e-6F) {
+        return;
+    }
+
+    const float HALF = thickness * 0.5F;
+    const float NX = -DY / LEN * HALF;
+    const float NY = DX / LEN * HALF;
+
+    const auto BASE_INDEX = static_cast<uint16_t>(vertices_.size());
+
+    vertices_.push_back({x1 + NX, y1 + NY, r, g, b, a});
+    vertices_.push_back({x1 - NX, y1 - NY, r, g, b, a});
+    vertices_.push_back({x2 + NX, y2 + NY, r, g, b, a});
+    vertices_.push_back({x2 - NX, y2 - NY, r, g, b, a});
+
+    indices_.push_back(BASE_INDEX + 0);
+    indices_.push_back(BASE_INDEX + 1);
+    indices_.push_back(BASE_INDEX + 2);
+    indices_.push_back(BASE_INDEX + 1);
+    indices_.push_back(BASE_INDEX + 3);
+    indices_.push_back(BASE_INDEX + 2);
+}
+
+void GpuFrameRenderer::flushBatch() {
+    if (vertices_.empty() || indices_.empty()) {
+        return;
+    }
+
+    SDL_GPUDevice* dev = device_.get();
+
+    const uint32_t VBO_SIZE = static_cast<uint32_t>(vertices_.size() * sizeof(LineVertex));
+    const uint32_t IBO_SIZE = static_cast<uint32_t>(indices_.size() * sizeof(uint16_t));
+
+    SDL_GPUBufferCreateInfo vbo_info{};
+    vbo_info.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
+    vbo_info.size = VBO_SIZE;
+    SDL_GPUBuffer* vbo = SDL_CreateGPUBuffer(dev, &vbo_info);
+
+    SDL_GPUBufferCreateInfo ibo_info{};
+    ibo_info.usage = SDL_GPU_BUFFERUSAGE_INDEX;
+    ibo_info.size = IBO_SIZE;
+    SDL_GPUBuffer* ibo = SDL_CreateGPUBuffer(dev, &ibo_info);
+
+    SDL_GPUTransferBufferCreateInfo tbo_info{};
+    tbo_info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+    tbo_info.size = VBO_SIZE + IBO_SIZE;
+    SDL_GPUTransferBuffer* tbo = SDL_CreateGPUTransferBuffer(dev, &tbo_info);
+
+    auto* mapped = static_cast<uint8_t*>(SDL_MapGPUTransferBuffer(dev, tbo, false));
+    std::memcpy(mapped, vertices_.data(), VBO_SIZE);
+    std::memcpy(mapped + VBO_SIZE, indices_.data(), IBO_SIZE);
+    SDL_UnmapGPUTransferBuffer(dev, tbo);
+
+    // Copy pass FUERA del render pass.
+    SDL_EndGPURenderPass(render_pass_);
+    render_pass_ = nullptr;
+
+    SDL_GPUCopyPass* copy_pass = SDL_BeginGPUCopyPass(cmd_buffer_);
+    SDL_GPUTransferBufferLocation vbo_src{.transfer_buffer = tbo, .offset = 0};
+    SDL_GPUBufferRegion vbo_dst{.buffer = vbo, .offset = 0, .size = VBO_SIZE};
+    SDL_UploadToGPUBuffer(copy_pass, &vbo_src, &vbo_dst, false);
+    SDL_GPUTransferBufferLocation ibo_src{.transfer_buffer = tbo, .offset = VBO_SIZE};
+    SDL_GPUBufferRegion ibo_dst{.buffer = ibo, .offset = 0, .size = IBO_SIZE};
+    SDL_UploadToGPUBuffer(copy_pass, &ibo_src, &ibo_dst, false);
+    SDL_EndGPUCopyPass(copy_pass);
+
+    // Reabrir render pass sobre OFFSCREEN (load_op=LOAD para preservar el clear).
+    SDL_GPUColorTargetInfo color_target{};
+    color_target.texture = offscreen_texture_;
+    color_target.load_op = SDL_GPU_LOADOP_LOAD;
+    color_target.store_op = SDL_GPU_STOREOP_STORE;
+    render_pass_ = SDL_BeginGPURenderPass(cmd_buffer_, &color_target, 1, nullptr);
+
+    SDL_BindGPUGraphicsPipeline(render_pass_, line_pipeline_.get());
+
+    // UBO de líneas usa el tamaño lógico (también del offscreen).
+    LineUniforms ubo{.viewport_width = logical_w_,
+                     .viewport_height = logical_h_,
+                     .padding_0 = 0.0F,
+                     .padding_1 = 0.0F};
+    SDL_PushGPUVertexUniformData(cmd_buffer_, 0, &ubo, sizeof(ubo));
+
+    SDL_GPUBufferBinding vbo_binding{.buffer = vbo, .offset = 0};
+    SDL_BindGPUVertexBuffers(render_pass_, 0, &vbo_binding, 1);
+
+    SDL_GPUBufferBinding ibo_binding{.buffer = ibo, .offset = 0};
+    SDL_BindGPUIndexBuffer(render_pass_, &ibo_binding, SDL_GPU_INDEXELEMENTSIZE_16BIT);
+
+    SDL_DrawGPUIndexedPrimitives(render_pass_,
+                                 static_cast<uint32_t>(indices_.size()),
+                                 1, 0, 0, 0);
+
+    SDL_ReleaseGPUBuffer(dev, vbo);
+    SDL_ReleaseGPUBuffer(dev, ibo);
+    SDL_ReleaseGPUTransferBuffer(dev, tbo);
+}
+
+void GpuFrameRenderer::compositePass() {
+    // Cierra el render pass actual (sobre offscreen).
+    if (render_pass_ != nullptr) {
+        SDL_EndGPURenderPass(render_pass_);
+        render_pass_ = nullptr;
+    }
+
+    // Pase final: render pass sobre SWAPCHAIN con clear a negro (cubre el
+    // letterbox del viewport físico).
+    SDL_GPUColorTargetInfo target{};
+    target.texture = swapchain_texture_;
+    target.clear_color = SDL_FColor{.r = 0.0F, .g = 0.0F, .b = 0.0F, .a = 1.0F};
+    target.load_op = SDL_GPU_LOADOP_CLEAR;
+    target.store_op = SDL_GPU_STOREOP_STORE;
+    target.cycle = false;
+    render_pass_ = SDL_BeginGPURenderPass(cmd_buffer_, &target, 1, nullptr);
+    if (render_pass_ == nullptr) {
+        std::cerr << "[GpuFrameRenderer] BeginRenderPass (composite): "
+                  << SDL_GetError() << '\n';
+        return;
+    }
+    applyFinalViewport();
+
+    SDL_BindGPUGraphicsPipeline(render_pass_, postfx_pipeline_.get());
+
+    // Bind del sampler (escena offscreen) en slot 0 del fragment shader.
+    SDL_GPUTextureSamplerBinding sampler_binding{};
+    sampler_binding.texture = offscreen_texture_;
+    sampler_binding.sampler = linear_sampler_;
+    SDL_BindGPUFragmentSamplers(render_pass_, 0, &sampler_binding, 1);
+
+    // Uniforms del postpro. Si una sección está desactivada, anulamos sus
+    // contribuciones (intensidad / amplitud / max=min) en lugar de tener
+    // un branch en el shader.
+    const float BLOOM_INTENSITY = postfx_params_.bloom_enabled
+        ? postfx_params_.bloom_intensity : 0.0F;
+    const float FLICKER_AMPLITUDE = postfx_params_.flicker_enabled
+        ? postfx_params_.flicker_amplitude : 0.0F;
+    const float BG_MIN_R = postfx_params_.background_enabled ? postfx_params_.background_min_r : 0.0F;
+    const float BG_MIN_G = postfx_params_.background_enabled ? postfx_params_.background_min_g : 0.0F;
+    const float BG_MIN_B = postfx_params_.background_enabled ? postfx_params_.background_min_b : 0.0F;
+    const float BG_MAX_R = postfx_params_.background_enabled ? postfx_params_.background_max_r : 0.0F;
+    const float BG_MAX_G = postfx_params_.background_enabled ? postfx_params_.background_max_g : 0.0F;
+    const float BG_MAX_B = postfx_params_.background_enabled ? postfx_params_.background_max_b : 0.0F;
+
+    // Tiempo en segundos desde el inicio de SDL (wall-clock real, robusto a FPS variables).
+    const float TIME_SECONDS = static_cast<float>(SDL_GetTicks()) / 1000.0F;
+
+    PostFxUniforms ubo{};
+    ubo.time = TIME_SECONDS;
+    ubo.bloom_intensity = BLOOM_INTENSITY;
+    ubo.bloom_threshold = postfx_params_.bloom_threshold;
+    ubo.bloom_radius_px = postfx_params_.bloom_radius_px;
+    ubo.flicker_amplitude = FLICKER_AMPLITUDE;
+    ubo.flicker_frequency_hz = postfx_params_.flicker_frequency_hz;
+    ubo.background_pulse_freq_hz = postfx_params_.background_pulse_freq_hz;
+    ubo.pad_a_ = 0.0F;
+    ubo.background_min_r = BG_MIN_R;
+    ubo.background_min_g = BG_MIN_G;
+    ubo.background_min_b = BG_MIN_B;
+    ubo.background_min_a = 1.0F;
+    ubo.background_max_r = BG_MAX_R;
+    ubo.background_max_g = BG_MAX_G;
+    ubo.background_max_b = BG_MAX_B;
+    ubo.background_max_a = 1.0F;
+    ubo.texel_size_x = 1.0F / logical_w_;
+    ubo.texel_size_y = 1.0F / logical_h_;
+    ubo.pad_b_ = 0.0F;
+    ubo.pad_c_ = 0.0F;
+
+    SDL_PushGPUFragmentUniformData(cmd_buffer_, 0, &ubo, sizeof(ubo));
+
+    // Fullscreen triangle: 3 vértices generados en el shader, sin VBO.
+    SDL_DrawGPUPrimitives(render_pass_, 3, 1, 0, 0);
+}
+
+void GpuFrameRenderer::endFrame() {
+    if (cmd_buffer_ == nullptr) {
+        return;
+    }
+    flushBatch();
+    compositePass();
+    if (render_pass_ != nullptr) {
+        SDL_EndGPURenderPass(render_pass_);
+        render_pass_ = nullptr;
+    }
+    SDL_SubmitGPUCommandBuffer(cmd_buffer_);
+    cmd_buffer_ = nullptr;
+    swapchain_texture_ = nullptr;
+}
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_frame_renderer.hpp b/source/core/rendering/gpu/gpu_frame_renderer.hpp
new file mode 100644
index 0000000..3e78bdd
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_frame_renderer.hpp
@@ -0,0 +1,139 @@
+// gpu_frame_renderer.hpp - Renderer de alto nivel basado en SDL_GPU
+// © 2025 Orni Attack
+//
+// Flujo por frame:
+//   1. beginFrame(clear_color)
+//        → acquire swapchain + begin render pass sobre la textura OFFSCREEN
+//          (clear a black; la swapchain se pinta después con el postpro).
+//   2. pushLine(...) — encola líneas (extrusión en CPU).
+//   3. endFrame()
+//        → flush del batch en offscreen + pase de postpro (sample offscreen
+//          → swapchain con bloom/flicker/background) + submit + presenta.
+//
+// La oscilación de brillo y el fondo pulsante viven ahora en el shader de
+// postpro; el CPU solo le pasa los uniformes del struct PostFxParams.
+
+#pragma once
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "core/rendering/gpu/gpu_device.hpp"
+#include "core/rendering/gpu/gpu_line_pipeline.hpp"
+#include "core/rendering/gpu/gpu_postfx_pipeline.hpp"
+
+namespace Rendering::GPU {
+
+// Parámetros del postpro que el caller (SDLManager) pasa cada frame.
+// Equivalente al lado "humano" del PostFxUniforms (sin paddings).
+struct PostFxParams {
+    bool bloom_enabled{true};
+    float bloom_intensity{0.6F};
+    float bloom_threshold{0.4F};
+    float bloom_radius_px{2.0F};
+
+    bool flicker_enabled{true};
+    float flicker_amplitude{0.10F};
+    float flicker_frequency_hz{6.0F};
+
+    bool background_enabled{true};
+    float background_min_r{0.0F};
+    float background_min_g{0.02F};
+    float background_min_b{0.0F};
+    float background_max_r{0.0F};
+    float background_max_g{0.06F};
+    float background_max_b{0.0F};
+    float background_pulse_freq_hz{6.0F};
+};
+
+class GpuFrameRenderer {
+    public:
+        GpuFrameRenderer() = default;
+        ~GpuFrameRenderer();
+
+        GpuFrameRenderer(const GpuFrameRenderer&) = delete;
+        auto operator=(const GpuFrameRenderer&) -> GpuFrameRenderer& = delete;
+        GpuFrameRenderer(GpuFrameRenderer&&) = delete;
+        auto operator=(GpuFrameRenderer&&) -> GpuFrameRenderer& = delete;
+
+        // Crea device + pipeline + offscreen + sampler. logical_w/h = tamaño
+        // en píxeles lógicos del juego (1280×720), usado como base del
+        // offscreen y de la transformación a NDC del shader de líneas.
+        [[nodiscard]] auto init(SDL_Window* window, float logical_w, float logical_h) -> bool;
+        void destroy();
+
+        // beginFrame: adquiere swapchain, abre render pass sobre offscreen
+        // con clear a negro. Devuelve false si no hay textura disponible.
+        // Los argumentos clear_r/g/b se ignoran (compatibilidad de API: el
+        // fondo lo dibuja el postpro).
+        [[nodiscard]] auto beginFrame(float clear_r, float clear_g, float clear_b) -> bool;
+
+        // Encola una línea con grosor configurable (px). Color RGBA en [0..1].
+        void pushLine(float x1, float y1, float x2, float y2, float thickness,
+                      float r, float g, float b, float a);
+
+        // endFrame: flush del batch de líneas → composite postpro → submit + presenta.
+        void endFrame();
+
+        // Viewport del PASE FINAL (postpro → swapchain) en píxeles físicos.
+        // Implementa el letterbox: cualquier área fuera del viewport queda
+        // como el clear color del pase de composite (negro). Si w<=0 o h<=0,
+        // se usa el tamaño completo de la ventana.
+        void setViewport(float x, float y, float w, float h);
+
+        // Activa/desactiva VSync. true = SDL_GPU_PRESENTMODE_VSYNC, false = IMMEDIATE.
+        void setVSync(bool enabled);
+
+        // Parámetros del postpro que se aplican en endFrame. Por defecto =
+        // valores de Defaults (bloom moderado, flicker suave, fondo verde tenue).
+        void setPostFx(const PostFxParams& params) { postfx_params_ = params; }
+        [[nodiscard]] auto postfx() const -> const PostFxParams& { return postfx_params_; }
+
+        // Acceso a internals.
+        [[nodiscard]] auto device() -> GpuDevice& { return device_; }
+        [[nodiscard]] auto isInsideFrame() const -> bool { return cmd_buffer_ != nullptr; }
+
+    private:
+        GpuDevice device_;
+        GpuLinePipeline line_pipeline_;
+        GpuPostFxPipeline postfx_pipeline_;
+
+        // Tamaño lógico del juego (= tamaño del offscreen).
+        float logical_w_{1280.0F};
+        float logical_h_{720.0F};
+
+        // Viewport del pase final en píxeles físicos. <0 = full window.
+        float viewport_x_{0.0F};
+        float viewport_y_{0.0F};
+        float viewport_w_{-1.0F};
+        float viewport_h_{-1.0F};
+
+        // Offscreen color target (formato fijo R8G8B8A8_UNORM para portabilidad).
+        SDL_GPUTexture* offscreen_texture_{nullptr};
+        SDL_GPUTextureFormat offscreen_format_{SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM};
+        SDL_GPUSampler* linear_sampler_{nullptr};
+
+        // Batch del frame en curso.
+        std::vector<LineVertex> vertices_;
+        std::vector<uint16_t> indices_;
+
+        // Estado del frame en curso.
+        SDL_GPUCommandBuffer* cmd_buffer_{nullptr};
+        SDL_GPUTexture* swapchain_texture_{nullptr};
+        SDL_GPURenderPass* render_pass_{nullptr};
+
+        // Parámetros del postpro (configurables vía YAML).
+        PostFxParams postfx_params_{};
+
+        // Helpers internos.
+        [[nodiscard]] auto createOffscreen() -> bool;
+        void destroyOffscreen();
+        void flushBatch();
+        void compositePass();
+        void applyFinalViewport();
+};
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_line_pipeline.cpp b/source/core/rendering/gpu/gpu_line_pipeline.cpp
new file mode 100644
index 0000000..38705bf
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_line_pipeline.cpp
@@ -0,0 +1,117 @@
+// gpu_line_pipeline.cpp - Implementación del pipeline de líneas
+
+#include "core/rendering/gpu/gpu_line_pipeline.hpp"
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <iostream>
+
+#include "core/rendering/gpu/gpu_device.hpp"
+
+namespace Rendering::GPU {
+
+GpuLinePipeline::~GpuLinePipeline() { destroy(); }
+
+auto GpuLinePipeline::init(const GpuDevice& device,
+                           SDL_GPUTextureFormat target_format) -> bool {
+    owner_ = device.get();
+    if (owner_ == nullptr) {
+        return false;
+    }
+
+    SDL_GPUShader* vert = device.loadShader("line.vert.spv",
+                                            SDL_GPU_SHADERSTAGE_VERTEX,
+                                            /*num_uniform_buffers=*/1);
+    SDL_GPUShader* frag = device.loadShader("line.frag.spv",
+                                            SDL_GPU_SHADERSTAGE_FRAGMENT,
+                                            /*num_uniform_buffers=*/0);
+    if ((vert == nullptr) || (frag == nullptr)) {
+        if (vert != nullptr) {
+            SDL_ReleaseGPUShader(owner_, vert);
+        }
+        if (frag != nullptr) {
+            SDL_ReleaseGPUShader(owner_, frag);
+        }
+        std::cerr << "[GpuLinePipeline] Error cargando shaders\n";
+        return false;
+    }
+
+    // Vertex layout: pos (vec2) + color (vec4) → 6 floats por vertex.
+    SDL_GPUVertexBufferDescription vbo_desc{};
+    vbo_desc.slot = 0;
+    vbo_desc.pitch = sizeof(LineVertex);
+    vbo_desc.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
+    vbo_desc.instance_step_rate = 0;
+
+    SDL_GPUVertexAttribute attrs[2];
+    attrs[0].location = 0;  // in_position
+    attrs[0].buffer_slot = 0;
+    attrs[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
+    attrs[0].offset = 0;
+    attrs[1].location = 1;  // in_color
+    attrs[1].buffer_slot = 0;
+    attrs[1].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4;
+    attrs[1].offset = sizeof(float) * 2;
+
+    SDL_GPUVertexInputState vertex_input{};
+    vertex_input.vertex_buffer_descriptions = &vbo_desc;
+    vertex_input.num_vertex_buffers = 1;
+    vertex_input.vertex_attributes = attrs;
+    vertex_input.num_vertex_attributes = 2;
+
+    // Color target = formato pasado por el caller (offscreen u otro).
+    // Blending alpha estándar.
+    SDL_GPUColorTargetDescription color_target{};
+    color_target.format = target_format;
+    color_target.blend_state.enable_blend = true;
+    color_target.blend_state.src_color_blendfactor = SDL_GPU_BLENDFACTOR_SRC_ALPHA;
+    color_target.blend_state.dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+    color_target.blend_state.color_blend_op = SDL_GPU_BLENDOP_ADD;
+    color_target.blend_state.src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE;
+    color_target.blend_state.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+    color_target.blend_state.alpha_blend_op = SDL_GPU_BLENDOP_ADD;
+    color_target.blend_state.color_write_mask =
+        SDL_GPU_COLORCOMPONENT_R | SDL_GPU_COLORCOMPONENT_G |
+        SDL_GPU_COLORCOMPONENT_B | SDL_GPU_COLORCOMPONENT_A;
+
+    SDL_GPUGraphicsPipelineTargetInfo target_info{};
+    target_info.color_target_descriptions = &color_target;
+    target_info.num_color_targets = 1;
+    target_info.has_depth_stencil_target = false;
+
+    SDL_GPUGraphicsPipelineCreateInfo info{};
+    info.vertex_shader = vert;
+    info.fragment_shader = frag;
+    info.vertex_input_state = vertex_input;
+    info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+    info.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL;
+    info.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;  // No backface culling para 2D
+    info.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
+    info.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1;
+    info.depth_stencil_state = {};
+    info.target_info = target_info;
+
+    pipeline_ = SDL_CreateGPUGraphicsPipeline(owner_, &info);
+
+    // Los shaders se pueden liberar tras crear el pipeline (SDL los retiene
+    // internamente mientras el pipeline esté vivo).
+    SDL_ReleaseGPUShader(owner_, vert);
+    SDL_ReleaseGPUShader(owner_, frag);
+
+    if (pipeline_ == nullptr) {
+        std::cerr << "[GpuLinePipeline] SDL_CreateGPUGraphicsPipeline: " << SDL_GetError() << '\n';
+        return false;
+    }
+    return true;
+}
+
+void GpuLinePipeline::destroy() {
+    if ((pipeline_ != nullptr) && (owner_ != nullptr)) {
+        SDL_ReleaseGPUGraphicsPipeline(owner_, pipeline_);
+    }
+    pipeline_ = nullptr;
+    owner_ = nullptr;
+}
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_line_pipeline.hpp b/source/core/rendering/gpu/gpu_line_pipeline.hpp
new file mode 100644
index 0000000..f5c6c0f
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_line_pipeline.hpp
@@ -0,0 +1,60 @@
+// gpu_line_pipeline.hpp - Pipeline gráfico para dibujar líneas vectoriales
+// © 2025 Orni Attack
+//
+// Las líneas se renderizan como quads (2 triángulos = 6 índices) ya extrudidos
+// en CPU según el grosor pedido por línea. Vertex layout: position (vec2) + color (vec4).
+// Primitive type: TRIANGLELIST. Sin depth test (juego 2D), blending alpha estándar.
+
+#pragma once
+
+#include <SDL3/SDL_gpu.h>
+
+#include <cstdint>
+
+namespace Rendering::GPU {
+
+class GpuDevice;
+
+// Vertex layout (debe coincidir con shaders/line.vert.glsl).
+struct LineVertex {
+        float x;
+        float y;
+        float r;
+        float g;
+        float b;
+        float a;
+};
+
+// Uniform buffer del vertex shader (debe coincidir con UBO en line.vert.glsl).
+struct LineUniforms {
+        float viewport_width;
+        float viewport_height;
+        float padding_0;
+        float padding_1;  // Alineamiento a 16 bytes
+};
+
+class GpuLinePipeline {
+    public:
+        GpuLinePipeline() = default;
+        ~GpuLinePipeline();
+
+        GpuLinePipeline(const GpuLinePipeline&) = delete;
+        auto operator=(const GpuLinePipeline&) -> GpuLinePipeline& = delete;
+        GpuLinePipeline(GpuLinePipeline&&) = delete;
+        auto operator=(GpuLinePipeline&&) -> GpuLinePipeline& = delete;
+
+        // target_format: formato del color target sobre el que renderizamos
+        // (swapchain o offscreen). Por defecto coincide con el del swapchain
+        // del device.
+        [[nodiscard]] auto init(const GpuDevice& device,
+                                SDL_GPUTextureFormat target_format) -> bool;
+        void destroy();
+
+        [[nodiscard]] auto get() const -> SDL_GPUGraphicsPipeline* { return pipeline_; }
+
+    private:
+        SDL_GPUDevice* owner_{nullptr};  // No-owning; el GpuDevice es el dueño
+        SDL_GPUGraphicsPipeline* pipeline_{nullptr};
+};
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_postfx_pipeline.cpp b/source/core/rendering/gpu/gpu_postfx_pipeline.cpp
new file mode 100644
index 0000000..63a53cd
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_postfx_pipeline.cpp
@@ -0,0 +1,98 @@
+// gpu_postfx_pipeline.cpp - Implementación del pipeline de postprocesado.
+
+#include "core/rendering/gpu/gpu_postfx_pipeline.hpp"
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <iostream>
+
+#include "core/rendering/gpu/gpu_device.hpp"
+
+namespace Rendering::GPU {
+
+GpuPostFxPipeline::~GpuPostFxPipeline() { destroy(); }
+
+auto GpuPostFxPipeline::init(const GpuDevice& device,
+                             SDL_GPUTextureFormat target_format) -> bool {
+    owner_ = device.get();
+    if (owner_ == nullptr) {
+        return false;
+    }
+
+    // El vertex shader no usa UBO (emite tres vértices hardcodeados).
+    // El fragment shader usa 1 sampler (escena) y 1 UBO (parámetros postpro).
+    SDL_GPUShader* vert = device.loadShader("postfx.vert.spv",
+                                            SDL_GPU_SHADERSTAGE_VERTEX,
+                                            /*num_uniform_buffers=*/0,
+                                            /*num_samplers=*/0);
+    SDL_GPUShader* frag = device.loadShader("postfx.frag.spv",
+                                            SDL_GPU_SHADERSTAGE_FRAGMENT,
+                                            /*num_uniform_buffers=*/1,
+                                            /*num_samplers=*/1);
+    if ((vert == nullptr) || (frag == nullptr)) {
+        if (vert != nullptr) {
+            SDL_ReleaseGPUShader(owner_, vert);
+        }
+        if (frag != nullptr) {
+            SDL_ReleaseGPUShader(owner_, frag);
+        }
+        std::cerr << "[GpuPostFxPipeline] Error cargando shaders postfx\n";
+        return false;
+    }
+
+    // Sin vertex input: los tres vértices del triángulo se generan en el shader.
+    SDL_GPUVertexInputState vertex_input{};
+    vertex_input.vertex_buffer_descriptions = nullptr;
+    vertex_input.num_vertex_buffers = 0;
+    vertex_input.vertex_attributes = nullptr;
+    vertex_input.num_vertex_attributes = 0;
+
+    // Color target del postpro = swapchain. Sin blending: el postpro reescribe
+    // píxeles directamente (la mezcla con la escena ya se hizo dentro del shader).
+    SDL_GPUColorTargetDescription color_target{};
+    color_target.format = target_format;
+    color_target.blend_state.enable_blend = false;
+    color_target.blend_state.color_write_mask =
+        SDL_GPU_COLORCOMPONENT_R | SDL_GPU_COLORCOMPONENT_G |
+        SDL_GPU_COLORCOMPONENT_B | SDL_GPU_COLORCOMPONENT_A;
+
+    SDL_GPUGraphicsPipelineTargetInfo target_info{};
+    target_info.color_target_descriptions = &color_target;
+    target_info.num_color_targets = 1;
+    target_info.has_depth_stencil_target = false;
+
+    SDL_GPUGraphicsPipelineCreateInfo info{};
+    info.vertex_shader = vert;
+    info.fragment_shader = frag;
+    info.vertex_input_state = vertex_input;
+    info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+    info.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL;
+    info.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;
+    info.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
+    info.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1;
+    info.depth_stencil_state = {};
+    info.target_info = target_info;
+
+    pipeline_ = SDL_CreateGPUGraphicsPipeline(owner_, &info);
+
+    SDL_ReleaseGPUShader(owner_, vert);
+    SDL_ReleaseGPUShader(owner_, frag);
+
+    if (pipeline_ == nullptr) {
+        std::cerr << "[GpuPostFxPipeline] SDL_CreateGPUGraphicsPipeline: "
+                  << SDL_GetError() << '\n';
+        return false;
+    }
+    return true;
+}
+
+void GpuPostFxPipeline::destroy() {
+    if ((pipeline_ != nullptr) && (owner_ != nullptr)) {
+        SDL_ReleaseGPUGraphicsPipeline(owner_, pipeline_);
+    }
+    pipeline_ = nullptr;
+    owner_ = nullptr;
+}
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/gpu/gpu_postfx_pipeline.hpp b/source/core/rendering/gpu/gpu_postfx_pipeline.hpp
new file mode 100644
index 0000000..0d897c4
--- /dev/null
+++ b/source/core/rendering/gpu/gpu_postfx_pipeline.hpp
@@ -0,0 +1,72 @@
+// gpu_postfx_pipeline.hpp - Pipeline de postprocesado (fullscreen triangle)
+// © 2025 Orni Attack
+//
+// Pase final del frame: muestrea la escena renderizada en offscreen y aplica
+// bloom + flicker + background pulse en el fragment shader. El vertex shader
+// emite un único triángulo que cubre toda la pantalla, así que el draw no
+// necesita vertex buffer (DrawPrimitives con vertex_count=3).
+//
+// Recursos del shader (SDL_gpu set bindings):
+//   fragment set=2, binding=0 → sampler2D (escena offscreen)
+//   fragment set=3, binding=0 → uniform buffer (parámetros del postpro)
+
+#pragma once
+
+#include <SDL3/SDL_gpu.h>
+
+namespace Rendering::GPU {
+
+class GpuDevice;
+
+// Uniform buffer del postpro. Debe coincidir EXACTAMENTE con
+// shaders/postfx.frag.glsl (layout std140 con vec4 alineadas a 16 bytes).
+struct PostFxUniforms {
+    float time;                          // Tiempo acumulado en segundos
+    float bloom_intensity;               // Mezcla bloom (0..2)
+    float bloom_threshold;               // Luminancia mínima high-pass (0..1)
+    float bloom_radius_px;               // Radio del kernel en píxeles lógicos
+
+    float flicker_amplitude;             // Profundidad del flicker (0..1)
+    float flicker_frequency_hz;          // Hz
+    float background_pulse_freq_hz;      // Hz
+    float pad_a_;
+
+    float background_min_r;              // Color min RGB en [0..1], A=1
+    float background_min_g;
+    float background_min_b;
+    float background_min_a;
+
+    float background_max_r;
+    float background_max_g;
+    float background_max_b;
+    float background_max_a;
+
+    float texel_size_x;                  // 1.0 / texture_width
+    float texel_size_y;
+    float pad_b_;
+    float pad_c_;
+};
+
+class GpuPostFxPipeline {
+    public:
+        GpuPostFxPipeline() = default;
+        ~GpuPostFxPipeline();
+
+        GpuPostFxPipeline(const GpuPostFxPipeline&) = delete;
+        auto operator=(const GpuPostFxPipeline&) -> GpuPostFxPipeline& = delete;
+        GpuPostFxPipeline(GpuPostFxPipeline&&) = delete;
+        auto operator=(GpuPostFxPipeline&&) -> GpuPostFxPipeline& = delete;
+
+        // target_format: formato del color target del pase final (swapchain).
+        [[nodiscard]] auto init(const GpuDevice& device,
+                                SDL_GPUTextureFormat target_format) -> bool;
+        void destroy();
+
+        [[nodiscard]] auto get() const -> SDL_GPUGraphicsPipeline* { return pipeline_; }
+
+    private:
+        SDL_GPUDevice* owner_{nullptr};
+        SDL_GPUGraphicsPipeline* pipeline_{nullptr};
+};
+
+}  // namespace Rendering::GPU
diff --git a/source/core/rendering/line_renderer.cpp b/source/core/rendering/line_renderer.cpp
index c387288..c6afdc8 100644
--- a/source/core/rendering/line_renderer.cpp
+++ b/source/core/rendering/line_renderer.cpp
@@ -1,102 +1,55 @@
-// line_renderer.cpp - Implementació de renderitzat de línies
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
+// line_renderer.cpp - Implementación de renderizado de líneas (SDL3 GPU)
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
 
 #include "core/rendering/line_renderer.hpp"
 
-#include <cmath>
-
-#include "core/rendering/coordinate_transform.hpp"
-
 namespace Rendering {
 
-// [NUEVO] Color global compartit (actualitzat per ColorOscillator via
-// SDLManager)
-SDL_Color g_current_line_color = {255, 255, 255, 255};  // Blanc inicial
+// Color global compartido para líneas sin paleta propia (HUD, debug, texto
+// genérico). Equivale al "color máximo" de la antigua oscilación CPU: verde
+// fósforo CRT. El pulso de brillo lo aplica ahora el shader de postpro.
+SDL_Color g_current_line_color = {100, 255, 100, 255};
 
-bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar, float brightness) {
-    // Algorisme de Bresenham per dibuixar línies
-    // Basat en el codi Pascal original
+// Grosor global por defecto. Configurable via setLineThickness.
+// 1.5 da una línea visible y crujiente; 1.0 se ve demasiado fino en pantallas grandes.
+float g_current_line_thickness = 1.5F;
 
-    // Helper function: retorna el signe d'un nombre
-    auto sign = [](int x) -> int {
-        if (x < 0) {
-            return -1;
-        }
-        if (x > 0) {
-            return 1;
-        }
-        return 0;
-    };
-
-    // Variables per a l'algorisme (no utilitzades fins Fase 10 - detecció de
-    // col·lisions) int x = x1, y = y1; int xs = x2 - x1; int ys = y2 - y1; int
-    // xm = sign(xs); int ym = sign(ys); xs = std::abs(xs); ys = std::abs(ys);
-
-    // Suprimir warning de variable no usada
-    (void)sign;
-
-    // Detecció de col·lisió (TODO per Fase 10)
-    // El codi Pascal original llegia pixels del framebuffer bit-packed
-    // i comptava col·lisions. Per ara, usem SDL_RenderDrawLine i retornem false.
-    bool colisio = false;
-
-    // Dibuixar amb SDL3 (més eficient que Bresenham píxel a píxel)
-    if (dibuixar && (renderer != nullptr)) {
-        // Transformar coordenades lògiques (640x480) a físiques (resolució real)
-        float scale = g_current_scale_factor;
-        int px1 = transform_x(x1, scale);
-        int py1 = transform_y(y1, scale);
-        int px2 = transform_x(x2, scale);
-        int py2 = transform_y(y2, scale);
-
-        // Aplicar brightness al color oscil·lat global
-        SDL_Color color_final;
-        color_final.r = static_cast<uint8_t>(g_current_line_color.r * brightness);
-        color_final.g = static_cast<uint8_t>(g_current_line_color.g * brightness);
-        color_final.b = static_cast<uint8_t>(g_current_line_color.b * brightness);
-        color_final.a = 255;
-
-        SDL_SetRenderDrawColor(renderer, color_final.r, color_final.g, color_final.b, 255);
-
-        // Renderitzar amb coordenades físiques
-        SDL_RenderLine(renderer, static_cast<float>(px1), static_cast<float>(py1), static_cast<float>(px2), static_cast<float>(py2));
+void linea(Renderer* renderer,
+           int x1, int y1, int x2, int y2,
+           float brightness,
+           float thickness,
+           SDL_Color color) {
+    if (renderer == nullptr) {
+        return;
     }
 
-    // Algorisme de Bresenham original (conservat per a futura detecció de
-    // col·lisió)
-    /*
-    if (xs > ys) {
-        // Línia plana (<45 graus)
-        int count = -(xs / 2);
-        while (x != x2) {
-            count = count + ys;
-            x = x + xm;
-            if (count > 0) {
-                y = y + ym;
-                count = count - xs;
-            }
-            // Aquí aniria la detecció de col·lisió píxel a píxel
-        }
-    } else {
-        // Línia pronunciada (>=45 graus)
-        int count = -(ys / 2);
-        while (y != y2) {
-            count = count + xs;
-            y = y + ym;
-            if (count > 0) {
-                x = x + xm;
-                count = count - ys;
-            }
-            // Aquí aniria la detecció de col·lisió píxel a píxel
-        }
-    }
-    */
+    // Coords lógicas (1280×720). El shader hace el mapeo a NDC; el viewport
+    // del SDLManager hace el letterbox a píxeles físicos.
+    const float FX1 = static_cast<float>(x1);
+    const float FY1 = static_cast<float>(y1);
+    const float FX2 = static_cast<float>(x2);
+    const float FY2 = static_cast<float>(y2);
 
-    return colisio;
+    // color.alpha==0 → usar color global (verde fósforo). alpha>0 → color directo.
+    const SDL_Color SOURCE = (color.a > 0) ? color : g_current_line_color;
+    const float R = (static_cast<float>(SOURCE.r) * brightness) / 255.0F;
+    const float G = (static_cast<float>(SOURCE.g) * brightness) / 255.0F;
+    const float B = (static_cast<float>(SOURCE.b) * brightness) / 255.0F;
+
+    const float W = (thickness > 0.0F) ? thickness : g_current_line_thickness;
+
+    renderer->pushLine(FX1, FY1, FX2, FY2, W, R, G, B, 1.0F);
 }
 
-// [NUEVO] Establir el color global de les línies
 void setLineColor(SDL_Color color) { g_current_line_color = color; }
 
+void setLineThickness(float thickness) {
+    if (thickness > 0.0F) {
+        g_current_line_thickness = thickness;
+    }
+}
+
+auto getLineThickness() -> float { return g_current_line_thickness; }
+
 }  // namespace Rendering
diff --git a/source/core/rendering/line_renderer.hpp b/source/core/rendering/line_renderer.hpp
index cf154a0..e1468f2 100644
--- a/source/core/rendering/line_renderer.hpp
+++ b/source/core/rendering/line_renderer.hpp
@@ -1,16 +1,36 @@
-// line_renderer.hpp - Renderitzat de línies
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
+// line_renderer.hpp - Renderizado de líneas vectoriales (SDL3 GPU)
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+//
+// El dibujo de líneas pasa por el pipeline GPU. Las coordenadas (x1,y1,x2,y2)
+// son lógicas (1280×720); el shader las mapea a NDC y el viewport del SDLManager
+// hace el letterbox a píxeles físicos. El brillo modula el color global de
+// línea (lo gestiona ColorOscillator). El grosor es configurable por línea
+// (parámetro thickness>0) o global (g_current_line_thickness vía setLineThickness).
 
 #pragma once
+
+#include "core/rendering/render_context.hpp"
 #include <SDL3/SDL.h>
 
 namespace Rendering {
-// Algorisme de Bresenham per dibuixar línies
-// Retorna true si hi ha col·lisió (per Fase 10)
-// brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
-bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar, float brightness = 1.0F);
 
-// [NUEVO] Establir el color global de les línies (oscil·lació)
+// 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).
+// 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).
+void linea(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});
+
+// Color global de las líneas (lo actualiza ColorOscillator vía SDLManager).
 void setLineColor(SDL_Color color);
+
+// Grosor global por defecto (en píxeles lógicos). Default: 1.5.
+void setLineThickness(float thickness);
+[[nodiscard]] auto getLineThickness() -> float;
+
 }  // namespace Rendering
diff --git a/source/core/rendering/polygon_renderer.cpp b/source/core/rendering/polygon_renderer.cpp
deleted file mode 100644
index f4ca471..0000000
--- a/source/core/rendering/polygon_renderer.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// polygon_renderer.cpp - Implementació de renderitzat de polígons
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-//
-// ==============================================================================
-// DEPRECATED: Use core/rendering/shape_renderer.cpp instead
-// ==============================================================================
-
-#include "core/rendering/polygon_renderer.hpp"
-
-#include <array>
-#include <cmath>
-
-#include "core/defaults.hpp"
-#include "core/rendering/line_renderer.hpp"
-
-namespace Rendering {
-
-void rota_tri(SDL_Renderer* renderer, const Triangle& tri, float angul, float velocitat, bool dibuixar) {
-    // Rotar i dibuixar triangle (nau)
-    // Conversió de coordenades polars a cartesianes amb rotació
-    // Basat en el codi Pascal original: lines 271-284
-
-    // Convertir cada punt polar a cartesià
-    // x = (r + velocitat) * cos(angle_punt + angle_nau) + centre.x
-    // y = (r + velocitat) * sin(angle_punt + angle_nau) + centre.y
-
-    int x1 = static_cast<int>(std::round((tri.p1.r + velocitat) *
-                 std::cos(tri.p1.angle + angul))) +
-        tri.centre.x;
-
-    int y1 = static_cast<int>(std::round((tri.p1.r + velocitat) *
-                 std::sin(tri.p1.angle + angul))) +
-        tri.centre.y;
-
-    int x2 = static_cast<int>(std::round((tri.p2.r + velocitat) *
-                 std::cos(tri.p2.angle + angul))) +
-        tri.centre.x;
-
-    int y2 = static_cast<int>(std::round((tri.p2.r + velocitat) *
-                 std::sin(tri.p2.angle + angul))) +
-        tri.centre.y;
-
-    int x3 = static_cast<int>(std::round((tri.p3.r + velocitat) *
-                 std::cos(tri.p3.angle + angul))) +
-        tri.centre.x;
-
-    int y3 = static_cast<int>(std::round((tri.p3.r + velocitat) *
-                 std::sin(tri.p3.angle + angul))) +
-        tri.centre.y;
-
-    // Dibuixar les 3 línies que formen el triangle
-    linea(renderer, x1, y1, x2, y2, dibuixar);
-    linea(renderer, x1, y1, x3, y3, dibuixar);
-    linea(renderer, x3, y3, x2, y2, dibuixar);
-}
-
-void rota_pol(SDL_Renderer* renderer, const Poligon& pol, float angul, bool dibuixar) {
-    // Rotar i dibuixar polígon (enemics i bales)
-    // Conversió de coordenades polars a cartesianes amb rotació
-    // Basat en el codi Pascal original: lines 286-296
-
-    // Array temporal per emmagatzemar punts convertits a cartesianes
-    std::array<Punt, Defaults::Entities::MAX_IPUNTS> xy;
-
-    // Convertir cada punt polar a cartesià
-    for (uint8_t i = 0; i < pol.n; i++) {
-        xy[i].x = static_cast<int>(std::round(
-                      pol.ipuntx[i].r * std::cos(pol.ipuntx[i].angle + angul))) +
-            pol.centre.x;
-
-        xy[i].y = static_cast<int>(std::round(
-                      pol.ipuntx[i].r * std::sin(pol.ipuntx[i].angle + angul))) +
-            pol.centre.y;
-    }
-
-    // Dibuixar línies entre punts consecutius
-    for (uint8_t i = 0; i < pol.n - 1; i++) {
-        linea(renderer, xy[i].x, xy[i].y, xy[i + 1].x, xy[i + 1].y, dibuixar);
-    }
-
-    // Tancar el polígon (últim punt → primer punt)
-    linea(renderer, xy[pol.n - 1].x, xy[pol.n - 1].y, xy[0].x, xy[0].y, dibuixar);
-}
-
-}  // namespace Rendering
diff --git a/source/core/rendering/polygon_renderer.hpp b/source/core/rendering/polygon_renderer.hpp
deleted file mode 100644
index 703a25a..0000000
--- a/source/core/rendering/polygon_renderer.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// polygon_renderer.hpp - Renderitzat de polígons polars
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-//
-// ==============================================================================
-// DEPRECATED: Use core/rendering/shape_renderer.hpp instead
-// ==============================================================================
-// This file is kept temporarily for chatarra_cosmica_ (Phase 10: explosions)
-// TODO Phase 10: Replace with particle system or remove completely
-
-#pragma once
-#include <SDL3/SDL.h>
-
-#include "core/types.hpp"
-
-namespace Rendering {
-// Rotar i dibuixar triangle (nau)
-void rota_tri(SDL_Renderer* renderer, const Triangle& tri, float angul, float velocitat, bool dibuixar);
-
-// Rotar i dibuixar polígon (enemics i bales)
-void rota_pol(SDL_Renderer* renderer, const Poligon& pol, float angul, bool dibuixar);
-}  // namespace Rendering
diff --git a/source/core/rendering/primitives.cpp b/source/core/rendering/primitives.cpp
deleted file mode 100644
index dd19167..0000000
--- a/source/core/rendering/primitives.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-// primitives.cpp - Implementació de funcions geomètriques
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-//
-// ==============================================================================
-// DEPRECATED: Use Shape system instead (.shp files + ShapeLoader)
-// ==============================================================================
-
-#include "primitives.hpp"
-
-#include <cmath>
-
-#include "core/defaults.hpp"
-
-float modul(const Punt& p) {
-    // Càlcul de la magnitud d'un vector: sqrt(x² + y²)
-    return std::sqrt((p.x * p.x) + (p.y * p.y));
-}
-
-void diferencia(const Punt& o, const Punt& d, Punt& p) {
-    // Resta de vectors (origen - destí)
-    p.x = o.x - d.x;
-    p.y = o.y - d.y;
-}
-
-int distancia(const Punt& o, const Punt& d) {
-    // Distància entre dos punts
-    Punt p;
-    diferencia(o, d, p);
-    return static_cast<int>(std::round(modul(p)));
-}
-
-float angle_punt(const Punt& p) {
-    // Càlcul de l'angle d'un punt (arctan)
-    if (p.y != 0) {
-        return std::atan(p.x / p.y);
-    }
-    return 0.0F;
-}
-
-void crear_poligon_regular(Poligon& pol, uint8_t n, float r) {
-    // Crear un polígon regular amb n costats i radi r
-    // Distribueix els punts uniformement al voltant d'un cercle
-
-    float interval = 2.0F * Defaults::Math::PI / n;
-    float act = 0.0F;
-
-    for (uint8_t i = 0; i < n; i++) {
-        pol.ipuntx[i].r = r;
-        pol.ipuntx[i].angle = act;
-        act += interval;
-    }
-
-    // Inicialitzar propietats del polígon
-    pol.centre.x = 320.0F;
-    pol.centre.y = 200.0F;
-    pol.angle = 0.0F;
-    // Convertir velocitat de px/frame a px/s: 2 px/frame × 20 FPS = 40 px/s
-    pol.velocitat = Defaults::Physics::ENEMY_SPEED * 20.0F;
-    pol.n = n;
-    // Convertir rotació de rad/frame a rad/s: 0.0785 rad/frame × 20 FPS = 1.57
-    // rad/s (~90°/s)
-    pol.drotacio = 0.078539816F * 20.0F;
-    pol.rotacio = 0.0F;
-    pol.esta = true;
-}
diff --git a/source/core/rendering/primitives.hpp b/source/core/rendering/primitives.hpp
deleted file mode 100644
index e97acb3..0000000
--- a/source/core/rendering/primitives.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-// primitives.hpp - Funcions geomètriques bàsiques
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-//
-// ==============================================================================
-// DEPRECATED: Use Shape system instead (.shp files + ShapeLoader)
-// ==============================================================================
-// This file is kept temporarily for chatarra_cosmica_ (Phase 10: explosions)
-// TODO Phase 10: Replace with particle system or remove completely
-
-#pragma once
-
-#include <cstdint>
-
-#include "core/types.hpp"
-
-// Funcions matemàtiques geomètriques pures (sense dependències d'estat)
-
-// Càlcul de la magnitud d'un vector
-float modul(const Punt& p);
-
-// Diferència entre dos punts (vector origen - destí)
-void diferencia(const Punt& o, const Punt& d, Punt& p);
-
-// Distància entre dos punts
-int distancia(const Punt& o, const Punt& d);
-
-// Càlcul de l'angle d'un punt
-float angle_punt(const Punt& p);
-
-// Creació de polígons regulars
-void crear_poligon_regular(Poligon& pol, uint8_t n, float r);
diff --git a/source/core/rendering/render_context.hpp b/source/core/rendering/render_context.hpp
new file mode 100644
index 0000000..c127b55
--- /dev/null
+++ b/source/core/rendering/render_context.hpp
@@ -0,0 +1,22 @@
+// render_context.hpp - Alias del contexto de rendering del juego
+// © 2025 Orni Attack
+//
+// Punto único de indireción entre el resto del código y el backend de
+// rendering. El juego habla con un `Rendering::Renderer*` opaco; el alias
+// apunta a la implementación concreta (SDL3 GPU vía GpuFrameRenderer).
+//
+// Antes (BETA 3.0): se propagaba un `SDL_Renderer*` por todas las firmas.
+// Ahora: `Rendering::Renderer*`. El cambio de backend (Vulkan→Metal vía
+// SDL_gpu) no toca el código del juego.
+
+#pragma once
+
+#include "core/rendering/gpu/gpu_frame_renderer.hpp"
+
+namespace Rendering {
+
+// Tipo único del contexto de dibujo que se pasa a las entidades, scenes,
+// effects, etc. Las llamadas concretas viven en GpuFrameRenderer.
+using Renderer = GPU::GpuFrameRenderer;
+
+}  // namespace Rendering
diff --git a/source/core/rendering/sdl_manager.cpp b/source/core/rendering/sdl_manager.cpp
index 091405d..7c87478 100644
--- a/source/core/rendering/sdl_manager.cpp
+++ b/source/core/rendering/sdl_manager.cpp
@@ -1,12 +1,15 @@
 // sdl_manager.cpp - Implementació del gestor SDL3
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #include "sdl_manager.hpp"
 
 #include <algorithm>
+#include <cmath>
+#include <cstdint>
 #include <format>
 #include <iostream>
 
+#include "core/config/postfx_config.hpp"
 #include "core/defaults.hpp"
 #include "core/input/mouse.hpp"
 #include "core/rendering/coordinate_transform.hpp"
@@ -14,12 +17,53 @@
 #include "game/options.hpp"
 #include "project.h"
 
+namespace {
+auto initWindowAndGpu(SDL_Window** out_window,
+                      Rendering::Renderer& gpu_renderer,
+                      int width, int height, bool fullscreen) -> bool {
+    // Título estático estilo CCAE. El FPS y el estado de VSync los muestra
+    // el DebugOverlay (toggle F11), no la barra de título.
+    const std::string TITLE = std::format("© 2026 {} — JailDesigner",
+                                          Project::LONG_NAME);
+
+    SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
+    if (fullscreen) {
+        flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
+    }
+
+    SDL_Window* window = SDL_CreateWindow(TITLE.c_str(), width, height, flags);
+    if (window == nullptr) {
+        std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
+        return false;
+    }
+
+    if (!fullscreen) {
+        SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    }
+
+    // Inicializar el FrameRenderer (claim del window + pipeline de líneas).
+    if (!gpu_renderer.init(window,
+                           static_cast<float>(Defaults::Game::WIDTH),
+                           static_cast<float>(Defaults::Game::HEIGHT))) {
+        std::cerr << "Error inicialitzant GpuFrameRenderer\n";
+        SDL_DestroyWindow(window);
+        return false;
+    }
+
+    gpu_renderer.setVSync(Options::rendering.vsync != 0);
+
+    // Cargar parámetros del postpro desde el resource pack. Si el YAML falta
+    // o falla, el loader devuelve los defaults built-in (bloom suave + flicker
+    // sutil + background verde tenue).
+    gpu_renderer.setPostFx(Config::PostFx::load("config/postfx.yaml"));
+
+    *out_window = window;
+    return true;
+}
+}  // namespace
+
 SDLManager::SDLManager()
     : finestra_(nullptr),
-      renderer_(nullptr),
-      fps_accumulator_(0.0F),
-      fps_frame_count_(0),
-      fps_display_(0),
       current_width_(Defaults::Window::WIDTH),
       current_height_(Defaults::Window::HEIGHT),
       is_fullscreen_(false),
@@ -29,61 +73,27 @@ SDLManager::SDLManager()
       windowed_width_(Defaults::Window::WIDTH),
       windowed_height_(Defaults::Window::HEIGHT),
       max_zoom_(1.0F) {
-    // Inicialitzar SDL3
     if (!SDL_Init(SDL_INIT_VIDEO)) {
         std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << '\n';
         return;
     }
 
-    // Calcular mida màxima des del display
     calculateMaxWindowSize();
 
-    // Construir títol dinàmic
-    std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
-
-    // Crear finestra CENTRADA (SDL ho fa automàticament amb CENTERED)
-    finestra_ =
-        SDL_CreateWindow(window_title.c_str(), current_width_, current_height_,
-            SDL_WINDOW_RESIZABLE  // Permetre resize manual també
-        );
-
-    if (finestra_ == nullptr) {
-        std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
+    if (!initWindowAndGpu(&finestra_, gpu_renderer_, current_width_, current_height_, false)) {
         SDL_Quit();
         return;
     }
 
-    // IMPORTANT: Centrar explícitament la finestra
-    SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-
-    // Crear renderer amb acceleració
-    renderer_ = SDL_CreateRenderer(finestra_, nullptr);
-
-    if (renderer_ == nullptr) {
-        std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
-        SDL_DestroyWindow(finestra_);
-        SDL_Quit();
-        return;
-    }
-
-    // Aplicar configuració de V-Sync
-    SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
-
-    // CRÍTIC: Configurar viewport scaling
-    updateLogicalPresentation();
+    updateViewport();
 
     std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
               << " (logic: " << Defaults::Game::WIDTH << "x"
               << Defaults::Game::HEIGHT << ")" << '\n';
 }
 
-// Constructor amb configuració
 SDLManager::SDLManager(int width, int height, bool fullscreen)
     : finestra_(nullptr),
-      renderer_(nullptr),
-      fps_accumulator_(0.0F),
-      fps_frame_count_(0),
-      fps_display_(0),
       current_width_(width),
       current_height_(height),
       is_fullscreen_(fullscreen),
@@ -93,56 +103,21 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
       windowed_width_(width),
       windowed_height_(height),
       max_zoom_(1.0F) {
-    // Inicialitzar SDL3
     if (!SDL_Init(SDL_INIT_VIDEO)) {
         std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << '\n';
         return;
     }
 
-    // Calcular mida màxima des del display
     calculateMaxWindowSize();
 
-    // Construir títol dinàmic
-    std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
-
-    // Configurar flags de la finestra
-    SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
-    if (is_fullscreen_) {
-        flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
-    }
-
-    // Crear finestra
-    finestra_ = SDL_CreateWindow(window_title.c_str(), current_width_, current_height_, flags);
-
-    if (finestra_ == nullptr) {
-        std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
+    if (!initWindowAndGpu(&finestra_, gpu_renderer_, current_width_, current_height_, is_fullscreen_)) {
         SDL_Quit();
         return;
     }
 
-    // Centrar explícitament la finestra (si no és fullscreen)
-    if (!is_fullscreen_) {
-        SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-    }
+    updateViewport();
 
-    // Crear renderer amb acceleració
-    renderer_ = SDL_CreateRenderer(finestra_, nullptr);
-
-    if (renderer_ == nullptr) {
-        std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
-        SDL_DestroyWindow(finestra_);
-        SDL_Quit();
-        return;
-    }
-
-    // Aplicar configuració de V-Sync
-    SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
-
-    // Configurar viewport scaling
-    updateLogicalPresentation();
-
-    // Inicialitzar sistema de cursor
-    // En fullscreen: forzar ocultació permanent
+    // En fullscreen: forzar ocultació permanent del cursor.
     if (is_fullscreen_) {
         Mouse::setForceHidden(true);
     }
@@ -157,10 +132,7 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
 }
 
 SDLManager::~SDLManager() {
-    if (renderer_ != nullptr) {
-        SDL_DestroyRenderer(renderer_);
-        renderer_ = nullptr;
-    }
+    gpu_renderer_.destroy();
 
     if (finestra_ != nullptr) {
         SDL_DestroyWindow(finestra_);
@@ -176,36 +148,27 @@ void SDLManager::calculateMaxWindowSize() {
     const SDL_DisplayMode* mode = SDL_GetCurrentDisplayMode(display);
 
     if (mode != nullptr) {
-        // Deixar marge de 100px per a decoracions de l'OS
+        // Deixar marge de 100px para decoracions de l'OS
         max_width_ = mode->w - 100;
         max_height_ = mode->h - 100;
         std::cout << "Display detectat: " << mode->w << "x" << mode->h
                   << " (max finestra: " << max_width_ << "x" << max_height_ << ")"
                   << '\n';
     } else {
-        // Fallback conservador
         max_width_ = 1920;
         max_height_ = 1080;
         std::cerr << "No s'ha pogut detectar el display, usant fallback: "
                   << max_width_ << "x" << max_height_ << '\n';
     }
 
-    // Calculate max zoom immediately after determining max size
     calculateMaxZoom();
 }
 
 void SDLManager::calculateMaxZoom() {
-    // Maximum zoom limited by BOTH width and height (preserves 4:3)
     float max_zoom_width = static_cast<float>(max_width_) / Defaults::Window::WIDTH;
     float max_zoom_height = static_cast<float>(max_height_) / Defaults::Window::HEIGHT;
-
-    // Take smaller constraint
     float max_zoom_unrounded = std::min(max_zoom_width, max_zoom_height);
-
-    // Round DOWN to nearest 0.1 increment (user preference)
     max_zoom_ = std::floor(max_zoom_unrounded / Defaults::Window::ZOOM_INCREMENT) * Defaults::Window::ZOOM_INCREMENT;
-
-    // Safety clamp
     max_zoom_ = std::max(max_zoom_, Defaults::Window::MIN_ZOOM);
 
     std::cout << "Max zoom: " << max_zoom_ << "x (display: "
@@ -213,37 +176,25 @@ void SDLManager::calculateMaxZoom() {
 }
 
 void SDLManager::applyZoom(float new_zoom) {
-    // Clamp to valid range
     new_zoom = std::max(Defaults::Window::MIN_ZOOM,
         std::min(new_zoom, max_zoom_));
-
-    // Round to nearest 0.1 increment
     new_zoom = std::round(new_zoom / Defaults::Window::ZOOM_INCREMENT) * Defaults::Window::ZOOM_INCREMENT;
 
-    // No change?
     if (std::abs(new_zoom - zoom_factor_) < 0.01F) {
         return;
     }
 
     zoom_factor_ = new_zoom;
 
-    // Calculate physical dimensions (4:3 maintained automatically)
-    int new_width = static_cast<int>(std::round(
-        Defaults::Window::WIDTH * zoom_factor_));
-    int new_height = static_cast<int>(std::round(
-        Defaults::Window::HEIGHT * zoom_factor_));
+    int new_width = static_cast<int>(std::round(Defaults::Window::WIDTH * zoom_factor_));
+    int new_height = static_cast<int>(std::round(Defaults::Window::HEIGHT * zoom_factor_));
 
-    // Apply to window (centers via applyWindowSize)
     applyWindowSize(new_width, new_height);
-
-    // Update viewport for new zoom
     updateViewport();
 
-    // Update windowed size cache
     windowed_width_ = new_width;
     windowed_height_ = new_height;
 
-    // Persist
     Options::window.width = new_width;
     Options::window.height = new_height;
     Options::window.zoom_factor = zoom_factor_;
@@ -252,30 +203,23 @@ void SDLManager::applyZoom(float new_zoom) {
               << new_width << "x" << new_height << ")" << '\n';
 }
 
-void SDLManager::updateLogicalPresentation() {
-    // CANVIAT: Ja no usem SDL_SetRenderLogicalPresentation
-    // Ara renderitzem directament a resolució física per evitar pixelació irregular
-    // El viewport amb letterbox es configura a updateViewport()
-    updateViewport();
-}
-
 void SDLManager::updateViewport() {
-    // Calcular dimensions físiques basades en el zoom
+    // Cálculo de letterbox: el juego se renderiza a 1280×720 lógicos, pero
+    // la swapchain tiene el tamaño físico de la ventana. Aplicamos un viewport
+    // centrado con la proporción 16:9 para preservar aspect ratio.
     float scale = zoom_factor_;
     int scaled_width = static_cast<int>(std::round(Defaults::Game::WIDTH * scale));
     int scaled_height = static_cast<int>(std::round(Defaults::Game::HEIGHT * scale));
 
-    // Càlcul de letterbox (centrar l'àrea escalada)
     int offset_x = (current_width_ - scaled_width) / 2;
     int offset_y = (current_height_ - scaled_height) / 2;
-
-    // Evitar offsets negatius
     offset_x = std::max(offset_x, 0);
     offset_y = std::max(offset_y, 0);
 
-    // Configurar viewport per al renderitzat
-    SDL_Rect viewport = {offset_x, offset_y, scaled_width, scaled_height};
-    SDL_SetRenderViewport(renderer_, &viewport);
+    gpu_renderer_.setViewport(static_cast<float>(offset_x),
+                              static_cast<float>(offset_y),
+                              static_cast<float>(scaled_width),
+                              static_cast<float>(scaled_height));
 
     std::cout << "Viewport: " << scaled_width << "x" << scaled_height
               << " @ (" << offset_x << "," << offset_y << ") [scale=" << scale << "]"
@@ -283,7 +227,6 @@ void SDLManager::updateViewport() {
 }
 
 void SDLManager::updateRenderingContext() const {
-    // Actualitzar el factor d'escala global per a totes les funcions de renderitzat
     Rendering::g_current_scale_factor = zoom_factor_;
 }
 
@@ -291,10 +234,8 @@ void SDLManager::increaseWindowSize() {
     if (is_fullscreen_) {
         return;
     }
-
     float new_zoom = zoom_factor_ + Defaults::Window::ZOOM_INCREMENT;
     applyZoom(new_zoom);
-
     std::cout << "F2: Zoom aumentat a " << zoom_factor_ << "x" << '\n';
 }
 
@@ -302,15 +243,12 @@ void SDLManager::decreaseWindowSize() {
     if (is_fullscreen_) {
         return;
     }
-
     float new_zoom = zoom_factor_ - Defaults::Window::ZOOM_INCREMENT;
     applyZoom(new_zoom);
-
     std::cout << "F1: Zoom reduït a " << zoom_factor_ << "x" << '\n';
 }
 
 void SDLManager::applyWindowSize(int new_width, int new_height) {
-    // Obtenir posició actual ABANS del resize
     int old_x;
     int old_y;
     SDL_GetWindowPosition(finestra_, &old_x, &old_y);
@@ -318,76 +256,56 @@ void SDLManager::applyWindowSize(int new_width, int new_height) {
     int old_width = current_width_;
     int old_height = current_height_;
 
-    // Actualitzar mida
     SDL_SetWindowSize(finestra_, new_width, new_height);
     current_width_ = new_width;
     current_height_ = new_height;
 
-    // CENTRADO INTEL·LIGENT (algoritme de pollo)
-    // Calcular nova posició per mantenir la finestra centrada sobre si mateixa
     int delta_width = old_width - new_width;
     int delta_height = old_height - new_height;
-
     int new_x = old_x + (delta_width / 2);
     int new_y = old_y + (delta_height / 2);
 
-    // Evitar que la finestra surti de la pantalla
-    constexpr int TITLEBAR_HEIGHT = 35;  // Alçada aproximada de la barra de títol
+    constexpr int TITLEBAR_HEIGHT = 35;
     new_x = std::max(new_x, 0);
     new_y = std::max(new_y, TITLEBAR_HEIGHT);
 
     SDL_SetWindowPosition(finestra_, new_x, new_y);
-
-    // Actualitzar viewport després del resize
     updateViewport();
 }
 
 void SDLManager::toggleFullscreen() {
     if (!is_fullscreen_) {
-        // ENTERING FULLSCREEN
         windowed_width_ = current_width_;
         windowed_height_ = current_height_;
-
         is_fullscreen_ = true;
         SDL_SetWindowFullscreen(finestra_, true);
-
         std::cout << "F3: Fullscreen activat (guardada: "
                   << windowed_width_ << "x" << windowed_height_ << ")" << '\n';
     } else {
-        // EXITING FULLSCREEN
         is_fullscreen_ = false;
         SDL_SetWindowFullscreen(finestra_, false);
-
-        // CRITICAL: Explicitly restore windowed size
         applyWindowSize(windowed_width_, windowed_height_);
-
         std::cout << "F3: Fullscreen desactivat (restaurada: "
                   << windowed_width_ << "x" << windowed_height_ << ")" << '\n';
     }
 
     Options::window.fullscreen = is_fullscreen_;
-
-    // Notificar al mòdul Mouse: Fullscreen requereix ocultació permanent del cursor.
-    // Quan es surt de fullscreen, restaurar el comportament normal d'auto-ocultació.
     Mouse::setForceHidden(is_fullscreen_);
 }
 
-bool SDLManager::handleWindowEvent(const SDL_Event& event) {
+auto SDLManager::handleWindowEvent(const SDL_Event& event) -> bool {
     if (event.type == SDL_EVENT_WINDOW_RESIZED) {
         SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
 
-        // Calculate zoom from actual size (may not align to 0.1 increments)
         float new_zoom = static_cast<float>(current_width_) / Defaults::Window::WIDTH;
         zoom_factor_ = std::max(Defaults::Window::MIN_ZOOM,
             std::min(new_zoom, max_zoom_));
 
-        // Update windowed cache (if not in fullscreen)
         if (!is_fullscreen_) {
             windowed_width_ = current_width_;
             windowed_height_ = current_height_;
         }
 
-        // Actualitzar viewport després del resize manual
         updateViewport();
 
         std::cout << "Finestra redimensionada: " << current_width_
@@ -398,84 +316,22 @@ bool SDLManager::handleWindowEvent(const SDL_Event& event) {
     return false;
 }
 
-void SDLManager::neteja(uint8_t r, uint8_t g, uint8_t b) {
-    if (renderer_ == nullptr) {
-        return;
-    }
-
-    // [MODIFICAT] Usar color oscil·lat del fons en lloc dels paràmetres
+void SDLManager::clear(uint8_t r, uint8_t g, uint8_t b) {
+    // El fondo lo dibuja ahora el shader de postpro (background pulse). El
+    // offscreen se limpia en negro dentro de beginFrame. Los argumentos r/g/b
+    // se mantienen por compatibilidad de API.
     (void)r;
     (void)g;
-    (void)b;  // Suprimir warnings
-    SDL_Color bg = color_oscillator_.getCurrentBackgroundColor();
-    SDL_SetRenderDrawColor(renderer_, bg.r, bg.g, bg.b, 255);
-    SDL_RenderClear(renderer_);
+    (void)b;
+    gpu_renderer_.beginFrame(0.0F, 0.0F, 0.0F);
 }
 
-void SDLManager::presenta() {
-    if (renderer_ == nullptr) {
-        return;
-    }
-
-    SDL_RenderPresent(renderer_);
+void SDLManager::present() {
+    gpu_renderer_.endFrame();
 }
 
-// [NUEVO] Actualitzar colors amb oscil·lació
-void SDLManager::updateColors(float delta_time) {
-    color_oscillator_.update(delta_time);
-
-    // Actualitzar color global de línies
-    Rendering::setLineColor(color_oscillator_.getCurrentLineColor());
-}
-
-// [NUEVO] Actualitzar comptador de FPS
-void SDLManager::updateFPS(float delta_time) {
-    // Acumular temps i frames
-    fps_accumulator_ += delta_time;
-    fps_frame_count_++;
-
-    // Actualitzar display cada 0.5 segons
-    if (fps_accumulator_ >= 0.5F) {
-        fps_display_ = static_cast<int>(fps_frame_count_ / fps_accumulator_);
-        fps_frame_count_ = 0;
-        fps_accumulator_ = 0.0F;
-
-        // Actualitzar títol de la finestra
-        std::string vsync_state = (Options::rendering.vsync == 1) ? "ON" : "OFF";
-        std::string title = std::format("{} v{} ({}) - {} FPS - VSync: {}",
-            Project::LONG_NAME,
-            Project::VERSION,
-            Project::COPYRIGHT,
-            fps_display_,
-            vsync_state);
-
-        if (finestra_ != nullptr) {
-            SDL_SetWindowTitle(finestra_, title.c_str());
-        }
-    }
-}
-
-// [NUEVO] Actualitzar títol de la finestra
-void SDLManager::setWindowTitle(const std::string& title) {
-    if (finestra_ != nullptr) {
-        SDL_SetWindowTitle(finestra_, title.c_str());
-    }
-}
-
-// [NUEVO] Toggle V-Sync (F4)
 void SDLManager::toggleVSync() {
-    // Toggle: 1 → 0 → 1
     Options::rendering.vsync = (Options::rendering.vsync == 1) ? 0 : 1;
-
-    // Aplicar a SDL
-    if (renderer_ != nullptr) {
-        SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
-    }
-
-    // Reset FPS counter para evitar valores mixtos entre regímenes
-    fps_accumulator_ = 0.0F;
-    fps_frame_count_ = 0;
-
-    // Guardar configuració
+    gpu_renderer_.setVSync(Options::rendering.vsync != 0);
     Options::saveToFile();
 }
diff --git a/source/core/rendering/sdl_manager.hpp b/source/core/rendering/sdl_manager.hpp
index de775fe..618d31d 100644
--- a/source/core/rendering/sdl_manager.hpp
+++ b/source/core/rendering/sdl_manager.hpp
@@ -1,61 +1,50 @@
-//  sdl_manager.hpp - Gestor d'inicialització de SDL3
-// © 2025 Port a C++20 amb SDL3
+//  sdl_manager.hpp - Gestor de inicialización de SDL3
+// © 2025 Port a C++20 con SDL3
+//
+// Tras la Fase 7 de la migración, el rendering ya no usa SDL_Renderer:
+// SDLManager posee un GpuFrameRenderer (SDL3 GPU) que es el contexto único
+// de dibujo del juego. El resto del código accede vía getRenderer() →
+// Rendering::Renderer* (alias del GpuFrameRenderer).
 
-#ifndef SDL_MANAGER_HPP
-#define SDL_MANAGER_HPP
+#pragma once
 
 #include <SDL3/SDL.h>
 
 #include <cstdint>
-#include <string>
 
-#include "core/rendering/color_oscillator.hpp"
+#include "core/rendering/render_context.hpp"
 
 class SDLManager {
     public:
         SDLManager();                                        // Constructor per defecte (usa Defaults::)
-        SDLManager(int width, int height, bool fullscreen);  // Constructor amb configuració
+        SDLManager(int width, int height, bool fullscreen);  // Constructor con configuración
         ~SDLManager();
 
         // No permetre còpia ni assignació
         SDLManager(const SDLManager&) = delete;
-        SDLManager& operator=(const SDLManager&) = delete;
+        auto operator=(const SDLManager&) -> SDLManager& = delete;
 
         // [NUEVO] Gestió de finestra dinàmica
         void increaseWindowSize();                       // F2: +100px
         void decreaseWindowSize();                       // F1: -100px
         void toggleFullscreen();                         // F3
         void toggleVSync();                              // F4
-        bool handleWindowEvent(const SDL_Event& event);  // Per a SDL_EVENT_WINDOW_RESIZED
+        auto handleWindowEvent(const SDL_Event& event) -> bool;  // Per a SDL_EVENT_WINDOW_RESIZED
 
-        // Funcions principals (renderitzat)
-        void neteja(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0);
-        void presenta();
-
-        // [NUEVO] Actualització de colors (oscil·lació)
-        void updateColors(float delta_time);
-
-        // [NUEVO] Actualitzar comptador de FPS
-        void updateFPS(float delta_time);
+        // Funciones principals (renderizado)
+        void clear(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0);
+        void present();
 
         // Getters
-        SDL_Renderer* obte_renderer() { return renderer_; }
-        [[nodiscard]] float getScaleFactor() const { return zoom_factor_; }
+        auto getRenderer() -> Rendering::Renderer* { return &gpu_renderer_; }
+        [[nodiscard]] auto getScaleFactor() const -> float { return zoom_factor_; }
 
-        // [NUEVO] Actualitzar títol de la finestra
-        void setWindowTitle(const std::string& title);
-
-        // [NUEVO] Actualitzar context de renderitzat (factor d'escala global)
+        // [NUEVO] Actualitzar context de renderizado (factor de scale global)
         void updateRenderingContext() const;
 
     private:
         SDL_Window* finestra_;
-        SDL_Renderer* renderer_;
-
-        // [NUEVO] Variables FPS
-        float fps_accumulator_;
-        int fps_frame_count_;
-        int fps_display_;
+        Rendering::Renderer gpu_renderer_;  // GpuFrameRenderer (SDL3 GPU)
 
         // [NUEVO] Estat de la finestra
         int current_width_;  // Mida física actual
@@ -70,16 +59,11 @@ class SDLManager {
         int windowed_height_;  // Saved size before fullscreen
         float max_zoom_;       // Maximum zoom (calculated from display)
 
-        // [NUEVO] Funcions internes
+        // [NUEVO] Funciones internes
         void calculateMaxWindowSize();                // Llegir resolució del display
         void calculateMaxZoom();                      // Calculate max zoom from display
         void applyZoom(float new_zoom);               // Apply zoom and resize window
         void applyWindowSize(int width, int height);  // Canviar mida + centrar
-        void updateLogicalPresentation();             // Actualitzar viewport
-        void updateViewport();                        // Configurar viewport amb letterbox
+        void updateViewport();                        // Configurar viewport con letterbox
 
-        // [NUEVO] Oscil·lador de colors
-        Rendering::ColorOscillator color_oscillator_;
 };
-
-#endif  // SDL_MANAGER_HPP
diff --git a/source/core/rendering/shape_renderer.cpp b/source/core/rendering/shape_renderer.cpp
index 5aec16b..2a99b7a 100644
--- a/source/core/rendering/shape_renderer.cpp
+++ b/source/core/rendering/shape_renderer.cpp
@@ -1,5 +1,5 @@
-// shape_renderer.cpp - Implementació del renderitzat de formes
-// © 2025 Port a C++20 amb SDL3
+// shape_renderer.cpp - Implementació del renderizado de formes
+// © 2025 Port a C++20 con SDL3
 
 #include "core/rendering/shape_renderer.hpp"
 
@@ -10,108 +10,100 @@
 
 namespace Rendering {
 
-// Helper: aplicar rotació 3D a un punt 2D (assumeix Z=0)
-static Punt apply_3d_rotation(float x, float y, const Rotation3D& rot) {
-    float z = 0.0F;  // Tots els punts 2D comencen a Z=0
+// Helper: aplicar rotación 3D a un point 2D (assumeix Z=0)
+static Vec2 apply_3d_rotation(float x, float y, const Rotation3D& rot) {
+    float z = 0.0F;  // Todos los points 2D comencen a Z=0
 
-    // Pitch (rotació eix X): cabeceo arriba/baix
+    // Pitch (rotación eix X): cabeceo arriba/baix
     float cos_pitch = std::cos(rot.pitch);
     float sin_pitch = std::sin(rot.pitch);
     float y1 = (y * cos_pitch) - (z * sin_pitch);
     float z1 = (y * sin_pitch) + (z * cos_pitch);
 
-    // Yaw (rotació eix Y): guiñada esquerra/dreta
+    // Yaw (rotación eix Y): guiñada izquierda/derecha
     float cos_yaw = std::cos(rot.yaw);
     float sin_yaw = std::sin(rot.yaw);
     float x2 = (x * cos_yaw) + (z1 * sin_yaw);
     float z2 = (-x * sin_yaw) + (z1 * cos_yaw);
 
-    // Roll (rotació eix Z): alabeo lateral
+    // Roll (rotación eix Z): alabeo lateral
     float cos_roll = std::cos(rot.roll);
     float sin_roll = std::sin(rot.roll);
     float x3 = (x2 * cos_roll) - (y1 * sin_roll);
     float y3 = (x2 * sin_roll) + (y1 * cos_roll);
 
     // Proyecció perspectiva (Z-divide simple)
-    // Naus volen cap al punt de fuga (320, 240) a "infinit" (Z → +∞)
-    // Z més gran = més lluny = més petit a pantalla
+    // Naves quieren hacia el point de fuga (320, 240) a "infinit" (Z → +∞)
+    // Z més grande = més lluny = més pequeño a pantalla
     constexpr float perspective_factor = 500.0F;
     float scale_factor = perspective_factor / (perspective_factor + z2);
 
     return {.x = x3 * scale_factor, .y = y3 * scale_factor};
 }
 
-// Helper: transformar un punt amb rotació, escala i trasllació
-static Punt transform_point(const Punt& point, const Punt& shape_centre, const Punt& posicio, float angle, float escala, const Rotation3D* rotation_3d) {
-    // 1. Centrar el punt respecte al centre de la forma
+// Helper: transformar un point con rotación, scale i traslación
+static Vec2 transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale, const Rotation3D* rotation_3d) {
+    // 1. Centrar el point respecte al centro de la shape
     float centered_x = point.x - shape_centre.x;
     float centered_y = point.y - shape_centre.y;
 
-    // 2. Aplicar rotació 3D (si es proporciona)
+    // 2. Aplicar rotación 3D (si es proporciona)
     if ((rotation_3d != nullptr) && rotation_3d->has_rotation()) {
-        Punt rotated_3d = apply_3d_rotation(centered_x, centered_y, *rotation_3d);
+        Vec2 rotated_3d = apply_3d_rotation(centered_x, centered_y, *rotation_3d);
         centered_x = rotated_3d.x;
         centered_y = rotated_3d.y;
     }
 
-    // 3. Aplicar escala al punt (després de rotació 3D)
-    float scaled_x = centered_x * escala;
-    float scaled_y = centered_y * escala;
+    // 3. Aplicar scale al point (después de rotación 3D)
+    float scaled_x = centered_x * scale;
+    float scaled_y = centered_y * scale;
 
-    // 4. Aplicar rotació 2D (Z-axis, tradicional)
-    // IMPORTANT: En el sistema original, angle=0 apunta AMUNT (no dreta)
+    // 4. Aplicar rotación 2D (Z-axis, tradicional)
+    // IMPORTANT: En el sistema original, angle=0 apunta AMUNT (no derecha)
     // Per això usem (angle - PI/2) per compensar
-    // Però aquí angle ja ve en el sistema correcte del joc
+    // Pero aquí angle ya ve en el sistema correcte del juego
     float cos_a = std::cos(angle);
     float sin_a = std::sin(angle);
 
     float rotated_x = (scaled_x * cos_a) - (scaled_y * sin_a);
     float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);
 
-    // 5. Aplicar trasllació a posició mundial
-    return {.x = rotated_x + posicio.x, .y = rotated_y + posicio.y};
+    // 5. Aplicar traslación a posición mundial
+    return {.x = rotated_x + position.x, .y = rotated_y + position.y};
 }
 
-void render_shape(SDL_Renderer* renderer,
+void render_shape(Rendering::Renderer* renderer,
     const std::shared_ptr<Graphics::Shape>& shape,
-    const Punt& posicio,
+    const Vec2& position,
     float angle,
-    float escala,
-    bool dibuixar,
+    float scale,
     float progress,
     float brightness,
-    const Rotation3D* rotation_3d) {
-    // Verificar que la forma és vàlida
-    if (!shape || !shape->es_valida()) {
+    const Rotation3D* rotation_3d,
+    SDL_Color color) {
+    if (!shape || !shape->isValid()) {
         return;
     }
-
-    // Si progress < 1.0, no dibuixar (tot o res)
     if (progress < 1.0F) {
         return;
     }
 
-    // Obtenir el centre de la forma per a transformacions
-    const Punt& shape_centre = shape->get_centre();
+    const Vec2& SHAPE_CENTRE = shape->getCenter();
 
-    // Iterar sobre totes les primitives
     for (const auto& primitive : shape->get_primitives()) {
         if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
-            // POLYLINE: connectar punts consecutius
+            // POLYLINE: conectar puntos consecutivos.
             for (size_t i = 0; i < primitive.points.size() - 1; i++) {
-                Punt p1 = transform_point(primitive.points[i], shape_centre, posicio, angle, escala, rotation_3d);
-                Punt p2 = transform_point(primitive.points[i + 1], shape_centre, posicio, angle, escala, rotation_3d);
-
-                linea(renderer, static_cast<int>(p1.x), static_cast<int>(p1.y), static_cast<int>(p2.x), static_cast<int>(p2.y), dibuixar, brightness);
-            }
-        } else {  // PrimitiveType::LINE
-            // LINE: exactament 2 punts
-            if (primitive.points.size() >= 2) {
-                Punt p1 = transform_point(primitive.points[0], shape_centre, posicio, angle, escala, rotation_3d);
-                Punt p2 = transform_point(primitive.points[1], shape_centre, posicio, angle, escala, rotation_3d);
-
-                linea(renderer, static_cast<int>(p1.x), static_cast<int>(p1.y), static_cast<int>(p2.x), static_cast<int>(p2.y), dibuixar, brightness);
+                const Vec2 P1 = transform_point(primitive.points[i], SHAPE_CENTRE, position, angle, scale, rotation_3d);
+                const Vec2 P2 = transform_point(primitive.points[i + 1], SHAPE_CENTRE, position, angle, scale, rotation_3d);
+                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);
             }
+        } else if (primitive.points.size() >= 2) {  // LINE
+            const Vec2 P1 = transform_point(primitive.points[0], SHAPE_CENTRE, position, angle, scale, rotation_3d);
+            const Vec2 P2 = transform_point(primitive.points[1], SHAPE_CENTRE, position, angle, scale, rotation_3d);
+            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);
         }
     }
 }
diff --git a/source/core/rendering/shape_renderer.hpp b/source/core/rendering/shape_renderer.hpp
index 2eba582..8b6940a 100644
--- a/source/core/rendering/shape_renderer.hpp
+++ b/source/core/rendering/shape_renderer.hpp
@@ -1,8 +1,10 @@
-// shape_renderer.hpp - Renderitzat de formes vectorials
-// © 2025 Port a C++20 amb SDL3
+// shape_renderer.hpp - Renderizado de formes vectorials
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
 
+#include "core/rendering/render_context.hpp"
+
 #include <SDL3/SDL.h>
 
 #include <memory>
@@ -14,9 +16,9 @@ namespace Rendering {
 
 // Estructura per rotacions 3D (pitch, yaw, roll)
 struct Rotation3D {
-        float pitch;  // Rotació eix X (cabeceo arriba/baix)
-        float yaw;    // Rotació eix Y (guiñada esquerra/dreta)
-        float roll;   // Rotació eix Z (alabeo lateral)
+        float pitch;  // Rotación eix X (cabeceo arriba/baix)
+        float yaw;    // Rotación eix Y (guiñada izquierda/derecha)
+        float roll;   // Rotación eix Z (alabeo lateral)
 
         Rotation3D()
             : pitch(0.0F),
@@ -32,23 +34,22 @@ struct Rotation3D {
         }
 };
 
-// Renderitzar forma amb transformacions
+// Renderizar shape con transformacions
 // - renderer: SDL renderer
-// - shape: forma vectorial a dibuixar
-// - posicio: posició del centre en coordenades mundials
-// - angle: rotació en radians (0 = amunt, sentit horari)
-// - escala: factor d'escala (1.0 = mida original)
-// - dibuixar: flag per dibuixar (false per col·lisions futures)
-// - progress: progrés de l'animació (0.0-1.0, default 1.0 = tot visible)
-// - brightness: factor de brillantor (0.0-1.0, default 1.0 = màxima brillantor)
-void render_shape(SDL_Renderer* renderer,
+// - shape: shape vectorial a draw
+// - position: posición del centro en coordenades mundials
+// - angle: rotación en radians (0 = amunt, sentit horari)
+// - 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)
+void render_shape(Rendering::Renderer* renderer,
     const std::shared_ptr<Graphics::Shape>& shape,
-    const Punt& posicio,
+    const Vec2& position,
     float angle,
-    float escala = 1.0F,
-    bool dibuixar = true,
+    float scale = 1.0F,
     float progress = 1.0F,
     float brightness = 1.0F,
-    const Rotation3D* rotation_3d = nullptr);
+    const Rotation3D* rotation_3d = nullptr,
+    SDL_Color color = {0, 0, 0, 0});  // alpha==0 → usa global oscilador
 
 }  // namespace Rendering
diff --git a/source/core/resources/resource_helper.cpp b/source/core/resources/resource_helper.cpp
index 4c8e09c..50c37fb 100644
--- a/source/core/resources/resource_helper.cpp
+++ b/source/core/resources/resource_helper.cpp
@@ -1,5 +1,5 @@
-// resource_helper.cpp - Implementació de funcions d'ajuda
-// © 2025 Port a C++20 amb SDL3
+// resource_helper.cpp - Implementació de funciones de ajuda
+// © 2025 Port a C++20 con SDL3
 
 #include "resource_helper.hpp"
 
@@ -15,7 +15,7 @@ bool initializeResourceSystem(const std::string& pack_file, bool fallback) {
     return Loader::get().initialize(pack_file, fallback);
 }
 
-// Carregar un fitxer
+// Carregar un file
 std::vector<uint8_t> loadFile(const std::string& filepath) {
     // Normalitzar la ruta
     std::string normalized = normalizePath(filepath);
@@ -24,7 +24,7 @@ std::vector<uint8_t> loadFile(const std::string& filepath) {
     return Loader::get().loadResource(normalized);
 }
 
-// Comprovar si existeix un fitxer
+// Comprovar si existeix un file
 bool fileExists(const std::string& filepath) {
     std::string normalized = normalizePath(filepath);
     return Loader::get().resourceExists(normalized);
@@ -37,7 +37,7 @@ std::string getPackPath(const std::string& asset_path) {
 
     // Eliminar rutes absolutes (detectar / o C:\ al principi)
     if (!path.empty() && path[0] == '/') {
-        // Buscar "data/" i agafar el que ve després
+        // Buscar "data/" i agafar el que ve después
         size_t data_pos = path.find("/data/");
         if (data_pos != std::string::npos) {
             path = path.substr(data_pos + 6);  // Saltar "/data/"
@@ -73,7 +73,7 @@ std::string normalizePath(const std::string& path) {
     return getPackPath(path);
 }
 
-// Comprovar si hi ha paquet carregat
+// Comprovar si hay paquet carregat
 bool isPackLoaded() {
     return Loader::get().isPackLoaded();
 }
diff --git a/source/core/resources/resource_helper.hpp b/source/core/resources/resource_helper.hpp
index 1c64f02..dbb30ee 100644
--- a/source/core/resources/resource_helper.hpp
+++ b/source/core/resources/resource_helper.hpp
@@ -1,5 +1,5 @@
-// resource_helper.hpp - Funcions d'ajuda per gestió de recursos
-// © 2025 Port a C++20 amb SDL3
+// resource_helper.hpp - Funciones de ajuda per gestió de recursos
+// © 2025 Port a C++20 con SDL3
 // API simplificada i normalització de rutes
 
 #pragma once
@@ -10,10 +10,10 @@
 
 namespace Resource::Helper {
 
-// Inicialització del sistema
+// Inicialización del sistema
 bool initializeResourceSystem(const std::string& pack_file, bool fallback);
 
-// Càrrega de fitxers
+// Càrrega de archivos
 std::vector<uint8_t> loadFile(const std::string& filepath);
 bool fileExists(const std::string& filepath);
 
diff --git a/source/core/resources/resource_loader.cpp b/source/core/resources/resource_loader.cpp
index 4426f55..af8113b 100644
--- a/source/core/resources/resource_loader.cpp
+++ b/source/core/resources/resource_loader.cpp
@@ -1,5 +1,5 @@
 // resource_loader.cpp - Implementació del carregador de recursos
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #include "resource_loader.hpp"
 
@@ -19,18 +19,18 @@ Loader& Loader::get() {
 bool Loader::initialize(const std::string& pack_file, bool enable_fallback) {
     fallback_enabled_ = enable_fallback;
 
-    // Intentar carregar el paquet
+    // Intentar load el paquet
     pack_ = std::make_unique<Pack>();
 
     if (!pack_->loadPack(pack_file)) {
         if (!fallback_enabled_) {
-            std::cerr << "[ResourceLoader] ERROR FATAL: No es pot carregar " << pack_file
-                      << " i el fallback està desactivat\n";
+            std::cerr << "[ResourceLoader] ERROR FATAL: No es pot load " << pack_file
+                      << " y el fallback está desactivat\n";
             return false;
         }
 
-        std::cout << "[ResourceLoader] Paquet no trobat, usant fallback al sistema de fitxers\n";
-        pack_.reset();  // No hi ha paquet
+        std::cout << "[ResourceLoader] Paquet no trobat, usant fallback al sistema de archivos\n";
+        pack_.reset();  // No hay paquet
         return true;
     }
 
@@ -40,7 +40,7 @@ bool Loader::initialize(const std::string& pack_file, bool enable_fallback) {
 
 // Carregar un recurs
 std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
-    // Intentar carregar del paquet primer
+    // Intentar load del paquet primer
     if (pack_) {
         if (pack_->hasResource(filename)) {
             auto data = pack_->getResource(filename);
@@ -51,7 +51,7 @@ std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
                       << "\n";
         }
 
-        // Si no està al paquet i no hi ha fallback, falla
+        // Si no está al paquet y no hay fallback, falla
         if (!fallback_enabled_) {
             std::cerr << "[ResourceLoader] ERROR: Recurs no trobat al paquet i fallback desactivat: "
                       << filename << "\n";
@@ -59,7 +59,7 @@ std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
         }
     }
 
-    // Fallback al sistema de fitxers
+    // Fallback al sistema de archivos
     if (fallback_enabled_) {
         return loadFromFilesystem(filename);
     }
@@ -74,7 +74,7 @@ bool Loader::resourceExists(const std::string& filename) {
         return true;
     }
 
-    // Comprovar al sistema de fitxers si està activat el fallback
+    // Comprovar al sistema de archivos si está activat el fallback
     if (fallback_enabled_) {
         std::string fullpath = base_path_.empty() ? "data/" + filename : base_path_ + "/data/" + filename;
         return std::filesystem::exists(fullpath);
@@ -86,14 +86,14 @@ bool Loader::resourceExists(const std::string& filename) {
 // Validar el paquet
 bool Loader::validatePack() {
     if (!pack_) {
-        std::cerr << "[ResourceLoader] Advertència: no hi ha paquet carregat per validar\n";
+        std::cerr << "[ResourceLoader] Advertència: no hay paquet carregat per validar\n";
         return false;
     }
 
     return pack_->validatePack();
 }
 
-// Comprovar si hi ha paquet carregat
+// Comprovar si hay paquet carregat
 bool Loader::isPackLoaded() const {
     return pack_ != nullptr;
 }
@@ -109,7 +109,7 @@ std::string Loader::getBasePath() const {
     return base_path_;
 }
 
-// Carregar des del sistema de fitxers (fallback)
+// Carregar des del sistema de archivos (fallback)
 std::vector<uint8_t> Loader::loadFromFilesystem(const std::string& filename) {
     // The filename is already normalized (e.g., "shapes/logo/letra_j.shp")
     // We need to prepend base_path + "data/"
@@ -136,7 +136,7 @@ std::vector<uint8_t> Loader::loadFromFilesystem(const std::string& filename) {
         return {};
     }
 
-    std::cout << "[ResourceLoader] Carregat des del sistema de fitxers: " << fullpath << "\n";
+    std::cout << "[ResourceLoader] Carregat des del sistema de archivos: " << fullpath << "\n";
     return data;
 }
 
diff --git a/source/core/resources/resource_loader.hpp b/source/core/resources/resource_loader.hpp
index 3d501ab..08fcfa3 100644
--- a/source/core/resources/resource_loader.hpp
+++ b/source/core/resources/resource_loader.hpp
@@ -1,6 +1,6 @@
 // resource_loader.hpp - Carregador de recursos (Singleton)
-// © 2025 Port a C++20 amb SDL3
-// Coordina càrrega des del paquet i/o sistema de fitxers
+// © 2025 Port a C++20 con SDL3
+// Coordina càrrega des del paquet i/o sistema de archivos
 
 #pragma once
 
@@ -18,7 +18,7 @@ class Loader {
         // Singleton
         static Loader& get();
 
-        // Inicialització
+        // Inicialización
         bool initialize(const std::string& pack_file, bool enable_fallback);
 
         // Càrrega de recursos
@@ -46,7 +46,7 @@ class Loader {
         bool fallback_enabled_ = false;
         std::string base_path_;
 
-        // Funcions auxiliars
+        // Funciones auxiliars
         std::vector<uint8_t> loadFromFilesystem(const std::string& filename);
 };
 
diff --git a/source/core/resources/resource_pack.cpp b/source/core/resources/resource_pack.cpp
index 4c4adbd..8d9d506 100644
--- a/source/core/resources/resource_pack.cpp
+++ b/source/core/resources/resource_pack.cpp
@@ -1,5 +1,5 @@
-// resource_pack.cpp - Implementació del sistema d'empaquetament
-// © 2025 Port a C++20 amb SDL3
+// resource_pack.cpp - Implementació del sistema de empaquetament
+// © 2025 Port a C++20 con SDL3
 
 #include "resource_pack.hpp"
 
@@ -30,11 +30,11 @@ void Pack::encryptData(std::vector<uint8_t>& data, const std::string& key) {
 }
 
 void Pack::decryptData(std::vector<uint8_t>& data, const std::string& key) {
-    // XOR és simètric
+    // XOR es simètric
     encryptData(data, key);
 }
 
-// Llegir fitxer complet a memòria
+// Llegir file complet a memòria
 std::vector<uint8_t> Pack::readFile(const std::string& filepath) {
     std::ifstream file(filepath, std::ios::binary | std::ios::ate);
     if (!file) {
@@ -54,7 +54,7 @@ std::vector<uint8_t> Pack::readFile(const std::string& filepath) {
     return data;
 }
 
-// Afegir un fitxer individual al paquet
+// Añadir un file individual al paquet
 bool Pack::addFile(const std::string& filepath, const std::string& pack_name) {
     auto file_data = readFile(filepath);
     if (file_data.empty()) {
@@ -67,17 +67,17 @@ bool Pack::addFile(const std::string& filepath, const std::string& pack_name) {
         .size = file_data.size(),
         .checksum = calculateChecksum(file_data)};
 
-    // Afegir dades al bloc de dades
+    // Añadir dades al bloc de dades
     data_.insert(data_.end(), file_data.begin(), file_data.end());
 
     resources_[pack_name] = entry;
 
-    std::cout << "[ResourcePack] Afegit: " << pack_name << " (" << file_data.size()
+    std::cout << "[ResourcePack] Añadido: " << pack_name << " (" << file_data.size()
               << " bytes)\n";
     return true;
 }
 
-// Afegir tots els fitxers d'un directori recursivament
+// Añadir todos los archivos de un directori recursivament
 bool Pack::addDirectory(const std::string& dir_path,
     const std::string& base_path) {
     namespace fs = std::filesystem;
@@ -100,7 +100,7 @@ bool Pack::addDirectory(const std::string& dir_path,
         // Convertir barres invertides a normals (Windows)
         std::ranges::replace(relative_path, '\\', '/');
 
-        // Saltar fitxers de desenvolupament
+        // Saltar archivos de desenvolupament
         if (relative_path.find(".world") != std::string::npos ||
             relative_path.find(".tsx") != std::string::npos ||
             relative_path.find(".DS_Store") != std::string::npos ||
@@ -134,7 +134,7 @@ bool Pack::savePack(const std::string& pack_file) {
 
     // Escriure metadades de recursos
     for (const auto& [name, entry] : resources_) {
-        // Nom del fitxer
+        // Nom del file
         auto name_len = static_cast<uint32_t>(entry.filename.length());
         file.write(reinterpret_cast<const char*>(&name_len), sizeof(name_len));
         file.write(entry.filename.c_str(), name_len);
@@ -149,7 +149,7 @@ bool Pack::savePack(const std::string& pack_file) {
     std::vector<uint8_t> encrypted_data = data_;
     encryptData(encrypted_data, DEFAULT_ENCRYPT_KEY);
 
-    // Escriure mida de dades i dades encriptades
+    // Escriure mida de dades y dades encriptades
     auto data_size = static_cast<uint64_t>(encrypted_data.size());
     file.write(reinterpret_cast<const char*>(&data_size), sizeof(data_size));
     file.write(reinterpret_cast<const char*>(encrypted_data.data()), encrypted_data.size());
@@ -160,7 +160,7 @@ bool Pack::savePack(const std::string& pack_file) {
     return true;
 }
 
-// Carregar paquet des de disc
+// Carregar paquet desde disc
 bool Pack::loadPack(const std::string& pack_file) {
     std::ifstream file(pack_file, std::ios::binary);
     if (!file) {
@@ -180,7 +180,7 @@ bool Pack::loadPack(const std::string& pack_file) {
     uint32_t version;
     file.read(reinterpret_cast<char*>(&version), sizeof(version));
     if (version != VERSION) {
-        std::cerr << "[ResourcePack] Error: versió incompatible (esperava " << VERSION
+        std::cerr << "[ResourcePack] Error: versión incompatible (esperava " << VERSION
                   << ", trobat " << version << ")\n";
         return false;
     }
@@ -192,7 +192,7 @@ bool Pack::loadPack(const std::string& pack_file) {
     // Llegir metadades de recursos
     resources_.clear();
     for (uint32_t i = 0; i < resource_count; ++i) {
-        // Nom del fitxer
+        // Nom del file
         uint32_t name_len;
         file.read(reinterpret_cast<char*>(&name_len), sizeof(name_len));
 
@@ -250,7 +250,7 @@ std::vector<uint8_t> Pack::getResource(const std::string& filename) {
         std::cerr << "[ResourcePack] ADVERTÈNCIA: checksum invàlid per " << filename
                   << " (esperat " << entry.checksum << ", calculat " << computed_checksum
                   << ")\n";
-        // No falla, però adverteix
+        // No falla, pero adverteix
     }
 
     return resource_data;
@@ -261,7 +261,7 @@ bool Pack::hasResource(const std::string& filename) const {
     return resources_.contains(filename);
 }
 
-// Obtenir llista de tots els recursos
+// Obtenir list de todos los recursos
 std::vector<std::string> Pack::getResourceList() const {
     std::vector<std::string> list;
     list.reserve(resources_.size());
diff --git a/source/core/resources/resource_pack.hpp b/source/core/resources/resource_pack.hpp
index 4629305..84ba874 100644
--- a/source/core/resources/resource_pack.hpp
+++ b/source/core/resources/resource_pack.hpp
@@ -1,6 +1,6 @@
-// resource_pack.hpp - Sistema d'empaquetament de recursos
-// © 2025 Port a C++20 amb SDL3
-// Basat en el sistema de "pollo" amb adaptacions per Orni Attack
+// resource_pack.hpp - Sistema de empaquetament de recursos
+// © 2025 Port a C++20 con SDL3
+// Basat en el sistema de "pollo" con adaptacions per Orni Attack
 
 #pragma once
 
@@ -11,31 +11,31 @@
 
 namespace Resource {
 
-// Capçalera del fitxer de paquet
+// Capçalera del file de paquet
 struct PackHeader {
         char magic[4];     // "ORNI"
-        uint32_t version;  // Versió del format (1)
+        uint32_t version;  // Versión del format (1)
 };
 
 // Entrada de recurs dins el paquet
 struct ResourceEntry {
-        std::string filename;  // Nom del recurs (amb barres normals)
-        uint64_t offset;       // Posició dins el bloc de dades
+        std::string filename;  // Nom del recurs (con barres normals)
+        uint64_t offset;       // Posición dins el bloc de dades
         uint64_t size;         // Mida en bytes
         uint32_t checksum;     // Checksum CRC32 per verificació
 };
 
-// Classe principal per gestionar paquets de recursos
+// Clase principal per gestionar paquets de recursos
 class Pack {
     public:
         Pack() = default;
         ~Pack() = default;
 
-        // Afegir fitxers al paquet
+        // Añadir archivos al paquet
         bool addFile(const std::string& filepath, const std::string& pack_name);
         bool addDirectory(const std::string& dir_path, const std::string& base_path = "");
 
-        // Guardar i carregar paquets
+        // Guardar i load paquets
         bool savePack(const std::string& pack_file);
         bool loadPack(const std::string& pack_file);
 
@@ -57,7 +57,7 @@ class Pack {
         std::unordered_map<std::string, ResourceEntry> resources_;
         std::vector<uint8_t> data_;
 
-        // Funcions auxiliars
+        // Funciones auxiliars
         std::vector<uint8_t> readFile(const std::string& filepath);
         [[nodiscard]] uint32_t calculateChecksum(const std::vector<uint8_t>& data) const;
         void encryptData(std::vector<uint8_t>& data, const std::string& key);
diff --git a/source/core/system/context_escenes.hpp b/source/core/system/context_escenes.hpp
deleted file mode 100644
index 7ce2f90..0000000
--- a/source/core/system/context_escenes.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-// context_escenes.hpp - Sistema de gestió d'escenes i context de transicions
-// © 2025 Port a C++20
-
-#pragma once
-
-#include "core/system/game_config.hpp"
-
-namespace GestorEscenes {
-
-// Context de transició entre escenes
-// Conté l'escena destinació i opcions específiques per aquella escena
-class ContextEscenes {
-    public:
-        // Tipus d'escena del joc
-        enum class Escena {
-            LOGO,   // Pantalla d'inici (logo JAILGAMES)
-            TITOL,  // Pantalla de títol amb menú
-            JOC,    // Joc principal (Asteroids)
-            EIXIR   // Sortir del programa
-        };
-
-        // Opcions específiques per a cada escena
-        enum class Opcio {
-            NONE,                // Sense opcions especials (comportament per defecte)
-            JUMP_TO_TITLE_MAIN,  // TITOL: Saltar directament a MAIN (starfield instantani)
-            // MODE_DEMO,           // JOC: Mode demostració amb IA (futur)
-        };
-
-        // Constructor inicial amb escena LOGO i sense opcions
-        ContextEscenes() = default;
-
-        // Canviar escena amb opció específica
-        void canviar_escena(Escena nova_escena, Opcio opcio = Opcio::NONE) {
-            escena_desti_ = nova_escena;
-            opcio_ = opcio;
-        }
-
-        // Consultar escena destinació
-        [[nodiscard]] auto escena_desti() const -> Escena {
-            return escena_desti_;
-        }
-
-        // Consultar opció actual
-        [[nodiscard]] auto opcio() const -> Opcio {
-            return opcio_;
-        }
-
-        // Consumir opció (retorna valor i reseteja a NONE)
-        // Utilitzar quan l'escena processa l'opció
-        [[nodiscard]] auto consumir_opcio() -> Opcio {
-            Opcio valor = opcio_;
-            opcio_ = Opcio::NONE;
-            return valor;
-        }
-
-        // Reset opció a NONE (sense retornar valor)
-        void reset_opcio() {
-            opcio_ = Opcio::NONE;
-        }
-
-        // Configurar partida abans de transicionar a JOC
-        void set_config_partida(const GameConfig::ConfigPartida& config) {
-            config_partida_ = config;
-        }
-
-        // Obtenir configuració de partida (consumit per EscenaJoc)
-        [[nodiscard]] const GameConfig::ConfigPartida& get_config_partida() const {
-            return config_partida_;
-        }
-
-    private:
-        Escena escena_desti_{Escena::LOGO};         // Escena a la qual transicionar
-        Opcio opcio_{Opcio::NONE};                  // Opció específica per l'escena
-        GameConfig::ConfigPartida config_partida_;  // Configuració de partida (jugadors actius, mode)
-};
-
-// Variable global inline per gestionar l'escena actual (backward compatibility)
-// Sincronitzada amb context.escena_desti() pel Director
-inline ContextEscenes::Escena actual = ContextEscenes::Escena::LOGO;
-
-}  // namespace GestorEscenes
diff --git a/source/core/system/debug_overlay.cpp b/source/core/system/debug_overlay.cpp
new file mode 100644
index 0000000..1dbc0ba
--- /dev/null
+++ b/source/core/system/debug_overlay.cpp
@@ -0,0 +1,64 @@
+// debug_overlay.cpp - Implementación del overlay de debug.
+
+#include "core/system/debug_overlay.hpp"
+
+#include <string>
+
+#include "core/types.hpp"
+#include "game/options.hpp"
+
+namespace System {
+
+namespace {
+// Posición y tamaño del overlay en coordenadas lógicas (1280×720).
+constexpr float OVERLAY_X = 12.0F;
+constexpr float OVERLAY_Y_FPS = 12.0F;
+constexpr float OVERLAY_LINE_HEIGHT = 18.0F;  // separación entre líneas (scale 0.4 → ~16 px alto)
+constexpr float OVERLAY_SCALE = 0.4F;
+constexpr float OVERLAY_SPACING = 2.0F;
+constexpr float OVERLAY_BRIGHTNESS = 1.0F;
+
+// Cadencia de actualización del valor de FPS mostrado.
+constexpr float FPS_UPDATE_INTERVAL = 0.5F;
+}  // namespace
+
+DebugOverlay::DebugOverlay(Rendering::Renderer* renderer)
+    : text_(renderer),
+#ifdef _DEBUG
+      visible_(true),
+#else
+      visible_(false),
+#endif
+      fps_accumulator_(0.0F),
+      fps_frame_count_(0),
+      fps_display_(0) {}
+
+void DebugOverlay::update(float delta_time) {
+    fps_accumulator_ += delta_time;
+    fps_frame_count_++;
+
+    if (fps_accumulator_ >= FPS_UPDATE_INTERVAL) {
+        fps_display_ = static_cast<int>(fps_frame_count_ / fps_accumulator_);
+        fps_frame_count_ = 0;
+        fps_accumulator_ = 0.0F;
+    }
+}
+
+void DebugOverlay::draw() const {
+    if (!visible_) {
+        return;
+    }
+
+    const std::string FPS_TEXT = "FPS: " + std::to_string(fps_display_);
+    const std::string VSYNC_TEXT = std::string("VSYNC: ")
+        + (Options::rendering.vsync == 1 ? "ON" : "OFF");
+
+    text_.render(FPS_TEXT,
+                 Vec2{.x = OVERLAY_X, .y = OVERLAY_Y_FPS},
+                 OVERLAY_SCALE, OVERLAY_SPACING, OVERLAY_BRIGHTNESS);
+    text_.render(VSYNC_TEXT,
+                 Vec2{.x = OVERLAY_X, .y = OVERLAY_Y_FPS + OVERLAY_LINE_HEIGHT},
+                 OVERLAY_SCALE, OVERLAY_SPACING, OVERLAY_BRIGHTNESS);
+}
+
+}  // namespace System
diff --git a/source/core/system/debug_overlay.hpp b/source/core/system/debug_overlay.hpp
new file mode 100644
index 0000000..bb012b0
--- /dev/null
+++ b/source/core/system/debug_overlay.hpp
@@ -0,0 +1,38 @@
+// debug_overlay.hpp - Overlay de debug (FPS + VSync) toggleable con F11
+// © 2025 Orni Attack
+//
+// Sistema global propiedad del Director. Se actualiza y dibuja cada frame
+// después de la escena (queda on top). En builds debug arranca visible,
+// en release oculto. F11 alterna visibilidad.
+
+#pragma once
+
+#include "core/graphics/vector_text.hpp"
+#include "core/rendering/render_context.hpp"
+
+namespace System {
+
+class DebugOverlay {
+    public:
+        explicit DebugOverlay(Rendering::Renderer* renderer);
+
+        // Acumula FPS. Llamar una vez por frame con el delta del Director.
+        void update(float delta_time);
+
+        // Pinta el overlay si está visible. Posición esquina sup-izq.
+        void draw() const;
+
+        void toggle() { visible_ = !visible_; }
+        [[nodiscard]] auto isVisible() const -> bool { return visible_; }
+
+    private:
+        Graphics::VectorText text_;
+        bool visible_;
+
+        // FPS counter — se actualiza cada FPS_UPDATE_INTERVAL segundos.
+        float fps_accumulator_;
+        int fps_frame_count_;
+        int fps_display_;
+};
+
+}  // namespace System
diff --git a/source/core/system/director.cpp b/source/core/system/director.cpp
index 5f3eda0..43f8133 100644
--- a/source/core/system/director.cpp
+++ b/source/core/system/director.cpp
@@ -3,13 +3,18 @@
 #include <SDL3/SDL.h>
 #include <sys/stat.h>
 
+#include <algorithm>
 #include <cerrno>
 #include <cstdlib>
 #include <iostream>
+#include <memory>
 
-#include "context_escenes.hpp"
+#include "debug_overlay.hpp"
+#include "scene.hpp"
+#include "scene_context.hpp"
+#include "global_events.hpp"
 #include "core/audio/audio.hpp"
-#include "core/audio/audio_cache.hpp"
+#include "core/audio/audio_adapter.hpp"
 #include "core/defaults.hpp"
 #include "core/input/input.hpp"
 #include "core/input/mouse.hpp"
@@ -17,9 +22,9 @@
 #include "core/resources/resource_helper.hpp"
 #include "core/resources/resource_loader.hpp"
 #include "core/utils/path_utils.hpp"
-#include "game/escenes/escena_joc.hpp"
-#include "game/escenes/escena_logo.hpp"
-#include "game/escenes/escena_titol.hpp"
+#include "game/scenes/game_scene.hpp"
+#include "game/scenes/logo_scene.hpp"
+#include "game/scenes/title_scene.hpp"
 #include "game/options.hpp"
 #include "project.h"
 
@@ -29,14 +34,14 @@
 #endif
 
 // Using declarations per simplificar el codi
-using GestorEscenes::ContextEscenes;
-using Escena = ContextEscenes::Escena;
+using SceneManager::SceneContext;
+using SceneType = SceneContext::SceneType;
 
 // Constructor
 Director::Director(std::vector<std::string> const& args) {
     std::cout << "Orni Attack - Inici\n";
 
-    // Inicialitzar opcions amb valors per defecte
+    // Inicialitzar opciones con valors per defecte
     Options::init();
 
     // Comprovar arguments del programa
@@ -50,28 +55,28 @@ Director::Director(std::vector<std::string> const& args) {
 
     // Inicialitzar sistema de recursos
 #ifdef RELEASE_BUILD
-    // Mode release: paquet obligatori, sense fallback
+    // Mode release: paquet obligatori, sin fallback
     std::string pack_path = resource_base + "/resources.pack";
     if (!Resource::Helper::initializeResourceSystem(pack_path, false)) {
-        std::cerr << "ERROR FATAL: No es pot carregar " << pack_path << "\n";
-        std::cerr << "El joc no pot continuar sense els recursos.\n";
+        std::cerr << "ERROR FATAL: No es pot load " << pack_path << "\n";
+        std::cerr << "El juego no pot continuar sin los recursos.\n";
         std::exit(1);
     }
 
     // Validar integritat del paquet
     if (!Resource::Loader::get().validatePack()) {
-        std::cerr << "ERROR FATAL: El paquet de recursos està corromput\n";
+        std::cerr << "ERROR FATAL: El paquet de recursos está corromput\n";
         std::exit(1);
     }
 
     std::cout << "Sistema de recursos inicialitzat (mode release)\n";
 #else
-    // Mode desenvolupament: intentar paquet amb fallback a data/
+    // Mode desenvolupament: intentar paquet con fallback a data/
     std::string pack_path = resource_base + "/resources.pack";
     Resource::Helper::initializeResourceSystem(pack_path, true);
 
     if (Resource::Helper::isPackLoaded()) {
-        std::cout << "Sistema de recursos inicialitzat (mode dev amb paquet)\n";
+        std::cout << "Sistema de recursos inicialitzat (mode dev con paquet)\n";
     } else {
         std::cout << "Sistema de recursos inicialitzat (mode dev, fallback a data/)\n";
     }
@@ -84,21 +89,21 @@ Director::Director(std::vector<std::string> const& args) {
     createSystemFolder("jailgames");
     createSystemFolder(std::string("jailgames/") + Project::NAME);
 
-    // Establir ruta del fitxer de configuració
+    // Establir ruta del file de configuración
     Options::setConfigFile(system_folder_ + "/config.yaml");
 
-    // Carregar o crear configuració
+    // Carregar o crear configuración
     Options::loadFromFile();
 
-    // Inicialitzar sistema d'input
+    // Inicialitzar sistema de input
     Input::init("data/gamecontrollerdb.txt");
 
-    // Aplicar configuració de controls dels jugadors
+    // Aplicar configuración de controls dels jugadors
     Input::get()->applyPlayer1BindingsFromOptions();
     Input::get()->applyPlayer2BindingsFromOptions();
 
     if (Options::console) {
-        std::cout << "Configuració carregada\n";
+        std::cout << "Configuración carregada\n";
         std::cout << "  Finestra: " << Options::window.width << "×"
                   << Options::window.height << '\n';
         std::cout << "  Física: rotation=" << Options::physics.rotation_speed
@@ -111,7 +116,7 @@ Director::Director(std::vector<std::string> const& args) {
 }
 
 Director::~Director() {
-    // Guardar opcions
+    // Guardar opciones
     Options::saveToFile();
 
     // Cleanup input
@@ -138,7 +143,7 @@ auto Director::checkProgramArguments(std::vector<std::string> const& args)
         } else if (argument == "--reset-config") {
             Options::init();
             Options::saveToFile();
-            std::cout << "Configuració restablida als valors per defecte\n";
+            std::cout << "Configuración restablida als valors per defecte\n";
         }
     }
 
@@ -188,7 +193,7 @@ void Director::createSystemFolder(const std::string& folder) {
                     exit(EXIT_FAILURE);
 
                 case EEXIST:
-                    // La carpeta ja existeix (race condition), continuar
+                    // La carpeta ya existeix (race condition), continuar
                     break;
 
                 case ENAMETOOLONG:
@@ -207,7 +212,7 @@ void Director::createSystemFolder(const std::string& folder) {
     }
 }
 
-// Bucle principal del joc
+// Bucle principal del juego
 auto Director::run() -> int {
     // Calculate initial size from saved zoom_factor
     int initial_width = static_cast<int>(std::round(
@@ -215,68 +220,115 @@ auto Director::run() -> int {
     int initial_height = static_cast<int>(std::round(
         Defaults::Window::HEIGHT * Options::window.zoom_factor));
 
-    // Crear gestor SDL amb configuració de Options
+    // Crear gestor SDL con configuración de Options
     SDLManager sdl(initial_width, initial_height, Options::window.fullscreen);
 
-    // CRÍTIC: Forçar ocultació del cursor DESPRÉS de tota la inicialització SDL
-    // Això evita que SDL mostre el cursor automàticament durant la creació de la finestra
+    // 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 (!Options::window.fullscreen) {
         Mouse::forceHide();
     }
 
-    // Inicialitzar sistema d'audio
-    Audio::init();
-    Audio::get()->setMusicVolume(1.0);
-    Audio::get()->setSoundVolume(0.4);
+    // 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
 
-    // Precachejar música per evitar lag al començar
-    AudioCache::getMusic("title.ogg");
-    AudioCache::getMusic("game.ogg");
+    // Precachear música para evitar lag al empezar
+    AudioResource::getMusic("title.ogg");
+    AudioResource::getMusic("game.ogg");
     if (Options::console) {
-        std::cout << "Música precachejada: "
-                  << AudioCache::getMusicCacheSize() << " fitxers\n";
+        std::cout << "Música precacheada\n";
     }
 
-    // Crear context d'escenes
-    ContextEscenes context;
+    // Crear context de escenes
+    SceneContext context;
 #ifdef _DEBUG
-    context.canviar_escena(Escena::TITOL);
+    context.setNextScene(SceneType::TITLE);
 #else
-    context.canviar_escena(Escena::LOGO);
+    context.setNextScene(SceneType::LOGO);
 #endif
 
-    // Bucle principal de gestió d'escenes
-    while (context.escena_desti() != Escena::EIXIR) {
-        // Sincronitzar GestorEscenes::actual amb context
-        // (altres sistemes encara poden llegir GestorEscenes::actual)
-        GestorEscenes::actual = context.escena_desti();
+    // 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());
 
-        switch (context.escena_desti()) {
-            case Escena::LOGO: {
-                EscenaLogo logo(sdl, context);
-                logo.executar();
-                break;
-            }
-
-            case Escena::TITOL: {
-                EscenaTitol titol(sdl, context);
-                titol.executar();
-                break;
-            }
-
-            case Escena::JOC: {
-                EscenaJoc joc(sdl, context);
-                joc.executar();
-                break;
-            }
-
-            default:
-                break;
+    // 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);
     }
 
-    // Sincronitzar final amb GestorEscenes::actual
-    GestorEscenes::actual = Escena::EIXIR;
-
+    SceneManager::actual = SceneType::EXIT;
     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:
+            return std::make_unique<TitleScene>(sdl, context);
+        case SceneType::GAME:
+            return std::make_unique<GameScene>(sdl, context);
+        case SceneType::EXIT:
+        default:
+            return nullptr;
+    }
+}
+
+void Director::runFrameLoop(Scene& scene, SDLManager& sdl, SceneContext& context,
+                            System::DebugOverlay& debug_overlay) {
+    SDL_Event event;
+    Uint64 last_time = SDL_GetTicks();
+
+    while (!scene.isFinished()) {
+        // Delta time real, capeado a 50ms para evitar grandes saltos.
+        const Uint64 NOW = SDL_GetTicks();
+        float delta_time = static_cast<float>(NOW - last_time) / 1000.0F;
+        last_time = NOW;
+        delta_time = std::min(delta_time, 0.05F);
+
+        Mouse::updateCursorVisibility();
+        Input::get()->update();
+
+        // Event loop: primero ventana, después globales, después F11
+        // (toggle del overlay), después escena.
+        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);
+        Audio::update();
+
+        sdl.clear(0, 0, 0);
+        sdl.updateRenderingContext();
+        scene.draw();
+        debug_overlay.draw();  // siempre on top de la escena
+        sdl.present();
+    }
+}
diff --git a/source/core/system/director.hpp b/source/core/system/director.hpp
index b1ce50f..9018f84 100644
--- a/source/core/system/director.hpp
+++ b/source/core/system/director.hpp
@@ -1,8 +1,15 @@
 #pragma once
 
+#include <memory>
 #include <string>
 #include <vector>
 
+#include "scene_context.hpp"
+
+class Scene;
+class SDLManager;
+namespace System { class DebugOverlay; }
+
 class Director {
     public:
         explicit Director(std::vector<std::string> const& args);
@@ -17,4 +24,18 @@ class Director {
         static auto checkProgramArguments(std::vector<std::string> const& args)
             -> std::string;
         void createSystemFolder(const std::string& folder);
+
+        // Construye la escena correspondiente al tipo solicitado. Retorna
+        // nullptr para EXIT u otros valores no constructibles.
+        static auto buildScene(SceneManager::SceneContext::SceneType type,
+                               SDLManager& sdl,
+                               SceneManager::SceneContext& context)
+            -> std::unique_ptr<Scene>;
+
+        // Ejecuta el bucle de frames de UNA escena hasta que scene.isFinished()
+        // sea true. Maneja delta_time, eventos (globales + escena), update y draw.
+        // El debug_overlay es global a todas las escenas; el Director lo posee.
+        static void runFrameLoop(Scene& scene, SDLManager& sdl,
+                                 SceneManager::SceneContext& context,
+                                 System::DebugOverlay& debug_overlay);
 };
diff --git a/source/core/system/game_config.hpp b/source/core/system/game_config.hpp
index ef0e907..72454a4 100644
--- a/source/core/system/game_config.hpp
+++ b/source/core/system/game_config.hpp
@@ -4,43 +4,43 @@
 
 namespace GameConfig {
 
-// Mode de joc
+// Mode de juego
 enum class Mode {
     NORMAL,  // Partida normal
     DEMO     // Mode demostració (futur)
 };
 
-// Configuració d'una partida
-struct ConfigPartida {
-        bool jugador1_actiu{false};  // És actiu el jugador 1?
-        bool jugador2_actiu{false};  // És actiu el jugador 2?
-        Mode mode{Mode::NORMAL};     // Mode de joc
+// Configuración de una match
+struct MatchConfig {
+        bool jugador1_actiu{false};  // Es active el player 1?
+        bool jugador2_actiu{false};  // Es active el player 2?
+        Mode mode{Mode::NORMAL};     // Mode de juego
 
-        // Mètodes auxiliars
+        // Métodos auxiliars
 
-        // Retorna true si només hi ha un jugador actiu
+        // Retorna true si solo hay un player active
         [[nodiscard]] bool es_un_jugador() const {
             return (jugador1_actiu && !jugador2_actiu) ||
                 (!jugador1_actiu && jugador2_actiu);
         }
 
-        // Retorna true si hi ha dos jugadors actius
+        // Retorna true si hay dos jugadors active
         [[nodiscard]] bool son_dos_jugadors() const {
             return jugador1_actiu && jugador2_actiu;
         }
 
-        // Retorna true si no hi ha cap jugador actiu
+        // Retorna true si no hay sin player active
         [[nodiscard]] bool cap_jugador() const {
             return !jugador1_actiu && !jugador2_actiu;
         }
 
-        // Compte de jugadors actius (0, 1 o 2)
+        // Compte de jugadors active (0, 1 o 2)
         [[nodiscard]] uint8_t compte_jugadors() const {
             return (jugador1_actiu ? 1 : 0) + (jugador2_actiu ? 1 : 0);
         }
 
-        // Retorna l'ID de l'únic jugador actiu (0 o 1)
-        // Només vàlid si es_un_jugador() retorna true
+        // Retorna l'ID de l'únic player active (0 o 1)
+        // Solo vàlid si es_un_jugador() retorna true
         [[nodiscard]] uint8_t id_unic_jugador() const {
             if (jugador1_actiu && !jugador2_actiu) {
                 return 0;
@@ -48,7 +48,7 @@ struct ConfigPartida {
             if (!jugador1_actiu && jugador2_actiu) {
                 return 1;
             }
-            return 0;  // Fallback (cal comprovar es_un_jugador() primer)
+            return 0;  // Fallback (necesario comprovar es_un_jugador() primer)
         }
 };
 
diff --git a/source/core/system/global_events.cpp b/source/core/system/global_events.cpp
index 0024ec2..2893bdf 100644
--- a/source/core/system/global_events.cpp
+++ b/source/core/system/global_events.cpp
@@ -5,18 +5,18 @@
 
 #include <iostream>
 
-#include "context_escenes.hpp"
+#include "scene_context.hpp"
 #include "core/input/input.hpp"
 #include "core/input/mouse.hpp"
 #include "core/rendering/sdl_manager.hpp"
 
 // Using declarations per simplificar el codi
-using GestorEscenes::ContextEscenes;
-using Escena = ContextEscenes::Escena;
+using SceneManager::SceneContext;
+using SceneType = SceneContext::SceneType;
 
 namespace GlobalEvents {
 
-bool handle(const SDL_Event& event, SDLManager& sdl, ContextEscenes& context) {
+bool handle(const SDL_Event& event, SDLManager& sdl, SceneContext& context) {
     // 1. Permitir que Input procese el evento (para hotplug de gamepads)
     auto event_msg = Input::get()->handleEvent(event);
     if (!event_msg.empty()) {
@@ -25,8 +25,8 @@ bool handle(const SDL_Event& event, SDLManager& sdl, ContextEscenes& context) {
 
     // 2. Procesar SDL_EVENT_QUIT directamente (no es input de juego)
     if (event.type == SDL_EVENT_QUIT) {
-        context.canviar_escena(Escena::EIXIR);
-        GestorEscenes::actual = Escena::EIXIR;
+        context.setNextScene(SceneType::EXIT);
+        SceneManager::actual = SceneType::EXIT;
         return true;
     }
 
@@ -54,8 +54,8 @@ bool handle(const SDL_Event& event, SDLManager& sdl, ContextEscenes& context) {
                 return true;
 
             case SDL_SCANCODE_ESCAPE:
-                context.canviar_escena(Escena::EIXIR);
-                GestorEscenes::actual = Escena::EIXIR;
+                context.setNextScene(SceneType::EXIT);
+                SceneManager::actual = SceneType::EXIT;
                 return true;
 
             default:
diff --git a/source/core/system/global_events.hpp b/source/core/system/global_events.hpp
index a11241d..c96fd0c 100644
--- a/source/core/system/global_events.hpp
+++ b/source/core/system/global_events.hpp
@@ -1,4 +1,4 @@
-// global_events.hpp - Events globals del joc
+// global_events.hpp - Events globals del juego
 // Basat en el patró del projecte "pollo"
 // © 2025 Port a C++20
 
@@ -8,12 +8,12 @@
 
 // Forward declarations
 class SDLManager;
-namespace GestorEscenes {
-class ContextEscenes;
+namespace SceneManager {
+class SceneContext;
 }
 
 namespace GlobalEvents {
 // Processa events globals (F1/F2/F3/ESC/QUIT)
-// Retorna true si l'event ha estat processat i no cal seguir processant-lo
-bool handle(const SDL_Event& event, SDLManager& sdl, GestorEscenes::ContextEscenes& context);
+// Retorna true si l'event ha state processat y no necesario seguir processant-lo
+bool handle(const SDL_Event& event, SDLManager& sdl, SceneManager::SceneContext& context);
 }  // namespace GlobalEvents
diff --git a/source/core/system/scene.hpp b/source/core/system/scene.hpp
new file mode 100644
index 0000000..96f6038
--- /dev/null
+++ b/source/core/system/scene.hpp
@@ -0,0 +1,41 @@
+// scene.hpp - Interfaz base para escenas del juego
+// © 2025 Orni Attack
+//
+// El frame loop vive en Director, no en cada escena. Cada escena implementa
+// estos cuatro métodos y el Director los llama en orden por frame:
+//   handleEvent(ev)   por cada evento SDL (tras los eventos globales)
+//   update(dt)        lógica
+//   draw()            pintado (entre clear y present del Director)
+//   isFinished()      consultar transición pendiente
+//
+// Cuando una escena pide transición (vía context_.setNextScene(...)),
+// isFinished() debe pasar a true y el Director destruye la escena para
+// construir la siguiente.
+
+#pragma once
+
+#include <SDL3/SDL.h>
+
+class Scene {
+    public:
+        Scene() = default;
+        virtual ~Scene() = default;
+
+        Scene(const Scene&) = delete;
+        auto operator=(const Scene&) -> Scene& = delete;
+        Scene(Scene&&) = delete;
+        auto operator=(Scene&&) -> Scene& = delete;
+
+        // Eventos específicos de la escena. Los globales (window resize,
+        // F1-F4, ESC, QUIT) los procesa GlobalEvents::handle antes.
+        virtual void handleEvent(const SDL_Event& event) = 0;
+
+        // Lógica de la escena. delta_time en segundos, ya capeado por el Director.
+        virtual void update(float delta_time) = 0;
+
+        // Pintar la escena (entre clear y present del Director).
+        virtual void draw() = 0;
+
+        // True cuando la escena ha pedido transición.
+        [[nodiscard]] virtual auto isFinished() const -> bool = 0;
+};
diff --git a/source/core/system/scene_context.hpp b/source/core/system/scene_context.hpp
new file mode 100644
index 0000000..b7a4b04
--- /dev/null
+++ b/source/core/system/scene_context.hpp
@@ -0,0 +1,81 @@
+// scene_context.hpp - Sistema de gestió de escenes i context de transiciones
+// © 2025 Port a C++20
+
+#pragma once
+
+#include "core/system/game_config.hpp"
+
+namespace SceneManager {
+
+// Context de transición entre escenes
+// Conté l'escena destinació i opciones específiques per aquella escena
+class SceneContext {
+    public:
+        // Tipo de escena del juego
+        enum class SceneType {
+            LOGO,   // Pantalla de start (logo JAILGAMES)
+            TITLE,  // Pantalla de título con menú
+            GAME,    // Juego principal (Asteroids)
+            EXIT   // Salir del programa
+        };
+
+        // Opciones específiques para cada escena
+        enum class Option {
+            NONE,                // Sin opciones especials (comportament per defecte)
+            JUMP_TO_TITLE_MAIN,  // TITLE: Saltar directament a MAIN (starfield instantani)
+            // MODE_DEMO,           // GAME: Mode demostració con IA (futur)
+        };
+
+        // Constructor inicial con escena LOGO i sin opciones
+        SceneContext() = default;
+
+        // Canviar escena con opción específica
+        void setNextScene(SceneType next_scene, Option option = Option::NONE) {
+            next_scene_ = next_scene;
+            option_ = option;
+        }
+
+        // Consultar escena destinació
+        [[nodiscard]] auto nextScene() const -> SceneType {
+            return next_scene_;
+        }
+
+        // Consultar opción actual
+        [[nodiscard]] auto option() const -> Option {
+            return option_;
+        }
+
+        // Consumir opción (retorna value i reseteja a NONE)
+        // Utilitzar cuando l'escena processa l'opción
+        [[nodiscard]] auto consumeOption() -> Option {
+            Option value = option_;
+            option_ = Option::NONE;
+            return value;
+        }
+
+        // Reset opción a NONE (sin retornar value)
+        void resetOption() {
+            option_ = Option::NONE;
+        }
+
+        // Configurar match antes de transicionar a GAME
+        void setMatchConfig(const GameConfig::MatchConfig& config) {
+            match_config_ = config;
+        }
+
+        // Obtenir configuración de match (consumit per GameScene)
+        [[nodiscard]] const GameConfig::MatchConfig& getMatchConfig() const {
+            return match_config_;
+        }
+
+    private:
+        SceneType next_scene_{SceneType::LOGO};         // SceneType a la qual transicionar
+        Option option_{Option::NONE};                  // Opción específica per l'escena
+        GameConfig::MatchConfig match_config_;  // Configuración de match (jugadors active, mode)
+};
+
+// Variable global inline per gestionar l'escena actual (backward compatibility)
+// Sincronitzada con context.nextScene() por el Director
+inline SceneContext::SceneType actual = SceneContext::SceneType::LOGO;
+
+}  // namespace SceneManager
diff --git a/source/core/types.hpp b/source/core/types.hpp
index 1c75a3e..c463496 100644
--- a/source/core/types.hpp
+++ b/source/core/types.hpp
@@ -1,43 +1,72 @@
+// types.hpp - Tipos básicos compartidos
+// © 2025 Orni Attack
+
 #pragma once
 
-#include <array>
-#include <cstdint>
+#include <cmath>
 
-#include "core/defaults.hpp"
+// Vector 2D cartesiano - única estructura de coordenadas del juego.
+// Aggregate (sin constructores definidos) para soportar designated initializers:
+//     Vec2{.x = 1.0F, .y = 2.0F}
+// y aggregate initialization clásica:
+//     Vec2{1.0F, 2.0F}
+struct Vec2 {
+        float x{0.0F};
+        float y{0.0F};
 
-// Punt polar (coordenades polars)
-struct IPunt {
-        float r;      // Radi
-        float angle;  // Angle en radians
+        constexpr auto operator+=(const Vec2& o) -> Vec2& {
+            x += o.x;
+            y += o.y;
+            return *this;
+        }
+        constexpr auto operator-=(const Vec2& o) -> Vec2& {
+            x -= o.x;
+            y -= o.y;
+            return *this;
+        }
+        constexpr auto operator*=(float s) -> Vec2& {
+            x *= s;
+            y *= s;
+            return *this;
+        }
+        constexpr auto operator/=(float s) -> Vec2& {
+            x /= s;
+            y /= s;
+            return *this;
+        }
+
+        [[nodiscard]] auto lengthSquared() const -> float { return (x * x) + (y * y); }
+        [[nodiscard]] auto length() const -> float { return std::sqrt(lengthSquared()); }
+        [[nodiscard]] auto dot(const Vec2& o) const -> float { return (x * o.x) + (y * o.y); }
+
+        // Devuelve el vector normalizado; si la magnitud es 0 devuelve {0,0}.
+        [[nodiscard]] auto normalized() const -> Vec2 {
+            const float L = length();
+            return L > 0.0F ? Vec2{.x = x / L, .y = y / L} : Vec2{};
+        }
 };
 
-// Punt cartesià
-struct Punt {
-        float x, y;
-};
-
-// ==============================================================================
-// DEPRECATED: Legacy types (replaced by Shape system)
-// ==============================================================================
-// These types are kept temporarily for chatarra_cosmica_ (Phase 10: explosions)
-// TODO Phase 10: Replace with particle system or remove completely
-
-// Nau (triangle) - DEPRECATED: Now using Shape system (ship.shp)
-struct Triangle {
-        IPunt p1, p2, p3;
-        Punt centre;
-        float angle;
-        float velocitat;
-};
-
-// Polígon (enemics i bales) - DEPRECATED: Now using Shape system (.shp files)
-struct Poligon {
-        std::array<IPunt, Defaults::Entities::MAX_IPUNTS> ipuntx;
-        Punt centre;
-        float angle;
-        float velocitat;
-        uint8_t n;
-        float drotacio;
-        float rotacio;
-        bool esta;
-};
+constexpr auto operator+(Vec2 a, const Vec2& b) -> Vec2 {
+    a += b;
+    return a;
+}
+constexpr auto operator-(Vec2 a, const Vec2& b) -> Vec2 {
+    a -= b;
+    return a;
+}
+constexpr auto operator*(Vec2 v, float s) -> Vec2 {
+    v *= s;
+    return v;
+}
+constexpr auto operator*(float s, Vec2 v) -> Vec2 {
+    v *= s;
+    return v;
+}
+constexpr auto operator/(Vec2 v, float s) -> Vec2 {
+    v /= s;
+    return v;
+}
+constexpr auto operator-(const Vec2& v) -> Vec2 { return {.x = -v.x, .y = -v.y}; }
+constexpr auto operator==(const Vec2& a, const Vec2& b) -> bool {
+    return a.x == b.x && a.y == b.y;
+}
diff --git a/source/core/utils/path_utils.cpp b/source/core/utils/path_utils.cpp
index e7d9214..2926503 100644
--- a/source/core/utils/path_utils.cpp
+++ b/source/core/utils/path_utils.cpp
@@ -1,5 +1,5 @@
 // path_utils.cpp - Implementació de utilitats de rutes
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #include "path_utils.hpp"
 
@@ -13,10 +13,10 @@ namespace Utils {
 static std::string executable_path_;
 static std::string executable_directory_;
 
-// Inicialitzar el sistema de rutes amb argv[0]
+// Inicialitzar el sistema de rutes con argv[0]
 void initializePathSystem(const char* argv0) {
     if (argv0 == nullptr) {
-        std::cerr << "[PathUtils] ADVERTÈNCIA: argv[0] és nullptr\n";
+        std::cerr << "[PathUtils] ADVERTÈNCIA: argv[0] es nullptr\n";
         executable_path_ = "";
         executable_directory_ = ".";
         return;
@@ -50,7 +50,7 @@ bool isMacOSBundle() {
 #ifdef MACOS_BUNDLE
     return true;
 #else
-    // Detecció en temps d'execució
+    // Detecció en time de execució
     // Cercar ".app/Contents/MacOS" a la ruta de l'executable
     std::string exe_dir = getExecutableDirectory();
     return exe_dir.find(".app/Contents/MacOS") != std::string::npos;
@@ -62,10 +62,10 @@ std::string getResourceBasePath() {
     std::string exe_dir = getExecutableDirectory();
 
     if (isMacOSBundle()) {
-        // Bundle de macOS: recursos a ../Resources des de MacOS/
+        // Bundle de macOS: recursos a ../Resources desde MacOS/
         std::cout << "[PathUtils] Detectat bundle de macOS\n";
         return exe_dir + "/../Resources";
-    }  // Executable normal: recursos al mateix directori
+    }  // Executable normal: recursos al mismo directori
     return exe_dir;
 }
 
@@ -76,7 +76,7 @@ std::string normalizePath(const std::string& path) {
     // Convertir barres invertides a normals
     std::ranges::replace(normalized, '\\', '/');
 
-    // Simplificar rutes amb filesystem
+    // Simplificar rutes con filesystem
     try {
         std::filesystem::path fs_path(normalized);
         normalized = fs_path.lexically_normal().string();
diff --git a/source/core/utils/path_utils.hpp b/source/core/utils/path_utils.hpp
index d4657e5..7819fad 100644
--- a/source/core/utils/path_utils.hpp
+++ b/source/core/utils/path_utils.hpp
@@ -1,5 +1,5 @@
 // path_utils.hpp - Utilitats de gestió de rutes
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 // Detecció de directoris i bundles multiplataforma
 
 #pragma once
@@ -8,7 +8,7 @@
 
 namespace Utils {
 
-// Inicialització amb argv[0]
+// Inicialización con argv[0]
 void initializePathSystem(const char* argv0);
 
 // Obtenció de rutes
diff --git a/source/external/fkyaml_node.hpp b/source/external/fkyaml_node.hpp
index 8791774..b3aefb2 100644
--- a/source/external/fkyaml_node.hpp
+++ b/source/external/fkyaml_node.hpp
@@ -2,9 +2,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_NODE_HPP
@@ -25,9 +25,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_MACROS_DEFINE_MACROS_HPP
@@ -38,9 +38,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 // Check version definitions if already defined.
@@ -94,9 +94,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_MACROS_CPP_CONFIG_MACROS_HPP
@@ -109,7 +109,7 @@
 // With the MSVC compilers, the value of __cplusplus is by default always
 // "199611L"(C++98). To avoid that, the library instead references _MSVC_LANG
 // which is always set a correct value. See
-// https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
+// https://devblogs.microsoft.como/cppblog/msvc-now-correctly-reports-__cplusplus/
 // for more details.
 #if defined(_MSVC_LANG) && !defined(__clang__)
 #define FK_YAML_CPLUSPLUS _MSVC_LANG
@@ -265,9 +265,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ASSERT_HPP
@@ -290,9 +290,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_DOCUMENT_METAINFO_HPP
@@ -308,9 +308,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_META_NODE_TRAITS_HPP
@@ -323,9 +323,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_META_DETECT_HPP
@@ -341,9 +341,9 @@
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_META_STL_SUPPLEMENT_HPP
@@ -373,13 +373,13 @@ FK_YAML_DETAIL_NAMESPACE_BEGIN
 
 /// @brief An alias template for std::add_pointer::type with C++11.
 /// @note std::add_pointer_t is available since C++14.
-/// @sa https://en.cppreference.com/w/cpp/types/add_pointer
+/// @sa https://en.cppreference.como/w/cpp/types/add_pointer
 /// @tparam T A type to be added a pointer.
 template <typename T> using add_pointer_t = typename std::add_pointer<T>::type;
 
 /// @brief An alias template for std::enable_if::type with C++11.
 /// @note std::enable_if_t is available since C++14.
-/// @sa https://en.cppreference.com/w/cpp/types/enable_if
+/// @sa https://en.cppreference.como/w/cpp/types/enable_if
 /// @tparam Condition A condition tested at compile time.
 /// @tparam T The type defined only if Condition is true.
 template <bool Condition, typename T = void>
@@ -387,7 +387,7 @@ using enable_if_t = typename std::enable_if<Condition, T>::type;
 
 /// @brief A simple implementation to use std::is_null_pointer with C++11.
 /// @note std::is_null_pointer is available since C++14.
-/// @sa https://en.cppreference.com/w/cpp/types/is_null_pointer
+/// @sa https://en.cppreference.como/w/cpp/types/is_null_pointer
 /// @tparam T The type to be checked if it's equal to std::nullptr_t.
 template <typename T>
 struct is_null_pointer
@@ -395,20 +395,20 @@ struct is_null_pointer
 
 /// @brief An alias template for std::remove_cv::type with C++11.
 /// @note std::remove_cv_t is available since C++14.
-/// @sa https://en.cppreference.com/w/cpp/types/remove_cv
+/// @sa https://en.cppreference.como/w/cpp/types/remove_cv
 /// @tparam T A type from which const-volatile qualifiers are removed.
 template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
 
 /// @brief An alias template for std::remove_pointer::type with C++11.
 /// @note std::remove_pointer_t is available since C++14.
-/// @sa https://en.cppreference.com/w/cpp/types/remove_pointer
+/// @sa https://en.cppreference.como/w/cpp/types/remove_pointer
 /// @tparam T A type from which a pointer is removed.
 template <typename T>
 using remove_pointer_t = typename std::remove_pointer<T>::type;
 
 /// @brief An alias template for std::remove_reference::type with C++11.
 /// @note std::remove_reference_t is available since C++14.
-/// @sa https://en.cppreference.com/w/cpp/types/remove_reference
+/// @sa https://en.cppreference.como/w/cpp/types/remove_reference
 /// @tparam T A type from which a reference is removed.
 template <typename T>
 using remove_reference_t = typename std::remove_reference<T>::type;
@@ -498,7 +498,7 @@ template <bool Val> using bool_constant = std::integral_constant<bool, Val>;
 /// @note
 /// std::conjunction is available since C++17.
 /// This is applied when no traits are specified as inputs.
-/// @sa https://en.cppreference.com/w/cpp/types/conjunction
+/// @sa https://en.cppreference.como/w/cpp/types/conjunction
 /// @tparam Traits Type traits to be checked if their ::value are all true.
 template <typename... Traits> struct conjunction : std::true_type {};
 
@@ -519,7 +519,7 @@ struct conjunction<First, Rest...>
 /// @note
 /// std::disjunction is available since C++17.
 /// This is applied when no traits are specified as inputs.
-/// @sa https://en.cppreference.com/w/cpp/types/disjunction
+/// @sa https://en.cppreference.como/w/cpp/types/disjunction
 /// @tparam Traits Type traits to be checked if at least one of their ::value is
 /// true.
 template <typename... Traits> struct disjunction : std::false_type {};
@@ -539,7 +539,7 @@ struct disjunction<First, Rest...>
 
 /// @brief A simple implementation to use std::negation with C++11/C++14.
 /// @note std::negation is available since C++17.
-/// @sa https://en.cppreference.com/w/cpp/types/negation
+/// @sa https://en.cppreference.como/w/cpp/types/negation
 /// @tparam Trait Type trait whose ::value is negated.
 template <typename Trait>
 struct negation : std::integral_constant<bool, !Trait::value> {};
@@ -552,7 +552,7 @@ template <typename... Types> struct make_void {
 
 /// @brief A simple implementation to use std::void_t with C++11/C++14.
 /// @note std::void_t is available since C++17.
-/// @sa https://en.cppreference.com/w/cpp/types/void_t
+/// @sa https://en.cppreference.como/w/cpp/types/void_t
 /// @tparam Types Any types to be transformed to void type.
 template <typename... Types> using void_t = typename make_void<Types...>::type;
 
@@ -571,7 +571,7 @@ using std::void_t;
 /// @brief A simple implementation to use std::remove_cvref_t with
 /// C++11/C++14/C++17.
 /// @note std::remove_cvref & std::remove_cvref_t are available since C++20.
-/// @sa https://en.cppreference.com/w/cpp/types/remove_cvref
+/// @sa https://en.cppreference.como/w/cpp/types/remove_cvref
 /// @tparam T A type from which cv-qualifiers and reference are removed.
 template <typename T>
 using remove_cvref_t =
@@ -790,9 +790,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_META_TYPE_TRAITS_HPP
@@ -890,9 +890,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_FKYAML_FWD_HPP
@@ -1106,9 +1106,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_YAML_VERSION_TYPE_HPP
@@ -1171,9 +1171,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_EXCEPTION_SAFE_ALLOCATION_HPP
@@ -1278,9 +1278,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_DESERIALIZER_HPP
@@ -1299,9 +1299,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_LEXICAL_ANALYZER_HPP
@@ -1320,9 +1320,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ENCODINGS_URI_ENCODING_HPP
@@ -1453,9 +1453,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ENCODINGS_UTF_ENCODINGS_HPP
@@ -1471,9 +1471,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_EXCEPTION_HPP
@@ -1491,9 +1491,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_STRING_FORMATTER_HPP
@@ -1541,9 +1541,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_TYPES_NODE_T_HPP
@@ -1558,9 +1558,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_NODE_TYPE_HPP
@@ -2155,9 +2155,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_BLOCK_SCALAR_HEADER_HPP
@@ -2196,9 +2196,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_POSITION_TRACKER_HPP
@@ -2213,9 +2213,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_STR_VIEW_HPP
@@ -3346,9 +3346,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_TYPES_LEXICAL_TOKEN_T_HPP
@@ -4396,7 +4396,7 @@ private:
     if FK_YAML_UNLIKELY (cur_itr == m_end_itr) {
       // Without the following iterator update, lexer cannot reach the end of
       // input buffer and causes infinite loops from the next loop.
-      // (https://github.com/fktn-k/fkYAML/pull/410)
+      // (https://github.como/fktn-k/fkYAML/pull/410)
       m_cur_itr = m_end_itr;
 
       // If there's no non-empty line, the content indentation level is equal to
@@ -4726,9 +4726,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_SCALAR_PARSER_HPP
@@ -4743,9 +4743,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 // **NOTE FOR LIBRARY DEVELOPERS**:
@@ -5644,9 +5644,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ENCODINGS_YAML_ESCAPER_HPP
@@ -6005,9 +6005,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_SCALAR_SCANNER_HPP
@@ -6377,9 +6377,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_TAG_T_HPP
@@ -6948,7 +6948,7 @@ private:
 
       // conversion error from a scalar which is not tagged with !!int is
       // recovered by treating it as a string scalar. See
-      // https://github.com/fktn-k/fkYAML/issues/428.
+      // https://github.como/fktn-k/fkYAML/issues/428.
       return basic_node_type(string_type(token.begin(), token.end()));
     }
     case node_type::FLOAT: {
@@ -6966,7 +6966,7 @@ private:
 
       // conversion error from a scalar which is not tagged with !!float is
       // recovered by treating it as a string scalar. See
-      // https://github.com/fktn-k/fkYAML/issues/428.
+      // https://github.como/fktn-k/fkYAML/issues/428.
       return basic_node_type(string_type(token.begin(), token.end()));
     }
     case node_type::STRING:
@@ -7000,9 +7000,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_TAG_RESOLVER_HPP
@@ -7208,9 +7208,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_META_INPUT_ADAPTER_TRAITS_HPP
@@ -7274,9 +7274,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_NODE_ATTRS_HPP
@@ -7417,9 +7417,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_NODE_PROPERTY_HPP
@@ -8019,7 +8019,7 @@ private:
               // (i.e., the properties are for a container node), the
               // application and the line advancement must happen here.
               // Otherwise, a false indent error will be emitted. See
-              // https://github.com/fktn-k/fkYAML/issues/368 for more details.
+              // https://github.como/fktn-k/fkYAML/issues/368 for more details.
               line = line_after_props;
               indent = lexer.get_last_token_begin_pos();
               *mp_current_node = basic_node_type::mapping();
@@ -8910,9 +8910,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_INPUT_INPUT_ADAPTER_HPP
@@ -8935,9 +8935,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_DETECTOR_HPP
@@ -8953,9 +8953,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ENCODINGS_UTF_ENCODE_T_HPP
@@ -10496,9 +10496,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_ITERATOR_HPP
@@ -10914,7 +10914,7 @@ namespace std {
 #ifdef __clang__
 // clang emits warnings against mixed usage of class/struct for
 // tuple_size/tuple_element. see also:
-// https://groups.google.com/a/isocpp.org/g/std-discussion/c/QC-AMb5oO1w
+// https://groups.google.como/a/isocpp.org/g/std-discussion/c/QC-AMb5oO1w
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wmismatched-tags"
 #endif
@@ -10949,9 +10949,9 @@ struct tuple_element<I, ::fkyaml::detail::iterator<ValueType>> {
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_MAP_RANGE_PROXY_HPP
@@ -11139,9 +11139,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_NODE_REF_STORAGE_HPP
@@ -11235,9 +11235,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_OUTPUT_SERIALIZER_HPP
@@ -11255,9 +11255,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_CONVERSIONS_TO_STRING_HPP
@@ -11337,7 +11337,7 @@ to_string(FloatType v, std::string &s) noexcept {
 
   // If `v` is actually an integer and no scientific notation is used for
   // serialization, ".0" must be appended. The result would cause a roundtrip
-  // issue otherwise. https://github.com/fktn-k/fkYAML/issues/405
+  // issue otherwise. https://github.como/fktn-k/fkYAML/issues/405
   const std::size_t pos = s.find_first_of(".e");
   if (pos == std::string::npos) {
     s += ".0";
@@ -11744,9 +11744,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_REVERSE_ITERATOR_HPP
@@ -12016,9 +12016,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_TYPES_YAML_VERSION_T_HPP
@@ -12073,9 +12073,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_NODE_VALUE_CONVERTER_HPP
@@ -12090,9 +12090,9 @@ FK_YAML_DETAIL_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_CONVERSIONS_FROM_NODE_HPP
@@ -12875,9 +12875,9 @@ FK_YAML_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_DETAIL_CONVERSIONS_TO_NODE_HPP
@@ -13262,9 +13262,9 @@ FK_YAML_NAMESPACE_END
 // |   __| |_/  |  \_/  |/  _  \ /  \/  \|  |     fkYAML: A C++ header-only YAML
 // library |   __|  _  < \_   _/|  ___  |    _   |  |___  version 0.4.2
 // |__|  |_| \__|  |_|  |_|   |_|___||___|______|
-// https://github.com/fktn-k/fkYAML
+// https://github.como/fktn-k/fkYAML
 //
-// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.com>
+// SPDX-FileCopyrightText: 2023-2025 Kensuke Fukutani <fktn.dev@gmail.como>
 // SPDX-License-Identifier: MIT
 
 #ifndef FK_YAML_ORDERED_MAP_HPP
@@ -13875,7 +13875,7 @@ public:
   /// iterators into a basic_node object.
   /// @note
   /// Iterators must satisfy the LegacyInputIterator requirements.
-  /// See https://en.cppreference.com/w/cpp/named_req/InputIterator.
+  /// See https://en.cppreference.como/w/cpp/named_req/InputIterator.
   /// @tparam ItrType Type of a compatible iterator
   /// @param[in] begin An iterator to the first element of an input sequence.
   /// @param[in] end An iterator to the past-the-last element of an input
@@ -15517,7 +15517,7 @@ inline namespace yaml_literals {
 
 // Whitespace before the literal operator identifier is deprecated in C++23 or
 // better but required in C++11. Ignore the warning as a workaround.
-// https://github.com/fktn-k/fkYAML/pull/417
+// https://github.como/fktn-k/fkYAML/pull/417
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated"
diff --git a/source/external/stb_vorbis.h b/source/external/stb_vorbis.c
similarity index 98%
rename from source/external/stb_vorbis.h
rename to source/external/stb_vorbis.c
index 49df433..7e5daa3 100644
--- a/source/external/stb_vorbis.h
+++ b/source/external/stb_vorbis.c
@@ -1,4 +1,4 @@
-// Ogg Vorbis audio decoder - v1.20 - public domain
+// Ogg Vorbis audio decoder - v1.22 - public domain
 // http://nothings.org/stb_vorbis/
 //
 // Original version written by Sean Barrett in 2007.
@@ -29,12 +29,15 @@
 //    Bernhard Wodo      Evan Balster        github:alxprd
 //    Tom Beaumont       Ingo Leitgeb        Nicolas Guillemot
 //    Phillip Bennefall  Rohit               Thiago Goulart
-//    github:manxorist   saga musix          github:infatum
+//    github:manxorist   Saga Musix          github:infatum
 //    Timur Gagiev       Maxwell Koo         Peter Waller
 //    github:audinowho   Dougall Johnson     David Reid
 //    github:Clownacy    Pedro J. Estebanez  Remi Verschelde
+//    AnthoFoxo          github:morlat       Gabriel Ravier
 //
 // Partial history:
+//    1.22    - 2021-07-11 - various small fixes
+//    1.21    - 2021-07-02 - fix bug for files with no comments
 //    1.20    - 2020-07-11 - several small fixes
 //    1.19    - 2020-02-05 - warnings
 //    1.18    - 2020-02-02 - fix seek bugs; parse header comments; misc warnings etc.
@@ -220,6 +223,12 @@ extern int stb_vorbis_decode_frame_pushdata(
 // channel. In other words, (*output)[0][0] contains the first sample from
 // the first channel, and (*output)[1][0] contains the first sample from
 // the second channel.
+//
+// *output points into stb_vorbis's internal output buffer storage; these
+// buffers are owned by stb_vorbis and application code should not free
+// them or modify their contents. They are transient and will be overwritten
+// once you ask for more data to get decoded, so be sure to grab any data
+// you need before then.
 
 extern void stb_vorbis_flush_pushdata(stb_vorbis *f);
 // inform stb_vorbis that your next datablock will not be contiguous with
@@ -579,7 +588,7 @@ enum STBVorbisError
    #if defined(_MSC_VER) || defined(__MINGW32__)
       #include <malloc.h>
    #endif
-   #if defined(__linux__) || defined(__linux) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)
+   #if defined(__linux__) || defined(__linux) || defined(__sun__) || defined(__EMSCRIPTEN__) || defined(__NEWLIB__)
       #include <alloca.h>
    #endif
 #else // STB_VORBIS_NO_CRT
@@ -646,6 +655,12 @@ typedef   signed int    int32;
 
 typedef float codetype;
 
+#ifdef _MSC_VER
+#define STBV_NOTUSED(v)  (void)(v)
+#else
+#define STBV_NOTUSED(v)  (void)sizeof(v)
+#endif
+
 // @NOTE
 //
 // Some arrays below are tagged "//varies", which means it's actually
@@ -1046,7 +1061,7 @@ static float float32_unpack(uint32 x)
    uint32 sign = x & 0x80000000;
    uint32 exp = (x & 0x7fe00000) >> 21;
    double res = sign ? -(double)mantissa : (double)mantissa;
-   return (float) ldexp((float)res, exp-788);
+   return (float) ldexp((float)res, (int)exp-788);
 }
 
 
@@ -1077,6 +1092,7 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
    // find the first entry
    for (k=0; k < n; ++k) if (len[k] < NO_CODE) break;
    if (k == n) { assert(c->sorted_entries == 0); return TRUE; }
+   assert(len[k] < 32); // no error return required, code reading lens checks this
    // add to the list
    add_entry(c, 0, k, m++, len[k], values);
    // add all available leaves
@@ -1090,6 +1106,7 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
       uint32 res;
       int z = len[i], y;
       if (z == NO_CODE) continue;
+      assert(z < 32); // no error return required, code reading lens checks this
       // find lowest available leaf (should always be earliest,
       // which is what the specification calls for)
       // note that this property, and the fact we can never have
@@ -1099,12 +1116,10 @@ static int compute_codewords(Codebook *c, uint8 *len, int n, uint32 *values)
       while (z > 0 && !available[z]) --z;
       if (z == 0) { return FALSE; }
       res = available[z];
-      assert(z >= 0 && z < 32);
       available[z] = 0;
       add_entry(c, bit_reverse(res), i, m++, len[i], values);
       // propagate availability up the tree
       if (z != len[i]) {
-         assert(len[i] >= 0 && len[i] < 32);
          for (y=len[i]; y > z; --y) {
             assert(available[y] == 0);
             available[y] = res + (1 << (32-y));
@@ -2577,34 +2592,33 @@ static void imdct_step3_inner_s_loop_ld654(int n, float *e, int i_off, float *A,
 
    while (z > base) {
       float k00,k11;
+      float l00,l11;
 
-      k00   = z[-0] - z[-8];
-      k11   = z[-1] - z[-9];
-      z[-0] = z[-0] + z[-8];
-      z[-1] = z[-1] + z[-9];
-      z[-8] =  k00;
-      z[-9] =  k11 ;
+      k00    = z[-0] - z[ -8];
+      k11    = z[-1] - z[ -9];
+      l00    = z[-2] - z[-10];
+      l11    = z[-3] - z[-11];
+      z[ -0] = z[-0] + z[ -8];
+      z[ -1] = z[-1] + z[ -9];
+      z[ -2] = z[-2] + z[-10];
+      z[ -3] = z[-3] + z[-11];
+      z[ -8] = k00;
+      z[ -9] = k11;
+      z[-10] = (l00+l11) * A2;
+      z[-11] = (l11-l00) * A2;
 
-      k00    = z[ -2] - z[-10];
-      k11    = z[ -3] - z[-11];
-      z[ -2] = z[ -2] + z[-10];
-      z[ -3] = z[ -3] + z[-11];
-      z[-10] = (k00+k11) * A2;
-      z[-11] = (k11-k00) * A2;
-
-      k00    = z[-12] - z[ -4];  // reverse to avoid a unary negation
+      k00    = z[ -4] - z[-12];
       k11    = z[ -5] - z[-13];
+      l00    = z[ -6] - z[-14];
+      l11    = z[ -7] - z[-15];
       z[ -4] = z[ -4] + z[-12];
       z[ -5] = z[ -5] + z[-13];
-      z[-12] = k11;
-      z[-13] = k00;
-
-      k00    = z[-14] - z[ -6];  // reverse to avoid a unary negation
-      k11    = z[ -7] - z[-15];
       z[ -6] = z[ -6] + z[-14];
       z[ -7] = z[ -7] + z[-15];
-      z[-14] = (k00+k11) * A2;
-      z[-15] = (k00-k11) * A2;
+      z[-12] = k11;
+      z[-13] = -k00;
+      z[-14] = (l11-l00) * A2;
+      z[-15] = (l00+l11) * -A2;
 
       iter_54(z);
       iter_54(z-8);
@@ -3069,6 +3083,7 @@ static int do_floor(vorb *f, Mapping *map, int i, int n, float *target, YTYPE *f
       for (q=1; q < g->values; ++q) {
          j = g->sorted_order[q];
          #ifndef STB_VORBIS_NO_DEFER_FLOOR
+         STBV_NOTUSED(step2_flag);
          if (finalY[j] >= 0)
          #else
          if (step2_flag[j])
@@ -3171,6 +3186,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,
 
 // WINDOWING
 
+   STBV_NOTUSED(left_end);
    n = f->blocksize[m->blockflag];
    map = &f->mapping[m->mapping];
 
@@ -3368,7 +3384,7 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,
       // this isn't to spec, but spec would require us to read ahead
       // and decode the size of all current frames--could be done,
       // but presumably it's not a commonly used feature
-      f->current_loc = -n2; // start of first frame is positioned for discard
+      f->current_loc = 0u - n2; // start of first frame is positioned for discard (NB this is an intentional unsigned overflow/wrap-around)
       // we might have to discard samples "from" the next frame too,
       // if we're lapping a large block then a small at the start?
       f->discard_samples_deferred = n - right_end;
@@ -3642,9 +3658,11 @@ static int start_decoder(vorb *f)
    f->vendor[len] = (char)'\0';
    //user comments
    f->comment_list_length = get32_packet(f);
-   if (f->comment_list_length > 0) {
-        f->comment_list = (char**)setup_malloc(f, sizeof(char*) * (f->comment_list_length));
-        if (f->comment_list == NULL)                     return error(f, VORBIS_outofmem);
+   f->comment_list = NULL;
+   if (f->comment_list_length > 0)
+   {
+      f->comment_list = (char**) setup_malloc(f, sizeof(char*) * (f->comment_list_length));
+      if (f->comment_list == NULL)                  return error(f, VORBIS_outofmem);
    }
 
    for(i=0; i < f->comment_list_length; ++i) {
@@ -3867,8 +3885,7 @@ static int start_decoder(vorb *f)
                unsigned int div=1;
                for (k=0; k < c->dimensions; ++k) {
                   int off = (z / div) % c->lookup_values;
-                  float val = mults[off];
-                  val = mults[off]*c->delta_value + c->minimum_value + last;
+                  float val = mults[off]*c->delta_value + c->minimum_value + last;
                   c->multiplicands[j*c->dimensions + k] = val;
                   if (c->sequence_p)
                      last = val;
@@ -3951,7 +3968,7 @@ static int start_decoder(vorb *f)
                if (g->class_masterbooks[j] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
             }
             for (k=0; k < 1 << g->class_subclasses[j]; ++k) {
-               g->subclass_books[j][k] = get_bits(f,8)-1;
+               g->subclass_books[j][k] = (int16)get_bits(f,8)-1;
                if (g->subclass_books[j][k] >= f->codebook_count) return error(f, VORBIS_invalid_setup);
             }
          }
@@ -4509,6 +4526,7 @@ stb_vorbis *stb_vorbis_open_pushdata(
          *error = VORBIS_need_more_data;
       else
          *error = p.error;
+      vorbis_deinit(&p);
       return NULL;
    }
    f = vorbis_alloc(&p);
@@ -4566,7 +4584,7 @@ static uint32 vorbis_find_page(stb_vorbis *f, uint32 *end, uint32 *last)
                header[i] = get8(f);
             if (f->eof) return 0;
             if (header[4] != 0) goto invalid;
-            goal = header[22] + (header[23] << 8) + (header[24]<<16) + (header[25]<<24);
+            goal = header[22] + (header[23] << 8) + (header[24]<<16) + ((uint32)header[25]<<24);
             for (i=22; i < 26; ++i)
                header[i] = 0;
             crc = 0;
@@ -4970,7 +4988,7 @@ unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
             // set. whoops!
             break;
          }
-         previous_safe = last_page_loc+1;
+         //previous_safe = last_page_loc+1; // NOTE: not used after this point, but note for debugging
          last_page_loc = stb_vorbis_get_file_offset(f);
       }
 
@@ -5081,7 +5099,10 @@ stb_vorbis * stb_vorbis_open_filename(const char *filename, int *error, const st
 stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *error, const stb_vorbis_alloc *alloc)
 {
    stb_vorbis *f, p;
-   if (data == NULL) return NULL;
+   if (!data) {
+      if (error) *error = VORBIS_unexpected_eof;
+      return NULL;
+   }
    vorbis_init(&p, alloc);
    p.stream = (uint8 *) data;
    p.stream_end = (uint8 *) data + len;
@@ -5156,11 +5177,11 @@ static void copy_samples(short *dest, float *src, int len)
 
 static void compute_samples(int mask, short *output, int num_c, float **data, int d_offset, int len)
 {
-   #define BUFFER_SIZE  32
-   float buffer[BUFFER_SIZE];
-   int i,j,o,n = BUFFER_SIZE;
+   #define STB_BUFFER_SIZE  32
+   float buffer[STB_BUFFER_SIZE];
+   int i,j,o,n = STB_BUFFER_SIZE;
    check_endianness();
-   for (o = 0; o < len; o += BUFFER_SIZE) {
+   for (o = 0; o < len; o += STB_BUFFER_SIZE) {
       memset(buffer, 0, sizeof(buffer));
       if (o + n > len) n = len - o;
       for (j=0; j < num_c; ++j) {
@@ -5177,16 +5198,17 @@ static void compute_samples(int mask, short *output, int num_c, float **data, in
          output[o+i] = v;
       }
    }
+   #undef STB_BUFFER_SIZE
 }
 
 static void compute_stereo_samples(short *output, int num_c, float **data, int d_offset, int len)
 {
-   #define BUFFER_SIZE  32
-   float buffer[BUFFER_SIZE];
-   int i,j,o,n = BUFFER_SIZE >> 1;
+   #define STB_BUFFER_SIZE  32
+   float buffer[STB_BUFFER_SIZE];
+   int i,j,o,n = STB_BUFFER_SIZE >> 1;
    // o is the offset in the source data
    check_endianness();
-   for (o = 0; o < len; o += BUFFER_SIZE >> 1) {
+   for (o = 0; o < len; o += STB_BUFFER_SIZE >> 1) {
       // o2 is the offset in the output data
       int o2 = o << 1;
       memset(buffer, 0, sizeof(buffer));
@@ -5216,6 +5238,7 @@ static void compute_stereo_samples(short *output, int num_c, float **data, int d
          output[o2+i] = v;
       }
    }
+   #undef STB_BUFFER_SIZE
 }
 
 static void convert_samples_short(int buf_c, short **buffer, int b_offset, int data_c, float **data, int d_offset, int samples)
@@ -5288,8 +5311,6 @@ int stb_vorbis_get_samples_short_interleaved(stb_vorbis *f, int channels, short
    float **outputs;
    int len = num_shorts / channels;
    int n=0;
-   int z = f->channels;
-   if (z > channels) z = channels;
    while (n < len) {
       int k = f->channel_buffer_end - f->channel_buffer_start;
       if (n+k >= len) k = len - n;
@@ -5308,8 +5329,6 @@ int stb_vorbis_get_samples_short(stb_vorbis *f, int channels, short **buffer, in
 {
    float **outputs;
    int n=0;
-   int z = f->channels;
-   if (z > channels) z = channels;
    while (n < len) {
       int k = f->channel_buffer_end - f->channel_buffer_start;
       if (n+k >= len) k = len - n;
diff --git a/source/external/stb_vorbis_impl.cpp b/source/external/stb_vorbis_impl.cpp
new file mode 100644
index 0000000..7adf65f
--- /dev/null
+++ b/source/external/stb_vorbis_impl.cpp
@@ -0,0 +1,13 @@
+// Unitat de compilació aïllada per a la implementació de stb_vorbis.
+// Viu dins de source/external/ perquè el `.clang-tidy` d'aquesta carpeta
+// desactiva tots els checks (com fa per stb_image_write_impl.cpp) i el
+// pre-commit hook ja filtra aquesta ruta de clang-format / clang-tidy.
+// Així els fals positius de clang-analyzer-* dins de codi C de tercers
+// no afecten el nostre codi, que continua tenint tots els checks actius.
+//
+// jail_audio.cpp defineix STB_VORBIS_HEADER_ONLY abans d'incloure el .c,
+// així només en veu les declaracions; les definicions les aporta aquest
+// TU i l'enllaçador les resol.
+
+// NOLINTNEXTLINE(bugprone-suspicious-include)
+#include "external/stb_vorbis.c"
diff --git a/source/game/constants.hpp b/source/game/constants.hpp
index 5b70523..82bb20a 100644
--- a/source/game/constants.hpp
+++ b/source/game/constants.hpp
@@ -2,20 +2,19 @@
 
 #include "core/defaults.hpp"
 
-// Aliases per a backward compatibility amb codi existent
-// Permet usar Constants::MARGE_ESQ en lloc de Defaults::Game::MARGIN_LEFT
+// Aliases para backward compatibility con codi existent
+// Permet usar Constants::MARGIN_LEFT en lloc de Defaults::Game::MARGIN_LEFT
 
 namespace Constants {
-// Marges de l'àrea de joc (derivats de Defaults::Zones::GAME)
-constexpr int MARGE_ESQ = static_cast<int>(Defaults::Zones::PLAYAREA.x);
-constexpr int MARGE_DRET =
+// Márgenes de l'àrea de juego (derivats de Defaults::Zones::GAME)
+constexpr int MARGIN_LEFT = static_cast<int>(Defaults::Zones::PLAYAREA.x);
+constexpr int MARGIN_RIGHT =
     static_cast<int>(Defaults::Zones::PLAYAREA.x + Defaults::Zones::PLAYAREA.w);
-constexpr int MARGE_DALT = static_cast<int>(Defaults::Zones::PLAYAREA.y);
-constexpr int MARGE_BAIX =
+constexpr int MARGIN_TOP = static_cast<int>(Defaults::Zones::PLAYAREA.y);
+constexpr int MARGIN_BOTTOM =
     static_cast<int>(Defaults::Zones::PLAYAREA.y + Defaults::Zones::PLAYAREA.h);
 
-// Límits de polígons i objectes
-constexpr int MAX_IPUNTS = Defaults::Entities::MAX_IPUNTS;
+// Límits de objectes
 constexpr int MAX_ORNIS = Defaults::Entities::MAX_ORNIS;
 constexpr int MAX_BALES = Defaults::Entities::MAX_BALES;
 
@@ -28,8 +27,8 @@ constexpr float PI = Defaults::Math::PI;
 
 // Helpers per comprovar límits de zona
 inline bool dins_zona_joc(float x, float y) {
-    const SDL_FPoint punt = {x, y};
-    return SDL_PointInRectFloat(&punt, &Defaults::Zones::PLAYAREA);
+    const SDL_FPoint point = {x, y};
+    return SDL_PointInRectFloat(&point, &Defaults::Zones::PLAYAREA);
 }
 
 inline void obtenir_limits_zona(float& min_x, float& max_x, float& min_y, float& max_y) {
@@ -40,7 +39,7 @@ inline void obtenir_limits_zona(float& min_x, float& max_x, float& min_y, float&
     max_y = zona.y + zona.h;
 }
 
-// Obtenir límits segurs (compensant radi de l'entitat)
+// Obtenir límits segurs (compensant radi de l'entidad)
 inline void obtenir_limits_zona_segurs(float radi, float& min_x, float& max_x, float& min_y, float& max_y) {
     const auto& zona = Defaults::Zones::PLAYAREA;
     constexpr float MARGE_SEGURETAT = 10.0F;  // Safety margin
@@ -51,7 +50,7 @@ inline void obtenir_limits_zona_segurs(float radi, float& min_x, float& max_x, f
     max_y = zona.y + zona.h - radi - MARGE_SEGURETAT;
 }
 
-// Obtenir centre de l'àrea de joc
+// Obtenir centro de l'àrea de juego
 inline void obtenir_centre_zona(float& centre_x, float& centre_y) {
     const auto& zona = Defaults::Zones::PLAYAREA;
     centre_x = zona.x + (zona.w / 2.0F);
diff --git a/source/game/effects/debris.hpp b/source/game/effects/debris.hpp
index 0b2a0ec..e0126fe 100644
--- a/source/game/effects/debris.hpp
+++ b/source/game/effects/debris.hpp
@@ -1,37 +1,40 @@
-// debris.hpp - Fragment de línia volant (explosió de formes)
-// © 2025 Port a C++20 amb SDL3
+// debris.hpp - Fragment de línia volant (explosión de formes)
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
+#include <SDL3/SDL.h>
+
 #include "core/types.hpp"
 
 namespace Effects {
 
-// Debris: un segment de línia que vola perpendicular a sí mateix
-// Representa un fragment d'una forma destruïda (nau, enemic, bala)
+// Debris: un segment de línia que vola perpendicular a sí mismo
+// Representa un fragment de una shape destruïda (ship, enemy, bullet)
 struct Debris {
-        // Geometria del segment (2 punts en coordenades mundials)
-        Punt p1;  // Punt inicial del segment
-        Punt p2;  // Punt final del segment
+        // Geometria del segment (2 points en coordenades mundials)
+        Vec2 p1;  // Vec2 inicial del segment
+        Vec2 p2;  // Vec2 final del segment
 
         // Física
-        Punt velocitat;     // Velocitat en px/s (components x, y)
-        float acceleracio;  // Acceleració negativa (fricció) en px/s²
+        Vec2 velocity;     // Velocidad en px/s (components x, y)
+        float acceleration;  // Aceleración negativa (fricció) en px/s²
 
-        // Rotació
-        float angle_rotacio;         // Angle de rotació acumulat (radians)
-        float velocitat_rot;         // Velocitat de rotació de TRAYECTORIA (rad/s)
-        float velocitat_rot_visual;  // Velocitat de rotació VISUAL del segment (rad/s)
+        // Rotación
+        float angle_rotacio;         // Angle de rotación acumulat (radians)
+        float velocitat_rot;         // Velocidad de rotación de TRAYECTORIA (rad/s)
+        float velocitat_rot_visual;  // Velocidad de rotación VISUAL del segment (rad/s)
 
         // Estat de vida
         float temps_vida;  // Temps transcorregut (segons)
         float temps_max;   // Temps de vida màxim (segons)
-        bool actiu;        // Està actiu?
+        bool active;        // Está active?
 
-        // Shrinking (reducció de distància entre punts)
+        // Shrinking (reducció de distancia entre points)
         float factor_shrink;  // Factor de reducció per segon (0.0-1.0)
 
         // Rendering
-        float brightness;  // Factor de brillantor (0.0-1.0, heretat de l'objecte original)
+        float brightness;   // Factor de brightness (0.0-1.0, heretat de l'objecte original)
+        SDL_Color color{};  // Color heredado del padre. alpha==0 → usa global oscilador
 };
 
 }  // namespace Effects
diff --git a/source/game/effects/debris_manager.cpp b/source/game/effects/debris_manager.cpp
index 273d84b..46478c1 100644
--- a/source/game/effects/debris_manager.cpp
+++ b/source/game/effects/debris_manager.cpp
@@ -1,5 +1,5 @@
 // debris_manager.cpp - Implementació del gestor de fragments
-// © 2025 Port a C++20 amb SDL3
+// © 2025 Port a C++20 con SDL3
 
 #include "debris_manager.hpp"
 
@@ -14,60 +14,61 @@
 
 namespace Effects {
 
-// Helper: transformar punt amb rotació, escala i trasllació
+// Helper: transformar point con rotación, scale i traslación
 // (Copiat de shape_renderer.cpp:12-34)
-static Punt transform_point(const Punt& point, const Punt& shape_centre, const Punt& posicio, float angle, float escala) {
-    // 1. Centrar el punt respecte al centre de la forma
+static Vec2 transform_point(const Vec2& point, const Vec2& shape_centre, const Vec2& position, float angle, float scale) {
+    // 1. Centrar el point respecte al centro de la shape
     float centered_x = point.x - shape_centre.x;
     float centered_y = point.y - shape_centre.y;
 
-    // 2. Aplicar escala al punt centrat
-    float scaled_x = centered_x * escala;
-    float scaled_y = centered_y * escala;
+    // 2. Aplicar scale al point centrat
+    float scaled_x = centered_x * scale;
+    float scaled_y = centered_y * scale;
 
-    // 3. Aplicar rotació
+    // 3. Aplicar rotación
     float cos_a = std::cos(angle);
     float sin_a = std::sin(angle);
 
     float rotated_x = (scaled_x * cos_a) - (scaled_y * sin_a);
     float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);
 
-    // 4. Aplicar trasllació a posició mundial
-    return {.x = rotated_x + posicio.x, .y = rotated_y + posicio.y};
+    // 4. Aplicar traslación a posición mundial
+    return {.x = rotated_x + position.x, .y = rotated_y + position.y};
 }
 
-DebrisManager::DebrisManager(SDL_Renderer* renderer)
+DebrisManager::DebrisManager(Rendering::Renderer* renderer)
     : renderer_(renderer) {
-    // Inicialitzar tots els debris com inactius
+    // Inicialitzar todos los debris como inactius
     for (auto& debris : debris_pool_) {
-        debris.actiu = false;
+        debris.active = false;
     }
 }
 
-void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
-    const Punt& centre,
+void DebrisManager::explode(const std::shared_ptr<Graphics::Shape>& shape,
+    const Vec2& centro,
     float angle,
-    float escala,
+    float scale,
     float velocitat_base,
     float brightness,
-    const Punt& velocitat_objecte,
+    const Vec2& velocitat_objecte,
     float velocitat_angular,
     float factor_herencia_visual,
-    const std::string& sound) {
-    if (!shape || !shape->es_valida()) {
+    const std::string& sound,
+    SDL_Color color) {
+    if (!shape || !shape->isValid()) {
         return;
     }
 
     // Reproducir sonido de explosión
     Audio::get()->playSound(sound, Audio::Group::GAME);
 
-    // Obtenir centre de la forma per a transformacions
-    const Punt& shape_centre = shape->get_centre();
+    // Obtenir centro de la shape para transformacions
+    const Vec2& shape_centre = shape->getCenter();
 
-    // Iterar sobre totes les primitives de la forma
+    // Iterar sobre todas las primitives de la shape
     for (const auto& primitive : shape->get_primitives()) {
         // Processar cada segment de línia
-        std::vector<std::pair<Punt, Punt>> segments;
+        std::vector<std::pair<Vec2, Vec2>> segments;
 
         if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
             // Polyline: extreure segments consecutius
@@ -81,16 +82,16 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
             }
         }
 
-        // Crear debris per a cada segment
+        // Crear debris para cada segment
         for (const auto& [local_p1, local_p2] : segments) {
-            // 1. Transformar punts locals → coordenades mundials
-            Punt world_p1 =
-                transform_point(local_p1, shape_centre, centre, angle, escala);
-            Punt world_p2 =
-                transform_point(local_p2, shape_centre, centre, angle, escala);
+            // 1. Transformar points locals → coordenades mundials
+            Vec2 world_p1 =
+                transform_point(local_p1, shape_centre, centro, angle, scale);
+            Vec2 world_p2 =
+                transform_point(local_p2, shape_centre, centro, angle, scale);
 
             // 2. Trobar slot lliure
-            Debris* debris = trobar_slot_lliure();
+            Debris* debris = findFreeSlot();
             if (debris == nullptr) {
                 std::cerr << "[DebrisManager] Warning: no debris slots disponibles\n";
                 return;  // Pool ple
@@ -100,25 +101,25 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
             debris->p1 = world_p1;
             debris->p2 = world_p2;
 
-            // 4. Calcular direcció d'explosió (radial, des del centre cap a fora)
-            Punt direccio = calcular_direccio_explosio(world_p1, world_p2, centre);
+            // 4. Calcular direcció de explosión (radial, des del centro hacia fuera)
+            Vec2 direccio = computeExplosionDirection(world_p1, world_p2, centro);
 
-            // 5. Velocitat inicial (base ± variació aleatòria + velocitat heretada)
+            // 5. Velocidad inicial (base ± variació aleatòria + velocity heretada)
             float speed =
                 velocitat_base +
                 (((std::rand() / static_cast<float>(RAND_MAX)) * 2.0F - 1.0F) *
                     Defaults::Physics::Debris::VARIACIO_VELOCITAT);
 
-            // Heredar velocitat de l'objecte original (suma vectorial)
-            debris->velocitat.x = (direccio.x * speed) + velocitat_objecte.x;
-            debris->velocitat.y = (direccio.y * speed) + velocitat_objecte.y;
-            debris->acceleracio = Defaults::Physics::Debris::ACCELERACIO;
+            // Heredar velocity de l'objecte original (suma vectorial)
+            debris->velocity.x = (direccio.x * speed) + velocitat_objecte.x;
+            debris->velocity.y = (direccio.y * speed) + velocitat_objecte.y;
+            debris->acceleration = Defaults::Physics::Debris::ACCELERACIO;
 
-            // 6. Herència de velocitat angular amb cap + conversió d'excés
+            // 6. Herència de velocity angular con sin + conversió de excés
 
-            // 6a. Rotació de TRAYECTORIA amb cap + conversió tangencial
+            // 6a. Rotación de TRAYECTORIA con sin + conversió tangencial
             if (std::abs(velocitat_angular) > 0.01F) {
-                // FASE 1: Aplicar herència i variació (igual que abans)
+                // FASE 1: Aplicar herència i variació (igual que antes)
                 float factor_herencia =
                     Defaults::Physics::Debris::FACTOR_HERENCIA_MIN +
                     ((std::rand() / static_cast<float>(RAND_MAX)) *
@@ -131,19 +132,19 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
                     ((std::rand() / static_cast<float>(RAND_MAX)) * 0.2F) - 0.1F;
                 velocitat_ang_heretada *= (1.0F + variacio);
 
-                // FASE 2: Aplicar cap i calcular excés
+                // FASE 2: Aplicar sin i calcular excés
                 constexpr float CAP = Defaults::Physics::Debris::VELOCITAT_ROT_MAX;
                 float abs_ang = std::abs(velocitat_ang_heretada);
                 float sign_ang = (velocitat_ang_heretada >= 0.0F) ? 1.0F : -1.0F;
 
                 if (abs_ang > CAP) {
-                    // Excés: convertir a velocitat tangencial
+                    // Excés: convertir a velocity tangencial
                     float excess = abs_ang - CAP;
 
-                    // Radi de la forma (enemics = 20 px)
+                    // Radi de la shape (enemigos = 20 px)
                     float radius = 20.0F;
 
-                    // Velocitat tangencial = ω_excés × radi
+                    // Velocidad tangencial = ω_excés × radi
                     float v_tangential = excess * radius;
 
                     // Direcció tangencial: perpendicular a la radial (90° CCW)
@@ -151,38 +152,38 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
                     float tangent_x = -direccio.y;
                     float tangent_y = direccio.x;
 
-                    // Afegir velocitat tangencial (suma vectorial)
-                    debris->velocitat.x += tangent_x * v_tangential;
-                    debris->velocitat.y += tangent_y * v_tangential;
+                    // Añadir velocity tangencial (suma vectorial)
+                    debris->velocity.x += tangent_x * v_tangential;
+                    debris->velocity.y += tangent_y * v_tangential;
 
-                    // Aplicar cap a velocitat angular (preservar signe)
+                    // Aplicar hacia velocity angular (preservar signe)
                     debris->velocitat_rot = sign_ang * CAP;
                 } else {
-                    // Per sota del cap: comportament normal
+                    // Per sota del sin: comportament normal
                     debris->velocitat_rot = velocitat_ang_heretada;
                 }
             } else {
                 debris->velocitat_rot = 0.0F;  // Nave: sin curvas
             }
 
-            // 6b. Rotació VISUAL (proporcional según factor_herencia_visual)
+            // 6b. Rotación VISUAL (proporcional según factor_herencia_visual)
             if (factor_herencia_visual > 0.01F && std::abs(velocitat_angular) > 0.01F) {
                 // Heredar rotación visual con factor proporcional
                 debris->velocitat_rot_visual = debris->velocitat_rot * factor_herencia_visual;
 
-                // Variació aleatòria petita (±5%) per naturalitat
+                // Variació aleatòria pequeña (±5%) per naturalitat
                 float variacio_visual =
                     ((std::rand() / static_cast<float>(RAND_MAX)) * 0.1F) - 0.05F;
                 debris->velocitat_rot_visual *= (1.0F + variacio_visual);
             } else {
-                // Rotació visual aleatòria (factor = 0.0 o sin velocidad angular)
+                // Rotación visual aleatòria (factor = 0.0 o sin velocidad angular)
                 debris->velocitat_rot_visual =
                     Defaults::Physics::Debris::ROTACIO_MIN +
                     ((std::rand() / static_cast<float>(RAND_MAX)) *
                         (Defaults::Physics::Debris::ROTACIO_MAX -
                             Defaults::Physics::Debris::ROTACIO_MIN));
 
-                // 50% probabilitat de rotació en sentit contrari
+                // 50% probabilitat de rotación en sentit contrari
                 if (std::rand() % 2 == 0) {
                     debris->velocitat_rot_visual = -debris->velocitat_rot_visual;
                 }
@@ -195,66 +196,67 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
             debris->temps_max = Defaults::Physics::Debris::TEMPS_VIDA;
             debris->factor_shrink = Defaults::Physics::Debris::SHRINK_RATE;
 
-            // 8. Heredar brightness
+            // 8. Heredar brightness y color del padre
             debris->brightness = brightness;
+            debris->color = color;
 
             // 9. Activar
-            debris->actiu = true;
+            debris->active = true;
         }
     }
 }
 
-void DebrisManager::actualitzar(float delta_time) {
+void DebrisManager::update(float delta_time) {
     for (auto& debris : debris_pool_) {
-        if (!debris.actiu) {
+        if (!debris.active) {
             continue;
         }
 
-        // 1. Actualitzar temps de vida
+        // 1. Actualitzar time de vida
         debris.temps_vida += delta_time;
 
-        // Desactivar si ha superat temps màxim
+        // Desactivar si ha superat time màxim
         if (debris.temps_vida >= debris.temps_max) {
-            debris.actiu = false;
+            debris.active = false;
             continue;
         }
 
-        // 2. Actualitzar velocitat (desacceleració)
-        // Aplicar fricció en la direcció del moviment
-        float speed = std::sqrt((debris.velocitat.x * debris.velocitat.x) +
-            (debris.velocitat.y * debris.velocitat.y));
+        // 2. Actualitzar velocity (desacceleració)
+        // Aplicar fricció en la direcció del movement
+        float speed = std::sqrt((debris.velocity.x * debris.velocity.x) +
+            (debris.velocity.y * debris.velocity.y));
 
         if (speed > 1.0F) {
             // Calcular direcció normalitzada
-            float dir_x = debris.velocitat.x / speed;
-            float dir_y = debris.velocitat.y / speed;
+            float dir_x = debris.velocity.x / speed;
+            float dir_y = debris.velocity.y / speed;
 
-            // Aplicar acceleració negativa (fricció)
-            float nova_speed = speed + (debris.acceleracio * delta_time);
+            // Aplicar aceleración negativa (fricció)
+            float nova_speed = speed + (debris.acceleration * delta_time);
             nova_speed = std::max(nova_speed, 0.0F);
 
-            debris.velocitat.x = dir_x * nova_speed;
-            debris.velocitat.y = dir_y * nova_speed;
+            debris.velocity.x = dir_x * nova_speed;
+            debris.velocity.y = dir_y * nova_speed;
         } else {
-            // Velocitat molt baixa, aturar
-            debris.velocitat.x = 0.0F;
-            debris.velocitat.y = 0.0F;
+            // Velocidad mucho baixa, aturar
+            debris.velocity.x = 0.0F;
+            debris.velocity.y = 0.0F;
         }
 
-        // 2b. Rotar vector de velocitat (trayectoria curva)
+        // 2b. Rotar vector de velocity (trayectoria curva)
         if (std::abs(debris.velocitat_rot) > 0.01F) {
-            // Calcular angle de rotació aquest frame
+            // Calcular angle de rotación este frame
             float dangle = debris.velocitat_rot * delta_time;
 
-            // Rotar vector de velocitat usant matriu de rotació 2D
-            float vel_x_old = debris.velocitat.x;
-            float vel_y_old = debris.velocitat.y;
+            // Rotar vector de velocity usant matriu de rotación 2D
+            float vel_x_old = debris.velocity.x;
+            float vel_y_old = debris.velocity.y;
 
             float cos_a = std::cos(dangle);
             float sin_a = std::sin(dangle);
 
-            debris.velocitat.x = (vel_x_old * cos_a) - (vel_y_old * sin_a);
-            debris.velocitat.y = (vel_x_old * sin_a) + (vel_y_old * cos_a);
+            debris.velocity.x = (vel_x_old * cos_a) - (vel_y_old * sin_a);
+            debris.velocity.y = (vel_x_old * sin_a) + (vel_y_old * cos_a);
         }
 
         // 2c. Aplicar fricció angular (desacceleració gradual)
@@ -270,80 +272,79 @@ void DebrisManager::actualitzar(float delta_time) {
             }
         }
 
-        // 3. Calcular centre del segment
-        Punt centre = {.x = (debris.p1.x + debris.p2.x) / 2.0F,
+        // 3. Calcular centro del segment
+        Vec2 centro = {.x = (debris.p1.x + debris.p2.x) / 2.0F,
             .y = (debris.p1.y + debris.p2.y) / 2.0F};
 
-        // 4. Actualitzar posició del centre
-        centre.x += debris.velocitat.x * delta_time;
-        centre.y += debris.velocitat.y * delta_time;
+        // 4. Actualitzar posición del centro
+        centro.x += debris.velocity.x * delta_time;
+        centro.y += debris.velocity.y * delta_time;
 
-        // 5. Actualitzar rotació VISUAL
+        // 5. Actualitzar rotación VISUAL
         debris.angle_rotacio += debris.velocitat_rot_visual * delta_time;
 
-        // 6. Aplicar shrinking (reducció de distància entre punts)
+        // 6. Aplicar shrinking (reducció de distancia entre points)
         float shrink_factor =
             1.0F - (debris.factor_shrink * debris.temps_vida / debris.temps_max);
         shrink_factor = std::max(0.0F, shrink_factor);  // No negatiu
 
-        // Calcular distància original entre punts
+        // Calcular distancia original entre points
         float dx = debris.p2.x - debris.p1.x;
         float dy = debris.p2.y - debris.p1.y;
 
-        // 7. Reconstruir segment amb nova mida i rotació
+        // 7. Reconstruir segment con nueva mida i rotación
         float half_length = std::sqrt((dx * dx) + (dy * dy)) * shrink_factor / 2.0F;
         float original_angle = std::atan2(dy, dx);
         float new_angle = original_angle + debris.angle_rotacio;
 
-        debris.p1.x = centre.x - (half_length * std::cos(new_angle));
-        debris.p1.y = centre.y - (half_length * std::sin(new_angle));
-        debris.p2.x = centre.x + (half_length * std::cos(new_angle));
-        debris.p2.y = centre.y + (half_length * std::sin(new_angle));
+        debris.p1.x = centro.x - (half_length * std::cos(new_angle));
+        debris.p1.y = centro.y - (half_length * std::sin(new_angle));
+        debris.p2.x = centro.x + (half_length * std::cos(new_angle));
+        debris.p2.y = centro.y + (half_length * std::sin(new_angle));
     }
 }
 
-void DebrisManager::dibuixar() const {
+void DebrisManager::draw() const {
     for (const auto& debris : debris_pool_) {
-        if (!debris.actiu) {
+        if (!debris.active) {
             continue;
         }
 
-        // Dibuixar segment de línia amb brightness heretat
+        // Dibujar segmento con brightness y color heredados del padre.
         Rendering::linea(renderer_,
             static_cast<int>(debris.p1.x),
             static_cast<int>(debris.p1.y),
             static_cast<int>(debris.p2.x),
             static_cast<int>(debris.p2.y),
-            true,
-            debris.brightness);
+            debris.brightness, 0.0F, debris.color);
     }
 }
 
-Debris* DebrisManager::trobar_slot_lliure() {
+Debris* DebrisManager::findFreeSlot() {
     for (auto& debris : debris_pool_) {
-        if (!debris.actiu) {
+        if (!debris.active) {
             return &debris;
         }
     }
     return nullptr;  // Pool ple
 }
 
-Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,
-    const Punt& p2,
-    const Punt& centre_objecte) const {
-    // 1. Calcular centre del segment
+Vec2 DebrisManager::computeExplosionDirection(const Vec2& p1,
+    const Vec2& p2,
+    const Vec2& centre_objecte) const {
+    // 1. Calcular centro del segment
     float centro_seg_x = (p1.x + p2.x) / 2.0F;
     float centro_seg_y = (p1.y + p2.y) / 2.0F;
 
-    // 2. Calcular vector des del centre de l'objecte cap al centre del segment
-    // Això garanteix que la direcció sempre apunte cap a fora (direcció radial)
+    // 2. Calcular vector des del centro de l'objecte hacia el centro del segment
+    // Això garanteix que la direcció siempre apunte hacia fuera (direcció radial)
     float dx = centro_seg_x - centre_objecte.x;
     float dy = centro_seg_y - centre_objecte.y;
 
     // 3. Normalitzar (obtenir vector unitari)
     float length = std::sqrt((dx * dx) + (dy * dy));
     if (length < 0.001F) {
-        // Segment al centre (cas extrem molt improbable), retornar direcció aleatòria
+        // Segment al centro (cas extrem mucho improbable), retornar direcció aleatòria
         float angle_rand =
             (std::rand() / static_cast<float>(RAND_MAX)) * 2.0F * Defaults::Math::PI;
         return {.x = std::cos(angle_rand), .y = std::sin(angle_rand)};
@@ -352,7 +353,7 @@ Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,
     dx /= length;
     dy /= length;
 
-    // 4. Afegir variació aleatòria petita (±15°) per varietat visual
+    // 4. Añadir variació aleatòria pequeña (±15°) per varietat visual
     float angle_variacio =
         ((std::rand() % 30) - 15) * Defaults::Math::PI / 180.0F;
 
@@ -365,16 +366,16 @@ Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,
     return {.x = final_x, .y = final_y};
 }
 
-void DebrisManager::reiniciar() {
+void DebrisManager::reset() {
     for (auto& debris : debris_pool_) {
-        debris.actiu = false;
+        debris.active = false;
     }
 }
 
-int DebrisManager::get_num_actius() const {
+int DebrisManager::getActiveCount() const {
     int count = 0;
     for (const auto& debris : debris_pool_) {
-        if (debris.actiu) {
+        if (debris.active) {
             count++;
         }
     }
diff --git a/source/game/effects/debris_manager.hpp b/source/game/effects/debris_manager.hpp
index 147a49b..89acddd 100644
--- a/source/game/effects/debris_manager.hpp
+++ b/source/game/effects/debris_manager.hpp
@@ -1,72 +1,76 @@
-// debris_manager.hpp - Gestor de fragments d'explosions
-// © 2025 Port a C++20 amb SDL3
+// debris_manager.hpp - Gestor de fragments de explosions
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
+
+#include "core/rendering/render_context.hpp"
 #include <SDL3/SDL.h>
 
 #include <array>
 #include <memory>
 
+#include "core/defaults.hpp"
 #include "core/graphics/shape.hpp"
 #include "core/types.hpp"
 #include "debris.hpp"
 
 namespace Effects {
 
-// Gestor de fragments d'explosions
-// Manté un pool d'objectes Debris i gestiona el seu cicle de vida
+// Gestor de fragments de explosions
+// Manté un pool de objectes Debris i gestiona el seu cicle de vida
 class DebrisManager {
     public:
-        explicit DebrisManager(SDL_Renderer* renderer);
+        explicit DebrisManager(Rendering::Renderer* renderer);
 
-        // Crear explosió a partir d'una forma
-        // - shape: forma vectorial a explotar
-        // - centre: posició del centre de l'objecte
+        // Crear explosión a partir de una shape
+        // - shape: shape vectorial a explode
+        // - centro: posición del centro de l'objecte
         // - angle: orientació de l'objecte (radians)
-        // - escala: escala de l'objecte (1.0 = normal)
-        // - velocitat_base: velocitat inicial dels fragments (px/s)
-        // - brightness: factor de brillantor heretat (0.0-1.0, per defecte 1.0)
-        // - velocitat_objecte: velocitat de l'objecte que explota (px/s, per defecte 0)
-        // - velocitat_angular: velocitat angular heretada (rad/s, per defecte 0)
-        // - factor_herencia_visual: factor de herència rotació visual (0.0-1.0, per defecte 0.0)
-        void explotar(const std::shared_ptr<Graphics::Shape>& shape,
-            const Punt& centre,
+        // - scale: scale de l'objecte (1.0 = normal)
+        // - velocitat_base: velocity inicial dels fragments (px/s)
+        // - brightness: factor de brightness heretat (0.0-1.0, per defecte 1.0)
+        // - velocitat_objecte: velocity de l'objecte que explota (px/s, per defecte 0)
+        // - velocitat_angular: velocity angular heretada (rad/s, per defecte 0)
+        // - factor_herencia_visual: factor de herència rotación visual (0.0-1.0, per defecte 0.0)
+        void explode(const std::shared_ptr<Graphics::Shape>& shape,
+            const Vec2& centro,
             float angle,
-            float escala,
+            float scale,
             float velocitat_base,
             float brightness = 1.0F,
-            const Punt& velocitat_objecte = {.x = 0.0F, .y = 0.0F},
+            const Vec2& velocitat_objecte = {.x = 0.0F, .y = 0.0F},
             float velocitat_angular = 0.0F,
             float factor_herencia_visual = 0.0F,
-            const std::string& sound = Defaults::Sound::EXPLOSION);
+            const std::string& sound = Defaults::Sound::EXPLOSION,
+            SDL_Color color = {0, 0, 0, 0});  // alpha==0 → fragmentos usan oscilador global
 
-        // Actualitzar tots els fragments actius
-        void actualitzar(float delta_time);
+        // Actualitzar todos los fragments active
+        void update(float delta_time);
 
-        // Dibuixar tots els fragments actius
-        void dibuixar() const;
+        // Dibuixar todos los fragments active
+        void draw() const;
 
-        // Reiniciar tots els fragments (neteja)
-        void reiniciar();
+        // Reiniciar todos los fragments (clear)
+        void reset();
 
-        // Obtenir número de fragments actius
-        [[nodiscard]] int get_num_actius() const;
+        // Obtenir número de fragments active
+        [[nodiscard]] int getActiveCount() const;
 
     private:
-        SDL_Renderer* renderer_;
+        Rendering::Renderer* renderer_;
 
         // Pool de fragments (màxim concurrent)
-        // Un pentàgon té 5 línies, 15 enemics = 75 línies
-        // + nau (3 línies) + bales (5 línies * 3) = 93 línies màxim
+        // Un pentágono té 5 línies, 15 enemigos = 75 línies
+        // + ship (3 línies) + balas (5 línies * 3) = 93 línies màxim
         // Arrodonit a 100 per seguretat
         static constexpr int MAX_DEBRIS = 150;
         std::array<Debris, MAX_DEBRIS> debris_pool_;
 
         // Trobar primer slot inactiu
-        Debris* trobar_slot_lliure();
+        Debris* findFreeSlot();
 
-        // Calcular direcció d'explosió (radial, des del centre cap al segment)
-        [[nodiscard]] Punt calcular_direccio_explosio(const Punt& p1, const Punt& p2, const Punt& centre_objecte) const;
+        // Calcular direcció de explosión (radial, des del centro hacia el segment)
+        [[nodiscard]] Vec2 computeExplosionDirection(const Vec2& p1, const Vec2& p2, const Vec2& centre_objecte) const;
 };
 
 }  // namespace Effects
diff --git a/source/game/effects/floating_score.hpp b/source/game/effects/floating_score.hpp
new file mode 100644
index 0000000..f56bd34
--- /dev/null
+++ b/source/game/effects/floating_score.hpp
@@ -0,0 +1,33 @@
+// floating_score.hpp - Número de puntuación que apareix y desapareix
+// © 2025 Port a C++20 con SDL3
+
+#pragma once
+
+#include <string>
+
+#include "core/types.hpp"
+
+namespace Effects {
+
+// FloatingScore: text animat que muestra points guanyats
+// S'activa cuando es destrueix un enemy i s'esvaeix después de un time
+struct FloatingScore {
+        // Text a mostrar (e.g., "100", "150", "200")
+        std::string text;
+
+        // Posición actual (coordenades mundials)
+        Vec2 position;
+
+        // Animación de movement
+        Vec2 velocity;  // px/s (normalment sin amunt: {0.0f, -30.0f})
+
+        // Animación de fade
+        float temps_vida;  // Temps transcorregut (segons)
+        float temps_max;   // Temps de vida màxim (segons)
+        float brightness;  // Brillantor calculada (0.0-1.0)
+
+        // Estat
+        bool active;
+};
+
+}  // namespace Effects
diff --git a/source/game/effects/floating_score_manager.cpp b/source/game/effects/floating_score_manager.cpp
new file mode 100644
index 0000000..a03e24f
--- /dev/null
+++ b/source/game/effects/floating_score_manager.cpp
@@ -0,0 +1,99 @@
+// floating_score_manager.cpp - Implementació del gestor de números flotantes
+// © 2025 Port a C++20 con SDL3
+
+#include "floating_score_manager.hpp"
+
+#include <string>
+
+namespace Effects {
+
+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) {
+    // 1. Trobar slot lliure
+    FloatingScore* pf = findFreeSlot();
+    if (pf == nullptr) {
+        return;  // Pool ple (improbable)
+    }
+
+    // 2. Inicialitzar puntuación flotante
+    pf->text = std::to_string(points);
+    pf->position = position;
+    pf->velocity = {.x = Defaults::FloatingScore::VELOCITY_X,
+        .y = Defaults::FloatingScore::VELOCITY_Y};
+    pf->temps_vida = 0.0F;
+    pf->temps_max = Defaults::FloatingScore::LIFETIME;
+    pf->brightness = 1.0F;
+    pf->active = true;
+}
+
+void FloatingScoreManager::update(float delta_time) {
+    for (auto& pf : pool_) {
+        if (!pf.active) {
+            continue;
+        }
+
+        // 1. Actualitzar posición (deriva sin amunt)
+        pf.position.x += pf.velocity.x * delta_time;
+        pf.position.y += pf.velocity.y * delta_time;
+
+        // 2. Actualitzar time de vida
+        pf.temps_vida += delta_time;
+
+        // 3. Calcular brightness (fade lineal)
+        float progress = pf.temps_vida / pf.temps_max;  // 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) {
+            pf.active = false;
+        }
+    }
+}
+
+void FloatingScoreManager::draw() {
+    for (const auto& pf : pool_) {
+        if (!pf.active) {
+            continue;
+        }
+
+        // Renderizar centrat con brightness (fade)
+        constexpr float scale = Defaults::FloatingScore::SCALE;
+        constexpr float spacing = Defaults::FloatingScore::SPACING;
+
+        text_.renderCentered(pf.text, pf.position, scale, spacing, pf.brightness);
+    }
+}
+
+void FloatingScoreManager::reset() {
+    for (auto& pf : pool_) {
+        pf.active = false;
+    }
+}
+
+int FloatingScoreManager::getActiveCount() const {
+    int count = 0;
+    for (const auto& pf : pool_) {
+        if (pf.active) {
+            count++;
+        }
+    }
+    return count;
+}
+
+FloatingScore* FloatingScoreManager::findFreeSlot() {
+    for (auto& pf : pool_) {
+        if (!pf.active) {
+            return &pf;
+        }
+    }
+    return nullptr;  // Pool ple
+}
+
+}  // namespace Effects
diff --git a/source/game/effects/floating_score_manager.hpp b/source/game/effects/floating_score_manager.hpp
new file mode 100644
index 0000000..2b37eae
--- /dev/null
+++ b/source/game/effects/floating_score_manager.hpp
@@ -0,0 +1,55 @@
+// floating_score_manager.hpp - Gestor de números de puntuación flotantes
+// © 2025 Port a C++20 con SDL3
+
+#pragma once
+
+#include "core/rendering/render_context.hpp"
+
+#include <SDL3/SDL.h>
+
+#include <array>
+
+#include "core/defaults.hpp"
+#include "core/graphics/vector_text.hpp"
+#include "core/types.hpp"
+#include "floating_score.hpp"
+
+namespace Effects {
+
+// Gestor de números de puntuación flotantes
+// Manté un pool de FloatingScore i gestiona el seu cicle de vida
+class FloatingScoreManager {
+    public:
+        explicit FloatingScoreManager(Rendering::Renderer* renderer);
+
+        // Crear número flotante
+        // - points: value numèric (100, 150, 200)
+        // - position: on apareix (normalment centro de enemy destruït)
+        void crear(int points, const Vec2& position);
+
+        // Actualitzar todos los números active
+        void update(float delta_time);
+
+        // Dibuixar todos los números active
+        void draw();
+
+        // Reiniciar tots (clear)
+        void reset();
+
+        // Obtenir número active (debug)
+        [[nodiscard]] int getActiveCount() const;
+
+    private:
+        Graphics::VectorText text_;  // Sistema de text vectorial
+
+        // Pool de números flotantes (màxim concurrent)
+        // Màxim 15 enemigos simultanis = màxim 15 números
+        static constexpr int MAX_PUNTUACIONS =
+            Defaults::FloatingScore::MAX_CONCURRENT;
+        std::array<FloatingScore, MAX_PUNTUACIONS> pool_;
+
+        // Trobar primer slot inactiu
+        FloatingScore* findFreeSlot();
+};
+
+}  // namespace Effects
diff --git a/source/game/effects/gestor_puntuacio_flotant.cpp b/source/game/effects/gestor_puntuacio_flotant.cpp
deleted file mode 100644
index 17c0bd4..0000000
--- a/source/game/effects/gestor_puntuacio_flotant.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-// gestor_puntuacio_flotant.cpp - Implementació del gestor de números flotants
-// © 2025 Port a C++20 amb SDL3
-
-#include "gestor_puntuacio_flotant.hpp"
-
-#include <string>
-
-namespace Effects {
-
-GestorPuntuacioFlotant::GestorPuntuacioFlotant(SDL_Renderer* renderer)
-    : text_(renderer) {
-    // Inicialitzar tots els slots com inactius
-    for (auto& pf : pool_) {
-        pf.actiu = false;
-    }
-}
-
-void GestorPuntuacioFlotant::crear(int punts, const Punt& posicio) {
-    // 1. Trobar slot lliure
-    PuntuacioFlotant* pf = trobar_slot_lliure();
-    if (pf == nullptr) {
-        return;  // Pool ple (improbable)
-    }
-
-    // 2. Inicialitzar puntuació flotant
-    pf->text = std::to_string(punts);
-    pf->posicio = posicio;
-    pf->velocitat = {.x = Defaults::FloatingScore::VELOCITY_X,
-        .y = Defaults::FloatingScore::VELOCITY_Y};
-    pf->temps_vida = 0.0F;
-    pf->temps_max = Defaults::FloatingScore::LIFETIME;
-    pf->brightness = 1.0F;
-    pf->actiu = true;
-}
-
-void GestorPuntuacioFlotant::actualitzar(float delta_time) {
-    for (auto& pf : pool_) {
-        if (!pf.actiu) {
-            continue;
-        }
-
-        // 1. Actualitzar posició (deriva cap amunt)
-        pf.posicio.x += pf.velocitat.x * delta_time;
-        pf.posicio.y += pf.velocitat.y * delta_time;
-
-        // 2. Actualitzar temps de vida
-        pf.temps_vida += delta_time;
-
-        // 3. Calcular brightness (fade lineal)
-        float progress = pf.temps_vida / pf.temps_max;  // 0.0 → 1.0
-        pf.brightness = 1.0F - progress;                // 1.0 → 0.0
-
-        // 4. Desactivar quan acaba el temps
-        if (pf.temps_vida >= pf.temps_max) {
-            pf.actiu = false;
-        }
-    }
-}
-
-void GestorPuntuacioFlotant::dibuixar() {
-    for (const auto& pf : pool_) {
-        if (!pf.actiu) {
-            continue;
-        }
-
-        // Renderitzar centrat amb brightness (fade)
-        constexpr float escala = Defaults::FloatingScore::SCALE;
-        constexpr float spacing = Defaults::FloatingScore::SPACING;
-
-        text_.render_centered(pf.text, pf.posicio, escala, spacing, pf.brightness);
-    }
-}
-
-void GestorPuntuacioFlotant::reiniciar() {
-    for (auto& pf : pool_) {
-        pf.actiu = false;
-    }
-}
-
-int GestorPuntuacioFlotant::get_num_actius() const {
-    int count = 0;
-    for (const auto& pf : pool_) {
-        if (pf.actiu) {
-            count++;
-        }
-    }
-    return count;
-}
-
-PuntuacioFlotant* GestorPuntuacioFlotant::trobar_slot_lliure() {
-    for (auto& pf : pool_) {
-        if (!pf.actiu) {
-            return &pf;
-        }
-    }
-    return nullptr;  // Pool ple
-}
-
-}  // namespace Effects
diff --git a/source/game/effects/gestor_puntuacio_flotant.hpp b/source/game/effects/gestor_puntuacio_flotant.hpp
deleted file mode 100644
index f3d4fe6..0000000
--- a/source/game/effects/gestor_puntuacio_flotant.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-// gestor_puntuacio_flotant.hpp - Gestor de números de puntuació flotants
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-
-#include <SDL3/SDL.h>
-
-#include <array>
-
-#include "core/defaults.hpp"
-#include "core/graphics/vector_text.hpp"
-#include "core/types.hpp"
-#include "puntuacio_flotant.hpp"
-
-namespace Effects {
-
-// Gestor de números de puntuació flotants
-// Manté un pool de PuntuacioFlotant i gestiona el seu cicle de vida
-class GestorPuntuacioFlotant {
-    public:
-        explicit GestorPuntuacioFlotant(SDL_Renderer* renderer);
-
-        // Crear número flotant
-        // - punts: valor numèric (100, 150, 200)
-        // - posicio: on apareix (normalment centre d'enemic destruït)
-        void crear(int punts, const Punt& posicio);
-
-        // Actualitzar tots els números actius
-        void actualitzar(float delta_time);
-
-        // Dibuixar tots els números actius
-        void dibuixar();
-
-        // Reiniciar tots (neteja)
-        void reiniciar();
-
-        // Obtenir número actius (debug)
-        [[nodiscard]] int get_num_actius() const;
-
-    private:
-        Graphics::VectorText text_;  // Sistema de text vectorial
-
-        // Pool de números flotants (màxim concurrent)
-        // Màxim 15 enemics simultanis = màxim 15 números
-        static constexpr int MAX_PUNTUACIONS =
-            Defaults::FloatingScore::MAX_CONCURRENT;
-        std::array<PuntuacioFlotant, MAX_PUNTUACIONS> pool_;
-
-        // Trobar primer slot inactiu
-        PuntuacioFlotant* trobar_slot_lliure();
-};
-
-}  // namespace Effects
diff --git a/source/game/effects/puntuacio_flotant.hpp b/source/game/effects/puntuacio_flotant.hpp
deleted file mode 100644
index 340e2a4..0000000
--- a/source/game/effects/puntuacio_flotant.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// puntuacio_flotant.hpp - Número de puntuació que apareix i desapareix
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-
-#include <string>
-
-#include "core/types.hpp"
-
-namespace Effects {
-
-// PuntuacioFlotant: text animat que mostra punts guanyats
-// S'activa quan es destrueix un enemic i s'esvaeix després d'un temps
-struct PuntuacioFlotant {
-        // Text a mostrar (e.g., "100", "150", "200")
-        std::string text;
-
-        // Posició actual (coordenades mundials)
-        Punt posicio;
-
-        // Animació de moviment
-        Punt velocitat;  // px/s (normalment cap amunt: {0.0f, -30.0f})
-
-        // Animació de fade
-        float temps_vida;  // Temps transcorregut (segons)
-        float temps_max;   // Temps de vida màxim (segons)
-        float brightness;  // Brillantor calculada (0.0-1.0)
-
-        // Estat
-        bool actiu;
-};
-
-}  // namespace Effects
diff --git a/source/game/entities/bala.cpp b/source/game/entities/bala.cpp
deleted file mode 100644
index 17794cd..0000000
--- a/source/game/entities/bala.cpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// bala.cpp - Implementació de projectils de la nau
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#include "game/entities/bala.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <iostream>
-
-#include "core/audio/audio.hpp"
-#include "core/defaults.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/graphics/shape_loader.hpp"
-#include "core/rendering/shape_renderer.hpp"
-#include "core/types.hpp"
-#include "game/constants.hpp"
-
-Bala::Bala(SDL_Renderer* renderer)
-    : Entitat(renderer),
-      velocitat_(0.0F),
-      esta_(false),
-      owner_id_(0),
-      grace_timer_(0.0F) {
-    // [NUEVO] Brightness específic per bales
-    brightness_ = Defaults::Brightness::BALA;
-
-    // [NUEVO] Carregar forma compartida des de fitxer
-    forma_ = Graphics::ShapeLoader::load("bullet.shp");
-
-    if (!forma_ || !forma_->es_valida()) {
-        std::cerr << "[Bala] Error: no s'ha pogut carregar bullet.shp" << '\n';
-    }
-}
-
-void Bala::inicialitzar() {
-    // Inicialment inactiva
-    esta_ = false;
-    centre_ = {.x = 0.0F, .y = 0.0F};
-    angle_ = 0.0F;
-    velocitat_ = 0.0F;
-    grace_timer_ = 0.0F;
-}
-
-void Bala::disparar(const Punt& posicio, float angle, uint8_t owner_id) {
-    // Activar bala i posicionar-la a la nau
-    // Basat en joc_asteroides.cpp línies 188-200
-
-    // Activar bala
-    esta_ = true;
-
-    // Posició inicial = centre de la nau
-    centre_.x = posicio.x;
-    centre_.y = posicio.y;
-
-    // Angle = angle de la nau (dispara en la direcció que apunta)
-    angle_ = angle;
-
-    // Almacenar propietario (0=P1, 1=P2)
-    owner_id_ = owner_id;
-
-    // Velocitat alta (el joc Pascal original usava 7 px/frame)
-    // 7 px/frame × 20 FPS = 140 px/s
-    velocitat_ = 140.0F;
-
-    // Activar grace period (prevents instant self-collision)
-    grace_timer_ = Defaults::Game::BULLET_GRACE_PERIOD;
-
-    // Reproducir sonido de disparo láser
-    Audio::get()->playSound(Defaults::Sound::LASER, Audio::Group::GAME);
-}
-
-void Bala::actualitzar(float delta_time) {
-    if (esta_) {
-        // Decrementar grace timer
-        if (grace_timer_ > 0.0F) {
-            grace_timer_ -= delta_time;
-            grace_timer_ = std::max(grace_timer_, 0.0F);
-        }
-
-        mou(delta_time);
-    }
-}
-
-void Bala::dibuixar() const {
-    if (esta_ && forma_) {
-        // [NUEVO] Usar render_shape en lloc de rota_pol
-        // Les bales roten segons l'angle de trajectòria
-        Rendering::render_shape(renderer_, forma_, centre_, angle_, 1.0F, true, 1.0F, brightness_);
-    }
-}
-
-void Bala::mou(float delta_time) {
-    // Moviment rectilini de la bala
-    // Basat en el codi Pascal original: procedure mou_bales
-    // Copiat EXACTAMENT de joc_asteroides.cpp línies 396-419
-
-    // Calcular nova posició (moviment polar time-based)
-    // velocitat ja està en px/s (140 px/s), només cal multiplicar per delta_time
-    float velocitat_efectiva = velocitat_ * delta_time;
-
-    // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
-    float dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(angle_ - (Constants::PI / 2.0F));
-
-    // Acumulació directa amb precisió subpíxel
-    centre_.y += dy;
-    centre_.x += dx;
-
-    // Desactivar si surt de la zona de joc (no rebota com els ORNIs)
-    // CORRECCIÓ: Usar límits segurs amb radi de la bala
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::BULLET_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    if (centre_.x < min_x || centre_.x > max_x ||
-        centre_.y < min_y || centre_.y > max_y) {
-        esta_ = false;
-    }
-}
diff --git a/source/game/entities/bala.hpp b/source/game/entities/bala.hpp
deleted file mode 100644
index de801bd..0000000
--- a/source/game/entities/bala.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// bala.hpp - Classe per a projectils de la nau
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-#include <SDL3/SDL.h>
-
-#include <cstdint>
-
-#include "core/defaults.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/types.hpp"
-
-class Bala : public Entities::Entitat {
-    public:
-        Bala()
-            : Entitat(nullptr) {}
-        Bala(SDL_Renderer* renderer);
-
-        void inicialitzar() override;
-        void disparar(const Punt& posicio, float angle, uint8_t owner_id);
-        void actualitzar(float delta_time) override;
-        void dibuixar() const override;
-
-        // Override: Interfície d'Entitat
-        [[nodiscard]] bool esta_actiu() const override { return esta_; }
-
-        // Override: Interfície de col·lisió
-        [[nodiscard]] float get_collision_radius() const override {
-            return Defaults::Entities::BULLET_RADIUS;
-        }
-        [[nodiscard]] bool es_collidable() const override {
-            return esta_ && grace_timer_ <= 0.0F;
-        }
-
-        // Getters (API pública sense canvis)
-        [[nodiscard]] bool esta_activa() const { return esta_; }
-        [[nodiscard]] uint8_t get_owner_id() const { return owner_id_; }
-        [[nodiscard]] float get_grace_timer() const { return grace_timer_; }
-        void desactivar() { esta_ = false; }
-
-    private:
-        // Membres específics de Bala (heretats: renderer_, forma_, centre_, angle_, brightness_)
-        float velocitat_;
-        bool esta_;
-        uint8_t owner_id_;   // 0=P1, 1=P2
-        float grace_timer_;  // Grace period timer (0.0 = vulnerable)
-
-        void mou(float delta_time);
-};
diff --git a/source/game/entities/bullet.cpp b/source/game/entities/bullet.cpp
new file mode 100644
index 0000000..9a52f56
--- /dev/null
+++ b/source/game/entities/bullet.cpp
@@ -0,0 +1,143 @@
+// bullet.cpp - Implementación de projectils de la ship
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#include "game/entities/bullet.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <iostream>
+
+#include "core/audio/audio.hpp"
+#include "core/defaults.hpp"
+#include "core/entities/entity.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/rendering/shape_renderer.hpp"
+#include "core/types.hpp"
+#include "game/constants.hpp"
+
+namespace {
+// Velocidad escalar de las balas (px/s). Conserva el feel del Pascal original
+// (7 px/frame × 20 FPS = 140 px/s).
+constexpr float BULLET_SPEED = 140.0F;
+}  // namespace
+
+Bullet::Bullet(Rendering::Renderer* renderer)
+    : Entity(renderer),
+      esta_(false),
+      owner_id_(0),
+      grace_timer_(0.0F) {
+    // Brightness específico para balas
+    brightness_ = Defaults::Brightness::BALA;
+
+    // Configuración del cuerpo físico.
+    // Las balas son cinemáticas: no colisionan con otros bodies ni paredes.
+    // El gameplay (GameScene) gestiona los hits con check_collision y la
+    // salida del PLAYAREA. Por eso radius=0 en el world (no participa en
+    // resolveBodyCollisions ni resolveBoundsCollisions).
+    body_.setMass(0.5F);          // Ligera (no afecta a nadie, pero por consistencia)
+    body_.radius = 0.0F;          // Sin colisión física (cinemática pura)
+    body_.restitution = 0.0F;     // Irrelevante (no rebota)
+    body_.linear_damping = 0.0F;  // Sin fricción (movimiento rectilíneo uniforme)
+    body_.angular_damping = 0.0F;
+
+    // Cargar shape compartida desde archivo
+    shape_ = Graphics::ShapeLoader::load("bullet.shp");
+    if (!shape_ || !shape_->isValid()) {
+        std::cerr << "[Bullet] Error: no s'ha pogut load bullet.shp" << '\n';
+    }
+}
+
+void Bullet::init() {
+    // Inicialment inactiva
+    esta_ = false;
+    center_ = {.x = 0.0F, .y = 0.0F};
+    angle_ = 0.0F;
+    grace_timer_ = 0.0F;
+
+    // Reset del cuerpo físico
+    body_.position = Vec2{};
+    body_.velocity = Vec2{};
+    body_.angle = 0.0F;
+    body_.angular_velocity = 0.0F;
+    body_.clearAccumulators();
+}
+
+void Bullet::disparar(const Vec2& position, float angle, uint8_t owner_id) {
+    // Activar bullet
+    esta_ = 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;
+    angle_ = angle;
+
+    // Sincronizar el body físico: posición + velocidad cartesiana
+    // angle - PI/2 porque angle=0 apunta hacia arriba (eje Y negativo SDL)
+    body_.position = position;
+    body_.angle = angle;
+    const float DIR_X = std::cos(angle - (Constants::PI / 2.0F));
+    const float DIR_Y = std::sin(angle - (Constants::PI / 2.0F));
+    body_.velocity = Vec2{.x = DIR_X * BULLET_SPEED, .y = DIR_Y * BULLET_SPEED};
+    body_.angular_velocity = 0.0F;
+    body_.clearAccumulators();
+
+    // Reproducir sonido de disparo láser
+    Audio::get()->playSound(Defaults::Sound::LASER, Audio::Group::GAME);
+}
+
+void Bullet::update(float delta_time) {
+    if (!esta_) {
+        return;
+    }
+
+    // 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::obtenir_limits_zona_segurs(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.
+    center_ = body_.position;
+    // angle_ no cambia (las balas no rotan visualmente).
+}
+
+void Bullet::desactivar() {
+    esta_ = false;
+    // Detener el cuerpo físico para que no acumule deriva mientras inactiva.
+    body_.velocity = Vec2{};
+    body_.angular_velocity = 0.0F;
+}
+
+void Bullet::draw() const {
+    if (esta_ && shape_) {
+        // Les bales roten segons l'angle de trayectòria (estático tras disparo)
+        Rendering::render_shape(renderer_, shape_, center_, angle_, 1.0F, 1.0F, brightness_,
+                                /*rotation_3d=*/nullptr, Defaults::Palette::BULLET);
+    }
+}
diff --git a/source/game/entities/bullet.hpp b/source/game/entities/bullet.hpp
new file mode 100644
index 0000000..b41337e
--- /dev/null
+++ b/source/game/entities/bullet.hpp
@@ -0,0 +1,48 @@
+// bullet.hpp - Clase para projectils de la ship
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#pragma once
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+
+#include "core/defaults.hpp"
+#include "core/entities/entity.hpp"
+#include "core/types.hpp"
+
+class Bullet : public Entities::Entity {
+    public:
+        Bullet()
+            : Entity(nullptr) {}
+        Bullet(Rendering::Renderer* renderer);
+
+        void init() override;
+        void disparar(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;
+
+        // Override: Interfaz de Entity
+        [[nodiscard]] auto isActive() const -> bool override { return esta_; }
+
+        // Override: Interfaz de colisión (gameplay-level: PLAYAREA bounds-check)
+        [[nodiscard]] auto getCollisionRadius() const -> float override {
+            return Defaults::Entities::BULLET_RADIUS;
+        }
+        [[nodiscard]] auto isCollidable() const -> bool override {
+            return esta_ && grace_timer_ <= 0.0F;
+        }
+
+        // Getters (API pública sin cambios)
+        [[nodiscard]] auto esta_activa() const -> bool { return esta_; }
+        [[nodiscard]] auto getOwnerId() const -> uint8_t { return owner_id_; }
+        [[nodiscard]] auto getGraceTimer() const -> float { return grace_timer_; }
+        void desactivar();
+
+    private:
+        // Miembros específicos de Bullet (heredados: renderer_, shape_, center_, angle_, brightness_, body_)
+        bool esta_;
+        uint8_t owner_id_;   // 0=P1, 1=P2
+        float grace_timer_;  // Grace period timer (0.0 = vulnerable)
+};
diff --git a/source/game/entities/enemic.cpp b/source/game/entities/enemic.cpp
deleted file mode 100644
index 022f688..0000000
--- a/source/game/entities/enemic.cpp
+++ /dev/null
@@ -1,551 +0,0 @@
-// enemic.cpp - Implementació d'enemics (ORNIs)
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#include "game/entities/enemic.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <iostream>
-
-#include "core/defaults.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/graphics/shape_loader.hpp"
-#include "core/rendering/shape_renderer.hpp"
-#include "core/types.hpp"
-#include "game/constants.hpp"
-
-Enemic::Enemic(SDL_Renderer* renderer)
-    : Entitat(renderer),
-      velocitat_(0.0F),
-      drotacio_(0.0F),
-      rotacio_(0.0F),
-      esta_(false),
-      tipus_(TipusEnemic::PENTAGON),
-      tracking_timer_(0.0F),
-      ship_position_(nullptr),
-      tracking_strength_(0.5F),        // Default tracking strength
-      timer_invulnerabilitat_(0.0F) {  // Start vulnerable
-    // [NUEVO] Brightness específic per enemics
-    brightness_ = Defaults::Brightness::ENEMIC;
-
-    // [NUEVO] Forma es carrega a inicialitzar() segons el tipus
-    // Constructor no carrega forma per permetre tipus diferents
-}
-
-void Enemic::inicialitzar(TipusEnemic tipus, const Punt* ship_pos) {
-    // Guardar tipus
-    tipus_ = tipus;
-
-    // Carregar forma segons el tipus
-    const char* shape_file;
-    float drotacio_min;
-    float drotacio_max;
-
-    switch (tipus_) {
-        case TipusEnemic::PENTAGON:
-            shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
-            velocitat_ = Defaults::Enemies::Pentagon::VELOCITAT;
-            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
-            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
-            break;
-
-        case TipusEnemic::QUADRAT:
-            shape_file = Defaults::Enemies::Quadrat::SHAPE_FILE;
-            velocitat_ = Defaults::Enemies::Quadrat::VELOCITAT;
-            drotacio_min = Defaults::Enemies::Quadrat::DROTACIO_MIN;
-            drotacio_max = Defaults::Enemies::Quadrat::DROTACIO_MAX;
-            tracking_timer_ = 0.0F;
-            break;
-
-        case TipusEnemic::MOLINILLO:
-            shape_file = Defaults::Enemies::Molinillo::SHAPE_FILE;
-            velocitat_ = Defaults::Enemies::Molinillo::VELOCITAT;
-            drotacio_min = Defaults::Enemies::Molinillo::DROTACIO_MIN;
-            drotacio_max = Defaults::Enemies::Molinillo::DROTACIO_MAX;
-            break;
-
-        default:
-            // Fallback segur: usar valors de PENTAGON
-            std::cerr << "[Enemic] Error: tipus desconegut ("
-                      << static_cast<int>(tipus_) << "), utilitzant PENTAGON\n";
-            shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
-            velocitat_ = Defaults::Enemies::Pentagon::VELOCITAT;
-            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
-            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
-            break;
-    }
-
-    // Carregar forma
-    forma_ = Graphics::ShapeLoader::load(shape_file);
-    if (!forma_ || !forma_->es_valida()) {
-        std::cerr << "[Enemic] Error: no s'ha pogut carregar " << shape_file << '\n';
-    }
-
-    // [MODIFIED] Posició aleatòria amb comprovació de seguretat
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    if (ship_pos != nullptr) {
-        // [NEW] Safe spawn: attempt to find position away from ship
-        bool found_safe_position = false;
-
-        for (int attempt = 0; attempt < Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS; attempt++) {
-            float candidate_x;
-            float candidate_y;
-
-            if (intent_spawn_safe(*ship_pos, candidate_x, candidate_y)) {
-                centre_.x = candidate_x;
-                centre_.y = candidate_y;
-                found_safe_position = true;
-                break;
-            }
-        }
-
-        if (!found_safe_position) {
-            // Fallback: spawn anywhere (user's preference)
-            int range_x = static_cast<int>(max_x - min_x);
-            int range_y = static_cast<int>(max_y - min_y);
-            centre_.x = static_cast<float>((std::rand() % range_x) + static_cast<int>(min_x));
-            centre_.y = static_cast<float>((std::rand() % range_y) + static_cast<int>(min_y));
-
-            std::cout << "[Enemic] Advertència: spawn sense zona segura després de "
-                      << Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS << " intents" << '\n';
-        }
-    } else {
-        // [EXISTING] No ship position: spawn anywhere (backward compatibility)
-        int range_x = static_cast<int>(max_x - min_x);
-        int range_y = static_cast<int>(max_y - min_y);
-        centre_.x = static_cast<float>((std::rand() % range_x) + static_cast<int>(min_x));
-        centre_.y = static_cast<float>((std::rand() % range_y) + static_cast<int>(min_y));
-    }
-
-    // Angle aleatori de moviment
-    angle_ = (std::rand() % 360) * Constants::PI / 180.0F;
-
-    // Rotació visual aleatòria (rad/s) dins del rang del tipus
-    float drotacio_range = drotacio_max - drotacio_min;
-    drotacio_ = drotacio_min + ((static_cast<float>(std::rand()) / RAND_MAX) * drotacio_range);
-    rotacio_ = 0.0F;
-
-    // Inicialitzar estat d'animació
-    animacio_ = AnimacioEnemic();  // Reset to defaults
-    animacio_.drotacio_base = drotacio_;
-    animacio_.drotacio_objetivo = drotacio_;
-    animacio_.drotacio_t = 1.0F;  // Start without interpolating
-
-    // [NEW] Inicialitzar invulnerabilitat
-    timer_invulnerabilitat_ = Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;  // 3.0s
-    brightness_ = Defaults::Enemies::Spawn::INVULNERABILITY_BRIGHTNESS_START;      // 0.3f
-
-    // Activar
-    esta_ = true;
-}
-
-void Enemic::actualitzar(float delta_time) {
-    if (esta_) {
-        // [NEW] Update invulnerability timer and brightness
-        if (timer_invulnerabilitat_ > 0.0F) {
-            timer_invulnerabilitat_ -= delta_time;
-
-            timer_invulnerabilitat_ = std::max(timer_invulnerabilitat_, 0.0F);
-
-            // [NEW] Update brightness with LERP during invulnerability
-            float t_inv = timer_invulnerabilitat_ / Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
-            float t = 1.0F - t_inv;                      // 0.0 → 1.0
-            float smooth_t = t * t * (3.0F - 2.0F * t);  // smoothstep
-
-            constexpr float START = Defaults::Enemies::Spawn::INVULNERABILITY_BRIGHTNESS_START;
-            constexpr float END = Defaults::Enemies::Spawn::INVULNERABILITY_BRIGHTNESS_END;
-            brightness_ = START + ((END - START) * smooth_t);
-        }
-
-        // Moviment autònom
-        mou(delta_time);
-
-        // Actualitzar animacions (palpitació, rotació accelerada)
-        actualitzar_animacio(delta_time);
-
-        // Rotació visual (time-based: drotacio_ està en rad/s)
-        rotacio_ += drotacio_ * delta_time;
-    }
-}
-
-void Enemic::dibuixar() const {
-    if (esta_ && forma_) {
-        // Calculate animated scale (includes invulnerability LERP)
-        float escala = calcular_escala_actual();
-
-        // brightness_ is already updated in actualitzar()
-        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, escala, true, 1.0F, brightness_);
-    }
-}
-
-void Enemic::mou(float delta_time) {
-    // Dispatcher: crida el comportament específic segons el tipus
-    switch (tipus_) {
-        case TipusEnemic::PENTAGON:
-            comportament_pentagon(delta_time);
-            break;
-        case TipusEnemic::QUADRAT:
-            comportament_quadrat(delta_time);
-            break;
-        case TipusEnemic::MOLINILLO:
-            comportament_molinillo(delta_time);
-            break;
-        default:
-            // Fallback: comportament bàsic (Pentagon)
-            comportament_pentagon(delta_time);
-            break;
-    }
-}
-
-void Enemic::comportament_pentagon(float delta_time) {
-    // Pentagon: zigzag esquivador (frequent direction changes)
-    // Similar a comportament original però amb probabilitat més alta
-
-    float velocitat_efectiva = velocitat_ * delta_time;
-
-    // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
-    float dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(angle_ - (Constants::PI / 2.0F));
-
-    float new_y = centre_.y + dy;
-    float new_x = centre_.x + dx;
-
-    // Obtenir límits segurs
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    // Zigzag: canvi d'angle més freqüent en tocar límits
-    if (new_y >= min_y && new_y <= max_y) {
-        centre_.y = new_y;
-    } else {
-        // Probabilitat més alta de canvi d'angle
-        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Pentagon::CANVI_ANGLE_PROB) {
-            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
-                Defaults::Enemies::Pentagon::CANVI_ANGLE_MAX;
-            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
-        }
-    }
-
-    if (new_x >= min_x && new_x <= max_x) {
-        centre_.x = new_x;
-    } else {
-        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Pentagon::CANVI_ANGLE_PROB) {
-            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
-                Defaults::Enemies::Pentagon::CANVI_ANGLE_MAX;
-            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
-        }
-    }
-}
-
-void Enemic::comportament_quadrat(float delta_time) {
-    // Quadrat: perseguidor (tracks player position)
-
-    // Update tracking timer
-    tracking_timer_ += delta_time;
-
-    // Periodically update angle toward ship
-    if (tracking_timer_ >= Defaults::Enemies::Quadrat::TRACKING_INTERVAL) {
-        tracking_timer_ = 0.0F;
-
-        if (ship_position_ != nullptr) {
-            // Calculate angle to ship
-            float dx = ship_position_->x - centre_.x;
-            float dy = ship_position_->y - centre_.y;
-            float target_angle = std::atan2(dy, dx) + (Constants::PI / 2.0F);
-
-            // Interpolate toward target angle
-            float angle_diff = target_angle - angle_;
-
-            // Normalize angle difference to [-π, π]
-            while (angle_diff > Constants::PI) {
-                angle_diff -= 2.0F * Constants::PI;
-            }
-            while (angle_diff < -Constants::PI) {
-                angle_diff += 2.0F * Constants::PI;
-            }
-
-            // Apply tracking strength (uses member variable, defaults to 0.5)
-            angle_ += angle_diff * tracking_strength_;
-        }
-    }
-
-    // Move in current direction
-    float velocitat_efectiva = velocitat_ * delta_time;
-    float dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(angle_ - (Constants::PI / 2.0F));
-
-    float new_y = centre_.y + dy;
-    float new_x = centre_.x + dx;
-
-    // Obtenir límits segurs
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    // Bounce on walls (simple reflection)
-    if (new_y >= min_y && new_y <= max_y) {
-        centre_.y = new_y;
-    } else {
-        angle_ = -angle_;  // Vertical reflection
-    }
-
-    if (new_x >= min_x && new_x <= max_x) {
-        centre_.x = new_x;
-    } else {
-        angle_ = Constants::PI - angle_;  // Horizontal reflection
-    }
-}
-
-void Enemic::comportament_molinillo(float delta_time) {
-    // Molinillo: agressiu (fast, straight lines, proximity spin-up)
-
-    // Check proximity to ship for spin-up effect
-    if (ship_position_ != nullptr) {
-        float dx = ship_position_->x - centre_.x;
-        float dy = ship_position_->y - centre_.y;
-        float distance = std::sqrt((dx * dx) + (dy * dy));
-
-        if (distance < Defaults::Enemies::Molinillo::PROXIMITY_DISTANCE) {
-            // Temporarily boost rotation speed when near ship
-            float boost = Defaults::Enemies::Molinillo::DROTACIO_PROXIMITY_MULTIPLIER;
-            drotacio_ = animacio_.drotacio_base * boost;
-        } else {
-            // Normal rotation speed
-            drotacio_ = animacio_.drotacio_base;
-        }
-    }
-
-    // Fast straight-line movement
-    float velocitat_efectiva = velocitat_ * delta_time;
-    float dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(angle_ - (Constants::PI / 2.0F));
-
-    float new_y = centre_.y + dy;
-    float new_x = centre_.x + dx;
-
-    // Obtenir límits segurs
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    // Rare angle changes on wall hits
-    if (new_y >= min_y && new_y <= max_y) {
-        centre_.y = new_y;
-    } else {
-        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Molinillo::CANVI_ANGLE_PROB) {
-            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
-                Defaults::Enemies::Molinillo::CANVI_ANGLE_MAX;
-            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
-        }
-    }
-
-    if (new_x >= min_x && new_x <= max_x) {
-        centre_.x = new_x;
-    } else {
-        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Molinillo::CANVI_ANGLE_PROB) {
-            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
-                Defaults::Enemies::Molinillo::CANVI_ANGLE_MAX;
-            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
-        }
-    }
-}
-
-void Enemic::actualitzar_animacio(float delta_time) {
-    actualitzar_palpitacio(delta_time);
-    actualitzar_rotacio_accelerada(delta_time);
-}
-
-void Enemic::actualitzar_palpitacio(float delta_time) {
-    if (animacio_.palpitacio_activa) {
-        // Advance phase (2π * frequency * dt)
-        animacio_.palpitacio_fase += 2.0F * Constants::PI * animacio_.palpitacio_frequencia * delta_time;
-
-        // Decrement timer
-        animacio_.palpitacio_temps_restant -= delta_time;
-
-        // Deactivate when timer expires
-        if (animacio_.palpitacio_temps_restant <= 0.0F) {
-            animacio_.palpitacio_activa = false;
-        }
-    } else {
-        // Random trigger (probability per second)
-        float rand_val = static_cast<float>(std::rand()) / RAND_MAX;
-        float trigger_prob = Defaults::Enemies::Animation::PALPITACIO_TRIGGER_PROB * delta_time;
-
-        if (rand_val < trigger_prob) {
-            // Activate palpitation
-            animacio_.palpitacio_activa = true;
-            animacio_.palpitacio_fase = 0.0F;
-
-            // Randomize parameters
-            float freq_range = Defaults::Enemies::Animation::PALPITACIO_FREQ_MAX -
-                Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN;
-            animacio_.palpitacio_frequencia = Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN +
-                ((static_cast<float>(std::rand()) / RAND_MAX) * freq_range);
-
-            float amp_range = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MAX -
-                Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN;
-            animacio_.palpitacio_amplitud = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN +
-                ((static_cast<float>(std::rand()) / RAND_MAX) * amp_range);
-
-            float dur_range = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MAX -
-                Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN;
-            animacio_.palpitacio_temps_restant = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN +
-                ((static_cast<float>(std::rand()) / RAND_MAX) * dur_range);
-        }
-    }
-}
-
-void Enemic::actualitzar_rotacio_accelerada(float delta_time) {
-    if (animacio_.drotacio_t < 1.0F) {
-        // Transitioning to new target
-        animacio_.drotacio_t += delta_time / animacio_.drotacio_duracio;
-
-        if (animacio_.drotacio_t >= 1.0F) {
-            animacio_.drotacio_t = 1.0F;
-            animacio_.drotacio_base = animacio_.drotacio_objetivo;  // Reached target
-            drotacio_ = animacio_.drotacio_base;
-        } else {
-            // Smoothstep interpolation: t² * (3 - 2t)
-            float t = animacio_.drotacio_t;
-            float smooth_t = t * t * (3.0F - 2.0F * t);
-
-            // Interpolate between base and target
-            float initial = animacio_.drotacio_base;
-            float target = animacio_.drotacio_objetivo;
-            drotacio_ = initial + ((target - initial) * smooth_t);
-        }
-    } else {
-        // Random trigger for new acceleration
-        float rand_val = static_cast<float>(std::rand()) / RAND_MAX;
-        float trigger_prob = Defaults::Enemies::Animation::ROTACIO_ACCEL_TRIGGER_PROB * delta_time;
-
-        if (rand_val < trigger_prob) {
-            // Start new transition
-            animacio_.drotacio_t = 0.0F;
-
-            // Randomize target speed (multiplier * base)
-            float mult_range = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MAX -
-                Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN;
-            float multiplier = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN +
-                ((static_cast<float>(std::rand()) / RAND_MAX) * mult_range);
-
-            animacio_.drotacio_objetivo = animacio_.drotacio_base * multiplier;
-
-            // Randomize duration
-            float dur_range = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MAX -
-                Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN;
-            animacio_.drotacio_duracio = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN +
-                ((static_cast<float>(std::rand()) / RAND_MAX) * dur_range);
-        }
-    }
-}
-
-float Enemic::calcular_escala_actual() const {
-    float escala = 1.0F;
-
-    // [NEW] Invulnerability LERP prioritza sobre palpitació
-    if (timer_invulnerabilitat_ > 0.0F) {
-        // Calculate t: 0.0 at spawn → 1.0 at end
-        float t_inv = timer_invulnerabilitat_ / Defaults::Enemies::Spawn::INVULNERABILITY_DURATION;
-        float t = 1.0F - t_inv;  // 0.0 → 1.0
-
-        // Apply smoothstep: t² * (3 - 2t)
-        float smooth_t = t * t * (3.0F - 2.0F * t);
-
-        // LERP scale from 0.0 to 1.0
-        constexpr float START = Defaults::Enemies::Spawn::INVULNERABILITY_SCALE_START;
-        constexpr float END = Defaults::Enemies::Spawn::INVULNERABILITY_SCALE_END;
-        escala = START + ((END - START) * smooth_t);
-    } else if (animacio_.palpitacio_activa) {
-        // [EXISTING] Palpitació només quan no invulnerable
-        escala += animacio_.palpitacio_amplitud * std::sin(animacio_.palpitacio_fase);
-    }
-
-    return escala;
-}
-
-// [NEW] Stage system API implementations
-
-float Enemic::get_base_velocity() const {
-    switch (tipus_) {
-        case TipusEnemic::PENTAGON:
-            return Defaults::Enemies::Pentagon::VELOCITAT;
-        case TipusEnemic::QUADRAT:
-            return Defaults::Enemies::Quadrat::VELOCITAT;
-        case TipusEnemic::MOLINILLO:
-            return Defaults::Enemies::Molinillo::VELOCITAT;
-        default:
-            return Defaults::Enemies::Pentagon::VELOCITAT;  // Fallback segur
-    }
-}
-
-float Enemic::get_base_rotation() const {
-    // Return the base rotation speed (drotacio_base if available, otherwise current drotacio_)
-    return animacio_.drotacio_base != 0.0F ? animacio_.drotacio_base : drotacio_;
-}
-
-void Enemic::set_tracking_strength(float strength) {
-    // Only applies to QUADRAT type
-    if (tipus_ == TipusEnemic::QUADRAT) {
-        tracking_strength_ = strength;
-    }
-}
-
-// [NEW] Safe spawn helper - checks if position is away from ship
-bool Enemic::intent_spawn_safe(const Punt& ship_pos, float& out_x, float& out_y) {
-    // Generate random position within safe bounds
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    int range_x = static_cast<int>(max_x - min_x);
-    int range_y = static_cast<int>(max_y - min_y);
-
-    out_x = static_cast<float>((std::rand() % range_x) + static_cast<int>(min_x));
-    out_y = static_cast<float>((std::rand() % range_y) + static_cast<int>(min_y));
-
-    // Check Euclidean distance to ship
-    float dx = out_x - ship_pos.x;
-    float dy = out_y - ship_pos.y;
-    float distancia = std::sqrt((dx * dx) + (dy * dy));
-
-    // Return true if position is safe (>= 36px from ship)
-    return distancia >= Defaults::Enemies::Spawn::SAFETY_DISTANCE;
-}
diff --git a/source/game/entities/enemic.hpp b/source/game/entities/enemic.hpp
deleted file mode 100644
index 5a8e14d..0000000
--- a/source/game/entities/enemic.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-// enemic.hpp - Classe per a enemics (ORNIs pentàgons)
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-#include <SDL3/SDL.h>
-
-#include <cmath>
-#include <cstdint>
-
-#include "core/defaults.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/types.hpp"
-#include "game/constants.hpp"
-
-// Tipus d'enemic
-enum class TipusEnemic : uint8_t {
-    PENTAGON = 0,  // Pentàgon esquivador (zigzag)
-    QUADRAT = 1,   // Quadrat perseguidor (tracks ship)
-    MOLINILLO = 2  // Molinillo agressiu (fast, spinning)
-};
-
-// Estat d'animació (palpitació i rotació accelerada)
-struct AnimacioEnemic {
-        // Palpitation (breathing effect)
-        bool palpitacio_activa = false;
-        float palpitacio_fase = 0.0F;           // Phase in cycle (0.0-2π)
-        float palpitacio_frequencia = 2.0F;     // Hz (cycles per second)
-        float palpitacio_amplitud = 0.15F;      // Scale variation (±15%)
-        float palpitacio_temps_restant = 0.0F;  // Time remaining (seconds)
-
-        // Rotation acceleration (long-term spin modulation)
-        float drotacio_base = 0.0F;      // Base rotation speed (rad/s)
-        float drotacio_objetivo = 0.0F;  // Target rotation speed (rad/s)
-        float drotacio_t = 0.0F;         // Interpolation progress (0.0-1.0)
-        float drotacio_duracio = 0.0F;   // Duration of transition (seconds)
-};
-
-class Enemic : public Entities::Entitat {
-    public:
-        Enemic()
-            : Entitat(nullptr) {}
-        Enemic(SDL_Renderer* renderer);
-
-        void inicialitzar() override { inicialitzar(TipusEnemic::PENTAGON, nullptr); }
-        void inicialitzar(TipusEnemic tipus, const Punt* ship_pos = nullptr);
-        void actualitzar(float delta_time) override;
-        void dibuixar() const override;
-
-        // Override: Interfície d'Entitat
-        [[nodiscard]] bool esta_actiu() const override { return esta_; }
-
-        // Override: Interfície de col·lisió
-        [[nodiscard]] float get_collision_radius() const override {
-            return Defaults::Entities::ENEMY_RADIUS;
-        }
-        [[nodiscard]] bool es_collidable() const override {
-            return esta_ && timer_invulnerabilitat_ <= 0.0F;
-        }
-
-        // Getters (API pública sense canvis)
-        void destruir() { esta_ = false; }
-        [[nodiscard]] float get_drotacio() const { return drotacio_; }
-        [[nodiscard]] Punt get_velocitat_vector() const {
-            return {
-                .x = velocitat_ * std::cos(angle_ - (Constants::PI / 2.0F)),
-                .y = velocitat_ * std::sin(angle_ - (Constants::PI / 2.0F))};
-        }
-
-        // Set ship position reference for tracking behavior
-        void set_ship_position(const Punt* ship_pos) { ship_position_ = ship_pos; }
-
-        // [NEW] Getters for stage system (base stats)
-        [[nodiscard]] float get_base_velocity() const;
-        [[nodiscard]] float get_base_rotation() const;
-        [[nodiscard]] TipusEnemic get_tipus() const { return tipus_; }
-
-        // [NEW] Setters for difficulty multipliers (stage system)
-        void set_velocity(float vel) { velocitat_ = vel; }
-        void set_rotation(float rot) {
-            drotacio_ = rot;
-            animacio_.drotacio_base = rot;
-        }
-        void set_tracking_strength(float strength);
-
-        // [NEW] Invulnerability queries
-        [[nodiscard]] bool es_invulnerable() const { return timer_invulnerabilitat_ > 0.0F; }
-        [[nodiscard]] float get_temps_invulnerabilitat() const { return timer_invulnerabilitat_; }
-
-    private:
-        // Membres específics d'Enemic (heretats: renderer_, forma_, centre_, angle_, brightness_)
-        float velocitat_;
-        float drotacio_;  // Delta rotació visual (rad/s)
-        float rotacio_;   // Rotació visual acumulada
-        bool esta_;
-
-        // [NEW] Enemy type and configuration
-        TipusEnemic tipus_;
-
-        // [NEW] Animation state
-        AnimacioEnemic animacio_;
-
-        // [NEW] Behavior state (type-specific)
-        float tracking_timer_;       // For Quadrat: time since last angle update
-        const Punt* ship_position_;  // Pointer to ship position (for tracking)
-        float tracking_strength_;    // For Quadrat: tracking intensity (0.0-1.5), default 0.5
-
-        // [NEW] Invulnerability state
-        float timer_invulnerabilitat_;  // Countdown timer (seconds), 0.0f = vulnerable
-
-        // [EXISTING] Private methods
-        void mou(float delta_time);
-
-        // [NEW] Private methods
-        void actualitzar_animacio(float delta_time);
-        void actualitzar_palpitacio(float delta_time);
-        void actualitzar_rotacio_accelerada(float delta_time);
-        void comportament_pentagon(float delta_time);
-        void comportament_quadrat(float delta_time);
-        void comportament_molinillo(float delta_time);
-        [[nodiscard]] float calcular_escala_actual() const;  // Returns scale with palpitation applied
-        bool intent_spawn_safe(const Punt& ship_pos, float& out_x, float& out_y);
-};
diff --git a/source/game/entities/enemy.cpp b/source/game/entities/enemy.cpp
new file mode 100644
index 0000000..98a3083
--- /dev/null
+++ b/source/game/entities/enemy.cpp
@@ -0,0 +1,457 @@
+// enemy.cpp - Implementación de enemigos (ORNIs)
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#include "game/entities/enemy.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <iostream>
+
+#include "core/defaults.hpp"
+#include "core/entities/entity.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/rendering/shape_renderer.hpp"
+#include "core/types.hpp"
+#include "game/constants.hpp"
+
+namespace {
+
+// Velocidad inicial vectorial a partir de un ángulo (rad).
+// angle=0 apunta hacia arriba (eje Y negativo SDL), como el resto del juego.
+auto angleToDirection(float angle) -> Vec2 {
+    return Vec2{
+        .x = std::cos(angle - (Constants::PI / 2.0F)),
+        .y = std::sin(angle - (Constants::PI / 2.0F)),
+    };
+}
+
+// Recupera el "ángulo equivalente" de un body en movimiento (para zigzag).
+// Si está parado, devuelve 0.
+auto velocityToAngle(const Vec2& velocity) -> float {
+    if (velocity.lengthSquared() < 0.0001F) {
+        return 0.0F;
+    }
+    // El movimiento (vx, vy) corresponde a angle - PI/2; invertimos.
+    return std::atan2(velocity.y, velocity.x) + (Constants::PI / 2.0F);
+}
+
+}  // namespace
+
+Enemy::Enemy(Rendering::Renderer* renderer)
+    : Entity(renderer),
+      drotacio_(0.0F),
+      rotacio_(0.0F),
+      esta_(false),
+      type_(EnemyType::PENTAGON),
+      tracking_timer_(0.0F),
+      ship_position_(nullptr),
+      tracking_strength_(0.5F),
+      direction_change_timer_(0.0F),
+      timer_invulnerabilitat_(0.0F) {
+    brightness_ = Defaults::Brightness::ENEMIC;
+
+    // Configuración del cuerpo físico — defaults para enemy genérico.
+    // init() ajusta velocidad y masa según el tipo (Pentagon/Quadrat/Molinillo).
+    body_.setMass(5.0F);                                  // Más liviano que la nave (10.0)
+    body_.radius = 0.0F;                                  // 0 hasta spawn (no colisiona inactivo)
+    body_.restitution = 1.0F;                             // Rebote elástico perfecto contra paredes
+    body_.linear_damping = 0.0F;                          // Sin fricción: mantienen velocidad
+    body_.angular_damping = 0.0F;                         // Idem
+}
+
+void Enemy::init(EnemyType type, const Vec2* ship_pos) {
+    type_ = type;
+
+    const char* shape_file = nullptr;
+    float base_speed = 0.0F;
+    float drotacio_min = 0.0F;
+    float drotacio_max = 0.0F;
+    float type_mass = 5.0F;
+
+    switch (type_) {
+        case EnemyType::PENTAGON:
+            shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
+            base_speed = Defaults::Enemies::Pentagon::VELOCITAT;
+            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
+            type_mass = 5.0F;
+            break;
+
+        case EnemyType::QUADRAT:
+            shape_file = Defaults::Enemies::Cuadrado::SHAPE_FILE;
+            base_speed = Defaults::Enemies::Cuadrado::VELOCITAT;
+            drotacio_min = Defaults::Enemies::Cuadrado::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Cuadrado::DROTACIO_MAX;
+            type_mass = 8.0F;  // Más pesado, "tanque"
+            tracking_timer_ = 0.0F;
+            break;
+
+        case EnemyType::MOLINILLO:
+            shape_file = Defaults::Enemies::Molinillo::SHAPE_FILE;
+            base_speed = Defaults::Enemies::Molinillo::VELOCITAT;
+            drotacio_min = Defaults::Enemies::Molinillo::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Molinillo::DROTACIO_MAX;
+            type_mass = 4.0F;  // Más liviano, ágil
+            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;
+            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
+            break;
+    }
+
+    body_.setMass(type_mass);
+    body_.radius = Defaults::Entities::ENEMY_RADIUS;
+
+    // Cargar shape
+    shape_ = Graphics::ShapeLoader::load(shape_file);
+    if (!shape_ || !shape_->isValid()) {
+        std::cerr << "[Enemy] Error: no se ha podido cargar " << shape_file << '\n';
+    }
+
+    // Posición aleatoria con comprobación de seguridad
+    float min_x;
+    float max_x;
+    float min_y;
+    float max_y;
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS, min_x, max_x, min_y, max_y);
+
+    if (ship_pos != nullptr) {
+        bool found_safe_position = false;
+        for (int attempt = 0; attempt < Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS; attempt++) {
+            float candidate_x;
+            float candidate_y;
+            if (attemptSafeSpawn(*ship_pos, candidate_x, candidate_y)) {
+                center_.x = candidate_x;
+                center_.y = candidate_y;
+                found_safe_position = true;
+                break;
+            }
+        }
+        if (!found_safe_position) {
+            const int RANGE_X = static_cast<int>(max_x - min_x);
+            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 "
+                      << Defaults::Enemies::Spawn::MAX_SPAWN_ATTEMPTS << " intentos\n";
+        }
+    } else {
+        const int RANGE_X = static_cast<int>(max_x - min_x);
+        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));
+    }
+
+    // Dirección inicial aleatoria, velocidad escalar según tipo
+    const float ANGLE_INICIAL = (std::rand() % 360) * Constants::PI / 180.0F;
+    setVelocityFromAngle(ANGLE_INICIAL, base_speed);
+
+    // Sincronizar body_ con posición inicial
+    body_.position = center_;
+    body_.angle = 0.0F;
+    body_.angular_velocity = 0.0F;
+    body_.clearAccumulators();
+
+    // Rotación visual aleatoria (independiente del body)
+    const float DROTACIO_RANGE = drotacio_max - drotacio_min;
+    drotacio_ = drotacio_min + ((static_cast<float>(std::rand()) / RAND_MAX) * DROTACIO_RANGE);
+    rotacio_ = 0.0F;
+
+    // Estado de animación
+    animacio_ = EnemyAnimation();
+    animacio_.drotacio_base = drotacio_;
+    animacio_.drotacio_objetivo = drotacio_;
+    animacio_.drotacio_t = 1.0F;
+
+    // Invulnerabilidad post-spawn
+    timer_invulnerabilitat_ = 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;
+}
+
+void Enemy::update(float delta_time) {
+    if (!esta_) {
+        return;
+    }
+
+    // Decremento de invulnerabilidad + LERP de brightness
+    if (timer_invulnerabilitat_ > 0.0F) {
+        timer_invulnerabilitat_ -= delta_time;
+        timer_invulnerabilitat_ = std::max(timer_invulnerabilitat_, 0.0F);
+
+        const float T_INV = timer_invulnerabilitat_ / 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;
+        constexpr float END = Defaults::Enemies::Spawn::INVULNERABILITY_BRIGHTNESS_END;
+        brightness_ = START + ((END - START) * SMOOTH_T);
+    }
+
+    // Comportamiento por tipo (ajusta body_.velocity, NO mueve posición)
+    switch (type_) {
+        case EnemyType::PENTAGON:
+            behaviorPentagon(delta_time);
+            break;
+        case EnemyType::QUADRAT:
+            behaviorQuadrat(delta_time);
+            break;
+        case EnemyType::MOLINILLO:
+            behaviorMolinillo(delta_time);
+            break;
+    }
+
+    // Animaciones (palpitación + rotación acelerada)
+    updateAnimation(delta_time);
+
+    // Rotación visual (decoración, no afecta movimiento)
+    rotacio_ += drotacio_ * delta_time;
+}
+
+void Enemy::postUpdate(float /*delta_time*/) {
+    // Sincronizar mirror tras la integración del world.
+    if (esta_) {
+        center_ = body_.position;
+    }
+}
+
+void Enemy::draw() const {
+    if (!esta_ || !shape_) {
+        return;
+    }
+    const float SCALE = computeCurrentScale();
+    SDL_Color color{};
+    switch (type_) {
+        case EnemyType::PENTAGON:  color = Defaults::Palette::PENTAGON;  break;
+        case EnemyType::QUADRAT:   color = Defaults::Palette::QUADRAT;   break;
+        case EnemyType::MOLINILLO: color = Defaults::Palette::MOLINILLO; break;
+    }
+    Rendering::render_shape(renderer_, shape_, center_, rotacio_, SCALE, 1.0F, brightness_,
+                            /*rotation_3d=*/nullptr, color);
+}
+
+void Enemy::destruir() {
+    esta_ = false;
+    body_.velocity = Vec2{};
+    body_.angular_velocity = 0.0F;
+    body_.radius = 0.0F;  // No colisiona mientras está inactivo
+}
+
+void Enemy::setVelocity(float speed) {
+    // Mantener la dirección actual del body, cambiar solo la magnitud.
+    const float CURRENT_SPEED = body_.velocity.length();
+    if (CURRENT_SPEED > 0.0F) {
+        body_.velocity = body_.velocity * (speed / CURRENT_SPEED);
+    } else {
+        // Sin dirección actual: usar ángulo aleatorio
+        const float A = (std::rand() % 360) * Constants::PI / 180.0F;
+        setVelocityFromAngle(A, speed);
+    }
+}
+
+void Enemy::setVelocityFromAngle(float angle_movement, float speed) {
+    body_.velocity = angleToDirection(angle_movement) * speed;
+}
+
+// PENTAGON: zigzag esquivador. Cambios de dirección periódicos (probabilísticos)
+// en lugar de detectar paredes; el rebote contra muros lo hace PhysicsWorld
+// con restitution=1.0.
+void Enemy::behaviorPentagon(float delta_time) {
+    direction_change_timer_ += delta_time;
+
+    // Probabilidad de zigzag por segundo (calibrada para sensación equivalente
+    // a la versión vieja que disparaba en cada toque de pared).
+    constexpr float ZIGZAG_PROB_PER_SECOND = 0.8F;
+    const float RAND_VAL = static_cast<float>(std::rand()) / RAND_MAX;
+    if (RAND_VAL < ZIGZAG_PROB_PER_SECOND * delta_time) {
+        const float CURRENT_ANGLE = velocityToAngle(body_.velocity);
+        const float DELTA = (static_cast<float>(std::rand()) / RAND_MAX) *
+                            Defaults::Enemies::Pentagon::CANVI_ANGLE_MAX;
+        const float NEW_ANGLE = CURRENT_ANGLE + ((std::rand() % 2 == 0) ? DELTA : -DELTA);
+        const float SPEED = body_.velocity.length();
+        setVelocityFromAngle(NEW_ANGLE, SPEED);
+        direction_change_timer_ = 0.0F;
+    }
+}
+
+// QUADRAT: tracking discreto cada TRACKING_INTERVAL. Ajusta dirección
+// hacia el ship mezclando con tracking_strength_.
+void Enemy::behaviorQuadrat(float delta_time) {
+    tracking_timer_ += delta_time;
+
+    if (tracking_timer_ >= Defaults::Enemies::Cuadrado::TRACKING_INTERVAL && ship_position_ != nullptr) {
+        tracking_timer_ = 0.0F;
+
+        const Vec2 TO_SHIP = *ship_position_ - center_;
+        const float DIST = TO_SHIP.length();
+        if (DIST > 0.0F) {
+            const Vec2 DESIRED_DIR = TO_SHIP / DIST;
+            const float SPEED = body_.velocity.length();
+            const Vec2 DESIRED_VEL = DESIRED_DIR * SPEED;
+
+            // Mezcla LERP: velocidad actual con la deseada según tracking_strength_.
+            body_.velocity = (body_.velocity * (1.0F - tracking_strength_)) +
+                             (DESIRED_VEL * tracking_strength_);
+
+            // Renormalizar a la velocidad escalar original
+            const float NEW_SPEED = body_.velocity.length();
+            if (NEW_SPEED > 0.0F) {
+                body_.velocity = body_.velocity * (SPEED / NEW_SPEED);
+            }
+        }
+    }
+}
+
+// MOLINILLO: 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*/) {
+    // 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) {
+            drotacio_ = animacio_.drotacio_base * Defaults::Enemies::Molinillo::DROTACIO_PROXIMITY_MULTIPLIER;
+        } else {
+            drotacio_ = animacio_.drotacio_base;
+        }
+    }
+    // Movimiento lineal puro: el world se encarga de integrar y rebotar.
+}
+
+void Enemy::updateAnimation(float delta_time) {
+    updatePalpitation(delta_time);
+    updateRotationAcceleration(delta_time);
+}
+
+void Enemy::updatePalpitation(float delta_time) {
+    if (animacio_.palpitacio_activa) {
+        animacio_.palpitacio_fase += 2.0F * Constants::PI * animacio_.palpitacio_frequencia * delta_time;
+        animacio_.palpitacio_temps_restant -= delta_time;
+        if (animacio_.palpitacio_temps_restant <= 0.0F) {
+            animacio_.palpitacio_activa = false;
+        }
+    } else {
+        const float RAND_VAL = static_cast<float>(std::rand()) / RAND_MAX;
+        const float TRIGGER_PROB = Defaults::Enemies::Animation::PALPITACIO_TRIGGER_PROB * delta_time;
+        if (RAND_VAL < TRIGGER_PROB) {
+            animacio_.palpitacio_activa = true;
+            animacio_.palpitacio_fase = 0.0F;
+
+            const float FREQ_RANGE = Defaults::Enemies::Animation::PALPITACIO_FREQ_MAX -
+                                     Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN;
+            animacio_.palpitacio_frequencia = Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN +
+                                              ((static_cast<float>(std::rand()) / RAND_MAX) * FREQ_RANGE);
+
+            const float AMP_RANGE = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MAX -
+                                    Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN;
+            animacio_.palpitacio_amplitud = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN +
+                                            ((static_cast<float>(std::rand()) / RAND_MAX) * AMP_RANGE);
+
+            const float DUR_RANGE = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MAX -
+                                    Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN;
+            animacio_.palpitacio_temps_restant = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN +
+                                                 ((static_cast<float>(std::rand()) / RAND_MAX) * DUR_RANGE);
+        }
+    }
+}
+
+void Enemy::updateRotationAcceleration(float delta_time) {
+    if (animacio_.drotacio_t < 1.0F) {
+        animacio_.drotacio_t += delta_time / animacio_.drotacio_duracio;
+        if (animacio_.drotacio_t >= 1.0F) {
+            animacio_.drotacio_t = 1.0F;
+            animacio_.drotacio_base = animacio_.drotacio_objetivo;
+            drotacio_ = animacio_.drotacio_base;
+        } else {
+            const float T = animacio_.drotacio_t;
+            const float SMOOTH_T = T * T * (3.0F - (2.0F * T));
+            const float INITIAL = animacio_.drotacio_base;
+            const float TARGET = animacio_.drotacio_objetivo;
+            drotacio_ = INITIAL + ((TARGET - INITIAL) * SMOOTH_T);
+        }
+    } else {
+        const float RAND_VAL = static_cast<float>(std::rand()) / RAND_MAX;
+        const float TRIGGER_PROB = Defaults::Enemies::Animation::ROTACIO_ACCEL_TRIGGER_PROB * delta_time;
+        if (RAND_VAL < TRIGGER_PROB) {
+            animacio_.drotacio_t = 0.0F;
+
+            const float MULT_RANGE = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MAX -
+                                     Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN;
+            const float MULTIPLIER = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN +
+                                     ((static_cast<float>(std::rand()) / RAND_MAX) * MULT_RANGE);
+            animacio_.drotacio_objetivo = animacio_.drotacio_base * MULTIPLIER;
+
+            const float DUR_RANGE = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MAX -
+                                    Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN;
+            animacio_.drotacio_duracio = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN +
+                                         ((static_cast<float>(std::rand()) / RAND_MAX) * DUR_RANGE);
+        }
+    }
+}
+
+auto Enemy::computeCurrentScale() const -> float {
+    float scale = 1.0F;
+    if (timer_invulnerabilitat_ > 0.0F) {
+        const float T_INV = timer_invulnerabilitat_ / 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) {
+        scale += animacio_.palpitacio_amplitud * std::sin(animacio_.palpitacio_fase);
+    }
+    return scale;
+}
+
+auto Enemy::getBaseVelocity() const -> float {
+    switch (type_) {
+        case EnemyType::PENTAGON:
+            return Defaults::Enemies::Pentagon::VELOCITAT;
+        case EnemyType::QUADRAT:
+            return Defaults::Enemies::Cuadrado::VELOCITAT;
+        case EnemyType::MOLINILLO:
+            return Defaults::Enemies::Molinillo::VELOCITAT;
+        default:
+            return Defaults::Enemies::Pentagon::VELOCITAT;
+    }
+}
+
+auto Enemy::getBaseRotation() const -> float {
+    return animacio_.drotacio_base != 0.0F ? animacio_.drotacio_base : drotacio_;
+}
+
+void Enemy::setTrackingStrength(float strength) {
+    if (type_ == EnemyType::QUADRAT) {
+        tracking_strength_ = strength;
+    }
+}
+
+auto Enemy::attemptSafeSpawn(const Vec2& ship_pos, float& out_x, float& out_y) -> bool {
+    float min_x;
+    float max_x;
+    float min_y;
+    float max_y;
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS, min_x, max_x, min_y, max_y);
+
+    const int RANGE_X = static_cast<int>(max_x - min_x);
+    const int RANGE_Y = static_cast<int>(max_y - min_y);
+    out_x = static_cast<float>((std::rand() % RANGE_X) + static_cast<int>(min_x));
+    out_y = static_cast<float>((std::rand() % RANGE_Y) + static_cast<int>(min_y));
+
+    const float DX = out_x - ship_pos.x;
+    const float DY = out_y - ship_pos.y;
+    const float DISTANCE = std::sqrt((DX * DX) + (DY * DY));
+    return DISTANCE >= Defaults::Enemies::Spawn::SAFETY_DISTANCE;
+}
diff --git a/source/game/entities/enemy.hpp b/source/game/entities/enemy.hpp
new file mode 100644
index 0000000..71fe9a3
--- /dev/null
+++ b/source/game/entities/enemy.hpp
@@ -0,0 +1,120 @@
+// enemy.hpp - Clase para enemigos (ORNIs)
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#pragma once
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+
+#include "core/defaults.hpp"
+#include "core/entities/entity.hpp"
+#include "core/types.hpp"
+
+// Tipo de enemy
+enum class EnemyType : uint8_t {
+    PENTAGON = 0,  // Pentágono esquivador (zigzag)
+    QUADRAT = 1,   // Cuadrado perseguidor (tracks ship)
+    MOLINILLO = 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;
+        float palpitacio_fase = 0.0F;
+        float palpitacio_frequencia = 2.0F;
+        float palpitacio_amplitud = 0.15F;
+        float palpitacio_temps_restant = 0.0F;
+
+        // Aceleración de rotación visual (modulación a largo plazo)
+        float drotacio_base = 0.0F;
+        float drotacio_objetivo = 0.0F;
+        float drotacio_t = 0.0F;
+        float drotacio_duracio = 0.0F;
+};
+
+class Enemy : public Entities::Entity {
+    public:
+        Enemy()
+            : Entity(nullptr) {}
+        Enemy(Rendering::Renderer* renderer);
+
+        void init() override { init(EnemyType::PENTAGON, nullptr); }
+        void init(EnemyType type, const Vec2* ship_pos = nullptr);
+        void update(float delta_time) override;
+        void postUpdate(float delta_time) override;
+        void draw() const override;
+
+        // Override: Interfaz de Entity
+        [[nodiscard]] auto isActive() const -> bool override { return esta_; }
+
+        // Override: Interfaz de colisión
+        [[nodiscard]] auto getCollisionRadius() const -> float override {
+            return Defaults::Entities::ENEMY_RADIUS;
+        }
+        [[nodiscard]] auto isCollidable() const -> bool override {
+            return esta_ && timer_invulnerabilitat_ <= 0.0F;
+        }
+
+        // Marcar destruido (desactiva el cuerpo físicamente: radius=0)
+        void destruir();
+
+        // Getters
+        [[nodiscard]] auto getRotationDelta() const -> float { return drotacio_; }
+        [[nodiscard]] auto getVelocityVector() const -> Vec2 { return body_.velocity; }
+
+        // Set ship position reference for tracking behavior
+        void setShipPosition(const Vec2* ship_pos) { ship_position_ = ship_pos; }
+
+        // Stage system API (base stats)
+        [[nodiscard]] auto getBaseVelocity() const -> float;
+        [[nodiscard]] auto getBaseRotation() const -> float;
+        [[nodiscard]] auto getType() const -> EnemyType { return type_; }
+
+        // Setters para multiplicadores de dificultad (stage system).
+        // Establecen la velocidad escalar deseada manteniendo la dirección
+        // actual del body_.velocity.
+        void setVelocity(float speed);
+        void setRotation(float rot) {
+            drotacio_ = rot;
+            animacio_.drotacio_base = rot;
+        }
+        void setTrackingStrength(float strength);
+
+        // Invulnerabilidad
+        [[nodiscard]] auto isInvulnerable() const -> bool { return timer_invulnerabilitat_ > 0.0F; }
+        [[nodiscard]] auto getInvulnerabilityTime() const -> float { return timer_invulnerabilitat_; }
+
+    private:
+        // Miembros específicos (heredados: renderer_, shape_, center_, angle_, brightness_, body_)
+        float drotacio_;  // Velocidad angular visual (rad/s) — solo decoración, separada de body_.angular_velocity
+        float rotacio_;   // Rotación visual acumulada (no afecta movimiento)
+        bool esta_;
+
+        EnemyType type_;
+        EnemyAnimation animacio_;
+
+        // Comportamiento type-specific
+        float tracking_timer_;       // Quadrat: tiempo desde último update de dirección
+        const Vec2* ship_position_;  // Puntero a posición de la nave (para tracking)
+        float tracking_strength_;    // Quadrat: intensidad de tracking (0.0-1.5), default 0.5
+        float direction_change_timer_;  // Pentagon: tiempo para próximo cambio de dirección
+
+        // Invulnerabilidad post-spawn
+        float timer_invulnerabilitat_;
+
+        // Métodos privados
+        void updateAnimation(float delta_time);
+        void updatePalpitation(float delta_time);
+        void updateRotationAcceleration(float delta_time);
+        void behaviorPentagon(float delta_time);
+        void behaviorQuadrat(float delta_time);
+        void behaviorMolinillo(float delta_time);
+        [[nodiscard]] auto computeCurrentScale() const -> float;
+        auto attemptSafeSpawn(const Vec2& ship_pos, float& out_x, float& out_y) -> bool;
+
+        // Helper: setear body_.velocity desde un ángulo y magnitud.
+        // angle_movement=0 apunta hacia arriba (eje Y negativo SDL).
+        void setVelocityFromAngle(float angle_movement, float speed);
+};
diff --git a/source/game/entities/nau.cpp b/source/game/entities/nau.cpp
deleted file mode 100644
index de97759..0000000
--- a/source/game/entities/nau.cpp
+++ /dev/null
@@ -1,213 +0,0 @@
-// nau.cpp - Implementació de la nave del jugador
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#include "game/entities/nau.hpp"
-
-#include <SDL3/SDL.h>
-
-#include <algorithm>
-#include <cmath>
-#include <cstdint>
-#include <iostream>
-
-#include "core/defaults.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/graphics/shape_loader.hpp"
-#include "core/input/input.hpp"
-#include "core/input/input_types.hpp"
-#include "core/rendering/shape_renderer.hpp"
-#include "core/types.hpp"
-#include "game/constants.hpp"
-
-Nau::Nau(SDL_Renderer* renderer, const char* shape_file)
-    : Entitat(renderer),
-      velocitat_(0.0F),
-      esta_tocada_(false),
-      invulnerable_timer_(0.0F) {
-    // [NUEVO] Brightness específic per naus
-    brightness_ = Defaults::Brightness::NAU;
-
-    // [NUEVO] Carregar forma compartida des de fitxer
-    forma_ = Graphics::ShapeLoader::load(shape_file);
-
-    if (!forma_ || !forma_->es_valida()) {
-        std::cerr << "[Nau] Error: no s'ha pogut carregar " << shape_file << '\n';
-    }
-}
-
-void Nau::inicialitzar(const Punt* spawn_point, bool activar_invulnerabilitat) {
-    // Inicialització de la nau (triangle)
-    // Basat en el codi Pascal original: lines 380-384
-    // Copiat de joc_asteroides.cpp línies 30-44
-
-    // [NUEVO] Ja no cal configurar punts polars - la geometria es carrega del
-    // fitxer Només inicialitzem l'estat de la instància
-
-    // Use custom spawn point if provided, otherwise use center
-    if (spawn_point != nullptr) {
-        centre_.x = spawn_point->x;
-        centre_.y = spawn_point->y;
-    } else {
-        // Default: center of play area
-        float centre_x;
-        float centre_y;
-        Constants::obtenir_centre_zona(centre_x, centre_y);
-        centre_.x = static_cast<int>(centre_x);
-        centre_.y = static_cast<int>(centre_y);
-    }
-
-    // Estat inicial
-    angle_ = 0.0F;
-    velocitat_ = 0.0F;
-
-    // Activar invulnerabilidad solo si es respawn
-    if (activar_invulnerabilitat) {
-        invulnerable_timer_ = Defaults::Ship::INVULNERABILITY_DURATION;
-    } else {
-        invulnerable_timer_ = 0.0F;
-    }
-
-    esta_tocada_ = false;
-}
-
-void Nau::processar_input(float delta_time, uint8_t player_id) {
-    // Processar input continu (com teclapuls() del Pascal original)
-    // Basat en joc_asteroides.cpp línies 66-85
-    // Només processa input si la nau està viva
-    if (esta_tocada_) {
-        return;
-    }
-
-    auto* input = Input::get();
-
-    // Processar input segons el jugador
-    if (player_id == 0) {
-        // Jugador 1
-        if (input->checkActionPlayer1(InputAction::RIGHT, Input::ALLOW_REPEAT)) {
-            angle_ += Defaults::Physics::ROTATION_SPEED * delta_time;
-        }
-
-        if (input->checkActionPlayer1(InputAction::LEFT, Input::ALLOW_REPEAT)) {
-            angle_ -= Defaults::Physics::ROTATION_SPEED * delta_time;
-        }
-
-        if (input->checkActionPlayer1(InputAction::THRUST, Input::ALLOW_REPEAT)) {
-            if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
-                velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-                velocitat_ = std::min(velocitat_, Defaults::Physics::MAX_VELOCITY);
-            }
-        }
-    } else {
-        // Jugador 2
-        if (input->checkActionPlayer2(InputAction::RIGHT, Input::ALLOW_REPEAT)) {
-            angle_ += Defaults::Physics::ROTATION_SPEED * delta_time;
-        }
-
-        if (input->checkActionPlayer2(InputAction::LEFT, Input::ALLOW_REPEAT)) {
-            angle_ -= Defaults::Physics::ROTATION_SPEED * delta_time;
-        }
-
-        if (input->checkActionPlayer2(InputAction::THRUST, Input::ALLOW_REPEAT)) {
-            if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
-                velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-                velocitat_ = std::min(velocitat_, Defaults::Physics::MAX_VELOCITY);
-            }
-        }
-    }
-}
-
-void Nau::actualitzar(float delta_time) {
-    // Només actualitzar si la nau està viva
-    if (esta_tocada_) {
-        return;
-    }
-
-    // Decrementar timer de invulnerabilidad
-    if (invulnerable_timer_ > 0.0F) {
-        invulnerable_timer_ -= delta_time;
-        invulnerable_timer_ = std::max(invulnerable_timer_, 0.0F);
-    }
-
-    // Aplicar física (moviment + fricció)
-    aplicar_fisica(delta_time);
-}
-
-void Nau::dibuixar() const {
-    // Només dibuixar si la nau està viva
-    if (esta_tocada_) {
-        return;
-    }
-
-    // Si invulnerable, parpadear (toggle on/off)
-    if (es_invulnerable()) {
-        // Calcular ciclo de parpadeo
-        float blink_cycle = Defaults::Ship::BLINK_VISIBLE_TIME +
-            Defaults::Ship::BLINK_INVISIBLE_TIME;
-        float time_in_cycle = std::fmod(invulnerable_timer_, blink_cycle);
-
-        // Si estamos en fase invisible, no dibujar
-        if (time_in_cycle < Defaults::Ship::BLINK_INVISIBLE_TIME) {
-            return;  // No dibujar durante fase invisible
-        }
-    }
-
-    if (!forma_) {
-        return;
-    }
-
-    // Escalar velocitat per l'efecte visual (200 px/s → ~6 px d'efecte)
-    // El codi Pascal original sumava velocitat (0-6) al radi per donar
-    // sensació de "empenta". Ara velocitat està en px/s (0-200).
-    // Basat en joc_asteroides.cpp línies 127-134
-    //
-    // [NUEVO] Convertir suma de velocitat_visual a escala multiplicativa
-    // Radio base del ship = 12 px
-    // velocitat_visual = 0-6 → r = 12-18 → escala = 1.0-1.5
-    float velocitat_visual = velocitat_ / 33.33F;
-    float escala = 1.0F + (velocitat_visual / 12.0F);
-
-    Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true, 1.0F, brightness_);
-}
-
-void Nau::aplicar_fisica(float delta_time) {
-    // Aplicar física de moviment
-    // Basat en joc_asteroides.cpp línies 87-113
-
-    // Calcular nova posició basada en velocitat i angle
-    // S'usa (angle - PI/2) perquè angle=0 apunta cap amunt, no cap a la dreta
-    // velocitat_ està en px/s, així que multipliquem per delta_time
-    float dy =
-        ((velocitat_ * delta_time) * std::sin(angle_ - (Constants::PI / 2.0F))) +
-        centre_.y;
-    float dx =
-        ((velocitat_ * delta_time) * std::cos(angle_ - (Constants::PI / 2.0F))) +
-        centre_.x;
-
-    // Boundary checking amb radi de la nau
-    // CORRECCIÓ: Usar límits segurs i inequalitats inclusives
-    float min_x;
-    float max_x;
-    float min_y;
-    float max_y;
-    Constants::obtenir_limits_zona_segurs(Defaults::Entities::SHIP_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
-
-    // Inequalitats inclusives (>= i <=)
-    if (dy >= min_y && dy <= max_y) {
-        centre_.y = dy;
-    }
-
-    if (dx >= min_x && dx <= max_x) {
-        centre_.x = dx;
-    }
-
-    // Fricció - desacceleració gradual (time-based)
-    if (velocitat_ > 0.1F) {
-        velocitat_ -= Defaults::Physics::FRICTION * delta_time;
-        velocitat_ = std::max(velocitat_, 0.0F);
-    }
-}
diff --git a/source/game/entities/nau.hpp b/source/game/entities/nau.hpp
deleted file mode 100644
index cc477fe..0000000
--- a/source/game/entities/nau.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// nau.hpp - Classe per a la nave del jugador
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#pragma once
-#include <SDL3/SDL.h>
-
-#include <cmath>
-#include <cstdint>
-
-#include "core/defaults.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/types.hpp"
-#include "game/constants.hpp"
-
-class Nau : public Entities::Entitat {
-    public:
-        Nau()
-            : Entitat(nullptr) {}
-        Nau(SDL_Renderer* renderer, const char* shape_file = "ship.shp");
-
-        void inicialitzar() override { inicialitzar(nullptr, false); }
-        void inicialitzar(const Punt* spawn_point, bool activar_invulnerabilitat = false);
-        void processar_input(float delta_time, uint8_t player_id);
-        void actualitzar(float delta_time) override;
-        void dibuixar() const override;
-
-        // Override: Interfície d'Entitat
-        [[nodiscard]] bool esta_actiu() const override { return !esta_tocada_; }
-
-        // Override: Interfície de col·lisió
-        [[nodiscard]] float get_collision_radius() const override {
-            return Defaults::Entities::SHIP_RADIUS;
-        }
-        [[nodiscard]] bool es_collidable() const override {
-            return !esta_tocada_ && invulnerable_timer_ <= 0.0F;
-        }
-
-        // Getters (API pública sense canvis)
-        [[nodiscard]] bool esta_viva() const { return !esta_tocada_; }
-        [[nodiscard]] bool esta_tocada() const { return esta_tocada_; }
-        [[nodiscard]] bool es_invulnerable() const { return invulnerable_timer_ > 0.0F; }
-        [[nodiscard]] Punt get_velocitat_vector() const {
-            return {
-                .x = velocitat_ * std::cos(angle_ - (Constants::PI / 2.0F)),
-                .y = velocitat_ * std::sin(angle_ - (Constants::PI / 2.0F))};
-        }
-
-        // Setters
-        void set_centre(const Punt& nou_centre) { centre_ = nou_centre; }
-
-        // Col·lisions (Fase 10)
-        void marcar_tocada() { esta_tocada_ = true; }
-
-    private:
-        // Membres específics de Nau (heretats: renderer_, forma_, centre_, angle_, brightness_)
-        float velocitat_;  // Velocitat (px/s)
-        bool esta_tocada_;
-        float invulnerable_timer_;  // 0.0f = vulnerable, >0.0f = invulnerable
-
-        void aplicar_fisica(float delta_time);
-};
diff --git a/source/game/entities/ship.cpp b/source/game/entities/ship.cpp
new file mode 100644
index 0000000..087e1ef
--- /dev/null
+++ b/source/game/entities/ship.cpp
@@ -0,0 +1,165 @@
+// ship.cpp - Implementación de la nave del player
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#include "game/entities/ship.hpp"
+
+#include <SDL3/SDL.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <iostream>
+
+#include "core/defaults.hpp"
+#include "core/entities/entity.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/input/input.hpp"
+#include "core/input/input_types.hpp"
+#include "core/rendering/shape_renderer.hpp"
+#include "core/types.hpp"
+#include "game/constants.hpp"
+
+Ship::Ship(Rendering::Renderer* renderer, const char* shape_file)
+    : Entity(renderer),
+      is_hit_(false),
+      invulnerable_timer_(0.0F) {
+    // Brightness específico para naves
+    brightness_ = Defaults::Brightness::NAU;
+
+    // Configuración del cuerpo físico
+    body_.setMass(10.0F);                                       // Masa de referencia para choques
+    body_.radius = Defaults::Entities::SHIP_RADIUS;             // Radio de colisión
+    body_.restitution = 0.6F;                                   // Rebote moderado contra paredes
+    body_.linear_damping = 1.5F;                                // Fricción exponencial (s⁻¹)
+    body_.angular_damping = 0.0F;                               // La rotación es 100% por input, no inercial
+
+    // Cargar shape compartida desde archivo
+    shape_ = Graphics::ShapeLoader::load(shape_file);
+    if (!shape_ || !shape_->isValid()) {
+        std::cerr << "[Ship] Error: no se ha podido cargar " << shape_file << '\n';
+    }
+}
+
+void Ship::init(const Vec2* spawn_point, bool activar_invulnerabilitat) {
+    // Posición inicial
+    if (spawn_point != nullptr) {
+        center_ = *spawn_point;
+    } else {
+        float centre_x;
+        float centre_y;
+        Constants::obtenir_centre_zona(centre_x, centre_y);
+        center_ = {.x = centre_x, .y = centre_y};
+    }
+
+    // Reset orientación
+    angle_ = 0.0F;
+
+    // Sincronizar cuerpo físico con la posición/orientación inicial
+    body_.position = center_;
+    body_.angle = angle_;
+    body_.velocity = Vec2{};
+    body_.angular_velocity = 0.0F;
+    body_.clearAccumulators();
+
+    // Activar invulnerabilidad solo si es respawn
+    invulnerable_timer_ = activar_invulnerabilitat ? Defaults::Ship::INVULNERABILITY_DURATION : 0.0F;
+    is_hit_ = false;
+}
+
+void Ship::processInput(float delta_time, uint8_t player_id) {
+    // Solo procesa input si la nave está viva
+    if (is_hit_) {
+        return;
+    }
+
+    auto* input = Input::get();
+
+    // Rotación: control directo del ángulo (no física, no inercial).
+    // Se actualiza también body_.angle para que el dibujado tras
+    // postUpdate refleje el cambio inmediatamente.
+    const bool ROTATE_RIGHT = (player_id == 0)
+        ? input->checkActionPlayer1(InputAction::RIGHT, Input::ALLOW_REPEAT)
+        : input->checkActionPlayer2(InputAction::RIGHT, Input::ALLOW_REPEAT);
+    const bool ROTATE_LEFT = (player_id == 0)
+        ? input->checkActionPlayer1(InputAction::LEFT, Input::ALLOW_REPEAT)
+        : input->checkActionPlayer2(InputAction::LEFT, Input::ALLOW_REPEAT);
+    const bool THRUST = (player_id == 0)
+        ? input->checkActionPlayer1(InputAction::THRUST, Input::ALLOW_REPEAT)
+        : input->checkActionPlayer2(InputAction::THRUST, Input::ALLOW_REPEAT);
+
+    if (ROTATE_RIGHT) {
+        body_.angle += Defaults::Physics::ROTATION_SPEED * delta_time;
+    }
+    if (ROTATE_LEFT) {
+        body_.angle -= Defaults::Physics::ROTATION_SPEED * delta_time;
+    }
+
+    // Thrust: fuerza vectorial en la dirección de la nariz.
+    // angle - PI/2 porque angle=0 apunta hacia arriba (eje Y negativo SDL).
+    if (THRUST) {
+        const float DIR_X = std::cos(body_.angle - (Constants::PI / 2.0F));
+        const float DIR_Y = std::sin(body_.angle - (Constants::PI / 2.0F));
+        // Fuerza = masa * aceleración: 10 kg * 400 px/s² = 4000 (unidades arcade)
+        const float MAGNITUDE = body_.mass * Defaults::Physics::ACCELERATION;
+        body_.applyForce(Vec2{.x = DIR_X * MAGNITUDE, .y = DIR_Y * MAGNITUDE});
+    }
+}
+
+void Ship::update(float delta_time) {
+    // Solo update si la nave está viva
+    if (is_hit_) {
+        return;
+    }
+
+    // Decrementar timer de invulnerabilidad
+    if (invulnerable_timer_ > 0.0F) {
+        invulnerable_timer_ -= delta_time;
+        invulnerable_timer_ = std::max(invulnerable_timer_, 0.0F);
+    }
+
+    // El movimiento real lo hace PhysicsWorld::update().
+    // Aquí solo lógica de estado.
+
+    // Cap de velocidad: el thrust acumula fuerza sin límite; limitamos
+    // la magnitud de body_.velocity tras aplicar fuerzas para preservar
+    // el feel arcade del MAX_VELOCITY original.
+    const float CURRENT_SPEED = body_.velocity.length();
+    if (CURRENT_SPEED > Defaults::Physics::MAX_VELOCITY) {
+        body_.velocity = body_.velocity * (Defaults::Physics::MAX_VELOCITY / CURRENT_SPEED);
+    }
+}
+
+void Ship::postUpdate(float /*delta_time*/) {
+    // Sincronizar mirror desde body_ tras la integración del world.
+    center_ = body_.position;
+    angle_ = body_.angle;
+}
+
+void Ship::draw() const {
+    if (is_hit_) {
+        return;
+    }
+
+    // Parpadeo si invulnerable
+    if (isInvulnerable()) {
+        const float BLINK_CYCLE = Defaults::Ship::BLINK_VISIBLE_TIME + Defaults::Ship::BLINK_INVISIBLE_TIME;
+        const float TIME_IN_CYCLE = std::fmod(invulnerable_timer_, BLINK_CYCLE);
+        if (TIME_IN_CYCLE < Defaults::Ship::BLINK_INVISIBLE_TIME) {
+            return;
+        }
+    }
+
+    if (!shape_) {
+        return;
+    }
+
+    // Efecto visual de empuje: escala proporcional a la velocidad.
+    // 0..200 px/s → escala 1.0..1.5 (manteniendo la sensación del Pascal original).
+    const float SPEED = getSpeed();
+    const float VISUAL_PUSH = SPEED / 33.33F;
+    const float SCALE = 1.0F + (VISUAL_PUSH / 12.0F);
+
+    Rendering::render_shape(renderer_, shape_, center_, angle_, SCALE, 1.0F, brightness_,
+                            /*rotation_3d=*/nullptr, Defaults::Palette::SHIP);
+}
diff --git a/source/game/entities/ship.hpp b/source/game/entities/ship.hpp
new file mode 100644
index 0000000..8dc8448
--- /dev/null
+++ b/source/game/entities/ship.hpp
@@ -0,0 +1,63 @@
+// ship.hpp - Clase para la nave del player
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#pragma once
+#include <SDL3/SDL.h>
+
+#include <cstdint>
+
+#include "core/defaults.hpp"
+#include "core/entities/entity.hpp"
+#include "core/types.hpp"
+
+class Ship : public Entities::Entity {
+    public:
+        Ship()
+            : Entity(nullptr) {}
+        Ship(Rendering::Renderer* renderer, const char* shape_file = "ship.shp");
+
+        void init() override { init(nullptr, false); }
+        void init(const Vec2* spawn_point, bool activar_invulnerabilitat = false);
+        void processInput(float delta_time, uint8_t player_id);
+        void update(float delta_time) override;
+        void postUpdate(float delta_time) override;
+        void draw() const override;
+
+        // Override: Interfaz de Entity
+        [[nodiscard]] auto isActive() const -> bool override { return !is_hit_; }
+
+        // Override: Interfaz de colisión
+        [[nodiscard]] auto getCollisionRadius() const -> float override {
+            return Defaults::Entities::SHIP_RADIUS;
+        }
+        [[nodiscard]] auto isCollidable() const -> bool override {
+            return !is_hit_ && invulnerable_timer_ <= 0.0F;
+        }
+
+        // Getters (API pública sin cambios)
+        [[nodiscard]] auto isAlive() const -> bool { return !is_hit_; }
+        [[nodiscard]] auto isHit() const -> bool { return is_hit_; }
+        [[nodiscard]] auto isInvulnerable() const -> bool { return invulnerable_timer_ > 0.0F; }
+        // Velocidad como vector cartesiano (ahora viene directa del body_).
+        [[nodiscard]] auto getVelocityVector() const -> Vec2 { return body_.velocity; }
+        // Velocidad escalar (utilidad para draw y debugging).
+        [[nodiscard]] auto getSpeed() const -> float { return body_.velocity.length(); }
+
+        // Setters
+        void setCenter(const Vec2& nou_centre) {
+            center_ = nou_centre;
+            body_.position = nou_centre;
+        }
+
+        // Colisiones
+        void markHit() {
+            is_hit_ = true;
+            body_.velocity = Vec2{};  // Detener al morir
+        }
+
+    private:
+        // Miembros específicos de Ship (heredados: renderer_, shape_, center_, angle_, brightness_, body_)
+        bool is_hit_;
+        float invulnerable_timer_;  // 0.0f = vulnerable, >0.0f = invulnerable
+};
diff --git a/source/game/escenes/escena_joc.cpp b/source/game/escenes/escena_joc.cpp
deleted file mode 100644
index be6d3a3..0000000
--- a/source/game/escenes/escena_joc.cpp
+++ /dev/null
@@ -1,1400 +0,0 @@
-// escena_joc.cpp - Implementació de la lògica del joc
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#include "escena_joc.hpp"
-
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <ctime>
-#include <iostream>
-#include <vector>
-
-#include "core/audio/audio.hpp"
-#include "core/entities/entitat.hpp"
-#include "core/input/input.hpp"
-#include "core/input/mouse.hpp"
-#include "core/math/easing.hpp"
-#include "core/physics/collision.hpp"
-#include "core/rendering/line_renderer.hpp"
-#include "core/system/context_escenes.hpp"
-#include "core/system/global_events.hpp"
-#include "game/stage_system/stage_loader.hpp"
-
-// Using declarations per simplificar el codi
-using GestorEscenes::ContextEscenes;
-using Escena = ContextEscenes::Escena;
-using Opcio = ContextEscenes::Opcio;
-
-EscenaJoc::EscenaJoc(SDLManager& sdl, ContextEscenes& context)
-    : sdl_(sdl),
-      context_(context),
-      debris_manager_(sdl.obte_renderer()),
-      gestor_puntuacio_(sdl.obte_renderer()),
-      text_(sdl.obte_renderer()),
-      init_hud_rect_sound_played_(false) {
-    // Recuperar configuració de partida des del context
-    config_partida_ = context_.get_config_partida();
-
-    // Debug output de la configuració
-    std::cout << "[EscenaJoc] Configuració de partida - P1: "
-              << (config_partida_.jugador1_actiu ? "ACTIU" : "INACTIU")
-              << ", P2: "
-              << (config_partida_.jugador2_actiu ? "ACTIU" : "INACTIU")
-              << '\n';
-
-    // Consumir opcions (preparació per MODE_DEMO futur)
-    auto opcio = context_.consumir_opcio();
-    (void)opcio;  // Suprimir warning de variable no usada
-
-    // Inicialitzar naus amb renderer (P1=ship.shp, P2=ship2.shp)
-    naus_[0] = Nau(sdl.obte_renderer(), "ship.shp");   // Jugador 1: nave estàndar
-    naus_[1] = Nau(sdl.obte_renderer(), "ship2.shp");  // Jugador 2: interceptor amb ales
-
-    // Inicialitzar bales amb renderer
-    for (auto& bala : bales_) {
-        bala = Bala(sdl.obte_renderer());
-    }
-
-    // Inicialitzar enemics amb renderer
-    for (auto& enemy : orni_) {
-        enemy = Enemic(sdl.obte_renderer());
-    }
-}
-
-void EscenaJoc::executar() {
-    std::cout << "Escena Joc: Inicialitzant...\n";
-
-    // Inicialitzar estat del joc
-    inicialitzar();
-
-    SDL_Event event;
-    Uint64 last_time = SDL_GetTicks();
-
-    while (GestorEscenes::actual == Escena::JOC) {
-        // Calcular delta_time real
-        Uint64 current_time = SDL_GetTicks();
-        float delta_time = (current_time - last_time) / 1000.0F;
-        last_time = current_time;
-
-        // Limitar delta_time per evitar grans salts
-        delta_time = std::min(delta_time, 0.05F);
-
-        // Actualitzar comptador de FPS
-        sdl_.updateFPS(delta_time);
-
-        // Actualitzar visibilitat del cursor (auto-ocultar)
-        Mouse::updateCursorVisibility();
-
-        // Actualitzar sistema d'input ABANS del event loop
-        Input::get()->update();
-
-        // Processar events SDL
-        while (SDL_PollEvent(&event)) {
-            // Manejo de finestra
-            if (sdl_.handleWindowEvent(event)) {
-                continue;
-            }
-
-            // Events globals (F1/F2/F3/ESC/QUIT)
-            GlobalEvents::handle(event, sdl_, context_);
-        }
-
-        // Actualitzar física del joc amb delta_time real
-        actualitzar(delta_time);
-
-        // Actualitzar sistema d'audio
-        Audio::update();
-
-        // Actualitzar colors oscil·lats
-        sdl_.updateColors(delta_time);
-
-        // Netejar pantalla (usa color oscil·lat)
-        sdl_.neteja(0, 0, 0);
-
-        // Actualitzar context de renderitzat (factor d'escala global)
-        sdl_.updateRenderingContext();
-
-        // Dibuixar joc
-        dibuixar();
-
-        // Presentar renderer (swap buffers)
-        sdl_.presenta();
-    }
-
-    std::cout << "Escena Joc: Finalitzant...\n";
-}
-
-void EscenaJoc::inicialitzar() {
-    // Inicialitzar generador de números aleatoris
-    // Basat en el codi Pascal original: line 376
-    std::srand(static_cast<unsigned>(std::time(nullptr)));
-
-    // [NEW] Load stage configuration (only once)
-    if (!stage_config_) {
-        stage_config_ = StageSystem::StageLoader::carregar("data/stages/stages.yaml");
-        if (!stage_config_) {
-            std::cerr << "[EscenaJoc] Error: no s'ha pogut carregar stages.yaml" << '\n';
-            // Continue without stage system (will crash, but helps debugging)
-        }
-    }
-
-    // [NEW] Initialize stage manager
-    stage_manager_ = std::make_unique<StageSystem::StageManager>(stage_config_.get());
-    stage_manager_->inicialitzar();
-
-    // [NEW] Set ship position reference for safe spawn (P1 for now, TODO: dual tracking)
-    stage_manager_->get_spawn_controller().set_ship_position(&naus_[0].get_centre());
-
-    // Inicialitzar timers de muerte per jugador
-    itocado_per_jugador_[0] = 0.0F;
-    itocado_per_jugador_[1] = 0.0F;
-
-    // Initialize lives and game over state (independent lives per player)
-    vides_per_jugador_[0] = Defaults::Game::STARTING_LIVES;
-    vides_per_jugador_[1] = Defaults::Game::STARTING_LIVES;
-    estat_game_over_ = EstatGameOver::NONE;
-    continue_counter_ = 0;
-    continue_tick_timer_ = 0.0F;
-    continues_usados_ = 0;
-    game_over_timer_ = 0.0F;
-
-    // Initialize scores (separate per player)
-    puntuacio_per_jugador_[0] = 0;
-    puntuacio_per_jugador_[1] = 0;
-    gestor_puntuacio_.reiniciar();
-
-    // DEPRECATED: punt_spawn_ ja no s'usa, es calcula dinàmicament amb obtenir_punt_spawn(player_id)
-    // const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
-    // punt_spawn_.x = zona.x + zona.w * 0.5f;
-    // punt_spawn_.y = zona.y + zona.h * Defaults::Game::INIT_HUD_SHIP_START_Y_RATIO;
-
-    // Inicialitzar naus segons configuració (només jugadors actius)
-    for (uint8_t i = 0; i < 2; i++) {
-        bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-
-        if (jugador_actiu) {
-            // Jugador actiu: inicialitzar normalment
-            Punt spawn_pos = obtenir_punt_spawn(i);
-            naus_[i].inicialitzar(&spawn_pos, false);  // No invulnerability at start
-            std::cout << "[EscenaJoc] Jugador " << (i + 1) << " inicialitzat\n";
-        } else {
-            // Jugador inactiu: marcar com a mort permanent
-            naus_[i].marcar_tocada();
-            itocado_per_jugador_[i] = 999.0F;  // Valor sentinella (permanent inactiu)
-            vides_per_jugador_[i] = 0;         // Sense vides
-            std::cout << "[EscenaJoc] Jugador " << (i + 1) << " inactiu\n";
-        }
-    }
-
-    // [MODIFIED] Initialize enemies as inactive (stage system will spawn them)
-    for (auto& enemy : orni_) {
-        enemy = Enemic(sdl_.obte_renderer());
-        enemy.set_ship_position(&naus_[0].get_centre());  // Set ship reference (P1 for now)
-        // DON'T call enemy.inicialitzar() here - stage system handles spawning
-    }
-
-    // Inicialitzar bales (now 6 instead of 3)
-    for (auto& bala : bales_) {
-        bala.inicialitzar();
-    }
-
-    // [ELIMINAT] Iniciar música de joc (ara es gestiona en stage_manager)
-    // La música s'inicia quan es transiciona de INIT_HUD a LEVEL_START
-    // Audio::get()->playMusic("game.ogg");
-
-    // Reset flag de sons d'animació
-    init_hud_rect_sound_played_ = false;
-}
-
-void EscenaJoc::actualitzar(float delta_time) {
-    // Processar disparos (state-based, no event-based)
-    if (estat_game_over_ == EstatGameOver::NONE) {
-        auto* input = Input::get();
-
-        // Jugador 1 dispara (només si està actiu)
-        if (config_partida_.jugador1_actiu) {
-            if (input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
-                disparar_bala(0);
-            }
-        }
-
-        // Jugador 2 dispara (només si està actiu)
-        if (config_partida_.jugador2_actiu) {
-            if (input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
-                disparar_bala(1);
-            }
-        }
-
-        // [FIXED] Allow mid-game join: inactive or dead player presses START
-        // Only during PLAYING state (not INIT_HUD, CONTINUE, GAME_OVER)
-        if (stage_manager_->get_estat() == StageSystem::EstatStage::PLAYING) {
-            // Check if at least one player is alive and playing (game in progress)
-            bool algun_jugador_viu = false;
-            if (config_partida_.jugador1_actiu && itocado_per_jugador_[0] != 999.0F) {
-                algun_jugador_viu = true;
-            }
-            if (config_partida_.jugador2_actiu && itocado_per_jugador_[1] != 999.0F) {
-                algun_jugador_viu = true;
-            }
-
-            // Only allow join if there's an active game
-            if (algun_jugador_viu) {
-                // P2 can join if not currently playing (never joined OR dead without lives)
-                bool p2_no_juga = !config_partida_.jugador2_actiu ||  // Never joined
-                    itocado_per_jugador_[1] == 999.0F;                // Dead without lives
-
-                if (p2_no_juga) {
-                    if (input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)) {
-                        unir_jugador(1);
-                    }
-                }
-
-                // P1 can join if not currently playing (never joined OR dead without lives)
-                bool p1_no_juga = !config_partida_.jugador1_actiu ||  // Never joined
-                    itocado_per_jugador_[0] == 999.0F;                // Dead without lives
-
-                if (p1_no_juga) {
-                    if (input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)) {
-                        unir_jugador(0);
-                    }
-                }
-            }
-        }
-    }
-
-    // Handle CONTINUE screen
-    if (estat_game_over_ == EstatGameOver::CONTINUE) {
-        actualitzar_continue(delta_time);
-        processar_input_continue();
-
-        // Still update enemies, bullets, and effects during continue screen
-        for (auto& enemy : orni_) {
-            enemy.actualitzar(delta_time);
-        }
-        for (auto& bala : bales_) {
-            bala.actualitzar(delta_time);
-        }
-        debris_manager_.actualitzar(delta_time);
-        gestor_puntuacio_.actualitzar(delta_time);
-        return;
-    }
-
-    // Handle final GAME OVER state
-    if (estat_game_over_ == EstatGameOver::GAME_OVER) {
-        // Game over: only update timer, enemies, bullets, and debris
-        game_over_timer_ -= delta_time;
-
-        if (game_over_timer_ <= 0.0F) {
-            // Aturar música de joc abans de tornar al títol
-            Audio::get()->stopMusic();
-            // Transició a pantalla de títol
-            context_.canviar_escena(Escena::TITOL);
-            GestorEscenes::actual = Escena::TITOL;
-            return;
-        }
-
-        // Enemies and bullets continue moving during game over
-        for (auto& enemy : orni_) {
-            enemy.actualitzar(delta_time);
-        }
-
-        for (auto& bala : bales_) {
-            bala.actualitzar(delta_time);
-        }
-
-        debris_manager_.actualitzar(delta_time);
-        gestor_puntuacio_.actualitzar(delta_time);
-        return;
-    }
-
-    // Check death sequence state for BOTH players
-    bool algun_jugador_mort = false;
-    for (uint8_t i = 0; i < 2; i++) {
-        if (itocado_per_jugador_[i] > 0.0F && itocado_per_jugador_[i] < 999.0F) {
-            algun_jugador_mort = true;
-            // Death sequence active: update timer
-            itocado_per_jugador_[i] += delta_time;
-
-            // Check if death duration completed (only trigger ONCE using sentinel value)
-            if (itocado_per_jugador_[i] >= Defaults::Game::DEATH_DURATION) {
-                // *** PHASE 3: RESPAWN OR GAME OVER ***
-
-                // Decrement lives for this player (only once)
-                vides_per_jugador_[i]--;
-
-                if (vides_per_jugador_[i] > 0) {
-                    // Respawn ship en spawn position con invulnerabilidad
-                    Punt spawn_pos = obtenir_punt_spawn(i);
-                    naus_[i].inicialitzar(&spawn_pos, true);
-                    itocado_per_jugador_[i] = 0.0F;
-                } else {
-                    // Player is permanently dead (out of lives)
-                    // Set sentinel value to prevent re-entering this block
-                    itocado_per_jugador_[i] = 999.0F;
-
-                    // Check if ALL ACTIVE players are dead (trigger continue screen)
-                    bool p1_dead = !config_partida_.jugador1_actiu || vides_per_jugador_[0] <= 0;
-                    bool p2_dead = !config_partida_.jugador2_actiu || vides_per_jugador_[1] <= 0;
-
-                    if (p1_dead && p2_dead) {
-                        estat_game_over_ = EstatGameOver::CONTINUE;
-                        continue_counter_ = Defaults::Game::CONTINUE_COUNT_START;
-                        continue_tick_timer_ = Defaults::Game::CONTINUE_TICK_DURATION;
-                    }
-                }
-            }
-        }
-    }
-
-    // If any player is dead, still update enemies/bullets/effects
-    if (algun_jugador_mort) {
-        // Enemies and bullets continue moving during death sequence
-        for (auto& enemy : orni_) {
-            enemy.actualitzar(delta_time);
-        }
-
-        for (auto& bala : bales_) {
-            bala.actualitzar(delta_time);
-        }
-
-        debris_manager_.actualitzar(delta_time);
-        gestor_puntuacio_.actualitzar(delta_time);
-
-        // Don't return - allow alive players to continue playing
-    }
-
-    // *** STAGE SYSTEM STATE MACHINE ***
-
-    StageSystem::EstatStage estat = stage_manager_->get_estat();
-
-    switch (estat) {
-        case StageSystem::EstatStage::INIT_HUD: {
-            // Update stage manager timer (pot canviar l'estat!)
-            stage_manager_->actualitzar(delta_time);
-
-            // [FIX] Si l'estat ha canviat durant actualitzar(), sortir immediatament
-            // per evitar recalcular la posició de la nau amb el nou timer
-            if (stage_manager_->get_estat() != StageSystem::EstatStage::INIT_HUD) {
-                break;
-            }
-
-            // Calcular global progress (0.0 al inicio → 1.0 al final)
-            float global_progress = 1.0F - (stage_manager_->get_timer_transicio() / Defaults::Game::INIT_HUD_DURATION);
-            global_progress = std::min(1.0F, global_progress);
-
-            // [NEW] Calcular progress independiente para cada nave
-            float ship1_progress = calcular_progress_rango(
-                global_progress,
-                Defaults::Game::INIT_HUD_SHIP1_RATIO_INIT,
-                Defaults::Game::INIT_HUD_SHIP1_RATIO_END);
-
-            float ship2_progress = calcular_progress_rango(
-                global_progress,
-                Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
-                Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
-
-            // [MODIFICAT] Animar AMBAS naus con sus progress respectivos
-            if (config_partida_.jugador1_actiu && ship1_progress < 1.0F) {
-                Punt pos_p1 = calcular_posicio_nau_init_hud(ship1_progress, 0);
-                naus_[0].set_centre(pos_p1);
-            }
-
-            if (config_partida_.jugador2_actiu && ship2_progress < 1.0F) {
-                Punt pos_p2 = calcular_posicio_nau_init_hud(ship2_progress, 1);
-                naus_[1].set_centre(pos_p2);
-            }
-
-            // Una vegada l'animació acaba, permetre control normal
-            // però mantenir la posició inicial especial fins LEVEL_START
-
-            break;
-        }
-
-        case StageSystem::EstatStage::LEVEL_START: {
-            // [DEBUG] Log entrada a LEVEL_START
-            static bool first_entry = true;
-            if (first_entry) {
-                std::cout << "[LEVEL_START] ENTERED with P1 pos.y=" << naus_[0].get_centre().y << '\n';
-                first_entry = false;
-            }
-
-            // Update countdown timer
-            stage_manager_->actualitzar(delta_time);
-
-            // [NEW] Allow both ships movement and shooting during intro
-            for (uint8_t i = 0; i < 2; i++) {
-                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {  // Only active, alive players
-                    naus_[i].processar_input(delta_time, i);
-                    naus_[i].actualitzar(delta_time);
-                }
-            }
-
-            // [NEW] Update bullets
-            for (auto& bala : bales_) {
-                bala.actualitzar(delta_time);
-            }
-
-            // [NEW] Update debris
-            debris_manager_.actualitzar(delta_time);
-            break;
-        }
-
-        case StageSystem::EstatStage::PLAYING: {
-            // [NEW] Update stage manager (spawns enemies, pause if BOTH dead)
-            bool pausar_spawn = (itocado_per_jugador_[0] > 0.0F && itocado_per_jugador_[1] > 0.0F);
-            stage_manager_->get_spawn_controller().actualitzar(delta_time, orni_, pausar_spawn);
-
-            // [NEW] Check stage completion (only when at least one player alive)
-            bool algun_jugador_viu = (itocado_per_jugador_[0] == 0.0F || itocado_per_jugador_[1] == 0.0F);
-            if (algun_jugador_viu) {
-                auto& spawn_ctrl = stage_manager_->get_spawn_controller();
-                if (spawn_ctrl.tots_enemics_destruits(orni_)) {
-                    stage_manager_->stage_completat();
-                    Audio::get()->playSound(Defaults::Sound::GOOD_JOB_COMMANDER, Audio::Group::GAME);
-                    break;
-                }
-            }
-
-            // [EXISTING] Normal gameplay - update active players
-            for (uint8_t i = 0; i < 2; i++) {
-                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {  // Only active, alive players
-                    naus_[i].processar_input(delta_time, i);
-                    naus_[i].actualitzar(delta_time);
-                }
-            }
-
-            for (auto& enemy : orni_) {
-                enemy.actualitzar(delta_time);
-            }
-
-            for (auto& bala : bales_) {
-                bala.actualitzar(delta_time);
-            }
-
-            detectar_col·lisions_bales_enemics();
-            detectar_col·lisio_naus_enemics();
-            detectar_col·lisions_bales_jugadors();
-            debris_manager_.actualitzar(delta_time);
-            gestor_puntuacio_.actualitzar(delta_time);
-            break;
-        }
-
-        case StageSystem::EstatStage::LEVEL_COMPLETED:
-            // Update countdown timer
-            stage_manager_->actualitzar(delta_time);
-
-            // [NEW] Allow both ships movement and shooting during outro
-            for (uint8_t i = 0; i < 2; i++) {
-                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {  // Only active, alive players
-                    naus_[i].processar_input(delta_time, i);
-                    naus_[i].actualitzar(delta_time);
-                }
-            }
-
-            // [NEW] Update bullets (allow last shots to continue)
-            for (auto& bala : bales_) {
-                bala.actualitzar(delta_time);
-            }
-
-            // [NEW] Update debris (from last destroyed enemies)
-            debris_manager_.actualitzar(delta_time);
-            gestor_puntuacio_.actualitzar(delta_time);
-            break;
-    }
-}
-
-void EscenaJoc::dibuixar() {
-    // Handle CONTINUE screen
-    if (estat_game_over_ == EstatGameOver::CONTINUE) {
-        // Draw game background elements first
-        dibuixar_marges();
-
-        for (const auto& enemy : orni_) {
-            enemy.dibuixar();
-        }
-
-        for (const auto& bala : bales_) {
-            bala.dibuixar();
-        }
-
-        debris_manager_.dibuixar();
-        gestor_puntuacio_.dibuixar();
-        dibuixar_marcador();
-
-        // Draw CONTINUE screen overlay
-        dibuixar_continue();
-        return;
-    }
-
-    // Handle final GAME OVER state
-    if (estat_game_over_ == EstatGameOver::GAME_OVER) {
-        // Game over: draw enemies, bullets, debris, and "GAME OVER" text
-        dibuixar_marges();
-
-        for (const auto& enemy : orni_) {
-            enemy.dibuixar();
-        }
-
-        for (const auto& bala : bales_) {
-            bala.dibuixar();
-        }
-
-        debris_manager_.dibuixar();
-        gestor_puntuacio_.dibuixar();
-
-        // Draw centered "GAME OVER" text
-        const std::string game_over_text = "GAME OVER";
-        constexpr float escala = Defaults::Game::GameOverScreen::TEXT_SCALE;
-        constexpr float spacing = Defaults::Game::GameOverScreen::TEXT_SPACING;
-
-        // Calcular centre de l'àrea de joc usant constants
-        const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-        float centre_x = play_area.x + (play_area.w / 2.0F);
-        float centre_y = play_area.y + (play_area.h / 2.0F);
-
-        text_.render_centered(game_over_text, {.x = centre_x, .y = centre_y}, escala, spacing);
-
-        dibuixar_marcador();
-        return;
-    }
-
-    // [NEW] Stage state rendering
-    StageSystem::EstatStage estat = stage_manager_->get_estat();
-
-    switch (estat) {
-        case StageSystem::EstatStage::INIT_HUD: {
-            // Calcular progrés de cada animació independent
-            float timer = stage_manager_->get_timer_transicio();
-            float total_time = Defaults::Game::INIT_HUD_DURATION;
-            float global_progress = 1.0F - (timer / total_time);
-
-            // [NEW] Calcular progress independiente para cada elemento
-            float rect_progress = calcular_progress_rango(
-                global_progress,
-                Defaults::Game::INIT_HUD_RECT_RATIO_INIT,
-                Defaults::Game::INIT_HUD_RECT_RATIO_END);
-
-            float score_progress = calcular_progress_rango(
-                global_progress,
-                Defaults::Game::INIT_HUD_SCORE_RATIO_INIT,
-                Defaults::Game::INIT_HUD_SCORE_RATIO_END);
-
-            float ship1_progress = calcular_progress_rango(
-                global_progress,
-                Defaults::Game::INIT_HUD_SHIP1_RATIO_INIT,
-                Defaults::Game::INIT_HUD_SHIP1_RATIO_END);
-
-            float ship2_progress = calcular_progress_rango(
-                global_progress,
-                Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
-                Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
-
-            // Dibuixar elements animats
-            if (rect_progress > 0.0F) {
-                // [NOU] Reproduir so quan comença l'animació del rectangle
-                if (!init_hud_rect_sound_played_) {
-                    Audio::get()->playSound(Defaults::Sound::INIT_HUD, Audio::Group::GAME);
-                    init_hud_rect_sound_played_ = true;
-                }
-
-                dibuixar_marges_animat(rect_progress);
-            }
-
-            if (score_progress > 0.0F) {
-                dibuixar_marcador_animat(score_progress);
-            }
-
-            // [MODIFICAT] Dibuixar naus amb progress independent
-            if (ship1_progress > 0.0F && config_partida_.jugador1_actiu && !naus_[0].esta_tocada()) {
-                naus_[0].dibuixar();
-            }
-
-            if (ship2_progress > 0.0F && config_partida_.jugador2_actiu && !naus_[1].esta_tocada()) {
-                naus_[1].dibuixar();
-            }
-
-            break;
-        }
-
-        case StageSystem::EstatStage::LEVEL_START:
-            dibuixar_marges();
-            // [NEW] Draw both ships if active and alive
-            for (uint8_t i = 0; i < 2; i++) {
-                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {
-                    naus_[i].dibuixar();
-                }
-            }
-
-            // [NEW] Draw bullets
-            for (const auto& bala : bales_) {
-                bala.dibuixar();
-            }
-
-            // [NEW] Draw debris
-            debris_manager_.dibuixar();
-            gestor_puntuacio_.dibuixar();
-
-            // [EXISTING] Draw intro message and score
-            dibuixar_missatge_stage(stage_manager_->get_missatge_level_start());
-            dibuixar_marcador();
-            break;
-
-        case StageSystem::EstatStage::PLAYING:
-            dibuixar_marges();
-
-            // [EXISTING] Normal rendering - active ships
-            for (uint8_t i = 0; i < 2; i++) {
-                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {
-                    naus_[i].dibuixar();
-                }
-            }
-
-            for (const auto& enemy : orni_) {
-                enemy.dibuixar();
-            }
-
-            for (const auto& bala : bales_) {
-                bala.dibuixar();
-            }
-
-            debris_manager_.dibuixar();
-            gestor_puntuacio_.dibuixar();
-            dibuixar_marcador();
-            break;
-
-        case StageSystem::EstatStage::LEVEL_COMPLETED:
-            dibuixar_marges();
-            // [NEW] Draw both ships if active and alive
-            for (uint8_t i = 0; i < 2; i++) {
-                bool jugador_actiu = (i == 0) ? config_partida_.jugador1_actiu : config_partida_.jugador2_actiu;
-                if (jugador_actiu && itocado_per_jugador_[i] == 0.0F) {
-                    naus_[i].dibuixar();
-                }
-            }
-
-            // [NEW] Draw bullets (allow last shots to be visible)
-            for (const auto& bala : bales_) {
-                bala.dibuixar();
-            }
-
-            // [NEW] Draw debris (from last destroyed enemies)
-            debris_manager_.dibuixar();
-            gestor_puntuacio_.dibuixar();
-
-            // [EXISTING] Draw completion message and score
-            dibuixar_missatge_stage(StageSystem::Constants::MISSATGE_LEVEL_COMPLETED);
-            dibuixar_marcador();
-            break;
-    }
-}
-
-void EscenaJoc::tocado(uint8_t player_id) {
-    // Death sequence: 3 phases
-    // Phase 1: First call (itocado_per_jugador_[player_id] == 0) - trigger explosion
-    // Phase 2: Animation (0 < itocado_ < 3.0s) - debris animation
-    // Phase 3: Respawn or game over (itocado_ >= 3.0s) - handled in actualitzar()
-
-    if (itocado_per_jugador_[player_id] == 0.0F) {
-        // *** PHASE 1: TRIGGER DEATH ***
-
-        // Mark ship as dead (stops rendering and input)
-        naus_[player_id].marcar_tocada();
-
-        // Create ship explosion
-        const Punt& ship_pos = naus_[player_id].get_centre();
-        float ship_angle = naus_[player_id].get_angle();
-        Punt vel_nau = naus_[player_id].get_velocitat_vector();
-        // Reduir a 80% la velocitat heretada per la nau (més realista)
-        Punt vel_nau_80 = {.x = vel_nau.x * 0.8F, .y = vel_nau.y * 0.8F};
-
-        debris_manager_.explotar(
-            naus_[player_id].get_forma(),               // Ship shape (3 lines)
-            ship_pos,                                   // Center position
-            ship_angle,                                 // Ship orientation
-            1.0F,                                       // Normal scale
-            Defaults::Physics::Debris::VELOCITAT_BASE,  // 80 px/s
-            naus_[player_id].get_brightness(),          // Heredar brightness
-            vel_nau_80,                                 // Heredar 80% velocitat
-            0.0F,                                       // Nave: trayectorias rectas (sin drotacio)
-            0.0F,                                       // Sin herencia visual (rotación aleatoria)
-            Defaults::Sound::EXPLOSION2                 // Sonido alternativo para la explosión
-        );
-
-        // Start death timer (non-zero to avoid re-triggering)
-        itocado_per_jugador_[player_id] = 0.001F;
-    }
-    // Phase 2 is automatic (debris updates in actualitzar())
-    // Phase 3 is handled in actualitzar() when itocado_per_jugador_ >= DEATH_DURATION
-}
-
-void EscenaJoc::dibuixar_marges() const {
-    // Dibuixar rectangle de la zona de joc
-    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
-
-    // Coordenades dels cantons
-    int x1 = static_cast<int>(zona.x);
-    int y1 = static_cast<int>(zona.y);
-    int x2 = static_cast<int>(zona.x + zona.w);
-    int y2 = static_cast<int>(zona.y + zona.h);
-
-    // 4 línies per formar el rectangle
-    Rendering::linea(sdl_.obte_renderer(), x1, y1, x2, y1, true);  // Top
-    Rendering::linea(sdl_.obte_renderer(), x1, y2, x2, y2, true);  // Bottom
-    Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2, true);  // Left
-    Rendering::linea(sdl_.obte_renderer(), x2, y1, x2, y2, true);  // Right
-}
-
-void EscenaJoc::dibuixar_marcador() {
-    // Construir text del marcador
-    std::string text = construir_marcador();
-
-    // Paràmetres de renderització
-    const float escala = 0.85F;
-    const float spacing = 0.0F;
-
-    // Calcular centre de la zona del marcador
-    const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
-    float centre_x = scoreboard.w / 2.0F;
-    float centre_y = scoreboard.y + (scoreboard.h / 2.0F);
-
-    // Renderitzar centrat
-    text_.render_centered(text, {.x = centre_x, .y = centre_y}, escala, spacing);
-}
-
-void EscenaJoc::dibuixar_marges_animat(float progress) const {
-    // Animació seqüencial del rectangle amb efecte de "pinzell"
-    // Dos pinzells comencen al centre superior i baixen pels laterals
-
-    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
-
-    // Aplicar easing al progrés global
-    float eased_progress = Easing::ease_out_quad(progress);
-
-    // Coordenades del rectangle complet
-    int x1 = static_cast<int>(zona.x);
-    int y1 = static_cast<int>(zona.y);
-    int x2 = static_cast<int>(zona.x + zona.w);
-    int y2 = static_cast<int>(zona.y + zona.h);
-    int cx = (x1 + x2) / 2;
-
-    // Dividir en 3 fases de 33% cada una
-    constexpr float PHASE_1_END = 0.33F;
-    constexpr float PHASE_2_END = 0.66F;
-
-    // --- FASE 1: Línies horitzontals superiors (0-33%) ---
-    if (eased_progress > 0.0F) {
-        float phase1_progress = std::min(eased_progress / PHASE_1_END, 1.0F);
-
-        // Línia esquerra: creix des del centre cap a l'esquerra
-        int x1_phase1 = static_cast<int>(cx - ((cx - x1) * phase1_progress));
-        Rendering::linea(sdl_.obte_renderer(), cx, y1, x1_phase1, y1, true);
-
-        // Línia dreta: creix des del centre cap a la dreta
-        int x2_phase1 = static_cast<int>(cx + ((x2 - cx) * phase1_progress));
-        Rendering::linea(sdl_.obte_renderer(), cx, y1, x2_phase1, y1, true);
-    }
-
-    // --- FASE 2: Línies verticals laterals (33-66%) ---
-    if (eased_progress > PHASE_1_END) {
-        float phase2_progress = std::min((eased_progress - PHASE_1_END) / (PHASE_2_END - PHASE_1_END), 1.0F);
-
-        // Línia esquerra: creix des de dalt cap a baix
-        int y2_phase2 = static_cast<int>(y1 + ((y2 - y1) * phase2_progress));
-        Rendering::linea(sdl_.obte_renderer(), x1, y1, x1, y2_phase2, true);
-
-        // Línia dreta: creix des de dalt cap a baix
-        Rendering::linea(sdl_.obte_renderer(), x2, y1, x2, y2_phase2, true);
-    }
-
-    // --- FASE 3: Línies horitzontals inferiors (66-100%) ---
-    if (eased_progress > PHASE_2_END) {
-        float phase3_progress = (eased_progress - PHASE_2_END) / (1.0F - PHASE_2_END);
-
-        // Línia esquerra: creix des de l'esquerra cap al centre
-        int x_left_phase3 = static_cast<int>(x1 + ((cx - x1) * phase3_progress));
-        Rendering::linea(sdl_.obte_renderer(), x1, y2, x_left_phase3, y2, true);
-
-        // Línia dreta: creix des de la dreta cap al centre
-        int x_right_phase3 = static_cast<int>(x2 - ((x2 - cx) * phase3_progress));
-        Rendering::linea(sdl_.obte_renderer(), x2, y2, x_right_phase3, y2, true);
-    }
-}
-
-void EscenaJoc::dibuixar_marcador_animat(float progress) {
-    // Animació del marcador pujant des de baix amb easing
-
-    // Calcular progrés amb easing
-    float eased_progress = Easing::ease_out_quad(progress);
-
-    // Construir text
-    std::string text = construir_marcador();
-
-    // Paràmetres
-    const float escala = 0.85F;
-    const float spacing = 0.0F;
-
-    // Calcular centre de la zona del marcador
-    const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
-    float centre_x = scoreboard.w / 2.0F;
-    float centre_y_final = scoreboard.y + (scoreboard.h / 2.0F);
-
-    // Posició Y inicial (offscreen, sota de la pantalla)
-    auto centre_y_inicial = static_cast<float>(Defaults::Game::HEIGHT);
-
-    // Interpolació amb easing
-    float centre_y_animada = centre_y_inicial + ((centre_y_final - centre_y_inicial) * eased_progress);
-
-    // Renderitzar centrat en posició animada
-    text_.render_centered(text, {.x = centre_x, .y = centre_y_animada}, escala, spacing);
-}
-
-Punt EscenaJoc::calcular_posicio_nau_init_hud(float progress, uint8_t player_id) const {
-    // Animació de la nau pujant des de baix amb easing
-    // [MODIFICAT] Ambas naves usan ease_out_quad (desfase temporal via INIT/END)
-
-    // Aplicar easing (uniforme para ambas naves)
-    float eased_progress = Easing::ease_out_quad(progress);
-
-    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
-
-    // Calcular posició final segons jugador (reutilitza obtenir_punt_spawn)
-    Punt spawn_final = obtenir_punt_spawn(player_id);
-    float x_final = spawn_final.x;
-    float y_final = spawn_final.y;
-
-    // Y inicial: offscreen, 50px sota la zona de joc
-    float y_inicial = zona.y + zona.h + 50.0F;
-
-    // X no canvia (destí segons player_id)
-    // Y interpola amb easing
-    float y_animada = y_inicial + ((y_final - y_inicial) * eased_progress);
-
-    return {.x = x_final, .y = y_animada};
-}
-
-float EscenaJoc::calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const {
-    // Convierte global_progress (0.0→1.0) a element_progress usando ventana [INIT, END]
-    //
-    // Casos:
-    // - global_progress < INIT → 0.0 (no ha empezado)
-    // - global_progress > END → 1.0 (completado)
-    // - INIT ≤ global_progress ≤ END → interpola linealmente 0.0→1.0
-
-    // Validación de parámetros (evita división por cero)
-    if (ratio_init >= ratio_end) {
-        return (global_progress >= ratio_end) ? 1.0F : 0.0F;
-    }
-
-    if (global_progress < ratio_init) {
-        return 0.0F;
-    }
-
-    if (global_progress > ratio_end) {
-        return 1.0F;
-    }
-
-    // Normalizar rango [INIT, END] a [0.0, 1.0]
-    return (global_progress - ratio_init) / (ratio_end - ratio_init);
-}
-
-std::string EscenaJoc::construir_marcador() const {
-    // Puntuació P1 (6 dígits) - mostrar zeros si inactiu
-    std::string score_p1;
-    std::string vides_p1;
-    if (config_partida_.jugador1_actiu) {
-        score_p1 = std::to_string(puntuacio_per_jugador_[0]);
-        score_p1 = std::string(6 - std::min(6, static_cast<int>(score_p1.length())), '0') + score_p1;
-        vides_p1 = (vides_per_jugador_[0] < 10)
-            ? "0" + std::to_string(vides_per_jugador_[0])
-            : std::to_string(vides_per_jugador_[0]);
-    } else {
-        score_p1 = "000000";
-        vides_p1 = "00";
-    }
-
-    // Nivell (2 dígits)
-    uint8_t stage_num = stage_manager_->get_stage_actual();
-    std::string stage_str = (stage_num < 10) ? "0" + std::to_string(stage_num)
-                                             : std::to_string(stage_num);
-
-    // Puntuació P2 (6 dígits) - mostrar zeros si inactiu
-    std::string score_p2;
-    std::string vides_p2;
-    if (config_partida_.jugador2_actiu) {
-        score_p2 = std::to_string(puntuacio_per_jugador_[1]);
-        score_p2 = std::string(6 - std::min(6, static_cast<int>(score_p2.length())), '0') + score_p2;
-        vides_p2 = (vides_per_jugador_[1] < 10)
-            ? "0" + std::to_string(vides_per_jugador_[1])
-            : std::to_string(vides_per_jugador_[1]);
-    } else {
-        score_p2 = "000000";
-        vides_p2 = "00";
-    }
-
-    // Format: "123456 03  LEVEL 01  654321 02"
-    // Nota: dos espais entre seccions, mantenir ambdós slots sempre visibles
-    return score_p1 + " " + vides_p1 + "  LEVEL " + stage_str + "  " + score_p2 + " " + vides_p2;
-}
-
-void EscenaJoc::detectar_col·lisions_bales_enemics() {
-    // Amplificador per hitbox més generós (115%)
-    constexpr float AMPLIFIER = Defaults::Game::COLLISION_BULLET_ENEMY_AMPLIFIER;
-
-    // Velocitat d'explosió reduïda per efecte suau
-    constexpr float VELOCITAT_EXPLOSIO = 80.0F;  // px/s (en lloc de 80.0f per defecte)
-
-    // Iterar per totes les bales i enemics
-    for (auto& bala : bales_) {
-        for (auto& enemic : orni_) {
-            // Comprovar col·lisió utilitzant la interfície genèrica
-            if (Physics::check_collision(bala, enemic, AMPLIFIER)) {
-                // *** COL·LISIÓ DETECTADA ***
-
-                const Punt& pos_enemic = enemic.get_centre();
-
-                // 1. Calculate score for enemy type
-                int punts = 0;
-                switch (enemic.get_tipus()) {
-                    case TipusEnemic::PENTAGON:
-                        punts = Defaults::Enemies::Scoring::PENTAGON_SCORE;
-                        break;
-                    case TipusEnemic::QUADRAT:
-                        punts = Defaults::Enemies::Scoring::QUADRAT_SCORE;
-                        break;
-                    case TipusEnemic::MOLINILLO:
-                        punts = Defaults::Enemies::Scoring::MOLINILLO_SCORE;
-                        break;
-                }
-
-                // 2. Add score to the player who shot it
-                uint8_t owner_id = bala.get_owner_id();
-                puntuacio_per_jugador_[owner_id] += punts;
-
-                // 3. Create floating score number
-                gestor_puntuacio_.crear(punts, pos_enemic);
-
-                // 4. Destruir enemic (marca com inactiu)
-                enemic.destruir();
-
-                // 2. Crear explosió de fragments
-                Punt vel_enemic = enemic.get_velocitat_vector();
-                debris_manager_.explotar(
-                    enemic.get_forma(),       // Forma vectorial del pentàgon
-                    pos_enemic,               // Posició central
-                    0.0F,                     // Angle (enemic té rotació interna)
-                    1.0F,                     // Escala normal
-                    VELOCITAT_EXPLOSIO,       // 50 px/s (explosió suau)
-                    enemic.get_brightness(),  // Heredar brightness
-                    vel_enemic,               // Heredar velocitat
-                    enemic.get_drotacio(),    // Heredar velocitat angular (trayectorias curvas)
-                    0.0F                      // Sin herencia visual (rotación aleatoria)
-                );
-
-                // 3. Desactivar bala
-                bala.desactivar();
-
-                // 4. Eixir del bucle intern (bala només destrueix 1 enemic)
-                break;
-            }
-        }
-    }
-}
-
-void EscenaJoc::detectar_col·lisio_naus_enemics() {
-    // Amplificador per hitbox generós (80%)
-    constexpr float AMPLIFIER = Defaults::Game::COLLISION_SHIP_ENEMY_AMPLIFIER;
-
-    // Check collision for BOTH players
-    for (uint8_t i = 0; i < 2; i++) {
-        // Skip collisions if player is dead or invulnerable
-        if (itocado_per_jugador_[i] > 0.0F) {
-            continue;
-        }
-        if (!naus_[i].esta_viva()) {
-            continue;
-        }
-        if (naus_[i].es_invulnerable()) {
-            continue;
-        }
-
-        // Check collision with all active enemies
-        for (const auto& enemic : orni_) {
-            // Skip collision if enemy is invulnerable
-            if (enemic.es_invulnerable()) {
-                continue;
-            }
-
-            // Comprovar col·lisió utilitzant la interfície genèrica
-            if (Physics::check_collision(naus_[i], enemic, AMPLIFIER)) {
-                tocado(i);  // Trigger death sequence for player i
-                break;      // Only one collision per player per frame
-            }
-        }
-    }
-}
-
-void EscenaJoc::detectar_col·lisions_bales_jugadors() {
-    // Skip if friendly fire disabled
-    if (!Defaults::Game::FRIENDLY_FIRE_ENABLED) {
-        return;
-    }
-
-    // Amplificador per hitbox exacte (100%)
-    constexpr float AMPLIFIER = Defaults::Game::COLLISION_BULLET_PLAYER_AMPLIFIER;
-
-    // Check all active bullets
-    for (auto& bala : bales_) {
-        if (!bala.esta_activa()) {
-            continue;
-        }
-
-        // Skip bullets in grace period (prevents instant self-collision)
-        if (bala.get_grace_timer() > 0.0F) {
-            continue;
-        }
-
-        uint8_t bullet_owner = bala.get_owner_id();
-
-        // Check collision with BOTH players
-        for (uint8_t player_id = 0; player_id < 2; player_id++) {
-            // Skip if player is dead, invulnerable, or inactive
-            if (itocado_per_jugador_[player_id] > 0.0F) {
-                continue;
-            }
-            if (!naus_[player_id].esta_viva()) {
-                continue;
-            }
-            if (naus_[player_id].es_invulnerable()) {
-                continue;
-            }
-
-            // Skip inactive players
-            bool jugador_actiu = (player_id == 0) ? config_partida_.jugador1_actiu
-                                                  : config_partida_.jugador2_actiu;
-            if (!jugador_actiu) {
-                continue;
-            }
-
-            // Comprovar col·lisió utilitzant la interfície genèrica
-            if (Physics::check_collision(bala, naus_[player_id], AMPLIFIER)) {
-                // *** FRIENDLY FIRE HIT ***
-
-                if (bullet_owner == player_id) {
-                    // CASE 1: Self-hit (own bullet)
-                    // Player loses 1 life, no gain
-                    tocado(player_id);
-                } else {
-                    // CASE 2: Teammate hit
-                    // Victim loses 1 life
-                    tocado(player_id);
-
-                    // Attacker gains 1 life (no cap)
-                    vides_per_jugador_[bullet_owner]++;
-                }
-
-                // Play distinct sound
-                Audio::get()->playSound(Defaults::Sound::FRIENDLY_FIRE_HIT, Audio::Group::GAME);
-
-                // Deactivate bullet
-                bala.desactivar();
-
-                break;  // Bullet only hits once per frame
-            }
-        }
-    }
-}
-
-// [NEW] Stage system helper methods
-
-void EscenaJoc::dibuixar_missatge_stage(const std::string& missatge) {
-    constexpr float escala_base = 1.0F;
-    constexpr float spacing = 2.0F;
-
-    const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-    const float max_width = play_area.w * Defaults::Game::STAGE_MESSAGE_MAX_WIDTH_RATIO;
-
-    // ========== TYPEWRITER EFFECT (PARAMETRIZED) ==========
-    // Get state-specific timing configuration
-    float total_time;
-    float typing_ratio;
-
-    if (stage_manager_->get_estat() == StageSystem::EstatStage::LEVEL_START) {
-        total_time = Defaults::Game::LEVEL_START_DURATION;
-        typing_ratio = Defaults::Game::LEVEL_START_TYPING_RATIO;
-    } else {  // LEVEL_COMPLETED
-        total_time = Defaults::Game::LEVEL_COMPLETED_DURATION;
-        typing_ratio = Defaults::Game::LEVEL_COMPLETED_TYPING_RATIO;
-    }
-
-    // Calculate progress from timer (0.0 at start → 1.0 at end)
-    float remaining_time = stage_manager_->get_timer_transicio();
-    float progress = 1.0F - (remaining_time / total_time);
-
-    // Determine how many characters to show
-    size_t visible_chars;
-
-    if (typing_ratio > 0.0F && progress < typing_ratio) {
-        // Typewriter phase: show partial text
-        float typing_progress = progress / typing_ratio;  // Normalize to 0.0-1.0
-        visible_chars = static_cast<size_t>(missatge.length() * typing_progress);
-        if (visible_chars == 0 && progress > 0.0F) {
-            visible_chars = 1;  // Show at least 1 character after first frame
-        }
-    } else {
-        // Display phase: show complete text
-        // (Either after typing phase, or immediately if typing_ratio == 0.0)
-        visible_chars = missatge.length();
-    }
-
-    // Create partial message (substring for typewriter)
-    std::string partial_message = missatge.substr(0, visible_chars);
-    // ===================================================
-
-    // Calculate text width at base scale (using FULL message for position calculation)
-    float text_width_at_base = text_.get_text_width(missatge, escala_base, spacing);
-
-    // Auto-scale if text exceeds max width
-    float escala = (text_width_at_base <= max_width)
-        ? escala_base
-        : max_width / text_width_at_base;
-
-    // Recalculate dimensions with final scale (using FULL message for centering)
-    float full_text_width = text_.get_text_width(missatge, escala, spacing);
-    float text_height = text_.get_text_height(escala);
-
-    // Calculate position as if FULL text was there (for fixed position typewriter)
-    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)
-    Punt pos = {.x = x, .y = y};
-    text_.render(partial_message, pos, escala, spacing);
-}
-
-// ========================================
-// Helper methods for 2-player support
-// ========================================
-
-Punt EscenaJoc::obtenir_punt_spawn(uint8_t player_id) const {
-    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
-
-    float x_ratio;
-    if (config_partida_.es_un_jugador()) {
-        // Un sol jugador: spawn al centre (50%)
-        x_ratio = 0.5F;
-    } else {
-        // Dos jugadors: spawn a posicions separades
-        x_ratio = (player_id == 0)
-            ? Defaults::Game::P1_SPAWN_X_RATIO   // 33%
-            : Defaults::Game::P2_SPAWN_X_RATIO;  // 67%
-    }
-
-    return {
-        .x = zona.x + (zona.w * x_ratio),
-        .y = zona.y + (zona.h * Defaults::Game::SPAWN_Y_RATIO)};
-}
-
-void EscenaJoc::disparar_bala(uint8_t player_id) {
-    // Verificar que el jugador está vivo
-    if (itocado_per_jugador_[player_id] > 0.0F) {
-        return;
-    }
-    if (!naus_[player_id].esta_viva()) {
-        return;
-    }
-
-    // Calcular posición en la punta de la nave
-    const Punt& ship_centre = naus_[player_id].get_centre();
-    float ship_angle = naus_[player_id].get_angle();
-
-    constexpr float LOCAL_TIP_X = 0.0F;
-    constexpr float LOCAL_TIP_Y = -12.0F;
-    float cos_a = std::cos(ship_angle);
-    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;
-    Punt posicio_dispar = {.x = tip_x, .y = tip_y};
-
-    // Buscar primera bala inactiva en el pool del jugador
-    int start_idx = player_id * 3;  // P1=[0,1,2], P2=[3,4,5]
-    for (int i = start_idx; i < start_idx + 3; i++) {
-        if (!bales_[i].esta_activa()) {
-            bales_[i].disparar(posicio_dispar, ship_angle, player_id);
-            break;
-        }
-    }
-}
-
-// ==================== CONTINUE & JOIN SYSTEM ====================
-
-void EscenaJoc::check_and_apply_continue_timeout() {
-    if (continue_counter_ < 0) {
-        estat_game_over_ = EstatGameOver::GAME_OVER;
-        game_over_timer_ = Defaults::Game::GAME_OVER_DURATION;
-    }
-}
-
-void EscenaJoc::actualitzar_continue(float delta_time) {
-    continue_tick_timer_ -= delta_time;
-
-    if (continue_tick_timer_ <= 0.0F) {
-        continue_counter_--;
-        continue_tick_timer_ = Defaults::Game::CONTINUE_TICK_DURATION;
-
-        // Check if timeout reached (counter < 0)
-        check_and_apply_continue_timeout();
-
-        // Play sound only if still in CONTINUE state (not transitioned to GAME_OVER)
-        if (estat_game_over_ == EstatGameOver::CONTINUE) {
-            Audio::get()->playSound(Defaults::Sound::CONTINUE, Audio::Group::GAME);
-        }
-    }
-}
-
-void EscenaJoc::processar_input_continue() {
-    auto* input = Input::get();
-
-    // Check START for both players
-    bool p1_start = input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT);
-    bool p2_start = input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT);
-
-    if (p1_start || p2_start) {
-        // Check continue limit (skip if infinite continues)
-        if (!Defaults::Game::INFINITE_CONTINUES && continues_usados_ >= Defaults::Game::MAX_CONTINUES) {
-            // Max continues reached → final game over
-            estat_game_over_ = EstatGameOver::GAME_OVER;
-            game_over_timer_ = Defaults::Game::GAME_OVER_DURATION;
-            return;
-        }
-
-        // Only increment if not infinite
-        if (!Defaults::Game::INFINITE_CONTINUES) {
-            continues_usados_++;
-        }
-
-        // Determine which player(s) to revive
-        uint8_t player_to_revive = p1_start ? 0 : 1;
-
-        // Reset score and lives (KEEP level and enemies!)
-        puntuacio_per_jugador_[player_to_revive] = 0;
-        vides_per_jugador_[player_to_revive] = Defaults::Game::STARTING_LIVES;
-        itocado_per_jugador_[player_to_revive] = 0.0F;
-
-        // Activate player if not already
-        if (player_to_revive == 0) {
-            config_partida_.jugador1_actiu = true;
-        } else {
-            config_partida_.jugador2_actiu = true;
-        }
-
-        // Spawn with invulnerability
-        Punt spawn_pos = obtenir_punt_spawn(player_to_revive);
-        naus_[player_to_revive].inicialitzar(&spawn_pos, true);
-
-        // Check if other player wants to continue too
-        if (p1_start && p2_start) {
-            uint8_t other_player = 1;
-            puntuacio_per_jugador_[other_player] = 0;
-            vides_per_jugador_[other_player] = Defaults::Game::STARTING_LIVES;
-            itocado_per_jugador_[other_player] = 0.0F;
-            config_partida_.jugador2_actiu = true;
-            Punt spawn_pos2 = obtenir_punt_spawn(other_player);
-            naus_[other_player].inicialitzar(&spawn_pos2, true);
-        }
-
-        // Resume game
-        estat_game_over_ = EstatGameOver::NONE;
-        continue_counter_ = 0;
-        continue_tick_timer_ = 0.0F;
-
-        // Play continue confirmation sound
-        Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);
-
-        return;
-    }
-
-    // Check THRUST/FIRE to accelerate countdown (DO_NOT_ALLOW_REPEAT to avoid spam)
-    bool thrust_p1 = input->checkActionPlayer1(InputAction::THRUST, Input::DO_NOT_ALLOW_REPEAT);
-    bool thrust_p2 = input->checkActionPlayer2(InputAction::THRUST, Input::DO_NOT_ALLOW_REPEAT);
-    bool fire_p1 = input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT);
-    bool fire_p2 = input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT);
-
-    if (thrust_p1 || thrust_p2 || fire_p1 || fire_p2) {
-        continue_counter_--;
-
-        // Check if timeout reached (counter < 0)
-        check_and_apply_continue_timeout();
-
-        // Play sound only if still in CONTINUE state
-        if (estat_game_over_ == EstatGameOver::CONTINUE) {
-            Audio::get()->playSound(Defaults::Sound::CONTINUE, Audio::Group::GAME);
-        }
-
-        // Reset timer to prevent double-decrement
-        continue_tick_timer_ = Defaults::Game::CONTINUE_TICK_DURATION;
-    }
-}
-
-void EscenaJoc::dibuixar_continue() {
-    const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
-    constexpr float spacing = 4.0F;
-
-    // "CONTINUE" text (using constants)
-    const std::string continue_text = "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 centre_y_continue = play_area.y + (play_area.h * y_ratio_continue);
-
-    text_.render_centered(continue_text, {.x = centre_x, .y = centre_y_continue}, escala_continue, spacing);
-
-    // Countdown number (using constants)
-    const std::string counter_str = std::to_string(continue_counter_);
-    float escala_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_SCALE;
-    float y_ratio_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_Y_RATIO;
-
-    float centre_y_counter = play_area.y + (play_area.h * y_ratio_counter);
-
-    text_.render_centered(counter_str, {.x = centre_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_usados_);
-        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_.render_centered(continues_text, {.x = centre_x, .y = centre_y_info}, escala_info, spacing);
-    }
-}
-
-void EscenaJoc::unir_jugador(uint8_t player_id) {
-    // Activate player
-    if (player_id == 0) {
-        config_partida_.jugador1_actiu = true;
-    } else {
-        config_partida_.jugador2_actiu = true;
-    }
-
-    // Reset stats
-    vides_per_jugador_[player_id] = Defaults::Game::STARTING_LIVES;
-    puntuacio_per_jugador_[player_id] = 0;
-    itocado_per_jugador_[player_id] = 0.0F;
-
-    // Spawn with invulnerability
-    Punt spawn_pos = obtenir_punt_spawn(player_id);
-    naus_[player_id].inicialitzar(&spawn_pos, true);
-
-    // No visual message, just spawn (per user requirement)
-
-    std::cout << "[EscenaJoc] Jugador " << (int)(player_id + 1) << " s'ha unit a la partida!" << '\n';
-}
diff --git a/source/game/escenes/escena_joc.hpp b/source/game/escenes/escena_joc.hpp
deleted file mode 100644
index b9d6be3..0000000
--- a/source/game/escenes/escena_joc.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-// escena_joc.hpp - Lògica principal del joc
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
-
-#ifndef ESCENA_JOC_HPP
-#define ESCENA_JOC_HPP
-
-#include <array>
-#include <cstdint>
-#include <memory>
-#include <string>
-
-#include "core/graphics/vector_text.hpp"
-#include "core/rendering/sdl_manager.hpp"
-#include "core/system/context_escenes.hpp"
-#include "core/system/game_config.hpp"
-#include "core/types.hpp"
-#include "game/constants.hpp"
-#include "game/effects/debris_manager.hpp"
-#include "game/effects/gestor_puntuacio_flotant.hpp"
-#include "game/entities/bala.hpp"
-#include "game/entities/enemic.hpp"
-#include "game/entities/nau.hpp"
-#include "game/stage_system/stage_config.hpp"
-#include "game/stage_system/stage_manager.hpp"
-
-// Game over state machine
-enum class EstatGameOver {
-    NONE,      // Normal gameplay
-    CONTINUE,  // Continue countdown screen (9→0)
-    GAME_OVER  // Final game over (returning to title)
-};
-
-// Classe principal del joc (escena)
-class EscenaJoc {
-    public:
-        explicit EscenaJoc(SDLManager& sdl, GestorEscenes::ContextEscenes& context);
-        ~EscenaJoc() = default;
-
-        void executar();  // Bucle principal de l'escena
-        void inicialitzar();
-        void actualitzar(float delta_time);
-        void dibuixar();
-
-    private:
-        SDLManager& sdl_;
-        GestorEscenes::ContextEscenes& context_;
-        GameConfig::ConfigPartida config_partida_;  // Configuració de jugadors actius
-
-        // Efectes visuals
-        Effects::DebrisManager debris_manager_;
-        Effects::GestorPuntuacioFlotant gestor_puntuacio_;
-
-        // Estat del joc
-        std::array<Nau, 2> naus_;  // [0]=P1, [1]=P2
-        std::array<Enemic, Constants::MAX_ORNIS> orni_;
-        std::array<Bala, Constants::MAX_BALES * 2> bales_;  // 6 balas: P1=[0,1,2], P2=[3,4,5]
-        Poligon chatarra_cosmica_;
-        std::array<float, 2> itocado_per_jugador_;  // Death timers per player (seconds)
-
-        // Lives and game over system
-        std::array<int, 2> vides_per_jugador_;  // [0]=P1, [1]=P2
-        EstatGameOver estat_game_over_;         // Game over state machine (NONE, CONTINUE, GAME_OVER)
-        int continue_counter_;                  // Continue countdown (9→0)
-        float continue_tick_timer_;             // Timer for countdown tick (1.0s)
-        int continues_usados_;                  // Continues used this game (0-3 max)
-        float game_over_timer_;                 // Final GAME OVER timer before title screen
-        // Punt punt_spawn_;                       // DEPRECATED: usar obtenir_punt_spawn(player_id)
-        Punt punt_mort_;                            // Death position (for respawn, legacy)
-        std::array<int, 2> puntuacio_per_jugador_;  // [0]=P1, [1]=P2
-
-        // Text vectorial
-        Graphics::VectorText text_;
-
-        // [NEW] Stage system
-        std::unique_ptr<StageSystem::ConfigSistemaStages> stage_config_;
-        std::unique_ptr<StageSystem::StageManager> stage_manager_;
-
-        // Control de sons d'animació INIT_HUD
-        bool init_hud_rect_sound_played_;  // Flag para evitar repetir sonido del rectángulo
-
-        // Funcions privades
-        void tocado(uint8_t player_id);
-        void detectar_col·lisions_bales_enemics();                       // Col·lisions bala-enemic
-        void detectar_col·lisio_naus_enemics();                          // Ship-enemy collision detection (plural)
-        void detectar_col·lisions_bales_jugadors();                      // Bullet-player collision detection (friendly fire)
-        void dibuixar_marges() const;                                    // Dibuixar vores de la zona de joc
-        void dibuixar_marcador();                                        // Dibuixar marcador de puntuació
-        void disparar_bala(uint8_t player_id);                           // Shoot bullet from player
-        [[nodiscard]] Punt obtenir_punt_spawn(uint8_t player_id) const;  // Get spawn position for player
-
-        // [NEW] Continue & Join system
-        void unir_jugador(uint8_t player_id);         // Join inactive player mid-game
-        void processar_input_continue();              // Handle input during continue screen
-        void actualitzar_continue(float delta_time);  // Update continue countdown
-        void check_and_apply_continue_timeout();      // Check if continue timed out and transition to GAME_OVER
-        void dibuixar_continue();                     // Draw continue screen
-
-        // [NEW] Stage system helpers
-        void dibuixar_missatge_stage(const std::string& missatge);
-
-        // [NEW] Funcions d'animació per INIT_HUD
-        void dibuixar_marges_animat(float progress) const;                                          // Rectangle amb creixement uniforme
-        void dibuixar_marcador_animat(float progress);                                              // Marcador que puja des de baix
-        [[nodiscard]] Punt calcular_posicio_nau_init_hud(float progress, uint8_t player_id) const;  // Posició animada de la nau
-
-        // [NEW] Función helper del sistema de animación INIT_HUD
-        [[nodiscard]] float calcular_progress_rango(float global_progress, float ratio_init, float ratio_end) const;
-
-        // [NEW] Funció helper del marcador
-        [[nodiscard]] std::string construir_marcador() const;
-};
-
-#endif  // ESCENA_JOC_HPP
diff --git a/source/game/escenes/escena_logo.cpp b/source/game/escenes/escena_logo.cpp
deleted file mode 100644
index 30f7b7f..0000000
--- a/source/game/escenes/escena_logo.cpp
+++ /dev/null
@@ -1,426 +0,0 @@
-// escena_logo.cpp - Implementació de l'escena logo
-// © 2025 Port a C++20
-
-#include "escena_logo.hpp"
-
-#include <algorithm>
-#include <cfloat>
-#include <iostream>
-#include <random>
-#include <set>
-
-#include "core/audio/audio.hpp"
-#include "core/graphics/shape_loader.hpp"
-#include "core/input/input.hpp"
-#include "core/input/mouse.hpp"
-#include "core/rendering/shape_renderer.hpp"
-#include "core/system/context_escenes.hpp"
-#include "core/system/global_events.hpp"
-
-// Using declarations per simplificar el codi
-using GestorEscenes::ContextEscenes;
-using Escena = ContextEscenes::Escena;
-using Opcio = ContextEscenes::Opcio;
-
-// Helper: calcular el progrés individual d'una lletra
-// en funció del progrés global (efecte seqüencial)
-static float calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) {
-    if (num_letras == 0) {
-        return 1.0F;
-    }
-
-    // Calcular temps per lletra
-    float duration_per_letra = 1.0F / static_cast<float>(num_letras);
-    float step = threshold * duration_per_letra;
-    float start = static_cast<float>(letra_index) * step;
-    float end = start + duration_per_letra;
-
-    // Interpolar progrés
-    if (global_progress < start) {
-        return 0.0F;  // Encara no ha començat
-    }
-    if (global_progress >= end) {
-        return 1.0F;  // Completament apareguda
-    }
-    return (global_progress - start) / (end - start);
-}
-
-EscenaLogo::EscenaLogo(SDLManager& sdl, ContextEscenes& context)
-    : sdl_(sdl),
-      context_(context),
-      estat_actual_(EstatAnimacio::PRE_ANIMATION),
-      temps_estat_actual_(0.0F),
-      debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.obte_renderer())),
-      lletra_explosio_index_(0),
-      temps_des_ultima_explosio_(0.0F) {
-    std::cout << "Escena Logo: Inicialitzant...\n";
-
-    // Consumir opcions (LOGO no processa opcions actualment)
-    auto opcio = context_.consumir_opcio();
-    (void)opcio;  // Suprimir warning
-
-    so_reproduit_.fill(false);  // Inicialitzar seguiment de sons
-    inicialitzar_lletres();
-}
-
-EscenaLogo::~EscenaLogo() {
-    // Aturar tots els sons i la música
-    Audio::get()->stopAllSounds();
-    std::cout << "Escena Logo: Sons aturats\n";
-}
-
-void EscenaLogo::executar() {
-    SDL_Event event;
-    Uint64 last_time = SDL_GetTicks();
-
-    while (GestorEscenes::actual == Escena::LOGO) {
-        // Calcular delta_time real
-        Uint64 current_time = SDL_GetTicks();
-        float delta_time = (current_time - last_time) / 1000.0F;
-        last_time = current_time;
-
-        // Limitar delta_time per evitar grans salts
-        delta_time = std::min(delta_time, 0.05F);
-
-        // Actualitzar comptador de FPS
-        sdl_.updateFPS(delta_time);
-
-        // Actualitzar visibilitat del cursor (auto-ocultar)
-        Mouse::updateCursorVisibility();
-
-        // Actualitzar sistema d'input ABANS del event loop
-        Input::get()->update();
-
-        // Processar events SDL
-        while (SDL_PollEvent(&event)) {
-            // Manejo de finestra
-            if (sdl_.handleWindowEvent(event)) {
-                continue;
-            }
-
-            // Events globals (F1/F2/F3/ESC/QUIT)
-            if (GlobalEvents::handle(event, sdl_, context_)) {
-                continue;
-            }
-
-            // Processar events de l'escena (qualsevol tecla/clic salta al joc)
-            processar_events(event);
-        }
-
-        // Actualitzar lògica
-        actualitzar(delta_time);
-
-        // Actualitzar colors oscil·lats (efecte verd global)
-        sdl_.updateColors(delta_time);
-
-        // Actualitzar context de renderitzat (factor d'escala global)
-        sdl_.updateRenderingContext();
-
-        // Dibuixar
-        dibuixar();
-    }
-
-    std::cout << "Escena Logo: Finalitzant...\n";
-}
-
-void EscenaLogo::inicialitzar_lletres() {
-    using namespace Graphics;
-
-    // Llista de fitxers .shp (A repetida per a les dues A's)
-    std::vector<std::string> fitxers = {
-        "logo/letra_j.shp",
-        "logo/letra_a.shp",
-        "logo/letra_i.shp",
-        "logo/letra_l.shp",
-        "logo/letra_g.shp",
-        "logo/letra_a.shp",
-        "logo/letra_m.shp",
-        "logo/letra_e.shp",
-        "logo/letra_s.shp"};
-
-    // Pas 1: Carregar totes les formes i calcular amplades
-    float ancho_total = 0.0F;
-
-    for (const auto& fitxer : fitxers) {
-        auto forma = ShapeLoader::load(fitxer);
-        if (!forma || !forma->es_valida()) {
-            std::cerr << "[EscenaLogo] Error carregant " << fitxer << '\n';
-            continue;
-        }
-
-        // Calcular bounding box de la forma (trobar ancho)
-        float min_x = FLT_MAX;
-        float max_x = -FLT_MAX;
-
-        for (const auto& prim : forma->get_primitives()) {
-            for (const auto& punt : prim.points) {
-                min_x = std::min(min_x, punt.x);
-                max_x = std::max(max_x, punt.x);
-            }
-        }
-
-        float ancho_sin_escalar = max_x - min_x;
-
-        // IMPORTANT: Escalar ancho i offset amb ESCALA_FINAL
-        // per que les posicions finals coincideixin amb la mida real de les lletres
-        float ancho = ancho_sin_escalar * ESCALA_FINAL;
-        float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
-
-        lletres_.push_back({forma,
-            {.x = 0.0F, .y = 0.0F},  // Posició es calcularà després
-            ancho,
-            offset_centre});
-
-        ancho_total += ancho;
-    }
-
-    // Pas 2: Afegir espaiat entre lletres
-    ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
-
-    // Pas 3: Calcular posició inicial (centrat horitzontal)
-    constexpr float PANTALLA_ANCHO = 640.0F;
-    constexpr float PANTALLA_ALTO = 480.0F;
-
-    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0F;
-    float y_centre = PANTALLA_ALTO / 2.0F;
-
-    // Pas 4: Assignar posicions a cada lletra
-    float x_actual = x_inicial;
-
-    for (auto& lletra : lletres_) {
-        // Posicionar el centre de la forma (shape_centre) en pantalla
-        // Usar offset_centre en lloc de ancho/2 perquè shape_centre
-        // pot no estar exactament al mig del bounding box
-        lletra.posicio.x = x_actual + lletra.offset_centre;
-        lletra.posicio.y = y_centre;
-
-        // Avançar per a següent lletra
-        x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
-    }
-
-    std::cout << "[EscenaLogo] " << lletres_.size()
-              << " lletres carregades, ancho total: " << ancho_total << " px\n";
-}
-
-void EscenaLogo::canviar_estat(EstatAnimacio nou_estat) {
-    estat_actual_ = nou_estat;
-    temps_estat_actual_ = 0.0F;  // Reset temps
-
-    // Inicialitzar estat d'explosió
-    if (nou_estat == EstatAnimacio::EXPLOSION) {
-        lletra_explosio_index_ = 0;
-        temps_des_ultima_explosio_ = 0.0F;
-
-        // Generar ordre aleatori d'explosions
-        ordre_explosio_.clear();
-        for (size_t i = 0; i < lletres_.size(); i++) {
-            ordre_explosio_.push_back(i);
-        }
-        std::random_device rd;
-        std::mt19937 g(rd());
-        std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g);
-    } else if (nou_estat == EstatAnimacio::POST_EXPLOSION) {
-        Audio::get()->playMusic("title.ogg");
-    }
-
-    std::cout << "[EscenaLogo] Canvi a estat: " << static_cast<int>(nou_estat)
-              << "\n";
-}
-
-bool EscenaLogo::totes_lletres_completes() const {
-    // Quan global_progress = 1.0, totes les lletres tenen letra_progress = 1.0
-    return temps_estat_actual_ >= DURACIO_ZOOM;
-}
-
-void EscenaLogo::actualitzar_explosions(float delta_time) {
-    temps_des_ultima_explosio_ += delta_time;
-
-    // Comprovar si és el moment d'explotar la següent lletra
-    if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) {
-        if (lletra_explosio_index_ < lletres_.size()) {
-            // Explotar lletra actual (en ordre aleatori)
-            size_t index_actual = ordre_explosio_[lletra_explosio_index_];
-            const auto& lletra = lletres_[index_actual];
-
-            debris_manager_->explotar(
-                lletra.forma,           // Forma a explotar
-                lletra.posicio,         // Posició
-                0.0F,                   // Angle (sense rotació)
-                ESCALA_FINAL,           // Escala (lletres a escala final)
-                VELOCITAT_EXPLOSIO,     // Velocitat base
-                1.0F,                   // Brightness màxim (per defecte)
-                {.x = 0.0F, .y = 0.0F}  // Sense velocitat (per defecte)
-            );
-
-            std::cout << "[EscenaLogo] Explota lletra " << lletra_explosio_index_ << "\n";
-
-            // Passar a la següent lletra
-            lletra_explosio_index_++;
-            temps_des_ultima_explosio_ = 0.0F;
-        } else {
-            // Totes les lletres han explotat, transició a POST_EXPLOSION
-            canviar_estat(EstatAnimacio::POST_EXPLOSION);
-        }
-    }
-}
-
-void EscenaLogo::actualitzar(float delta_time) {
-    temps_estat_actual_ += delta_time;
-
-    switch (estat_actual_) {
-        case EstatAnimacio::PRE_ANIMATION:
-            if (temps_estat_actual_ >= DURACIO_PRE) {
-                canviar_estat(EstatAnimacio::ANIMATION);
-            }
-            break;
-
-        case EstatAnimacio::ANIMATION: {
-            // Reproduir so per cada lletra quan comença a aparèixer
-            float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F);
-
-            for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) {
-                if (!so_reproduit_[i]) {
-                    float letra_progress = calcular_progress_letra(
-                        i,
-                        lletres_.size(),
-                        global_progress,
-                        THRESHOLD_LETRA);
-
-                    // Reproduir so quan la lletra comença a aparèixer (progress > 0)
-                    if (letra_progress > 0.0F) {
-                        Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME);
-                        so_reproduit_[i] = true;
-                    }
-                }
-            }
-
-            if (totes_lletres_completes()) {
-                canviar_estat(EstatAnimacio::POST_ANIMATION);
-            }
-            break;
-        }
-
-        case EstatAnimacio::POST_ANIMATION:
-            if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
-                canviar_estat(EstatAnimacio::EXPLOSION);
-            }
-            break;
-
-        case EstatAnimacio::EXPLOSION:
-            actualitzar_explosions(delta_time);
-            break;
-
-        case EstatAnimacio::POST_EXPLOSION:
-            if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
-                // Transició a pantalla de títol
-                context_.canviar_escena(Escena::TITOL);
-                GestorEscenes::actual = Escena::TITOL;
-            }
-            break;
-    }
-
-    // Verificar botones de skip (SHOOT P1/P2)
-    if (checkSkipButtonPressed()) {
-        context_.canviar_escena(Escena::TITOL, Opcio::JUMP_TO_TITLE_MAIN);
-        GestorEscenes::actual = Escena::TITOL;
-    }
-
-    // Actualitzar animacions de debris
-    debris_manager_->actualitzar(delta_time);
-}
-
-void EscenaLogo::dibuixar() {
-    // Fons negre
-    sdl_.neteja(0, 0, 0);
-
-    // PRE_ANIMATION: Només pantalla negra
-    if (estat_actual_ == EstatAnimacio::PRE_ANIMATION) {
-        sdl_.presenta();
-        return;  // No renderitzar lletres
-    }
-
-    // ANIMATION o POST_ANIMATION: Dibuixar lletres amb animació
-    if (estat_actual_ == EstatAnimacio::ANIMATION ||
-        estat_actual_ == EstatAnimacio::POST_ANIMATION) {
-        float global_progress =
-            (estat_actual_ == EstatAnimacio::ANIMATION)
-            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F)
-            : 1.0F;  // POST: mantenir al 100%
-
-        const Punt ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y};
-
-        for (size_t i = 0; i < lletres_.size(); i++) {
-            const auto& lletra = lletres_[i];
-
-            float letra_progress = calcular_progress_letra(
-                i,
-                lletres_.size(),
-                global_progress,
-                THRESHOLD_LETRA);
-
-            if (letra_progress <= 0.0F) {
-                continue;
-            }
-
-            Punt pos_actual;
-            pos_actual.x =
-                ORIGEN_ZOOM.x + ((lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress);
-            pos_actual.y =
-                ORIGEN_ZOOM.y + ((lletra.posicio.y - ORIGEN_ZOOM.y) * letra_progress);
-
-            float t = letra_progress;
-            float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
-            float escala_actual =
-                ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor);
-
-            Rendering::render_shape(
-                sdl_.obte_renderer(),
-                lletra.forma,
-                pos_actual,
-                0.0F,
-                escala_actual,
-                true,
-                1.0F);
-        }
-    }
-
-    // EXPLOSION: Dibuixar només lletres que encara no han explotat
-    if (estat_actual_ == EstatAnimacio::EXPLOSION) {
-        // Crear conjunt de lletres ja explotades
-        std::set<size_t> explotades;
-        for (size_t i = 0; i < lletra_explosio_index_; i++) {
-            explotades.insert(ordre_explosio_[i]);
-        }
-
-        // Dibuixar només lletres que NO han explotat
-        for (size_t i = 0; i < lletres_.size(); i++) {
-            if (!explotades.contains(i)) {
-                const auto& lletra = lletres_[i];
-
-                Rendering::render_shape(
-                    sdl_.obte_renderer(),
-                    lletra.forma,
-                    lletra.posicio,
-                    0.0F,
-                    ESCALA_FINAL,
-                    true,
-                    1.0F);
-            }
-        }
-    }
-
-    // POST_EXPLOSION: No dibuixar lletres, només debris (a baix)
-
-    // Sempre dibuixar debris (si n'hi ha d'actius)
-    debris_manager_->dibuixar();
-
-    sdl_.presenta();
-}
-
-auto EscenaLogo::checkSkipButtonPressed() -> bool {
-    return Input::get()->checkAnyPlayerAction(ARCADE_BUTTONS);
-}
-
-void EscenaLogo::processar_events(const SDL_Event& event) {
-    // No procesar eventos genéricos aquí - la lógica se movió a actualitzar()
-}
diff --git a/source/game/options.cpp b/source/game/options.cpp
index 963835a..4a23a62 100644
--- a/source/game/options.cpp
+++ b/source/game/options.cpp
@@ -135,8 +135,8 @@ static const std::unordered_map<int, std::string> BUTTON_TO_STRING = {
     {SDL_GAMEPAD_BUTTON_DPAD_DOWN, "DPAD_DOWN"},
     {SDL_GAMEPAD_BUTTON_DPAD_LEFT, "DPAD_LEFT"},
     {SDL_GAMEPAD_BUTTON_DPAD_RIGHT, "DPAD_RIGHT"},
-    {100, "L2_AS_BUTTON"},  // Trigger L2 com a botó digital
-    {101, "R2_AS_BUTTON"}   // Trigger R2 com a botó digital
+    {100, "L2_AS_BUTTON"},  // Trigger L2 como a botó digital
+    {101, "R2_AS_BUTTON"}   // Trigger R2 como a botó digital
 };
 
 // Mapa invers: string a botó de gamepad
@@ -178,7 +178,7 @@ static auto stringToButton(const std::string& str) -> int {
 
 // ========== FI FUNCIONS AUXILIARS ==========
 
-// Inicialitzar opcions amb valors per defecte de Defaults::
+// Inicialitzar opciones con valors per defecte de Defaults::
 void init() {
 #ifdef _DEBUG
     console = true;
@@ -210,19 +210,19 @@ void init() {
     // Audio
     audio.enabled = Defaults::Audio::ENABLED;
     audio.volume = Defaults::Audio::VOLUME;
-    audio.music.enabled = Defaults::Music::ENABLED;
-    audio.music.volume = Defaults::Music::VOLUME;
-    audio.sound.enabled = Defaults::Sound::ENABLED;
-    audio.sound.volume = Defaults::Sound::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;
 
     // Version
     version = std::string(Project::VERSION);
 }
 
-// Establir la ruta del fitxer de configuració
+// Establir la ruta del file de configuración
 void setConfigFile(const std::string& path) { config_file_path = path; }
 
-// Funcions auxiliars per carregar seccions del YAML
+// Funciones auxiliars per load seccions del YAML
 
 static void loadWindowConfigFromYaml(const fkyaml::node& yaml) {
     if (yaml.contains("window")) {
@@ -372,7 +372,7 @@ static void loadRenderingConfigFromYaml(const fkyaml::node& yaml) {
         if (rend.contains("vsync")) {
             try {
                 int val = rend["vsync"].get_value<int>();
-                // Validar: només 0 o 1
+                // Validar: solo 0 o 1
                 rendering.vsync = (val == 0 || val == 1) ? val : Defaults::Rendering::VSYNC_DEFAULT;
             } catch (...) {
                 rendering.vsync = Defaults::Rendering::VSYNC_DEFAULT;
@@ -409,16 +409,16 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
                 try {
                     audio.music.enabled = mus["enabled"].get_value<bool>();
                 } catch (...) {
-                    audio.music.enabled = Defaults::Music::ENABLED;
+                    audio.music.enabled = Defaults::Audio::MUSIC_ENABLED;
                 }
             }
 
             if (mus.contains("volume")) {
                 try {
                     auto val = mus["volume"].get_value<float>();
-                    audio.music.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Music::VOLUME;
+                    audio.music.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Audio::MUSIC_VOLUME;
                 } catch (...) {
-                    audio.music.volume = Defaults::Music::VOLUME;
+                    audio.music.volume = Defaults::Audio::MUSIC_VOLUME;
                 }
             }
         }
@@ -430,23 +430,23 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
                 try {
                     audio.sound.enabled = snd["enabled"].get_value<bool>();
                 } catch (...) {
-                    audio.sound.enabled = Defaults::Sound::ENABLED;
+                    audio.sound.enabled = Defaults::Audio::SOUND_ENABLED;
                 }
             }
 
             if (snd.contains("volume")) {
                 try {
                     auto val = snd["volume"].get_value<float>();
-                    audio.sound.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Sound::VOLUME;
+                    audio.sound.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Audio::SOUND_VOLUME;
                 } catch (...) {
-                    audio.sound.volume = Defaults::Sound::VOLUME;
+                    audio.sound.volume = Defaults::Audio::SOUND_VOLUME;
                 }
             }
         }
     }
 }
 
-// Carregar controls del jugador 1 des de YAML
+// Carregar controls del player 1 desde YAML
 static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
     if (!yaml.contains("player1")) {
         return;
@@ -494,7 +494,7 @@ static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
     }
 }
 
-// Carregar controls del jugador 2 des de YAML
+// Carregar controls del player 2 desde YAML
 static void loadPlayer2ControlsFromYaml(const fkyaml::node& yaml) {
     if (!yaml.contains("player2")) {
         return;
@@ -542,22 +542,22 @@ static void loadPlayer2ControlsFromYaml(const fkyaml::node& yaml) {
     }
 }
 
-// Carregar configuració des del fitxer YAML
+// Carregar configuración des del file YAML
 auto loadFromFile() -> bool {
     const std::string CONFIG_VERSION = std::string(Project::VERSION);
 
     std::ifstream file(config_file_path);
     if (!file.good()) {
-        // El fitxer no existeix → crear-ne un de nou amb valors per defecte
+        // El file no existeix → crear-ne un de nuevo con valors per defecte
         if (console) {
-            std::cout << "Fitxer de config no trobat, creant-ne un de nou: "
+            std::cout << "Archivo de config no trobat, creant-ne un de nuevo: "
                       << config_file_path << '\n';
         }
         saveToFile();
         return true;
     }
 
-    // Llegir tot el contingut del fitxer
+    // Llegir todo el contingut del file
     std::string content((std::istreambuf_iterator<char>(file)),
         std::istreambuf_iterator<char>());
     file.close();
@@ -566,15 +566,15 @@ auto loadFromFile() -> bool {
         // Parsejar YAML
         auto yaml = fkyaml::node::deserialize(content);
 
-        // Validar versió
+        // Validar versión
         if (yaml.contains("version")) {
             version = yaml["version"].get_value<std::string>();
         }
 
         if (CONFIG_VERSION != version) {
-            // Versió incompatible → regenerar config
+            // Versión incompatible → regenerar config
             if (console) {
-                std::cout << "Versió de config incompatible (esperada: "
+                std::cout << "Versión de config incompatible (esperada: "
                           << CONFIG_VERSION << ", trobada: " << version
                           << "), regenerant config\n";
             }
@@ -593,7 +593,7 @@ auto loadFromFile() -> bool {
         loadPlayer2ControlsFromYaml(yaml);
 
         if (console) {
-            std::cout << "Config carregada correctament des de: " << config_file_path
+            std::cout << "Config carregada correctament desde: " << config_file_path
                       << '\n';
         }
 
@@ -603,7 +603,7 @@ auto loadFromFile() -> bool {
         // Error de parsejat YAML → regenerar config
         if (console) {
             std::cerr << "Error parsejant YAML: " << e.what() << '\n';
-            std::cerr << "Creant config nou amb valors per defecte\n";
+            std::cerr << "Creant config nuevo con valors per defecte\n";
         }
         init();
         saveToFile();
@@ -611,7 +611,7 @@ auto loadFromFile() -> bool {
     }
 }
 
-// Guardar controls del jugador 1 a YAML
+// Guardar controls del player 1 a YAML
 static void savePlayer1ControlsToYaml(std::ofstream& file) {
     file << "# CONTROLS JUGADOR 1\n";
     file << "player1:\n";
@@ -628,7 +628,7 @@ static void savePlayer1ControlsToYaml(std::ofstream& file) {
     file << "  gamepad_name: \"" << player1.gamepad_name << "\"   # Buit = primer disponible\n\n";
 }
 
-// Guardar controls del jugador 2 a YAML
+// Guardar controls del player 2 a YAML
 static void savePlayer2ControlsToYaml(std::ofstream& file) {
     file << "# CONTROLS JUGADOR 2\n";
     file << "player2:\n";
@@ -645,19 +645,19 @@ static void savePlayer2ControlsToYaml(std::ofstream& file) {
     file << "  gamepad_name: \"" << player2.gamepad_name << "\"   # Buit = segon disponible\n\n";
 }
 
-// Guardar configuració al fitxer YAML
+// Guardar configuración al file YAML
 auto saveToFile() -> bool {
     std::ofstream file(config_file_path);
     if (!file.is_open()) {
         if (console) {
-            std::cerr << "No s'ha pogut obrir el fitxer de config per escriure: "
+            std::cerr << "No s'ha pogut obrir el file de config per escriure: "
                       << config_file_path << '\n';
         }
         return false;
     }
 
     // Escriure manualment per controlar format i comentaris
-    file << "# Orni Attack - Fitxer de Configuració\n";
+    file << "# Orni Attack - Archivo de Configuración\n";
     file << "# Auto-generat. Les edicions manuals es preserven si són "
             "vàlides.\n\n";
 
@@ -670,7 +670,7 @@ auto saveToFile() -> bool {
     file << "  fullscreen: " << (window.fullscreen ? "true" : "false") << "\n";
     file << "  zoom_factor: " << window.zoom_factor << "   # 0.5x-max (0.1 increments)\n\n";
 
-    file << "# FÍSICA (tots els valors en px/s, rad/s, etc.)\n";
+    file << "# FÍSICA (todos los valors en px/s, rad/s, etc.)\n";
     file << "physics:\n";
     file << "  rotation_speed: " << physics.rotation_speed << "   # rad/s\n";
     file << "  acceleration: " << physics.acceleration << "     # px/s²\n";
diff --git a/source/game/options.hpp b/source/game/options.hpp
index 3d019d6..4fccd64 100644
--- a/source/game/options.hpp
+++ b/source/game/options.hpp
@@ -6,11 +6,11 @@
 
 namespace Options {
 
-// Estructures de configuració
+// Estructures de configuración
 
 struct Window {
-        int width{640};
-        int height{480};
+        int width{1280};
+        int height{720};
         bool fullscreen{false};
         float zoom_factor{1.0F};  // Zoom level (0.5x to max_zoom)
 };
@@ -75,7 +75,7 @@ struct PlayerControls {
 
 // Variables globals (inline per evitar ODR violations)
 
-inline std::string version{};  // Versió del config per validació
+inline std::string version{};  // Versión del config per validació
 inline bool console{false};    // Eixida de debug
 inline Window window{};
 inline Physics physics{};
@@ -83,7 +83,7 @@ inline Gameplay gameplay{};
 inline Rendering rendering{};
 inline Audio audio{};
 
-// Controles per jugador
+// Controles per player
 inline PlayerControls player1{
     .keyboard =
         {.key_left = SDL_SCANCODE_LEFT,
@@ -104,17 +104,17 @@ inline PlayerControls player2{
     .gamepad_name = ""  // Segon gamepad disponible
 };
 
-// Per compatibilitat amb pollo (no utilitzat en orni, però necessari per Input)
+// Per compatibilitat con pollo (no utilitzat en orni, pero necessari per Input)
 inline KeyboardControls keyboard_controls{};
 inline GamepadControls gamepad_controls{};
 
 inline std::string config_file_path{};  // Establert per setConfigFile()
 
-// Funcions públiques
+// Funciones públiques
 
-void init();  // Inicialitzar amb valors per defecte
+void init();  // Inicialitzar con valors per defecte
 void setConfigFile(
-    const std::string& path);  // Establir ruta del fitxer de config
+    const std::string& path);  // Establir ruta del file de config
 auto loadFromFile() -> bool;   // Carregar config YAML
 auto saveToFile() -> bool;     // Guardar config YAML
 
diff --git a/source/game/scenes/game_scene.cpp b/source/game/scenes/game_scene.cpp
new file mode 100644
index 0000000..e84b565
--- /dev/null
+++ b/source/game/scenes/game_scene.cpp
@@ -0,0 +1,965 @@
+// game_scene.cpp - Implementació de la lógica del juego
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#include "game_scene.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <ctime>
+#include <iostream>
+#include <vector>
+
+#include "core/audio/audio.hpp"
+#include "core/entities/entity.hpp"
+#include "core/input/input.hpp"
+#include "core/math/easing.hpp"
+#include "core/physics/collision.hpp"
+#include "core/rendering/line_renderer.hpp"
+#include "core/system/scene_context.hpp"
+#include "game/stage_system/stage_loader.hpp"
+#include "game/systems/collision_system.hpp"
+#include "game/systems/continue_system.hpp"
+#include "game/systems/init_hud_animator.hpp"
+
+// Using declarations per simplificar el codi
+using SceneManager::SceneContext;
+using SceneType = SceneContext::SceneType;
+using Option = SceneContext::Option;
+
+GameScene::GameScene(SDLManager& sdl, SceneContext& context)
+    : sdl_(sdl),
+      context_(context),
+      debris_manager_(sdl.getRenderer()),
+      floating_score_manager_(sdl.getRenderer()),
+      text_(sdl.getRenderer()),
+      init_hud_rect_sound_played_(false) {
+    // Recuperar configuración de match des del context
+    match_config_ = context_.getMatchConfig();
+
+    // Debug output de la configuración
+    std::cout << "[GameScene] Configuración de match - P1: "
+              << (match_config_.jugador1_actiu ? "ACTIU" : "INACTIU")
+              << ", P2: "
+              << (match_config_.jugador2_actiu ? "ACTIU" : "INACTIU")
+              << '\n';
+
+    // Consumir opciones (preparació per MODE_DEMO futur)
+    auto option = context_.consumeOption();
+    (void)option;  // Suprimir warning de variable no usada
+
+    // Inicialitzar naves con renderer (P1=ship.shp, P2=ship2.shp)
+    ships_[0] = Ship(sdl.getRenderer(), "ship.shp");   // Jugador 1: nave estàndar
+    ships_[1] = Ship(sdl.getRenderer(), "ship2.shp");  // Jugador 2: interceptor con ales
+
+    // Inicialitzar balas con renderer
+    for (auto& bullet : bullets_) {
+        bullet = Bullet(sdl.getRenderer());
+    }
+
+    // Inicialitzar enemigos con renderer
+    for (auto& enemy : enemies_) {
+        enemy = Enemy(sdl.getRenderer());
+    }
+
+    // El resto del estado del juego (física, stages, naves, vidas, puntuación)
+    // se inicializa en init(), que se llama al final del constructor para que
+    // la escena esté lista en cuanto el Director la haya construido.
+    init();
+}
+
+auto GameScene::isFinished() const -> bool {
+    return context_.nextScene() != SceneType::GAME;
+}
+
+void GameScene::handleEvent(const SDL_Event& event) {
+    // GameScene no procesa eventos puntuales SDL: la lógica de input se
+    // resuelve en update() consultando Input::checkAction.
+    (void)event;
+}
+
+void GameScene::init() {
+    // Inicialitzar generador de números aleatoris
+    // 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.
+    // Las entidades se registrarán cada una al inicializarse (Fase 6c-e).
+    physics_world_.clear();
+    physics_world_.setBounds(Defaults::Zones::PLAYAREA);
+
+    // [NEW] Load stage configuration (only once)
+    if (!stage_config_) {
+        stage_config_ = StageSystem::StageLoader::load("data/stages/stages.yaml");
+        if (!stage_config_) {
+            std::cerr << "[GameScene] Error: no s'ha pogut load stages.yaml" << '\n';
+            // Continue without stage system (will crash, but helps debugging)
+        }
+    }
+
+    // [NEW] Initialize stage manager
+    stage_manager_ = std::make_unique<StageSystem::StageManager>(stage_config_.get());
+    stage_manager_->init();
+
+    // [NEW] Set ship position reference for safe spawn (P1 for now, TODO: dual tracking)
+    stage_manager_->getSpawnController().setShipPosition(&ships_[0].getCenter());
+
+    // Inicialitzar timers de muerte per player
+    hit_timer_per_player_[0] = 0.0F;
+    hit_timer_per_player_[1] = 0.0F;
+
+    // Initialize lives and game over state (independent lives per player)
+    lives_per_player_[0] = Defaults::Game::STARTING_LIVES;
+    lives_per_player_[1] = Defaults::Game::STARTING_LIVES;
+    game_over_state_ = GameOverState::NONE;
+    continue_counter_ = 0;
+    continue_tick_timer_ = 0.0F;
+    continues_used_ = 0;
+    game_over_timer_ = 0.0F;
+
+    // Initialize scores (separate per player)
+    score_per_player_[0] = 0;
+    score_per_player_[1] = 0;
+    floating_score_manager_.reset();
+
+    // DEPRECATED: spawn_position_ ya no s'usa, es calcula dinàmicament con obtenir_punt_spawn(player_id)
+    // const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+    // spawn_position_.x = zona.x + zona.w * 0.5f;
+    // spawn_position_.y = zona.y + zona.h * Defaults::Game::INIT_HUD_SHIP_START_Y_RATIO;
+
+    // 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;
+
+        if (jugador_actiu) {
+            // Jugador active: init normalment
+            Vec2 spawn_pos = obtenir_punt_spawn(i);
+            ships_[i].init(&spawn_pos, false);  // No invulnerability at start
+            // Registrar el cuerpo físico de la nave en el mundo (Fase 6c)
+            physics_world_.addBody(&ships_[i].getBody());
+            std::cout << "[GameScene] Jugador " << (i + 1) << " inicialitzat\n";
+        } else {
+            // Jugador inactiu: marcar como a mort permanent
+            ships_[i].markHit();
+            hit_timer_per_player_[i] = 999.0F;  // Valor sentinella (permanent inactiu)
+            lives_per_player_[i] = 0;         // Sin vides
+            std::cout << "[GameScene] Jugador " << (i + 1) << " inactiu\n";
+        }
+    }
+
+    // [MODIFIED] Initialize enemies as inactive (stage system will spawn them).
+    // Registramos el body al world incluso inactivo: con radius=0 no colisiona
+    // ni se mueve, y al init() del stage system se activa sin re-registrar.
+    for (auto& enemy : enemies_) {
+        enemy = Enemy(sdl_.getRenderer());
+        enemy.setShipPosition(&ships_[0].getCenter());  // Set ship reference (P1 for now)
+        physics_world_.addBody(&enemy.getBody());
+        // DON'T call enemy.init() here - stage system handles spawning
+    }
+
+    // Inicialitzar balas (now 6 instead of 3).
+    // Se registran en el physics_world para integración cinemática.
+    // Como su body_.radius=0, no colisionan físicamente con nadie (las
+    // colisiones de gameplay se gestionan en detectar_col·lisions_*).
+    for (auto& bullet : bullets_) {
+        bullet.init();
+        physics_world_.addBody(&bullet.getBody());
+    }
+
+    // [ELIMINAT] Iniciar música de juego (ara es gestiona en stage_manager)
+    // La música s'inicia cuando es transiciona de INIT_HUD a LEVEL_START
+    // Audio::get()->playMusic("game.ogg");
+
+    // Reset flag de sons de animación
+    init_hud_rect_sound_played_ = false;
+}
+
+void GameScene::update(float delta_time) {
+    // Orquestador delgado: cada paso vive en su propia función para
+    // mantener update() legible y reducir complejidad cognitiva.
+    stepPhysics(delta_time);
+
+    if (game_over_state_ == GameOverState::NONE) {
+        stepShootingInput();
+        stepMidGameJoin();
+    }
+    if (stepContinueScreen(delta_time)) {
+        return;
+    }
+    if (stepGameOver(delta_time)) {
+        return;
+    }
+    stepDeathSequence(delta_time);
+    stepStageStateMachine(delta_time);
+}
+
+void GameScene::stepPhysics(float delta_time) {
+    // Las fuerzas aplicadas en el frame N-1 por processInput/AI se integran
+    // ahora; postUpdate sincroniza los mirrors (center_/angle_) antes de la
+    // lógica de juego que los lee.
+    physics_world_.update(delta_time);
+    for (auto& ship : ships_) {
+        ship.postUpdate(delta_time);
+    }
+    for (auto& enemy : enemies_) {
+        enemy.postUpdate(delta_time);
+    }
+    for (auto& bullet : bullets_) {
+        bullet.postUpdate(delta_time);
+    }
+}
+
+void GameScene::stepShootingInput() {
+    auto* input = Input::get();
+    if (match_config_.jugador1_actiu &&
+        input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
+        disparar_bala(0);
+    }
+    if (match_config_.jugador2_actiu &&
+        input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT)) {
+        disparar_bala(1);
+    }
+}
+
+void GameScene::stepMidGameJoin() {
+    // Permitir join solo durante PLAYING.
+    if (stage_manager_->get_estat() != StageSystem::EstatStage::PLAYING) {
+        return;
+    }
+
+    // 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] != 999.0F) ||
+        (match_config_.jugador2_actiu && hit_timer_per_player_[1] != 999.0F);
+    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
+                                       : match_config_.jugador2_actiu;
+        const bool MUERTO_SIN_VIDAS = hit_timer_per_player_[pid] == 999.0F;
+        if (ACTIU && !MUERTO_SIN_VIDAS) {
+            continue;  // jugador ya está jugando
+        }
+        const bool START_PRESSED = (pid == 0)
+            ? input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT)
+            : input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT);
+        if (START_PRESSED) {
+            unir_jugador(pid);
+        }
+    }
+}
+
+auto GameScene::stepContinueScreen(float delta_time) -> bool {
+    if (game_over_state_ != GameOverState::CONTINUE) {
+        return false;
+    }
+
+    Systems::ContinueScreen::Context cont_ctx{
+        .state = game_over_state_,
+        .counter = continue_counter_,
+        .tick_timer = continue_tick_timer_,
+        .continues_used = continues_used_,
+        .game_over_timer = game_over_timer_,
+        .lives_per_player = lives_per_player_,
+        .score_per_player = score_per_player_,
+        .hit_timer_per_player = hit_timer_per_player_,
+        .ships = ships_,
+        .match_config = match_config_,
+        .get_spawn_point = [this](uint8_t pid) { return obtenir_punt_spawn(pid); },
+    };
+    Systems::ContinueScreen::update(cont_ctx, delta_time);
+    Systems::ContinueScreen::processInput(cont_ctx);
+
+    // Enemies, bullets y efectos siguen moviéndose en background.
+    for (auto& enemy : enemies_) {
+        enemy.update(delta_time);
+    }
+    for (auto& bullet : bullets_) {
+        bullet.update(delta_time);
+    }
+    debris_manager_.update(delta_time);
+    floating_score_manager_.update(delta_time);
+    return true;
+}
+
+auto GameScene::stepGameOver(float delta_time) -> bool {
+    if (game_over_state_ != GameOverState::GAME_OVER) {
+        return false;
+    }
+
+    game_over_timer_ -= delta_time;
+    if (game_over_timer_ <= 0.0F) {
+        Audio::get()->stopMusic();
+        context_.setNextScene(SceneType::TITLE);
+        return true;
+    }
+
+    // Enemies, bullets y efectos siguen moviéndose como fondo.
+    for (auto& enemy : enemies_) {
+        enemy.update(delta_time);
+    }
+    for (auto& bullet : bullets_) {
+        bullet.update(delta_time);
+    }
+    debris_manager_.update(delta_time);
+    floating_score_manager_.update(delta_time);
+    return true;
+}
+
+auto GameScene::stepDeathSequence(float delta_time) -> bool {
+    bool algun_mort = false;
+    for (uint8_t i = 0; i < 2; i++) {
+        if (hit_timer_per_player_[i] <= 0.0F || hit_timer_per_player_[i] >= 999.0F) {
+            continue;
+        }
+        algun_mort = true;
+        hit_timer_per_player_[i] += delta_time;
+
+        if (hit_timer_per_player_[i] < Defaults::Game::DEATH_DURATION) {
+            continue;
+        }
+
+        // *** PHASE 3: RESPAWN OR GAME OVER ***
+        lives_per_player_[i]--;
+        if (lives_per_player_[i] > 0) {
+            Vec2 spawn_pos = obtenir_punt_spawn(i);
+            ships_[i].init(&spawn_pos, /*activar_invulnerabilitat=*/true);
+            hit_timer_per_player_[i] = 0.0F;
+            continue;
+        }
+
+        // Sin vidas: marcar definitivamente muerto y comprobar transición a CONTINUE.
+        hit_timer_per_player_[i] = 999.0F;
+        const bool P1_DEAD = !match_config_.jugador1_actiu || lives_per_player_[0] <= 0;
+        const bool P2_DEAD = !match_config_.jugador2_actiu || lives_per_player_[1] <= 0;
+        if (P1_DEAD && P2_DEAD) {
+            game_over_state_ = GameOverState::CONTINUE;
+            continue_counter_ = Defaults::Game::CONTINUE_COUNT_START;
+            continue_tick_timer_ = Defaults::Game::CONTINUE_TICK_DURATION;
+        }
+    }
+
+    // Si hay algún muerto, los enemigos/balas/efectos siguen actualizándose
+    // aunque otros jugadores aún jueguen.
+    if (algun_mort) {
+        for (auto& enemy : enemies_) {
+            enemy.update(delta_time);
+        }
+        for (auto& bullet : bullets_) {
+            bullet.update(delta_time);
+        }
+        debris_manager_.update(delta_time);
+        floating_score_manager_.update(delta_time);
+    }
+    return algun_mort;
+}
+
+void GameScene::stepStageStateMachine(float delta_time) {
+    const StageSystem::EstatStage STATE = stage_manager_->get_estat();
+    switch (STATE) {
+        case StageSystem::EstatStage::INIT_HUD:
+            runStageInitHud(delta_time);
+            break;
+        case StageSystem::EstatStage::LEVEL_START:
+            runStageLevelStart(delta_time);
+            break;
+        case StageSystem::EstatStage::PLAYING:
+            runStagePlaying(delta_time);
+            break;
+        case StageSystem::EstatStage::LEVEL_COMPLETED:
+            runStageLevelCompleted(delta_time);
+            break;
+    }
+}
+
+void GameScene::runStageInitHud(float delta_time) {
+    // Update stage manager timer (puede cambiar el state).
+    stage_manager_->update(delta_time);
+    // Si el state cambió, salir para no usar el timer del nuevo state.
+    if (stage_manager_->get_estat() != StageSystem::EstatStage::INIT_HUD) {
+        return;
+    }
+
+    float global_progress = 1.0F - (stage_manager_->get_timer_transicio() / Defaults::Game::INIT_HUD_DURATION);
+    global_progress = std::min(1.0F, global_progress);
+
+    const float SHIP1_P = Systems::InitHud::computeRangeProgress(
+        global_progress,
+        Defaults::Game::INIT_HUD_SHIP1_RATIO_INIT,
+        Defaults::Game::INIT_HUD_SHIP1_RATIO_END);
+    const float SHIP2_P = Systems::InitHud::computeRangeProgress(
+        global_progress,
+        Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
+        Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
+
+    if (match_config_.jugador1_actiu && SHIP1_P < 1.0F) {
+        ships_[0].setCenter(Systems::InitHud::computeShipPosition(SHIP1_P, obtenir_punt_spawn(0)));
+    }
+    if (match_config_.jugador2_actiu && SHIP2_P < 1.0F) {
+        ships_[1].setCenter(Systems::InitHud::computeShipPosition(SHIP2_P, obtenir_punt_spawn(1)));
+    }
+}
+
+void GameScene::runStageLevelStart(float delta_time) {
+    stage_manager_->update(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;
+        if (ACTIU && hit_timer_per_player_[i] == 0.0F) {
+            ships_[i].processInput(delta_time, i);
+            ships_[i].update(delta_time);
+        }
+    }
+    for (auto& bullet : bullets_) {
+        bullet.update(delta_time);
+    }
+    debris_manager_.update(delta_time);
+}
+
+void GameScene::runStagePlaying(float delta_time) {
+    const bool PAUSE_SPAWN = (hit_timer_per_player_[0] > 0.0F && hit_timer_per_player_[1] > 0.0F);
+    stage_manager_->getSpawnController().update(delta_time, enemies_, PAUSE_SPAWN);
+
+    // Stage completado: cuando al menos un jugador está vivo y todos los enemies muertos.
+    const bool ALGU_VIU = (hit_timer_per_player_[0] == 0.0F || hit_timer_per_player_[1] == 0.0F);
+    if (ALGU_VIU && stage_manager_->getSpawnController().tots_enemics_destruits(enemies_)) {
+        stage_manager_->stage_completat();
+        Audio::get()->playSound(Defaults::Sound::GOOD_JOB_COMMANDER, Audio::Group::GAME);
+        return;
+    }
+
+    // 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;
+        if (ACTIU && hit_timer_per_player_[i] == 0.0F) {
+            ships_[i].processInput(delta_time, i);
+            ships_[i].update(delta_time);
+        }
+    }
+    for (auto& enemy : enemies_) {
+        enemy.update(delta_time);
+    }
+    for (auto& bullet : bullets_) {
+        bullet.update(delta_time);
+    }
+
+    runCollisionDetections();
+    debris_manager_.update(delta_time);
+    floating_score_manager_.update(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;
+        if (ACTIU && hit_timer_per_player_[i] == 0.0F) {
+            ships_[i].processInput(delta_time, i);
+            ships_[i].update(delta_time);
+        }
+    }
+    for (auto& bullet : bullets_) {
+        bullet.update(delta_time);
+    }
+    debris_manager_.update(delta_time);
+    floating_score_manager_.update(delta_time);
+}
+
+void GameScene::runCollisionDetections() {
+    Systems::Collision::Context col_ctx{
+        .ships = ships_,
+        .enemies = enemies_,
+        .bullets = bullets_,
+        .hit_timer_per_player = hit_timer_per_player_,
+        .score_per_player = score_per_player_,
+        .lives_per_player = lives_per_player_,
+        .debris_manager = debris_manager_,
+        .floating_score_manager = floating_score_manager_,
+        .match_config = match_config_,
+        .on_player_hit = [this](uint8_t pid) { tocado(pid); },
+    };
+    Systems::Collision::detectAll(col_ctx);
+}
+
+void GameScene::draw() {
+    // Handle CONTINUE screen
+    if (game_over_state_ == GameOverState::CONTINUE) {
+        // Draw game background elements first
+        dibuixar_marges();
+
+        for (const auto& enemy : enemies_) {
+            enemy.draw();
+        }
+
+        for (const auto& bullet : bullets_) {
+            bullet.draw();
+        }
+
+        debris_manager_.draw();
+        floating_score_manager_.draw();
+        dibuixar_marcador();
+
+        // Draw CONTINUE screen overlay
+        dibuixar_continue();
+        return;
+    }
+
+    // Handle final GAME OVER state
+    if (game_over_state_ == GameOverState::GAME_OVER) {
+        // Game over: draw enemies, bullets, debris, and "GAME OVER" text
+        dibuixar_marges();
+
+        for (const auto& enemy : enemies_) {
+            enemy.draw();
+        }
+
+        for (const auto& bullet : bullets_) {
+            bullet.draw();
+        }
+
+        debris_manager_.draw();
+        floating_score_manager_.draw();
+
+        // Draw centered "GAME OVER" text
+        const std::string game_over_text = "GAME OVER";
+        constexpr float scale = Defaults::Game::GameOverScreen::TEXT_SCALE;
+        constexpr float spacing = Defaults::Game::GameOverScreen::TEXT_SPACING;
+
+        // Calcular centro de l'àrea de juego usant constants
+        const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
+        float centre_x = play_area.x + (play_area.w / 2.0F);
+        float centre_y = play_area.y + (play_area.h / 2.0F);
+
+        text_.renderCentered(game_over_text, {.x = centre_x, .y = centre_y}, scale, spacing);
+
+        dibuixar_marcador();
+        return;
+    }
+
+    // [NEW] Stage state rendering
+    StageSystem::EstatStage state = stage_manager_->get_estat();
+
+    switch (state) {
+        case StageSystem::EstatStage::INIT_HUD: {
+            // Calcular progrés de cada animación independent
+            float timer = stage_manager_->get_timer_transicio();
+            float total_time = Defaults::Game::INIT_HUD_DURATION;
+            float global_progress = 1.0F - (timer / total_time);
+
+            // [NEW] Calcular progress independiente para cada elemento
+            float rect_progress = Systems::InitHud::computeRangeProgress(
+                global_progress,
+                Defaults::Game::INIT_HUD_RECT_RATIO_INIT,
+                Defaults::Game::INIT_HUD_RECT_RATIO_END);
+
+            float score_progress = Systems::InitHud::computeRangeProgress(
+                global_progress,
+                Defaults::Game::INIT_HUD_SCORE_RATIO_INIT,
+                Defaults::Game::INIT_HUD_SCORE_RATIO_END);
+
+            float ship1_progress = Systems::InitHud::computeRangeProgress(
+                global_progress,
+                Defaults::Game::INIT_HUD_SHIP1_RATIO_INIT,
+                Defaults::Game::INIT_HUD_SHIP1_RATIO_END);
+
+            float ship2_progress = Systems::InitHud::computeRangeProgress(
+                global_progress,
+                Defaults::Game::INIT_HUD_SHIP2_RATIO_INIT,
+                Defaults::Game::INIT_HUD_SHIP2_RATIO_END);
+
+            // Dibuixar elements animats
+            if (rect_progress > 0.0F) {
+                // [NOU] Reproduir so cuando comença l'animación del rectangle
+                if (!init_hud_rect_sound_played_) {
+                    Audio::get()->playSound(Defaults::Sound::INIT_HUD, Audio::Group::GAME);
+                    init_hud_rect_sound_played_ = true;
+                }
+
+                Systems::InitHud::drawBordersAnimated(sdl_.getRenderer(), rect_progress);
+            }
+
+            if (score_progress > 0.0F) {
+                Systems::InitHud::drawScoreboardAnimated(text_, buildScoreboard(), score_progress);
+            }
+
+            // [MODIFICAT] Dibuixar naves con progress independent
+            if (ship1_progress > 0.0F && match_config_.jugador1_actiu && !ships_[0].isHit()) {
+                ships_[0].draw();
+            }
+
+            if (ship2_progress > 0.0F && match_config_.jugador2_actiu && !ships_[1].isHit()) {
+                ships_[1].draw();
+            }
+
+            break;
+        }
+
+        case StageSystem::EstatStage::LEVEL_START:
+            dibuixar_marges();
+            // [NEW] Draw both ships if active and alive
+            for (uint8_t i = 0; i < 2; i++) {
+                bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+                if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
+                    ships_[i].draw();
+                }
+            }
+
+            // [NEW] Draw bullets
+            for (const auto& bullet : bullets_) {
+                bullet.draw();
+            }
+
+            // [NEW] Draw debris
+            debris_manager_.draw();
+            floating_score_manager_.draw();
+
+            // [EXISTING] Draw intro message and score
+            dibuixar_missatge_stage(stage_manager_->get_missatge_level_start());
+            dibuixar_marcador();
+            break;
+
+        case StageSystem::EstatStage::PLAYING:
+            dibuixar_marges();
+
+            // [EXISTING] Normal rendering - active ships
+            for (uint8_t i = 0; i < 2; i++) {
+                bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+                if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
+                    ships_[i].draw();
+                }
+            }
+
+            for (const auto& enemy : enemies_) {
+                enemy.draw();
+            }
+
+            for (const auto& bullet : bullets_) {
+                bullet.draw();
+            }
+
+            debris_manager_.draw();
+            floating_score_manager_.draw();
+            dibuixar_marcador();
+            break;
+
+        case StageSystem::EstatStage::LEVEL_COMPLETED:
+            dibuixar_marges();
+            // [NEW] Draw both ships if active and alive
+            for (uint8_t i = 0; i < 2; i++) {
+                bool jugador_actiu = (i == 0) ? match_config_.jugador1_actiu : match_config_.jugador2_actiu;
+                if (jugador_actiu && hit_timer_per_player_[i] == 0.0F) {
+                    ships_[i].draw();
+                }
+            }
+
+            // [NEW] Draw bullets (allow last shots to be visible)
+            for (const auto& bullet : bullets_) {
+                bullet.draw();
+            }
+
+            // [NEW] Draw debris (from last destroyed enemies)
+            debris_manager_.draw();
+            floating_score_manager_.draw();
+
+            // [EXISTING] Draw completion message and score
+            dibuixar_missatge_stage(StageSystem::Constants::MISSATGE_LEVEL_COMPLETED);
+            dibuixar_marcador();
+            break;
+    }
+}
+
+void GameScene::tocado(uint8_t player_id) {
+    // Death sequence: 3 phases
+    // Phase 1: First call (hit_timer_per_player_[player_id] == 0) - trigger explosion
+    // Phase 2: Animation (0 < itocado_ < 3.0s) - debris animation
+    // Phase 3: Respawn or game over (itocado_ >= 3.0s) - handled in update()
+
+    if (hit_timer_per_player_[player_id] == 0.0F) {
+        // *** PHASE 1: TRIGGER DEATH ***
+
+        // Mark ship as dead (stops rendering and input)
+        ships_[player_id].markHit();
+
+        // Create ship explosion
+        const Vec2& ship_pos = ships_[player_id].getCenter();
+        float ship_angle = ships_[player_id].getAngle();
+        Vec2 vel_nau = ships_[player_id].getVelocityVector();
+        // Reduir a 80% la velocity heretada per la ship (més realista)
+        Vec2 vel_nau_80 = {.x = vel_nau.x * 0.8F, .y = vel_nau.y * 0.8F};
+
+        debris_manager_.explode(
+            ships_[player_id].getShape(),               // Ship shape (3 lines)
+            ship_pos,                                   // Center position
+            ship_angle,                                 // Ship orientation
+            1.0F,                                       // Normal scale
+            Defaults::Physics::Debris::VELOCITAT_BASE,  // 80 px/s
+            ships_[player_id].getBrightness(),          // Heredar brightness
+            vel_nau_80,                                 // Heredar 80% velocity
+            0.0F,                                       // Nave: trayectorias rectas (sin drotacio)
+            0.0F,                                       // Sin herencia visual (rotación aleatoria)
+            Defaults::Sound::EXPLOSION2,                // Sonido alternativo para la explosión
+            Defaults::Palette::SHIP                     // Debris hereda color de la nave
+        );
+
+        // Start death timer (non-zero to avoid re-triggering)
+        hit_timer_per_player_[player_id] = 0.001F;
+    }
+    // Phase 2 is automatic (debris updates in update())
+    // Phase 3 is handled in update() when hit_timer_per_player_ >= DEATH_DURATION
+}
+
+void GameScene::dibuixar_marges() const {
+    // Dibuixar rectangle de la zona de juego
+    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+
+    // Coordenades dels cantons
+    int x1 = static_cast<int>(zona.x);
+    int y1 = static_cast<int>(zona.y);
+    int x2 = static_cast<int>(zona.x + zona.w);
+    int y2 = static_cast<int>(zona.y + zona.h);
+
+    // 4 línies per formar el rectangle
+    Rendering::linea(sdl_.getRenderer(), x1, y1, x2, y1);  // Top
+    Rendering::linea(sdl_.getRenderer(), x1, y2, x2, y2);  // Bottom
+    Rendering::linea(sdl_.getRenderer(), x1, y1, x1, y2);  // Left
+    Rendering::linea(sdl_.getRenderer(), x2, y1, x2, y2);  // Right
+}
+
+void GameScene::dibuixar_marcador() {
+    // Construir text del marcador
+    std::string text = buildScoreboard();
+
+    // Parámetros de renderització
+    const float scale = 0.85F;
+    const float spacing = 0.0F;
+
+    // Calcular centro de la zona del marcador
+    const SDL_FRect& scoreboard = Defaults::Zones::SCOREBOARD;
+    float centre_x = scoreboard.w / 2.0F;
+    float centre_y = scoreboard.y + (scoreboard.h / 2.0F);
+
+    // Renderizar centrat
+    text_.renderCentered(text, {.x = centre_x, .y = centre_y}, scale, spacing);
+}
+
+std::string GameScene::buildScoreboard() const {
+    // Puntuación P1 (6 dígits) - mostrar zeros si inactiu
+    std::string score_p1;
+    std::string vides_p1;
+    if (match_config_.jugador1_actiu) {
+        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)
+            ? "0" + std::to_string(lives_per_player_[0])
+            : std::to_string(lives_per_player_[0]);
+    } else {
+        score_p1 = "000000";
+        vides_p1 = "00";
+    }
+
+    // Nivel (2 dígits)
+    uint8_t stage_num = stage_manager_->get_stage_actual();
+    std::string stage_str = (stage_num < 10) ? "0" + std::to_string(stage_num)
+                                             : std::to_string(stage_num);
+
+    // Puntuación P2 (6 dígits) - mostrar zeros si inactiu
+    std::string score_p2;
+    std::string vides_p2;
+    if (match_config_.jugador2_actiu) {
+        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)
+            ? "0" + std::to_string(lives_per_player_[1])
+            : std::to_string(lives_per_player_[1]);
+    } else {
+        score_p2 = "000000";
+        vides_p2 = "00";
+    }
+
+    // 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;
+}
+
+// [NEW] Stage system helper methods
+
+void GameScene::dibuixar_missatge_stage(const std::string& message) {
+    constexpr float escala_base = 1.0F;
+    constexpr float spacing = 2.0F;
+
+    const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
+    const float max_width = play_area.w * Defaults::Game::STAGE_MESSAGE_MAX_WIDTH_RATIO;
+
+    // ========== TYPEWRITER EFFECT (PARAMETRIZED) ==========
+    // Get state-specific timing configuration
+    float total_time;
+    float typing_ratio;
+
+    if (stage_manager_->get_estat() == StageSystem::EstatStage::LEVEL_START) {
+        total_time = Defaults::Game::LEVEL_START_DURATION;
+        typing_ratio = Defaults::Game::LEVEL_START_TYPING_RATIO;
+    } else {  // LEVEL_COMPLETED
+        total_time = Defaults::Game::LEVEL_COMPLETED_DURATION;
+        typing_ratio = Defaults::Game::LEVEL_COMPLETED_TYPING_RATIO;
+    }
+
+    // Calculate progress from timer (0.0 at start → 1.0 at end)
+    float remaining_time = stage_manager_->get_timer_transicio();
+    float progress = 1.0F - (remaining_time / total_time);
+
+    // Determine how many characters to show
+    size_t visible_chars;
+
+    if (typing_ratio > 0.0F && progress < typing_ratio) {
+        // Typewriter phase: show partial text
+        float typing_progress = progress / typing_ratio;  // Normalize to 0.0-1.0
+        visible_chars = static_cast<size_t>(message.length() * typing_progress);
+        if (visible_chars == 0 && progress > 0.0F) {
+            visible_chars = 1;  // Show at least 1 character after first frame
+        }
+    } else {
+        // Display phase: show complete text
+        // (Either after typing phase, or immediately if typing_ratio == 0.0)
+        visible_chars = message.length();
+    }
+
+    // Create partial message (substring for typewriter)
+    std::string partial_message = message.substr(0, visible_chars);
+    // ===================================================
+
+    // Calculate text width at base scale (using FULL message for position calculation)
+    float text_width_at_base = text_.get_text_width(message, escala_base, spacing);
+
+    // Auto-scale if text exceeds max width
+    float scale = (text_width_at_base <= max_width)
+        ? escala_base
+        : max_width / text_width_at_base;
+
+    // Recalculate dimensions with final scale (using FULL message for centering)
+    float full_text_width = text_.get_text_width(message, scale, spacing);
+    float text_height = text_.get_text_height(scale);
+
+    // Calculate position as if FULL text was there (for fixed position typewriter)
+    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)
+    Vec2 pos = {.x = x, .y = y};
+    text_.render(partial_message, pos, scale, spacing);
+}
+
+// ========================================
+// Helper methods for 2-player support
+// ========================================
+
+Vec2 GameScene::obtenir_punt_spawn(uint8_t player_id) const {
+    const SDL_FRect& zona = Defaults::Zones::PLAYAREA;
+
+    float x_ratio;
+    if (match_config_.es_un_jugador()) {
+        // Un sol player: spawn al centro (50%)
+        x_ratio = 0.5F;
+    } else {
+        // Dos jugadors: spawn a posicions separades
+        x_ratio = (player_id == 0)
+            ? Defaults::Game::P1_SPAWN_X_RATIO   // 33%
+            : Defaults::Game::P2_SPAWN_X_RATIO;  // 67%
+    }
+
+    return {
+        .x = zona.x + (zona.w * x_ratio),
+        .y = zona.y + (zona.h * Defaults::Game::SPAWN_Y_RATIO)};
+}
+
+void GameScene::disparar_bala(uint8_t player_id) {
+    // Verificar que el player está vivo
+    if (hit_timer_per_player_[player_id] > 0.0F) {
+        return;
+    }
+    if (!ships_[player_id].isAlive()) {
+        return;
+    }
+
+    // Calcular posición en la punta de la nave
+    const Vec2& ship_centre = ships_[player_id].getCenter();
+    float ship_angle = ships_[player_id].getAngle();
+
+    constexpr float LOCAL_TIP_X = 0.0F;
+    constexpr float LOCAL_TIP_Y = -12.0F;
+    float cos_a = std::cos(ship_angle);
+    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};
+
+    // Buscar primera bullet inactiva en el pool del player
+    int start_idx = player_id * 3;  // P1=[0,1,2], P2=[3,4,5]
+    for (int i = start_idx; i < start_idx + 3; i++) {
+        if (!bullets_[i].esta_activa()) {
+            bullets_[i].disparar(posicio_dispar, ship_angle, player_id);
+            break;
+        }
+    }
+}
+
+void GameScene::dibuixar_continue() {
+    const SDL_FRect& play_area = Defaults::Zones::PLAYAREA;
+    constexpr float spacing = 4.0F;
+
+    // "CONTINUE" text (using constants)
+    const std::string continue_text = "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 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);
+
+    // Countdown number (using constants)
+    const std::string counter_str = std::to_string(continue_counter_);
+    float escala_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_SCALE;
+    float y_ratio_counter = Defaults::Game::ContinueScreen::COUNTER_TEXT_Y_RATIO;
+
+    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);
+
+    // "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_);
+        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);
+    }
+}
+
+void GameScene::unir_jugador(uint8_t player_id) {
+    // Activate player
+    if (player_id == 0) {
+        match_config_.jugador1_actiu = true;
+    } else {
+        match_config_.jugador2_actiu = true;
+    }
+
+    // Reset stats
+    lives_per_player_[player_id] = Defaults::Game::STARTING_LIVES;
+    score_per_player_[player_id] = 0;
+    hit_timer_per_player_[player_id] = 0.0F;
+
+    // Spawn with invulnerability
+    Vec2 spawn_pos = obtenir_punt_spawn(player_id);
+    ships_[player_id].init(&spawn_pos, true);
+
+    // No visual message, just spawn (per user requirement)
+
+    std::cout << "[GameScene] Jugador " << (int)(player_id + 1) << " s'ha unit a la match!" << '\n';
+}
diff --git a/source/game/scenes/game_scene.hpp b/source/game/scenes/game_scene.hpp
new file mode 100644
index 0000000..7fe4ee7
--- /dev/null
+++ b/source/game/scenes/game_scene.hpp
@@ -0,0 +1,124 @@
+// game_scene.hpp - Lógica principal del juego
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "core/graphics/vector_text.hpp"
+#include "core/physics/physics_world.hpp"
+#include "core/rendering/sdl_manager.hpp"
+#include "core/system/scene.hpp"
+#include "core/system/scene_context.hpp"
+#include "core/system/game_config.hpp"
+#include "core/types.hpp"
+#include "game/constants.hpp"
+#include "game/effects/debris_manager.hpp"
+#include "game/effects/floating_score_manager.hpp"
+#include "game/entities/bullet.hpp"
+#include "game/entities/enemy.hpp"
+#include "game/entities/ship.hpp"
+#include "game/stage_system/stage_config.hpp"
+#include "game/stage_system/stage_manager.hpp"
+
+// Game over state machine
+enum class GameOverState : uint8_t {
+    NONE,      // Normal gameplay
+    CONTINUE,  // Continue countdown screen (9→0)
+    GAME_OVER  // Final game over (returning to title)
+};
+
+// Clase principal del juego (escena)
+class GameScene final : public Scene {
+    public:
+        explicit GameScene(SDLManager& sdl, SceneManager::SceneContext& context);
+        ~GameScene() override = default;
+
+        // Scene interface
+        void handleEvent(const SDL_Event& event) override;
+        void update(float delta_time) override;
+        void draw() override;
+        [[nodiscard]] auto isFinished() const -> bool override;
+
+        // Inicialización del estado del juego (llamado por Director tras crear la escena).
+        void init();
+
+    private:
+        SDLManager& sdl_;
+        SceneManager::SceneContext& context_;
+        GameConfig::MatchConfig match_config_;  // Configuración de jugadors active
+
+        // Mundo físico (Fase 5) — integración cinemática + colisiones
+        Physics::PhysicsWorld physics_world_;
+
+        // Efectes visuals
+        Effects::DebrisManager debris_manager_;
+        Effects::FloatingScoreManager floating_score_manager_;
+
+        // Estat del juego
+        std::array<Ship, 2> ships_;  // [0]=P1, [1]=P2
+        std::array<Enemy, Constants::MAX_ORNIS> enemies_;
+        std::array<Bullet, Constants::MAX_BALES * 2> bullets_;  // 6 balas: P1=[0,1,2], P2=[3,4,5]
+        std::array<float, 2> hit_timer_per_player_;  // Death timers per player (seconds)
+
+        // Lives and game over system
+        std::array<int, 2> lives_per_player_;  // [0]=P1, [1]=P2
+        GameOverState game_over_state_;         // Game over state machine (NONE, CONTINUE, GAME_OVER)
+        int continue_counter_;                  // Continue countdown (9→0)
+        float continue_tick_timer_;             // Timer for countdown tick (1.0s)
+        int continues_used_;                  // Continues used this game (0-3 max)
+        float game_over_timer_;                 // Final GAME OVER timer before title screen
+        Vec2 death_position_;                            // Death position (for respawn)
+        std::array<int, 2> score_per_player_;  // [0]=P1, [1]=P2
+
+        // Text vectorial
+        Graphics::VectorText text_;
+
+        // [NEW] Stage system
+        std::unique_ptr<StageSystem::StageSystemConfig> stage_config_;
+        std::unique_ptr<StageSystem::StageManager> stage_manager_;
+
+        // Control de sons de animación INIT_HUD
+        bool init_hud_rect_sound_played_;  // Flag para evitar repetir sonido del rectángulo
+
+        // Funciones privades
+        void tocado(uint8_t player_id);
+        void dibuixar_marges() const;                                    // Dibuixar vores de la zona de juego
+        void dibuixar_marcador();                                        // Dibuixar marcador de puntuación
+        void disparar_bala(uint8_t player_id);                           // Shoot bullet from player
+        [[nodiscard]] Vec2 obtenir_punt_spawn(uint8_t player_id) const;  // Get spawn position for player
+
+        // [NEW] Continue & Join system
+        void unir_jugador(uint8_t player_id);         // Join inactive player mid-game
+        void dibuixar_continue();                     // Draw continue screen
+
+        // [NEW] Stage system helpers
+        void dibuixar_missatge_stage(const std::string& message);
+
+        // [NEW] Función helper del marcador
+        [[nodiscard]] std::string buildScoreboard() const;
+
+        // Sub-pasos de update() (descompuestos en Fase 9d para reducir
+        // complejidad cognitiva; cada uno es responsable de una sección).
+        void stepPhysics(float delta_time);
+        void stepShootingInput();
+        void stepMidGameJoin();
+        // Devuelven true si el frame debe salir tras esta sección.
+        [[nodiscard]] auto stepContinueScreen(float delta_time) -> bool;
+        [[nodiscard]] auto stepGameOver(float delta_time) -> bool;
+        // Avanza el death timer / respawn / transition a CONTINUE. Devuelve
+        // true si algun jugador está en secuencia de muerte (para que el
+        // caller actualice efectos sin gameplay).
+        [[nodiscard]] auto stepDeathSequence(float delta_time) -> bool;
+        void stepStageStateMachine(float delta_time);
+        void runStageInitHud(float delta_time);
+        void runStageLevelStart(float delta_time);
+        void runStagePlaying(float delta_time);
+        void runStageLevelCompleted(float delta_time);
+        // Helper: ejecuta colisiones de gameplay con el Context preparado.
+        void runCollisionDetections();
+};
diff --git a/source/game/scenes/logo_scene.cpp b/source/game/scenes/logo_scene.cpp
new file mode 100644
index 0000000..283dcea
--- /dev/null
+++ b/source/game/scenes/logo_scene.cpp
@@ -0,0 +1,368 @@
+// logo_scene.cpp - Implementació de l'escena logo
+// © 2025 Port a C++20
+
+#include "logo_scene.hpp"
+
+#include <algorithm>
+#include <cfloat>
+#include <iostream>
+#include <random>
+#include <set>
+
+#include "core/audio/audio.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/input/input.hpp"
+#include "core/rendering/shape_renderer.hpp"
+#include "core/system/scene_context.hpp"
+
+// Using declarations per simplificar el codi
+using SceneManager::SceneContext;
+using SceneType = SceneContext::SceneType;
+using Option = SceneContext::Option;
+
+// Helper: calcular el progrés individual de una lletra
+// en función del progrés global (efecte seqüencial)
+static float calcular_progress_letra(size_t letra_index, size_t num_letras, float global_progress, float threshold) {
+    if (num_letras == 0) {
+        return 1.0F;
+    }
+
+    // Calcular time per lletra
+    float duration_per_letra = 1.0F / static_cast<float>(num_letras);
+    float step = threshold * duration_per_letra;
+    float start = static_cast<float>(letra_index) * step;
+    float end = start + duration_per_letra;
+
+    // Interpolar progrés
+    if (global_progress < start) {
+        return 0.0F;  // Aún no ha començat
+    }
+    if (global_progress >= end) {
+        return 1.0F;  // Completament apareguda
+    }
+    return (global_progress - start) / (end - start);
+}
+
+LogoScene::LogoScene(SDLManager& sdl, SceneContext& context)
+    : sdl_(sdl),
+      context_(context),
+      estat_actual_(AnimationState::PRE_ANIMATION),
+      temps_estat_actual_(0.0F),
+      debris_manager_(std::make_unique<Effects::DebrisManager>(sdl.getRenderer())),
+      lletra_explosio_index_(0),
+      temps_des_ultima_explosio_(0.0F) {
+    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
+    inicialitzar_lletres();
+}
+
+LogoScene::~LogoScene() {
+    // Aturar todos los sons y la música
+    Audio::get()->stopAllSounds();
+    std::cout << "SceneType Logo: Sons parados\n";
+}
+
+auto LogoScene::isFinished() const -> bool {
+    return context_.nextScene() != SceneType::LOGO;
+}
+
+void LogoScene::handleEvent(const SDL_Event& event) {
+    // La lógica de skip se decide en update() consultando el estado de Input;
+    // aquí no hay eventos puntuales que procesar.
+    (void)event;
+}
+
+void LogoScene::inicialitzar_lletres() {
+    using namespace Graphics;
+
+    // Llista de archivos .shp (A repetida para las dues A's)
+    std::vector<std::string> archivos = {
+        "logo/letra_j.shp",
+        "logo/letra_a.shp",
+        "logo/letra_i.shp",
+        "logo/letra_l.shp",
+        "logo/letra_g.shp",
+        "logo/letra_a.shp",
+        "logo/letra_m.shp",
+        "logo/letra_e.shp",
+        "logo/letra_s.shp"};
+
+    // Pas 1: Carregar todas las formes i calcular amplades
+    float ancho_total = 0.0F;
+
+    for (const auto& file : archivos) {
+        auto shape = ShapeLoader::load(file);
+        if (!shape || !shape->isValid()) {
+            std::cerr << "[LogoScene] Error carregant " << file << '\n';
+            continue;
+        }
+
+        // Calcular bounding box de la shape (trobar ancho)
+        float min_x = FLT_MAX;
+        float max_x = -FLT_MAX;
+
+        for (const auto& prim : shape->get_primitives()) {
+            for (const auto& point : prim.points) {
+                min_x = std::min(min_x, point.x);
+                max_x = std::max(max_x, point.x);
+            }
+        }
+
+        float ancho_sin_escalar = max_x - min_x;
+
+        // IMPORTANT: Escalar ancho i offset con ESCALA_FINAL
+        // per que las posicions finals coincideixin con la mida real de las lletres
+        float ancho = ancho_sin_escalar * ESCALA_FINAL;
+        float offset_centre = (shape->getCenter().x - min_x) * ESCALA_FINAL;
+
+        lletres_.push_back({shape,
+            {.x = 0.0F, .y = 0.0F},  // Posición es calcularà después
+            ancho,
+            offset_centre});
+
+        ancho_total += ancho;
+    }
+
+    // Pas 2: Añadir espaiat entre lletres
+    ancho_total += ESPAI_ENTRE_LLETRES * (lletres_.size() - 1);
+
+    // Pas 3: Calcular posición inicial (centrat horitzontal)
+    constexpr auto PANTALLA_ANCHO = 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 y_centre = PANTALLA_ALTO / 2.0F;
+
+    // Pas 4: Assignar posicions a cada lletra
+    float x_actual = x_inicial;
+
+    for (auto& lletra : lletres_) {
+        // Posicionar el centro de la shape (shape_centre) en pantalla
+        // Usar offset_centre 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;
+        lletra.position.y = y_centre;
+
+        // Avançar para següent lletra
+        x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
+    }
+
+    std::cout << "[LogoScene] " << lletres_.size()
+              << " lletres carregades, ancho total: " << ancho_total << " px\n";
+}
+
+void LogoScene::canviar_estat(AnimationState nou_estat) {
+    estat_actual_ = nou_estat;
+    temps_estat_actual_ = 0.0F;  // Reset time
+
+    // Inicialitzar state de explosión
+    if (nou_estat == AnimationState::EXPLOSION) {
+        lletra_explosio_index_ = 0;
+        temps_des_ultima_explosio_ = 0.0F;
+
+        // Generar ordre aleatori de explosions
+        ordre_explosio_.clear();
+        for (size_t i = 0; i < lletres_.size(); i++) {
+            ordre_explosio_.push_back(i);
+        }
+        std::random_device rd;
+        std::mt19937 g(rd());
+        std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g);
+    } else if (nou_estat == AnimationState::POST_EXPLOSION) {
+        Audio::get()->playMusic("title.ogg");
+    }
+
+    std::cout << "[LogoScene] Canvi a state: " << static_cast<int>(nou_estat)
+              << "\n";
+}
+
+bool LogoScene::totes_lletres_completes() const {
+    // Cuando global_progress = 1.0, todas las lletres tenen letra_progress = 1.0
+    return temps_estat_actual_ >= DURACIO_ZOOM;
+}
+
+void LogoScene::actualitzar_explosions(float delta_time) {
+    temps_des_ultima_explosio_ += delta_time;
+
+    // Comprovar si es el moment de explode la següent lletra
+    if (temps_des_ultima_explosio_ >= DELAY_ENTRE_EXPLOSIONS) {
+        if (lletra_explosio_index_ < lletres_.size()) {
+            // Explotar lletra actual (en ordre aleatori)
+            size_t index_actual = ordre_explosio_[lletra_explosio_index_];
+            const auto& lletra = lletres_[index_actual];
+
+            debris_manager_->explode(
+                lletra.shape,           // Forma a explode
+                lletra.position,         // Posición
+                0.0F,                   // Angle (sin rotación)
+                ESCALA_FINAL,           // Escala (lletres a scale final)
+                VELOCITAT_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";
+
+            // Passar a la següent lletra
+            lletra_explosio_index_++;
+            temps_des_ultima_explosio_ = 0.0F;
+        } else {
+            // Todas las lletres han explotat, transición a POST_EXPLOSION
+            canviar_estat(AnimationState::POST_EXPLOSION);
+        }
+    }
+}
+
+void LogoScene::update(float delta_time) {
+    temps_estat_actual_ += delta_time;
+
+    switch (estat_actual_) {
+        case AnimationState::PRE_ANIMATION:
+            if (temps_estat_actual_ >= DURACIO_PRE) {
+                canviar_estat(AnimationState::ANIMATION);
+            }
+            break;
+
+        case AnimationState::ANIMATION: {
+            // Reproduir so per cada lletra cuando comença a aparèixer
+            float global_progress = std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F);
+
+            for (size_t i = 0; i < lletres_.size() && i < so_reproduit_.size(); i++) {
+                if (!so_reproduit_[i]) {
+                    float letra_progress = calcular_progress_letra(
+                        i,
+                        lletres_.size(),
+                        global_progress,
+                        THRESHOLD_LETRA);
+
+                    // Reproduir so cuando la lletra comença a aparèixer (progress > 0)
+                    if (letra_progress > 0.0F) {
+                        Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME);
+                        so_reproduit_[i] = true;
+                    }
+                }
+            }
+
+            if (totes_lletres_completes()) {
+                canviar_estat(AnimationState::POST_ANIMATION);
+            }
+            break;
+        }
+
+        case AnimationState::POST_ANIMATION:
+            if (temps_estat_actual_ >= DURACIO_POST_ANIMATION) {
+                canviar_estat(AnimationState::EXPLOSION);
+            }
+            break;
+
+        case AnimationState::EXPLOSION:
+            actualitzar_explosions(delta_time);
+            break;
+
+        case AnimationState::POST_EXPLOSION:
+            if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
+                // Transición a pantalla de título
+                context_.setNextScene(SceneType::TITLE);
+            }
+            break;
+    }
+
+    // Verificar botones de skip (SHOOT P1/P2)
+    if (checkSkipButtonPressed()) {
+        context_.setNextScene(SceneType::TITLE, Option::JUMP_TO_TITLE_MAIN);
+    }
+
+    // Actualitzar animaciones de debris
+    debris_manager_->update(delta_time);
+}
+
+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) {
+        return;
+    }
+
+    // ANIMATION o POST_ANIMATION: Dibuixar lletres con animación
+    if (estat_actual_ == AnimationState::ANIMATION ||
+        estat_actual_ == AnimationState::POST_ANIMATION) {
+        float global_progress =
+            (estat_actual_ == AnimationState::ANIMATION)
+            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F)
+            : 1.0F;  // POST: mantenir al 100%
+
+        const Vec2 ORIGEN_ZOOM = {.x = ORIGEN_ZOOM_X, .y = ORIGEN_ZOOM_Y};
+
+        for (size_t i = 0; i < lletres_.size(); i++) {
+            const auto& lletra = lletres_[i];
+
+            float letra_progress = calcular_progress_letra(
+                i,
+                lletres_.size(),
+                global_progress,
+                THRESHOLD_LETRA);
+
+            if (letra_progress <= 0.0F) {
+                continue;
+            }
+
+            Vec2 pos_actual;
+            pos_actual.x =
+                ORIGEN_ZOOM.x + ((lletra.position.x - ORIGEN_ZOOM.x) * letra_progress);
+            pos_actual.y =
+                ORIGEN_ZOOM.y + ((lletra.position.y - ORIGEN_ZOOM.y) * letra_progress);
+
+            float t = letra_progress;
+            float ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
+            float current_scale =
+                ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor);
+
+            Rendering::render_shape(
+                sdl_.getRenderer(),
+                lletra.shape,
+                pos_actual,
+                0.0F,
+                current_scale,
+                1.0F);
+        }
+    }
+
+    // EXPLOSION: Dibuixar solo lletres que aún no han explotat
+    if (estat_actual_ == AnimationState::EXPLOSION) {
+        // Crear conjunt de lletres ya explotades
+        std::set<size_t> explotades;
+        for (size_t i = 0; i < lletra_explosio_index_; i++) {
+            explotades.insert(ordre_explosio_[i]);
+        }
+
+        // Dibuixar solo lletres que NO han explotat
+        for (size_t i = 0; i < lletres_.size(); i++) {
+            if (!explotades.contains(i)) {
+                const auto& lletra = lletres_[i];
+
+                Rendering::render_shape(
+                    sdl_.getRenderer(),
+                    lletra.shape,
+                    lletra.position,
+                    0.0F,
+                    ESCALA_FINAL,
+                    1.0F);
+            }
+        }
+    }
+
+    // POST_EXPLOSION: No draw lletres, solo debris (a baix)
+
+    // Siempre draw debris (si n'hay de active)
+    debris_manager_->draw();
+}
+
+auto LogoScene::checkSkipButtonPressed() -> bool {
+    return Input::get()->checkAnyPlayerAction(ARCADE_BUTTONS);
+}
diff --git a/source/game/escenes/escena_logo.hpp b/source/game/scenes/logo_scene.hpp
similarity index 54%
rename from source/game/escenes/escena_logo.hpp
rename to source/game/scenes/logo_scene.hpp
index a1d2579..845edbb 100644
--- a/source/game/escenes/escena_logo.hpp
+++ b/source/game/scenes/logo_scene.hpp
@@ -1,5 +1,5 @@
-// escena_logo.hpp - Pantalla d'inici del joc
-// Mostra logo JAILGAMES animat amb zoom i salta al joc
+// logo_scene.hpp - Pantalla de start del juego
+// Muestra logo JAILGAMES animat con zoom i salta al juego
 // © 2025 Port a C++20
 
 #pragma once
@@ -14,78 +14,81 @@
 #include "core/graphics/shape.hpp"
 #include "core/input/input_types.hpp"
 #include "core/rendering/sdl_manager.hpp"
-#include "core/system/context_escenes.hpp"
+#include "core/system/scene.hpp"
+#include "core/system/scene_context.hpp"
 #include "core/types.hpp"
 #include "game/effects/debris_manager.hpp"
 
-class EscenaLogo {
+class LogoScene final : public Scene {
     public:
-        explicit EscenaLogo(SDLManager& sdl, GestorEscenes::ContextEscenes& context);
-        ~EscenaLogo();    // Destructor per aturar sons
-        void executar();  // Bucle principal de l'escena
+        explicit LogoScene(SDLManager& sdl, SceneManager::SceneContext& context);
+        ~LogoScene() override;    // Destructor per aturar sons
+
+        // Scene interface
+        void handleEvent(const SDL_Event& event) override;
+        void update(float delta_time) override;
+        void draw() override;
+        [[nodiscard]] auto isFinished() const -> bool override;
 
     private:
-        // Màquina d'estats per l'animació
-        enum class EstatAnimacio {
+        // Màquina de estats per l'animación
+        enum class AnimationState {
             PRE_ANIMATION,   // Pantalla negra inicial
-            ANIMATION,       // Animació de zoom de lletres
+            ANIMATION,       // Animación de zoom de lletres
             POST_ANIMATION,  // Logo complet visible
-            EXPLOSION,       // Explosió seqüencial de lletres
-            POST_EXPLOSION   // Espera després de l'última explosió
+            EXPLOSION,       // Explosión seqüencial de lletres
+            POST_EXPLOSION   // Espera después de l'última explosión
         };
 
         SDLManager& sdl_;
-        GestorEscenes::ContextEscenes& context_;
-        EstatAnimacio estat_actual_;  // Estat actual de la màquina
+        SceneManager::SceneContext& context_;
+        AnimationState estat_actual_;  // Estat actual de la màquina
         float
-            temps_estat_actual_;  // Temps en l'estat actual (reset en cada transició)
+            temps_estat_actual_;  // Temps en l'state actual (reset en cada transición)
 
-        // Gestor de fragments d'explosions
+        // Gestor de fragments de explosions
         std::unique_ptr<Effects::DebrisManager> debris_manager_;
 
-        // Seguiment d'explosions seqüencials
-        size_t lletra_explosio_index_;        // Índex de la següent lletra a explotar
-        float temps_des_ultima_explosio_;     // Temps des de l'última explosió
-        std::vector<size_t> ordre_explosio_;  // Ordre aleatori d'índexs de lletres
+        // Seguiment de explosions seqüencials
+        size_t lletra_explosio_index_;        // Índex de la següent lletra a explode
+        float temps_des_ultima_explosio_;     // Temps desde l'última explosión
+        std::vector<size_t> ordre_explosio_;  // Ordre aleatori de índexs de lletres
 
-        // Estructura per a cada lletra del logo
+        // Estructura para cada lletra del logo
         struct LetraLogo {
-                std::shared_ptr<Graphics::Shape> forma;
-                Punt posicio;         // Posició final en pantalla
+                std::shared_ptr<Graphics::Shape> shape;
+                Vec2 position;         // Posición final en pantalla
                 float ancho;          // Ancho del bounding box
-                float offset_centre;  // Distància de min_x a shape_centre.x
+                float offset_centre;  // Distancia de min_x a shape_centre.x
         };
 
         std::vector<LetraLogo> lletres_;  // 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 ja ha reproduit el so
+        std::array<bool, 9> so_reproduit_;  // Track si cada lletra ya ha reproduit el so
 
-        // Constants d'animació
+        // Constants de animación
         static constexpr float DURACIO_PRE = 1.5F;             // Duració PRE_ANIMATION (pantalla negra)
         static constexpr float DURACIO_ZOOM = 4.0F;            // Duració del zoom (segons)
         static constexpr float DURACIO_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 DELAY_ENTRE_EXPLOSIONS = 0.1F;  // Temps entre explosions de lletres
-        static constexpr float VELOCITAT_EXPLOSIO = 240.0F;    // Velocitat base fragments (px/s)
+        static constexpr float VELOCITAT_EXPLOSIO = 240.0F;    // Velocidad base fragments (px/s)
         static constexpr float ESCALA_INICIAL = 0.1F;          // Escala inicial (10%)
         static constexpr float ESCALA_FINAL = 0.8F;            // Escala final (80%)
         static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;    // Espaiat entre lletres
 
-        // Constants d'animació seqüencial
+        // 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 ORIGEN_ZOOM_X = Defaults::Game::WIDTH * 0.5F;   // Punt inicial X del zoom
-        static constexpr float ORIGEN_ZOOM_Y = Defaults::Game::HEIGHT * 0.4F;  // Punt inicial Y del zoom
+        static constexpr float ORIGEN_ZOOM_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
 
-        // Mètodes privats
+        // Métodos privats
         void inicialitzar_lletres();
-        void actualitzar(float delta_time);
         void actualitzar_explosions(float delta_time);
-        void dibuixar();
-        void processar_events(const SDL_Event& event);
         auto checkSkipButtonPressed() -> bool;
 
-        // Mètodes de gestió d'estats
-        void canviar_estat(EstatAnimacio nou_estat);
+        // Métodos de gestió de estats
+        void canviar_estat(AnimationState nou_estat);
         [[nodiscard]] bool totes_lletres_completes() const;
 };
diff --git a/source/game/escenes/escena_titol.cpp b/source/game/scenes/title_scene.cpp
similarity index 51%
rename from source/game/escenes/escena_titol.cpp
rename to source/game/scenes/title_scene.cpp
index 2e7d123..af8006c 100644
--- a/source/game/escenes/escena_titol.cpp
+++ b/source/game/scenes/title_scene.cpp
@@ -1,7 +1,7 @@
-// escena_titol.cpp - Implementació de l'escena de títol
+// title_scene.cpp - Implementació de l'escena de título
 // © 2025 Port a C++20
 
-#include "escena_titol.hpp"
+#include "title_scene.hpp"
 
 #include <algorithm>
 #include <cfloat>
@@ -13,45 +13,43 @@
 #include "core/audio/audio.hpp"
 #include "core/graphics/shape_loader.hpp"
 #include "core/input/input.hpp"
-#include "core/input/mouse.hpp"
 #include "core/rendering/shape_renderer.hpp"
-#include "core/system/context_escenes.hpp"
-#include "core/system/global_events.hpp"
+#include "core/system/scene_context.hpp"
 #include "project.h"
 
 // Using declarations per simplificar el codi
-using GestorEscenes::ContextEscenes;
-using Escena = ContextEscenes::Escena;
-using Opcio = ContextEscenes::Opcio;
+using SceneManager::SceneContext;
+using SceneType = SceneContext::SceneType;
+using Option = SceneContext::Option;
 
-EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
+TitleScene::TitleScene(SDLManager& sdl, SceneContext& context)
     : sdl_(sdl),
       context_(context),
-      text_(sdl.obte_renderer()),
-      estat_actual_(EstatTitol::STARFIELD_FADE_IN),
+      text_(sdl.getRenderer()),
+      estat_actual_(TitleState::STARFIELD_FADE_IN),
       temps_acumulat_(0.0F),
       temps_animacio_(0.0F),
       temps_estat_main_(0.0F),
       animacio_activa_(false),
       factor_lerp_(0.0F) {
-    std::cout << "Escena Titol: Inicialitzant...\n";
+    std::cout << "SceneType Titol: Inicialitzant...\n";
 
-    // Inicialitzar configuració de partida (cap jugador actiu per defecte)
-    config_partida_.jugador1_actiu = false;
-    config_partida_.jugador2_actiu = false;
-    config_partida_.mode = GameConfig::Mode::NORMAL;
+    // Inicialitzar configuración de match (sin player active per defecte)
+    match_config_.jugador1_actiu = false;
+    match_config_.jugador2_actiu = false;
+    match_config_.mode = GameConfig::Mode::NORMAL;
 
-    // Processar opció del context
-    auto opcio = context_.consumir_opcio();
+    // Processar opción del context
+    auto option = context_.consumeOption();
 
-    if (opcio == Opcio::JUMP_TO_TITLE_MAIN) {
-        std::cout << "Escena Titol: Opció JUMP_TO_TITLE_MAIN activada\n";
-        estat_actual_ = EstatTitol::MAIN;
+    if (option == Option::JUMP_TO_TITLE_MAIN) {
+        std::cout << "SceneType Titol: Opción JUMP_TO_TITLE_MAIN activada\n";
+        estat_actual_ = TitleState::MAIN;
         temps_estat_main_ = 0.0F;
     }
 
     // Crear starfield de fons
-    Punt centre_pantalla{
+    Vec2 centre_pantalla{
         .x = Defaults::Game::WIDTH / 2.0F,
         .y = Defaults::Game::HEIGHT / 2.0F};
 
@@ -62,26 +60,26 @@ EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
         static_cast<float>(Defaults::Game::HEIGHT)};
 
     starfield_ = std::make_unique<Graphics::Starfield>(
-        sdl_.obte_renderer(),
+        sdl_.getRenderer(),
         centre_pantalla,
         area_completa,
         150  // densitat: 150 estrelles (50 per capa)
     );
 
-    // Brightness depèn de l'opció
-    if (estat_actual_ == EstatTitol::MAIN) {
+    // Brightness depèn de l'opción
+    if (estat_actual_ == TitleState::MAIN) {
         // Si saltem a MAIN, starfield instantàniament brillant
         starfield_->set_brightness(BRIGHTNESS_STARFIELD);
     } else {
-        // Flux normal: comença amb brightness 0.0 per fade-in
+        // Flux normal: comença con brightness 0.0 per fade-in
         starfield_->set_brightness(0.0F);
     }
 
-    // Inicialitzar animador de naus 3D
-    ship_animator_ = std::make_unique<Title::ShipAnimator>(sdl_.obte_renderer());
-    ship_animator_->inicialitzar();
+    // Inicialitzar animador de naves 3D
+    ship_animator_ = std::make_unique<Title::ShipAnimator>(sdl_.getRenderer());
+    ship_animator_->init();
 
-    if (estat_actual_ == EstatTitol::MAIN) {
+    if (estat_actual_ == TitleState::MAIN) {
         // Jump to MAIN: empezar entrada inmediatamente
         ship_animator_->set_visible(true);
         ship_animator_->start_entry_animation();
@@ -90,21 +88,21 @@ EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
         ship_animator_->set_visible(false);
     }
 
-    // Inicialitzar lletres del títol "ORNI ATTACK!"
+    // Inicialitzar lletres del título "ORNI ATTACK!"
     inicialitzar_titol();
 
-    // Iniciar música de títol si no està sonant
-    if (Audio::get()->getMusicState() != Audio::MusicState::PLAYING) {
+    // Iniciar música de título si no está sonant
+    if (Audio::getMusicState() != Audio::MusicState::PLAYING) {
         Audio::get()->playMusic("title.ogg");
     }
 }
 
-EscenaTitol::~EscenaTitol() {
-    // Aturar música de títol quan es destrueix l'escena
+TitleScene::~TitleScene() {
+    // Aturar música de título cuando es destrueix l'escena
     Audio::get()->stopMusic();
 }
 
-void EscenaTitol::inicialitzar_titol() {
+void TitleScene::inicialitzar_titol() {
     using namespace Graphics;
 
     // === LÍNIA 1: "ORNI" ===
@@ -117,65 +115,65 @@ void EscenaTitol::inicialitzar_titol() {
     // Pas 1: Carregar formes i calcular amplades per "ORNI"
     float ancho_total_orni = 0.0F;
 
-    for (const auto& fitxer : fitxers_orni) {
-        auto forma = ShapeLoader::load(fitxer);
-        if (!forma || !forma->es_valida()) {
-            std::cerr << "[EscenaTitol] Error carregant " << fitxer << '\n';
+    for (const auto& file : fitxers_orni) {
+        auto shape = ShapeLoader::load(file);
+        if (!shape || !shape->isValid()) {
+            std::cerr << "[TitleScene] Error carregant " << file << '\n';
             continue;
         }
 
-        // Calcular bounding box de la forma (trobar ancho i altura)
+        // Calcular bounding box de la shape (trobar ancho i altura)
         float min_x = FLT_MAX;
         float max_x = -FLT_MAX;
         float min_y = FLT_MAX;
         float max_y = -FLT_MAX;
 
-        for (const auto& prim : forma->get_primitives()) {
-            for (const auto& punt : prim.points) {
-                min_x = std::min(min_x, punt.x);
-                max_x = std::max(max_x, punt.x);
-                min_y = std::min(min_y, punt.y);
-                max_y = std::max(max_y, punt.y);
+        for (const auto& prim : shape->get_primitives()) {
+            for (const auto& point : prim.points) {
+                min_x = std::min(min_x, point.x);
+                max_x = std::max(max_x, point.x);
+                min_y = std::min(min_y, point.y);
+                max_y = std::max(max_y, point.y);
             }
         }
 
         float ancho_sin_escalar = max_x - min_x;
         float altura_sin_escalar = max_y - min_y;
 
-        // Escalar ancho, altura i offset amb LOGO_SCALE
+        // Escalar ancho, altura i offset con LOGO_SCALE
         float ancho = ancho_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
         float altura = altura_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
-        float offset_centre = (forma->get_centre().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
+        float offset_centre = (shape->getCenter().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
 
-        lletres_orni_.push_back({forma, {.x = 0.0F, .y = 0.0F}, ancho, altura, offset_centre});
+        lletres_orni_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ancho, altura, offset_centre});
 
         ancho_total_orni += ancho;
     }
 
-    // Afegir espaiat entre lletres
+    // Añadir espaiat entre lletres
     ancho_total_orni += ESPAI_ENTRE_LLETRES * (lletres_orni_.size() - 1);
 
-    // Calcular posició inicial (centrat horitzontal) per "ORNI"
+    // Calcular posición inicial (centrat horitzontal) per "ORNI"
     float x_inicial_orni = (Defaults::Game::WIDTH - ancho_total_orni) / 2.0F;
     float x_actual = x_inicial_orni;
 
     for (auto& lletra : lletres_orni_) {
-        lletra.posicio.x = x_actual + lletra.offset_centre;
-        lletra.posicio.y = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
+        lletra.position.x = x_actual + lletra.offset_centre;
+        lletra.position.y = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
         x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
     }
 
-    std::cout << "[EscenaTitol] Línia 1 (ORNI): " << lletres_orni_.size()
+    std::cout << "[TitleScene] Línia 1 (ORNI): " << lletres_orni_.size()
               << " lletres, ancho total: " << ancho_total_orni << " px\n";
 
-    // === Calcular posició Y dinàmica per "ATTACK!" ===
-    // Totes les lletres ORNI tenen la mateixa altura, utilitzem la primera
+    // === Calcular posición Y dinàmica per "ATTACK!" ===
+    // Todas las lletres ORNI tenen la misma altura, utilitzem la primera
     float altura_orni = lletres_orni_.empty() ? 50.0F : lletres_orni_[0].altura;
     float y_orni = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
     float separacion_lineas = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_LINE_SPACING;
     y_attack_dinamica_ = y_orni + altura_orni + separacion_lineas;
 
-    std::cout << "[EscenaTitol] Altura ORNI: " << altura_orni
+    std::cout << "[TitleScene] Altura ORNI: " << altura_orni
               << " px, Y_ATTACK dinàmica: " << y_attack_dinamica_ << " px\n";
 
     // === LÍNIA 2: "ATTACK!" ===
@@ -191,151 +189,92 @@ void EscenaTitol::inicialitzar_titol() {
     // Pas 1: Carregar formes i calcular amplades per "ATTACK!"
     float ancho_total_attack = 0.0F;
 
-    for (const auto& fitxer : fitxers_attack) {
-        auto forma = ShapeLoader::load(fitxer);
-        if (!forma || !forma->es_valida()) {
-            std::cerr << "[EscenaTitol] Error carregant " << fitxer << '\n';
+    for (const auto& file : fitxers_attack) {
+        auto shape = ShapeLoader::load(file);
+        if (!shape || !shape->isValid()) {
+            std::cerr << "[TitleScene] Error carregant " << file << '\n';
             continue;
         }
 
-        // Calcular bounding box de la forma (trobar ancho i altura)
+        // Calcular bounding box de la shape (trobar ancho i altura)
         float min_x = FLT_MAX;
         float max_x = -FLT_MAX;
         float min_y = FLT_MAX;
         float max_y = -FLT_MAX;
 
-        for (const auto& prim : forma->get_primitives()) {
-            for (const auto& punt : prim.points) {
-                min_x = std::min(min_x, punt.x);
-                max_x = std::max(max_x, punt.x);
-                min_y = std::min(min_y, punt.y);
-                max_y = std::max(max_y, punt.y);
+        for (const auto& prim : shape->get_primitives()) {
+            for (const auto& point : prim.points) {
+                min_x = std::min(min_x, point.x);
+                max_x = std::max(max_x, point.x);
+                min_y = std::min(min_y, point.y);
+                max_y = std::max(max_y, point.y);
             }
         }
 
         float ancho_sin_escalar = max_x - min_x;
         float altura_sin_escalar = max_y - min_y;
 
-        // Escalar ancho, altura i offset amb LOGO_SCALE
+        // Escalar ancho, altura i offset con LOGO_SCALE
         float ancho = ancho_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
         float altura = altura_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
-        float offset_centre = (forma->get_centre().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
+        float offset_centre = (shape->getCenter().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
 
-        lletres_attack_.push_back({forma, {.x = 0.0F, .y = 0.0F}, ancho, altura, offset_centre});
+        lletres_attack_.push_back({shape, {.x = 0.0F, .y = 0.0F}, ancho, altura, offset_centre});
 
         ancho_total_attack += ancho;
     }
 
-    // Afegir espaiat entre lletres
+    // Añadir espaiat entre lletres
     ancho_total_attack += ESPAI_ENTRE_LLETRES * (lletres_attack_.size() - 1);
 
-    // Calcular posició inicial (centrat horitzontal) per "ATTACK!"
+    // Calcular posición inicial (centrat horitzontal) per "ATTACK!"
     float x_inicial_attack = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0F;
     x_actual = x_inicial_attack;
 
     for (auto& lletra : lletres_attack_) {
-        lletra.posicio.x = x_actual + lletra.offset_centre;
-        lletra.posicio.y = y_attack_dinamica_;  // Usar posició dinàmica
+        lletra.position.x = x_actual + lletra.offset_centre;
+        lletra.position.y = y_attack_dinamica_;  // Usar posición dinàmica
         x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
     }
 
-    std::cout << "[EscenaTitol] Línia 2 (ATTACK!): " << lletres_attack_.size()
+    std::cout << "[TitleScene] Línia 2 (ATTACK!): " << lletres_attack_.size()
               << " lletres, ancho total: " << ancho_total_attack << " px\n";
 
-    // Guardar posicions originals per l'animació orbital
+    // Guardar posicions originals per l'animación orbital
     posicions_originals_orni_.clear();
     for (const auto& lletra : lletres_orni_) {
-        posicions_originals_orni_.push_back(lletra.posicio);
+        posicions_originals_orni_.push_back(lletra.position);
     }
 
     posicions_originals_attack_.clear();
     for (const auto& lletra : lletres_attack_) {
-        posicions_originals_attack_.push_back(lletra.posicio);
+        posicions_originals_attack_.push_back(lletra.position);
     }
 
-    std::cout << "[EscenaTitol] Animació: Posicions originals guardades\n";
+    std::cout << "[TitleScene] Animación: Posicions originals guardades\n";
 }
 
-void EscenaTitol::executar() {
-    SDL_Event event;
-    Uint64 last_time = SDL_GetTicks();
-
-    while (GestorEscenes::actual == Escena::TITOL) {
-        // Calcular delta_time real
-        Uint64 current_time = SDL_GetTicks();
-        float delta_time = (current_time - last_time) / 1000.0F;
-        last_time = current_time;
-
-        // Limitar delta_time per evitar grans salts
-        delta_time = std::min(delta_time, 0.05F);
-
-        // Actualitzar comptador de FPS
-        sdl_.updateFPS(delta_time);
-
-        // Actualitzar visibilitat del cursor (auto-ocultar)
-        Mouse::updateCursorVisibility();
-
-        // Actualitzar sistema d'input ABANS del event loop
-        Input::get()->update();
-
-        // Processar events SDL
-        while (SDL_PollEvent(&event)) {
-            // Manejo de finestra
-            if (sdl_.handleWindowEvent(event)) {
-                continue;
-            }
-
-            // Events globals (F1/F2/F3/F4/ESC/QUIT)
-            if (GlobalEvents::handle(event, sdl_, context_)) {
-                continue;
-            }
-
-            // Processar events de l'escena
-            processar_events(event);
-        }
-
-        // Actualitzar lògica
-        actualitzar(delta_time);
-
-        // Actualitzar sistema d'audio
-        Audio::update();
-
-        // Actualitzar colors oscil·lats
-        sdl_.updateColors(delta_time);
-
-        // Netejar pantalla
-        sdl_.neteja(0, 0, 0);
-
-        // Actualitzar context de renderitzat (factor d'escala global)
-        sdl_.updateRenderingContext();
-
-        // Dibuixar
-        dibuixar();
-
-        // Presentar renderer (swap buffers)
-        sdl_.presenta();
-    }
-
-    std::cout << "Escena Titol: Finalitzant...\n";
+auto TitleScene::isFinished() const -> bool {
+    return context_.nextScene() != SceneType::TITLE;
 }
 
-void EscenaTitol::actualitzar(float delta_time) {
-    // Actualitzar starfield (sempre actiu)
+void TitleScene::update(float delta_time) {
+    // Actualitzar starfield (siempre active)
     if (starfield_) {
-        starfield_->actualitzar(delta_time);
+        starfield_->update(delta_time);
     }
 
-    // Actualitzar naus (quan visibles)
+    // Actualitzar naves (cuando visibles)
     if (ship_animator_ &&
-        (estat_actual_ == EstatTitol::STARFIELD_FADE_IN ||
-            estat_actual_ == EstatTitol::STARFIELD ||
-            estat_actual_ == EstatTitol::MAIN ||
-            estat_actual_ == EstatTitol::PLAYER_JOIN_PHASE)) {
-        ship_animator_->actualitzar(delta_time);
+        (estat_actual_ == TitleState::STARFIELD_FADE_IN ||
+            estat_actual_ == TitleState::STARFIELD ||
+            estat_actual_ == TitleState::MAIN ||
+            estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) {
+        ship_animator_->update(delta_time);
     }
 
     switch (estat_actual_) {
-        case EstatTitol::STARFIELD_FADE_IN: {
+        case TitleState::STARFIELD_FADE_IN: {
             temps_acumulat_ += delta_time;
 
             // Calcular progrés del fade (0.0 → 1.0)
@@ -345,31 +284,31 @@ void EscenaTitol::actualitzar(float delta_time) {
             float brightness_actual = progress * BRIGHTNESS_STARFIELD;
             starfield_->set_brightness(brightness_actual);
 
-            // Transició a STARFIELD quan el fade es completa
+            // Transición a STARFIELD cuando el fade es completa
             if (temps_acumulat_ >= DURACIO_FADE_IN) {
-                estat_actual_ = EstatTitol::STARFIELD;
-                temps_acumulat_ = 0.0F;                            // Reset timer per al següent estat
-                starfield_->set_brightness(BRIGHTNESS_STARFIELD);  // Assegurar valor final
+                estat_actual_ = TitleState::STARFIELD;
+                temps_acumulat_ = 0.0F;                            // Reset timer per al següent state
+                starfield_->set_brightness(BRIGHTNESS_STARFIELD);  // Assegurar value final
             }
             break;
         }
 
-        case EstatTitol::STARFIELD:
+        case TitleState::STARFIELD:
             temps_acumulat_ += delta_time;
             if (temps_acumulat_ >= DURACIO_INIT) {
-                estat_actual_ = EstatTitol::MAIN;
+                estat_actual_ = TitleState::MAIN;
                 temps_estat_main_ = 0.0F;  // Reset timer al entrar a MAIN
                 animacio_activa_ = false;  // Comença estàtic
-                factor_lerp_ = 0.0F;       // Sense animació encara
+                factor_lerp_ = 0.0F;       // Sin animación aún
 
-                // Naus esperaran ENTRANCE_DELAY abans d'entrar (no iniciar aquí)
+                // Naves esperaran ENTRANCE_DELAY antes de entrar (no start aquí)
             }
             break;
 
-        case EstatTitol::MAIN: {
+        case TitleState::MAIN: {
             temps_estat_main_ += delta_time;
 
-            // Iniciar animació d'entrada de naus després del delay
+            // Iniciar animación de entrada de naves después del delay
             if (temps_estat_main_ >= Defaults::Title::Ships::ENTRANCE_DELAY) {
                 if (ship_animator_ && !ship_animator_->is_visible()) {
                     ship_animator_->set_visible(true);
@@ -388,120 +327,121 @@ void EscenaTitol::actualitzar(float delta_time) {
                 factor_lerp_ = temps_lerp / DURACIO_LERP;  // 0.0 → 1.0 linealment
                 animacio_activa_ = true;
             }
-            // Fase 3: Animació completa (12s+)
+            // Fase 3: Animación completa (12s+)
             else {
                 factor_lerp_ = 1.0F;
                 animacio_activa_ = true;
             }
 
-            // Actualitzar animació del logo
+            // Actualitzar animación del logo
             actualitzar_animacio_logo(delta_time);
             break;
         }
 
-        case EstatTitol::PLAYER_JOIN_PHASE:
+        case TitleState::PLAYER_JOIN_PHASE:
             temps_acumulat_ += delta_time;
 
-            // Continuar animació orbital durant la transició
+            // Continuar animación orbital durante la transición
             actualitzar_animacio_logo(delta_time);
 
-            // [NOU] Continuar comprovant si l'altre jugador vol unir-se durant la transició ("late join")
+            // [NOU] Continuar comprovant si l'altre player quiere unir-se durante la transición ("late join")
             {
-                bool p1_actiu_abans = config_partida_.jugador1_actiu;
-                bool p2_actiu_abans = config_partida_.jugador2_actiu;
+                bool p1_actiu_abans = match_config_.jugador1_actiu;
+                bool p2_actiu_abans = match_config_.jugador2_actiu;
 
                 if (checkStartGameButtonPressed()) {
-                    // Updates config_partida_ if pressed, logs are in the method
-                    context_.set_config_partida(config_partida_);
+                    // Updates match_config_ if pressed, logs are in the method
+                    context_.setMatchConfig(match_config_);
 
-                    // Trigger animació de sortida per la nau que acaba d'unir-se
+                    // Trigger animación de salida per la ship que acaba de unir-se
                     if (ship_animator_) {
-                        if (config_partida_.jugador1_actiu && !p1_actiu_abans) {
+                        if (match_config_.jugador1_actiu && !p1_actiu_abans) {
                             ship_animator_->trigger_exit_animation_for_player(1);
-                            std::cout << "[EscenaTitol] P1 late join - ship exiting\n";
+                            std::cout << "[TitleScene] P1 late join - ship exiting\n";
                         }
-                        if (config_partida_.jugador2_actiu && !p2_actiu_abans) {
+                        if (match_config_.jugador2_actiu && !p2_actiu_abans) {
                             ship_animator_->trigger_exit_animation_for_player(2);
-                            std::cout << "[EscenaTitol] P2 late join - ship exiting\n";
+                            std::cout << "[TitleScene] P2 late join - ship exiting\n";
                         }
                     }
 
-                    // Reproducir so de START quan el segon jugador s'uneix
+                    // Reproducir so de START cuando el segon player s'uneix
                     Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);
 
-                    // Reiniciar el timer per allargar el temps de transició
+                    // Reiniciar el timer per allargar el time de transición
                     temps_acumulat_ = 0.0F;
 
-                    std::cout << "[EscenaTitol] Segon jugador s'ha unit - so i timer reiniciats\n";
+                    std::cout << "[TitleScene] Segon player s'ha unit - so i timer reiniciats\n";
                 }
             }
 
             if (temps_acumulat_ >= DURACIO_TRANSITION) {
-                // Transició a pantalla negra
-                estat_actual_ = EstatTitol::BLACK_SCREEN;
+                // Transición a pantalla negra
+                estat_actual_ = TitleState::BLACK_SCREEN;
                 temps_acumulat_ = 0.0F;
-                std::cout << "[EscenaTitol] Passant a BLACK_SCREEN\n";
+                std::cout << "[TitleScene] Passant a BLACK_SCREEN\n";
             }
             break;
 
-        case EstatTitol::BLACK_SCREEN:
+        case TitleState::BLACK_SCREEN:
             temps_acumulat_ += delta_time;
 
             // No animation, no input checking - just wait
             if (temps_acumulat_ >= DURACIO_BLACK_SCREEN) {
-                // Transició a escena JOC
-                GestorEscenes::actual = Escena::JOC;
-                std::cout << "[EscenaTitol] Canviant a escena JOC\n";
+                // Transición a escena GAME (el Director detecta isFinished()).
+                context_.setNextScene(SceneType::GAME);
+                std::cout << "[TitleScene] Canviant a escena GAME\n";
             }
             break;
     }
 
     // Verificar botones de skip (FIRE/THRUST/START) para saltar escenas ANTES de MAIN
-    if (estat_actual_ == EstatTitol::STARFIELD_FADE_IN || estat_actual_ == EstatTitol::STARFIELD) {
+    if (estat_actual_ == TitleState::STARFIELD_FADE_IN || estat_actual_ == TitleState::STARFIELD) {
         if (checkSkipButtonPressed()) {
             // Saltar a MAIN
-            estat_actual_ = EstatTitol::MAIN;
+            estat_actual_ = TitleState::MAIN;
             starfield_->set_brightness(BRIGHTNESS_STARFIELD);
             temps_estat_main_ = 0.0F;
 
-            // Naus esperaran ENTRANCE_DELAY abans d'entrar (no iniciar aquí)
+            // Naves esperaran ENTRANCE_DELAY antes de entrar (no start aquí)
         }
     }
 
-    // Verificar boton START para iniciar partida desde MAIN
-    if (estat_actual_ == EstatTitol::MAIN) {
-        // Guardar estat anterior per detectar qui ha premut START AQUEST frame
-        bool p1_actiu_abans = config_partida_.jugador1_actiu;
-        bool p2_actiu_abans = config_partida_.jugador2_actiu;
+    // Verificar boton START para start match desde MAIN
+    if (estat_actual_ == TitleState::MAIN) {
+        // Guardar state anterior per detectar qui ha premut START AQUEST frame
+        bool p1_actiu_abans = match_config_.jugador1_actiu;
+        bool p2_actiu_abans = match_config_.jugador2_actiu;
 
         if (checkStartGameButtonPressed()) {
-            // Si START es prem durant el delay (naus encara invisibles), saltar-les a FLOATING
+            // Si START es prem durante el delay (naves aún invisibles), saltar-las a FLOATING
             if (ship_animator_ && !ship_animator_->is_visible()) {
                 ship_animator_->set_visible(true);
                 ship_animator_->skip_to_floating_state();
             }
 
-            // Configurar partida abans de canviar d'escena
-            context_.set_config_partida(config_partida_);
-            std::cout << "[EscenaTitol] Configuració de partida - P1: "
-                      << (config_partida_.jugador1_actiu ? "ACTIU" : "INACTIU")
+            // Configurar match antes de canviar de escena
+            context_.setMatchConfig(match_config_);
+            std::cout << "[TitleScene] Configuración de match - P1: "
+                      << (match_config_.jugador1_actiu ? "ACTIU" : "INACTIU")
                       << ", P2: "
-                      << (config_partida_.jugador2_actiu ? "ACTIU" : "INACTIU")
+                      << (match_config_.jugador2_actiu ? "ACTIU" : "INACTIU")
                       << '\n';
 
-            context_.canviar_escena(Escena::JOC);
-            estat_actual_ = EstatTitol::PLAYER_JOIN_PHASE;
+            // El setNextScene a GAME se hace al final de BLACK_SCREEN para no
+            // saltar la animación de salida (isFinished() lo recoge entonces).
+            estat_actual_ = TitleState::PLAYER_JOIN_PHASE;
             temps_acumulat_ = 0.0F;
 
-            // Trigger animació de sortida NOMÉS per les naus que han premut START
+            // Trigger animación de salida NOMÉS per las naves que han premut START
             if (ship_animator_) {
-                if (config_partida_.jugador1_actiu && !p1_actiu_abans) {
+                if (match_config_.jugador1_actiu && !p1_actiu_abans) {
                     ship_animator_->trigger_exit_animation_for_player(1);
-                    std::cout << "[EscenaTitol] P1 ship exiting\n";
+                    std::cout << "[TitleScene] P1 ship exiting\n";
                 }
-                if (config_partida_.jugador2_actiu && !p2_actiu_abans) {
+                if (match_config_.jugador2_actiu && !p2_actiu_abans) {
                     ship_animator_->trigger_exit_animation_for_player(2);
-                    std::cout << "[EscenaTitol] P2 ship exiting\n";
+                    std::cout << "[TitleScene] P2 ship exiting\n";
                 }
             }
 
@@ -511,10 +451,10 @@ void EscenaTitol::actualitzar(float delta_time) {
     }
 }
 
-void EscenaTitol::actualitzar_animacio_logo(float delta_time) {
-    // Només calcular i aplicar offsets si l'animació està activa
+void TitleScene::actualitzar_animacio_logo(float delta_time) {
+    // Solo calcular i aplicar offsets si l'animación está activa
     if (animacio_activa_) {
-        // Acumular temps escalat
+        // Acumular time escalat
         temps_animacio_ += delta_time * factor_lerp_;
 
         // Usar amplituds i freqüències completes
@@ -527,47 +467,47 @@ void EscenaTitol::actualitzar_animacio_logo(float delta_time) {
         float offset_x = amplitude_x_actual * std::sin(2.0F * Defaults::Math::PI * frequency_x_actual * temps_animacio_);
         float offset_y = amplitude_y_actual * std::sin((2.0F * Defaults::Math::PI * frequency_y_actual * temps_animacio_) + ORBIT_PHASE_OFFSET);
 
-        // Aplicar offset a totes les lletres de "ORNI"
+        // Aplicar offset a todas las lletres de "ORNI"
         for (size_t i = 0; i < lletres_orni_.size(); ++i) {
-            lletres_orni_[i].posicio.x = posicions_originals_orni_[i].x + static_cast<int>(std::round(offset_x));
-            lletres_orni_[i].posicio.y = posicions_originals_orni_[i].y + static_cast<int>(std::round(offset_y));
+            lletres_orni_[i].position.x = posicions_originals_orni_[i].x + static_cast<int>(std::round(offset_x));
+            lletres_orni_[i].position.y = posicions_originals_orni_[i].y + static_cast<int>(std::round(offset_y));
         }
 
-        // Aplicar offset a totes les lletres de "ATTACK!"
+        // Aplicar offset a todas las lletres de "ATTACK!"
         for (size_t i = 0; i < lletres_attack_.size(); ++i) {
-            lletres_attack_[i].posicio.x = posicions_originals_attack_[i].x + static_cast<int>(std::round(offset_x));
-            lletres_attack_[i].posicio.y = posicions_originals_attack_[i].y + static_cast<int>(std::round(offset_y));
+            lletres_attack_[i].position.x = posicions_originals_attack_[i].x + static_cast<int>(std::round(offset_x));
+            lletres_attack_[i].position.y = posicions_originals_attack_[i].y + static_cast<int>(std::round(offset_y));
         }
     }
 }
 
-void EscenaTitol::dibuixar() {
-    // Dibuixar starfield de fons (en tots els estats excepte BLACK_SCREEN)
-    if (starfield_ && estat_actual_ != EstatTitol::BLACK_SCREEN) {
-        starfield_->dibuixar();
+void TitleScene::draw() {
+    // Dibuixar starfield de fons (en todos los estats excepte BLACK_SCREEN)
+    if (starfield_ && estat_actual_ != TitleState::BLACK_SCREEN) {
+        starfield_->draw();
     }
 
-    // Dibuixar naus (després starfield, abans logo)
+    // Dibuixar naves (después starfield, antes logo)
     if (ship_animator_ &&
-        (estat_actual_ == EstatTitol::STARFIELD_FADE_IN ||
-            estat_actual_ == EstatTitol::STARFIELD ||
-            estat_actual_ == EstatTitol::MAIN ||
-            estat_actual_ == EstatTitol::PLAYER_JOIN_PHASE)) {
-        ship_animator_->dibuixar();
+        (estat_actual_ == TitleState::STARFIELD_FADE_IN ||
+            estat_actual_ == TitleState::STARFIELD ||
+            estat_actual_ == TitleState::MAIN ||
+            estat_actual_ == TitleState::PLAYER_JOIN_PHASE)) {
+        ship_animator_->draw();
     }
 
-    // En els estats STARFIELD_FADE_IN i STARFIELD, només mostrar starfield (sense text)
-    if (estat_actual_ == EstatTitol::STARFIELD_FADE_IN || estat_actual_ == EstatTitol::STARFIELD) {
+    // En los estats STARFIELD_FADE_IN i STARFIELD, solo mostrar starfield (sin text)
+    if (estat_actual_ == TitleState::STARFIELD_FADE_IN || estat_actual_ == TitleState::STARFIELD) {
         return;
     }
 
-    // Estat MAIN i PLAYER_JOIN_PHASE: Dibuixar títol i text (sobre el starfield)
-    // BLACK_SCREEN: no dibuixar res (fons negre ja està netejat)
-    if (estat_actual_ == EstatTitol::MAIN || estat_actual_ == EstatTitol::PLAYER_JOIN_PHASE) {
-        // === Calcular i renderitzar ombra (només si animació activa) ===
+    // Estat MAIN i PLAYER_JOIN_PHASE: Dibuixar título i text (sobre el starfield)
+    // BLACK_SCREEN: no draw res (fons negre ya está netejat)
+    if (estat_actual_ == TitleState::MAIN || estat_actual_ == TitleState::PLAYER_JOIN_PHASE) {
+        // === Calcular i renderizar ombra (solo si animación activa) ===
         if (animacio_activa_) {
             float temps_shadow = temps_animacio_ - SHADOW_DELAY;
-            temps_shadow = std::max(temps_shadow, 0.0F);  // Evitar temps negatiu
+            temps_shadow = std::max(temps_shadow, 0.0F);  // Evitar time negatiu
 
             // Usar amplituds i freqüències completes per l'ombra
             float amplitude_x_shadow = ORBIT_AMPLITUDE_X;
@@ -583,35 +523,33 @@ void EscenaTitol::dibuixar() {
 
             // Ombra "ORNI"
             for (size_t i = 0; i < lletres_orni_.size(); ++i) {
-                Punt pos_shadow;
+                Vec2 pos_shadow;
                 pos_shadow.x = posicions_originals_orni_[i].x + static_cast<int>(std::round(shadow_offset_x));
                 pos_shadow.y = posicions_originals_orni_[i].y + static_cast<int>(std::round(shadow_offset_y));
 
                 Rendering::render_shape(
-                    sdl_.obte_renderer(),
-                    lletres_orni_[i].forma,
+                    sdl_.getRenderer(),
+                    lletres_orni_[i].shape,
                     pos_shadow,
                     0.0F,
                     Defaults::Title::Layout::LOGO_SCALE,
-                    true,
                     1.0F,              // progress = 1.0 (totalment visible)
-                    SHADOW_BRIGHTNESS  // brightness = 0.4 (brillantor reduïda)
+                    SHADOW_BRIGHTNESS  // brightness = 0.4 (brightness reduïda)
                 );
             }
 
             // Ombra "ATTACK!"
             for (size_t i = 0; i < lletres_attack_.size(); ++i) {
-                Punt pos_shadow;
+                Vec2 pos_shadow;
                 pos_shadow.x = posicions_originals_attack_[i].x + static_cast<int>(std::round(shadow_offset_x));
                 pos_shadow.y = posicions_originals_attack_[i].y + static_cast<int>(std::round(shadow_offset_y));
 
                 Rendering::render_shape(
-                    sdl_.obte_renderer(),
-                    lletres_attack_[i].forma,
+                    sdl_.getRenderer(),
+                    lletres_attack_[i].shape,
                     pos_shadow,
                     0.0F,
                     Defaults::Title::Layout::LOGO_SCALE,
-                    true,
                     1.0F,  // progress = 1.0 (totalment visible)
                     SHADOW_BRIGHTNESS);
             }
@@ -622,12 +560,11 @@ void EscenaTitol::dibuixar() {
         // Dibuixar "ORNI" (línia 1)
         for (const auto& lletra : lletres_orni_) {
             Rendering::render_shape(
-                sdl_.obte_renderer(),
-                lletra.forma,
-                lletra.posicio,
+                sdl_.getRenderer(),
+                lletra.shape,
+                lletra.position,
                 0.0F,
                 Defaults::Title::Layout::LOGO_SCALE,
-                true,
                 1.0F  // Brillantor completa
             );
         }
@@ -635,26 +572,25 @@ void EscenaTitol::dibuixar() {
         // Dibuixar "ATTACK!" (línia 2)
         for (const auto& lletra : lletres_attack_) {
             Rendering::render_shape(
-                sdl_.obte_renderer(),
-                lletra.forma,
-                lletra.posicio,
+                sdl_.getRenderer(),
+                lletra.shape,
+                lletra.position,
                 0.0F,
                 Defaults::Title::Layout::LOGO_SCALE,
-                true,
                 1.0F  // Brillantor completa
             );
         }
 
         // === Text "PRESS START TO PLAY" ===
-        // En estat MAIN: sempre visible
-        // En estat TRANSITION: parpellejant (blink amb sinusoide)
+        // En state MAIN: siempre visible
+        // En state TRANSITION: parpellejant (blink con sinusoide)
 
         const float spacing = Defaults::Title::Layout::TEXT_SPACING;
 
         bool mostrar_text = true;
-        if (estat_actual_ == EstatTitol::PLAYER_JOIN_PHASE) {
-            // Parpelleig: sin oscil·la entre -1 i 1, volem ON quan > 0
-            float fase = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v<float>;  // 2π × freq × temps
+        if (estat_actual_ == TitleState::PLAYER_JOIN_PHASE) {
+            // Parpelleig: sin oscil·la entre -1 i 1, volem ON cuando > 0
+            float fase = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v<float>;  // 2π × freq × time
             mostrar_text = (std::sin(fase) > 0.0F);
         }
 
@@ -665,7 +601,7 @@ void EscenaTitol::dibuixar() {
             float centre_x = Defaults::Game::WIDTH / 2.0F;
             float centre_y = Defaults::Game::HEIGHT * Defaults::Title::Layout::PRESS_START_POS;
 
-            text_.render_centered(main_text, {.x = centre_x, .y = centre_y}, escala_main, spacing);
+            text_.renderCentered(main_text, {.x = centre_x, .y = centre_y}, escala_main, spacing);
         }
 
         // === Copyright a la part inferior (centrat horitzontalment, dues línies) ===
@@ -693,35 +629,35 @@ void EscenaTitol::dibuixar() {
         float y_line1 = Defaults::Game::HEIGHT * Defaults::Title::Layout::COPYRIGHT1_POS;
         float y_line2 = y_line1 + copy_height + line_spacing;  // Línea 2 debajo de línea 1
 
-        // Renderitzar línees centrades
+        // Renderizar línees centrades
         float centre_x = Defaults::Game::WIDTH / 2.0F;
 
-        text_.render_centered(copyright_original, {.x = centre_x, .y = y_line1}, escala_copy, spacing);
-        text_.render_centered(copyright_port, {.x = centre_x, .y = y_line2}, escala_copy, spacing);
+        text_.renderCentered(copyright_original, {.x = centre_x, .y = y_line1}, escala_copy, spacing);
+        text_.renderCentered(copyright_port, {.x = centre_x, .y = y_line2}, escala_copy, spacing);
     }
 }
 
-auto EscenaTitol::checkSkipButtonPressed() -> bool {
+auto TitleScene::checkSkipButtonPressed() -> bool {
     return Input::get()->checkAnyPlayerAction(ARCADE_BUTTONS);
 }
 
-auto EscenaTitol::checkStartGameButtonPressed() -> bool {
+auto TitleScene::checkStartGameButtonPressed() -> bool {
     auto* input = Input::get();
     bool any_pressed = false;
 
     for (auto action : START_GAME_BUTTONS) {
         if (input->checkActionPlayer1(action, Input::DO_NOT_ALLOW_REPEAT)) {
-            if (!config_partida_.jugador1_actiu) {
-                config_partida_.jugador1_actiu = true;
+            if (!match_config_.jugador1_actiu) {
+                match_config_.jugador1_actiu = true;
                 any_pressed = true;
-                std::cout << "[EscenaTitol] P1 pressed START\n";
+                std::cout << "[TitleScene] P1 pressed START\n";
             }
         }
         if (input->checkActionPlayer2(action, Input::DO_NOT_ALLOW_REPEAT)) {
-            if (!config_partida_.jugador2_actiu) {
-                config_partida_.jugador2_actiu = true;
+            if (!match_config_.jugador2_actiu) {
+                match_config_.jugador2_actiu = true;
                 any_pressed = true;
-                std::cout << "[EscenaTitol] P2 pressed START\n";
+                std::cout << "[TitleScene] P2 pressed START\n";
             }
         }
     }
@@ -729,6 +665,8 @@ auto EscenaTitol::checkStartGameButtonPressed() -> bool {
     return any_pressed;
 }
 
-void EscenaTitol::processar_events(const SDL_Event& event) {
-    // No procesar eventos genéricos aquí - la lógica se movió a actualitzar()
+void TitleScene::handleEvent(const SDL_Event& event) {
+    // La lógica de input se decide en update() consultando Input::checkAction;
+    // aquí no hay eventos puntuales que procesar.
+    (void)event;
 }
diff --git a/source/game/escenes/escena_titol.hpp b/source/game/scenes/title_scene.hpp
similarity index 58%
rename from source/game/escenes/escena_titol.hpp
rename to source/game/scenes/title_scene.hpp
index 8f27887..826da38 100644
--- a/source/game/escenes/escena_titol.hpp
+++ b/source/game/scenes/title_scene.hpp
@@ -1,5 +1,5 @@
-// escena_titol.hpp - Pantalla de títol del joc
-// Mostra missatge "PRESS BUTTON TO PLAY" i copyright
+// title_scene.hpp - Pantalla de título del juego
+// Muestra message "PRESS BUTTON TO PLAY" y copyright
 // © 2025 Port a C++20
 
 #pragma once
@@ -16,7 +16,8 @@
 #include "core/graphics/vector_text.hpp"
 #include "core/input/input_types.hpp"
 #include "core/rendering/sdl_manager.hpp"
-#include "core/system/context_escenes.hpp"
+#include "core/system/scene.hpp"
+#include "core/system/scene_context.hpp"
 #include "core/system/game_config.hpp"
 #include "core/types.hpp"
 #include "game/title/ship_animator.hpp"
@@ -25,88 +26,90 @@
 static constexpr std::array<InputAction, 1> START_GAME_BUTTONS = {
     InputAction::START};
 
-class EscenaTitol {
+class TitleScene final : public Scene {
     public:
-        explicit EscenaTitol(SDLManager& sdl, GestorEscenes::ContextEscenes& context);
-        ~EscenaTitol();   // Destructor per aturar música
-        void executar();  // Bucle principal de l'escena
+        explicit TitleScene(SDLManager& sdl, SceneManager::SceneContext& context);
+        ~TitleScene() override;   // Destructor per aturar música
+
+        // Scene interface
+        void handleEvent(const SDL_Event& event) override;
+        void update(float delta_time) override;
+        void draw() override;
+        [[nodiscard]] auto isFinished() const -> bool override;
 
     private:
-        // Màquina d'estats per la pantalla de títol
-        enum class EstatTitol {
+        // Màquina de estats per la pantalla de título
+        enum class TitleState {
             STARFIELD_FADE_IN,  // Fade-in del starfield (3.0s)
-            STARFIELD,          // Pantalla amb camp d'estrelles (4.0s)
-            MAIN,               // Pantalla de títol amb text (indefinit, fins START)
-            PLAYER_JOIN_PHASE,  // Fase d'unió de jugadors: fade-out música + text parpellejant (2.5s)
-            BLACK_SCREEN        // Pantalla negra de transició (2.0s)
+            STARFIELD,          // Pantalla con camp de estrelles (4.0s)
+            MAIN,               // Pantalla de título con text (indefinit, hasta START)
+            PLAYER_JOIN_PHASE,  // Fase de unió de jugadors: fade-out música + text parpellejant (2.5s)
+            BLACK_SCREEN        // Pantalla negra de transición (2.0s)
         };
 
-        // Estructura per emmagatzemar informació de cada lletra del títol
+        // Estructura per emmagatzemar informació de cada lletra del título
         struct LetraLogo {
-                std::shared_ptr<Graphics::Shape> forma;  // Forma vectorial de la lletra
-                Punt posicio;                            // Posició en pantalla
-                float ancho;                             // Amplada escalada
-                float altura;                            // Altura escalada
-                float offset_centre;                     // Offset del centre per posicionament
+                std::shared_ptr<Graphics::Shape> shape;  // Forma vectorial de la lletra
+                Vec2 position;                            // Posición en pantalla
+                float ancho;                             // Amplada scaled
+                float altura;                            // Altura scaled
+                float offset_centre;                     // Offset del centro per posicionament
         };
 
         SDLManager& sdl_;
-        GestorEscenes::ContextEscenes& context_;
-        GameConfig::ConfigPartida config_partida_;            // Configuració de jugadors actius
+        SceneManager::SceneContext& context_;
+        GameConfig::MatchConfig match_config_;            // Configuración de jugadors active
         Graphics::VectorText text_;                           // Sistema de text vectorial
-        std::unique_ptr<Graphics::Starfield> starfield_;      // Camp d'estrelles de fons
-        std::unique_ptr<Title::ShipAnimator> ship_animator_;  // Naus 3D flotants
-        EstatTitol estat_actual_;                             // Estat actual de la màquina
-        float temps_acumulat_;                                // Temps acumulat per l'estat INIT
+        std::unique_ptr<Graphics::Starfield> starfield_;      // Camp de estrelles de fons
+        std::unique_ptr<Title::ShipAnimator> ship_animator_;  // Naves 3D flotantes
+        TitleState estat_actual_;                             // Estat actual de la màquina
+        float temps_acumulat_;                                // Temps acumulat per l'state INIT
 
-        // Lletres del títol "ORNI ATTACK!"
+        // Lletres del título "ORNI ATTACK!"
         std::vector<LetraLogo> lletres_orni_;    // Lletres de "ORNI" (línia 1)
         std::vector<LetraLogo> lletres_attack_;  // Lletres de "ATTACK!" (línia 2)
-        float y_attack_dinamica_;                // Posició Y calculada dinàmicament per "ATTACK!"
+        float y_attack_dinamica_;                // Posición Y calculada dinàmicament per "ATTACK!"
 
-        // Estat d'animació del logo
-        float temps_animacio_;                          // Temps acumulat per animació orbital
-        std::vector<Punt> posicions_originals_orni_;    // Posicions originals de "ORNI"
-        std::vector<Punt> posicions_originals_attack_;  // Posicions originals de "ATTACK!"
+        // Estat de animación del logo
+        float temps_animacio_;                          // Temps acumulat per animación orbital
+        std::vector<Vec2> posicions_originals_orni_;    // Posicions originals de "ORNI"
+        std::vector<Vec2> posicions_originals_attack_;  // Posicions originals de "ATTACK!"
 
-        // Estat d'arrencada de l'animació
-        float temps_estat_main_;  // Temps acumulat en estat MAIN
-        bool animacio_activa_;    // Flag: true quan animació està activa
+        // Estat de arrencada de l'animación
+        float temps_estat_main_;  // Temps acumulat en state MAIN
+        bool animacio_activa_;    // Flag: true cuando animación está activa
         float factor_lerp_;       // Factor de lerp actual (0.0 → 1.0)
 
         // Constants
         static constexpr float BRIGHTNESS_STARFIELD = 1.2F;  // Brightness del starfield (>1.0 = més brillant)
         static constexpr float DURACIO_FADE_IN = 3.0F;       // Duració del fade-in del starfield (1.5 segons)
-        static constexpr float DURACIO_INIT = 4.0F;          // Duració de l'estat INIT (2 segons)
-        static constexpr float DURACIO_TRANSITION = 2.5F;    // Duració de la transició (1.5 segons)
+        static constexpr float DURACIO_INIT = 4.0F;          // Duració de l'state INIT (2 segons)
+        static constexpr float DURACIO_TRANSITION = 2.5F;    // Duració de la transición (1.5 segons)
         static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;  // Espai entre lletres
         static constexpr float BLINK_FREQUENCY = 3.0F;       // Freqüència de parpelleig (3 Hz)
         static constexpr float DURACIO_BLACK_SCREEN = 2.0F;  // Duració pantalla negra (2 segons)
         static constexpr int MUSIC_FADE = 1500;              // Duracio del fade de la musica del titol al començar a jugar
 
-        // Constants d'animació del logo
+        // Constants de animación del logo
         static constexpr float ORBIT_AMPLITUDE_X = 4.0F;    // Amplitud oscil·lació horitzontal (píxels)
         static constexpr float ORBIT_AMPLITUDE_Y = 3.0F;    // Amplitud oscil·lació vertical (píxels)
-        static constexpr float ORBIT_FREQUENCY_X = 0.8F;    // Velocitat oscil·lació horitzontal (Hz)
-        static constexpr float ORBIT_FREQUENCY_Y = 1.2F;    // Velocitat oscil·lació vertical (Hz)
+        static constexpr float ORBIT_FREQUENCY_X = 0.8F;    // Velocidad oscil·lació horitzontal (Hz)
+        static constexpr float ORBIT_FREQUENCY_Y = 1.2F;    // Velocidad oscil·lació vertical (Hz)
         static constexpr float ORBIT_PHASE_OFFSET = 1.57F;  // Desfasament entre X i Y (90° per circular)
 
-        // Constants d'ombra del logo
+        // Constants de ombra del logo
         static constexpr float SHADOW_DELAY = 0.5F;       // Retard temporal de l'ombra (segons)
-        static constexpr float SHADOW_BRIGHTNESS = 0.4F;  // Multiplicador de brillantor de l'ombra (0.0-1.0)
+        static constexpr float SHADOW_BRIGHTNESS = 0.4F;  // Multiplicador de brightness de l'ombra (0.0-1.0)
         static constexpr float SHADOW_OFFSET_X = 2.0F;    // Offset espacial X fix (píxels)
         static constexpr float SHADOW_OFFSET_Y = 2.0F;    // Offset espacial Y fix (píxels)
 
-        // Temporització de l'arrencada de l'animació
-        static constexpr float DELAY_INICI_ANIMACIO = 10.0F;  // 10s estàtic abans d'animar
+        // Temporització de l'arrencada de l'animación
+        static constexpr float DELAY_INICI_ANIMACIO = 10.0F;  // 10s estàtic antes de animar
         static constexpr float DURACIO_LERP = 2.0F;           // 2s per arribar a amplitud completa
 
-        // Mètodes privats
-        void actualitzar(float delta_time);
-        void actualitzar_animacio_logo(float delta_time);  // Actualitza l'animació orbital del logo
-        void dibuixar();
-        void processar_events(const SDL_Event& event);
+        // Métodos privats
+        void actualitzar_animacio_logo(float delta_time);  // Actualitza l'animación orbital del logo
         auto checkSkipButtonPressed() -> bool;
         auto checkStartGameButtonPressed() -> bool;
-        void inicialitzar_titol();  // Carrega i posiciona les lletres del títol
+        void inicialitzar_titol();  // Carrega i posiciona las lletres del título
 };
diff --git a/source/game/stage_system/spawn_controller.cpp b/source/game/stage_system/spawn_controller.cpp
index ddf93b6..2f415e1 100644
--- a/source/game/stage_system/spawn_controller.cpp
+++ b/source/game/stage_system/spawn_controller.cpp
@@ -10,7 +10,7 @@
 #include <utility>
 
 #include "core/types.hpp"
-#include "game/entities/enemic.hpp"
+#include "game/entities/enemy.hpp"
 #include "stage_config.hpp"
 
 namespace StageSystem {
@@ -21,13 +21,13 @@ SpawnController::SpawnController()
       index_spawn_actual_(0),
       ship_position_(nullptr) {}
 
-void SpawnController::configurar(const ConfigStage* config) {
+void SpawnController::configure(const StageConfig* config) {
     config_ = config;
 }
 
-void SpawnController::iniciar() {
+void SpawnController::start() {
     if (config_ == nullptr) {
-        std::cerr << "[SpawnController] Error: config_ és null" << '\n';
+        std::cerr << "[SpawnController] Error: config_ es null" << '\n';
         return;
     }
 
@@ -44,7 +44,7 @@ void SpawnController::reset() {
     index_spawn_actual_ = 0;
 }
 
-void SpawnController::actualitzar(float delta_time, std::array<Enemic, 15>& orni_array, bool pausar) {
+void SpawnController::update(float delta_time, std::array<Enemy, 15>& orni_array, bool pausar) {
     if ((config_ == nullptr) || spawn_queue_.empty()) {
         return;
     }
@@ -65,9 +65,9 @@ void SpawnController::actualitzar(float delta_time, std::array<Enemic, 15>& orni
 
         if (temps_transcorregut_ >= event.temps_spawn) {
             // Find first inactive enemy
-            for (auto& enemic : orni_array) {
-                if (!enemic.esta_actiu()) {
-                    spawn_enemic(enemic, event.tipus, ship_position_);
+            for (auto& enemy : orni_array) {
+                if (!enemy.isActive()) {
+                    spawn_enemic(enemy, event.type, ship_position_);
                     event.spawnejat = true;
                     index_spawn_actual_++;
                     break;
@@ -89,13 +89,13 @@ bool SpawnController::tots_enemics_spawnejats() const {
     return index_spawn_actual_ >= spawn_queue_.size();
 }
 
-bool SpawnController::tots_enemics_destruits(const std::array<Enemic, 15>& orni_array) const {
+bool SpawnController::tots_enemics_destruits(const std::array<Enemy, 15>& orni_array) const {
     if (!tots_enemics_spawnejats()) {
         return false;
     }
 
-    for (const auto& enemic : orni_array) {
-        if (enemic.esta_actiu()) {
+    for (const auto& enemy : orni_array) {
+        if (enemy.isActive()) {
             return false;
         }
     }
@@ -103,10 +103,10 @@ bool SpawnController::tots_enemics_destruits(const std::array<Enemic, 15>& orni_
     return true;
 }
 
-uint8_t SpawnController::get_enemics_vius(const std::array<Enemic, 15>& orni_array) const {
+uint8_t SpawnController::get_enemics_vius(const std::array<Enemy, 15>& orni_array) const {
     uint8_t count = 0;
-    for (const auto& enemic : orni_array) {
-        if (enemic.esta_actiu()) {
+    for (const auto& enemy : orni_array) {
+        if (enemy.isActive()) {
             count++;
         }
     }
@@ -122,56 +122,56 @@ void SpawnController::generar_spawn_events() {
         return;
     }
 
-    for (uint8_t i = 0; i < config_->total_enemics; i++) {
+    for (uint8_t i = 0; i < config_->total_enemies; i++) {
         float spawn_time = config_->config_spawn.delay_inicial +
             (i * config_->config_spawn.interval_spawn);
 
-        TipusEnemic tipus = seleccionar_tipus_aleatori();
+        EnemyType type = seleccionar_tipus_aleatori();
 
-        spawn_queue_.push_back({spawn_time, tipus, false});
+        spawn_queue_.push_back({spawn_time, type, false});
     }
 }
 
-TipusEnemic SpawnController::seleccionar_tipus_aleatori() const {
+EnemyType SpawnController::seleccionar_tipus_aleatori() const {
     if (config_ == nullptr) {
-        return TipusEnemic::PENTAGON;
+        return EnemyType::PENTAGON;
     }
 
     // Weighted random selection based on distribution
     int rand_val = std::rand() % 100;
 
     if (std::cmp_less(rand_val, config_->distribucio.pentagon)) {
-        return TipusEnemic::PENTAGON;
+        return EnemyType::PENTAGON;
     }
-    if (rand_val < config_->distribucio.pentagon + config_->distribucio.quadrat) {
-        return TipusEnemic::QUADRAT;
+    if (rand_val < config_->distribucio.pentagon + config_->distribucio.cuadrado) {
+        return EnemyType::QUADRAT;
     }
-    return TipusEnemic::MOLINILLO;
+    return EnemyType::MOLINILLO;
 }
 
-void SpawnController::spawn_enemic(Enemic& enemic, TipusEnemic tipus, const Punt* ship_pos) {
+void SpawnController::spawn_enemic(Enemy& enemy, EnemyType type, const Vec2* ship_pos) {
     // Initialize enemy (with safe spawn if ship_pos provided)
-    enemic.inicialitzar(tipus, ship_pos);
+    enemy.init(type, ship_pos);
 
     // Apply difficulty multipliers
-    aplicar_multiplicadors(enemic);
+    aplicar_multiplicadors(enemy);
 }
 
-void SpawnController::aplicar_multiplicadors(Enemic& enemic) const {
+void SpawnController::aplicar_multiplicadors(Enemy& enemy) const {
     if (config_ == nullptr) {
         return;
     }
 
     // Apply velocity multiplier
-    float base_vel = enemic.get_base_velocity();
-    enemic.set_velocity(base_vel * config_->multiplicadors.velocitat);
+    float base_vel = enemy.getBaseVelocity();
+    enemy.setVelocity(base_vel * config_->multiplicadors.velocity);
 
     // Apply rotation multiplier
-    float base_rot = enemic.get_base_rotation();
-    enemic.set_rotation(base_rot * config_->multiplicadors.rotacio);
+    float base_rot = enemy.getBaseRotation();
+    enemy.setRotation(base_rot * config_->multiplicadors.rotation);
 
     // Apply tracking strength (only affects QUADRAT)
-    enemic.set_tracking_strength(config_->multiplicadors.tracking_strength);
+    enemy.setTrackingStrength(config_->multiplicadors.tracking_strength);
 }
 
 }  // namespace StageSystem
diff --git a/source/game/stage_system/spawn_controller.hpp b/source/game/stage_system/spawn_controller.hpp
index f042c4f..cc60115 100644
--- a/source/game/stage_system/spawn_controller.hpp
+++ b/source/game/stage_system/spawn_controller.hpp
@@ -1,4 +1,4 @@
-// spawn_controller.hpp - Controlador de spawn d'enemics
+// spawn_controller.hpp - Controlador de spawn de enemigos
 // © 2025 Orni Attack
 
 #pragma once
@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "core/types.hpp"
-#include "game/entities/enemic.hpp"
+#include "game/entities/enemy.hpp"
 #include "stage_config.hpp"
 
 namespace StageSystem {
@@ -16,8 +16,8 @@ namespace StageSystem {
 // Informació de spawn planificat
 struct SpawnEvent {
         float temps_spawn;  // Temps absolut (segons) per spawnejar
-        TipusEnemic tipus;  // Tipus d'enemic
-        bool spawnejat;     // Ja s'ha processat?
+        EnemyType type;  // Tipo de enemy
+        bool spawnejat;     // Ya s'ha processat?
 };
 
 class SpawnController {
@@ -25,34 +25,34 @@ class SpawnController {
         SpawnController();
 
         // Configuration
-        void configurar(const ConfigStage* config);  // Set stage config
-        void iniciar();                              // Generate spawn schedule
+        void configure(const StageConfig* config);  // Set stage config
+        void start();                              // Generate spawn schedule
         void reset();                                // Clear all pending spawns
 
         // Update
-        void actualitzar(float delta_time, std::array<Enemic, 15>& orni_array, bool pausar = false);
+        void update(float delta_time, std::array<Enemy, 15>& orni_array, bool pausar = false);
 
         // Status queries
         [[nodiscard]] bool tots_enemics_spawnejats() const;
-        [[nodiscard]] bool tots_enemics_destruits(const std::array<Enemic, 15>& orni_array) const;
-        [[nodiscard]] uint8_t get_enemics_vius(const std::array<Enemic, 15>& orni_array) const;
+        [[nodiscard]] bool tots_enemics_destruits(const std::array<Enemy, 15>& orni_array) const;
+        [[nodiscard]] uint8_t get_enemics_vius(const std::array<Enemy, 15>& orni_array) const;
         [[nodiscard]] uint8_t get_enemics_spawnejats() const;
 
         // [NEW] Set ship position reference for safe spawn
-        void set_ship_position(const Punt* ship_pos) { ship_position_ = ship_pos; }
+        void setShipPosition(const Vec2* ship_pos) { ship_position_ = ship_pos; }
 
     private:
-        const ConfigStage* config_;  // Non-owning pointer to current stage config
+        const StageConfig* config_;  // Non-owning pointer to current stage config
         std::vector<SpawnEvent> spawn_queue_;
         float temps_transcorregut_;   // Elapsed time since stage start
         uint8_t index_spawn_actual_;  // Next spawn to process
 
         // Spawn generation
         void generar_spawn_events();
-        [[nodiscard]] TipusEnemic seleccionar_tipus_aleatori() const;
-        void spawn_enemic(Enemic& enemic, TipusEnemic tipus, const Punt* ship_pos = nullptr);
-        void aplicar_multiplicadors(Enemic& enemic) const;
-        const Punt* ship_position_;  // [NEW] Non-owning pointer to ship position
+        [[nodiscard]] EnemyType seleccionar_tipus_aleatori() const;
+        void spawn_enemic(Enemy& enemy, EnemyType type, const Vec2* ship_pos = nullptr);
+        void aplicar_multiplicadors(Enemy& enemy) const;
+        const Vec2* ship_position_;  // [NEW] Non-owning pointer to ship position
 };
 
 }  // namespace StageSystem
diff --git a/source/game/stage_system/stage_config.hpp b/source/game/stage_system/stage_config.hpp
index ff41e34..3b11429 100644
--- a/source/game/stage_system/stage_config.hpp
+++ b/source/game/stage_system/stage_config.hpp
@@ -1,4 +1,4 @@
-// stage_config.hpp - Estructures de dades per configuració d'stages
+// stage_config.hpp - Estructures de dades per configuración de stages
 // © 2025 Orni Attack
 
 #pragma once
@@ -10,46 +10,46 @@
 
 namespace StageSystem {
 
-// Tipus de mode de spawn
+// Tipo de mode de spawn
 enum class ModeSpawn {
-    PROGRESSIVE,  // Spawn progressiu amb intervals
-    IMMEDIATE,    // Tots els enemics de cop
-    WAVE          // Onades de 3-5 enemics (futura extensió)
+    PROGRESSIVE,  // Spawn progressiu con intervals
+    IMMEDIATE,    // Todos los enemigos de cop
+    WAVE          // Onades de 3-5 enemigos (futura extensió)
 };
 
-// Configuració de spawn
+// Configuración de spawn
 struct ConfigSpawn {
         ModeSpawn mode;
-        float delay_inicial;   // Segons abans del primer spawn
+        float delay_inicial;   // Segons antes del primer spawn
         float interval_spawn;  // Segons entre spawns consecutius
 };
 
-// Distribució de tipus d'enemics (percentatges)
+// Distribució de type de enemigos (percentatges)
 struct DistribucioEnemics {
         uint8_t pentagon;   // 0-100
-        uint8_t quadrat;    // 0-100
+        uint8_t cuadrado;    // 0-100
         uint8_t molinillo;  // 0-100
                             // Suma ha de ser 100, validat en StageLoader
 };
 
 // Multiplicadors de dificultat
 struct MultiplicadorsDificultat {
-        float velocitat;          // 0.5-2.0 típic
-        float rotacio;            // 0.5-2.0 típic
-        float tracking_strength;  // 0.0-1.5 (aplicat a Quadrat)
+        float velocity;          // 0.5-2.0 típic
+        float rotation;            // 0.5-2.0 típic
+        float tracking_strength;  // 0.0-1.5 (aplicat a Cuadrado)
 };
 
-// Metadades del fitxer YAML
+// Metadades del file YAML
 struct MetadataStages {
         std::string version;
         uint8_t total_stages;
         std::string descripcio;
 };
 
-// Configuració completa d'un stage
-struct ConfigStage {
+// Configuración completa de un stage
+struct StageConfig {
         uint8_t stage_id;       // 1-10
-        uint8_t total_enemics;  // 5-15
+        uint8_t total_enemies;  // 5-15
         ConfigSpawn config_spawn;
         DistribucioEnemics distribucio;
         MultiplicadorsDificultat multiplicadors;
@@ -57,18 +57,18 @@ struct ConfigStage {
         // Validació
         [[nodiscard]] bool es_valid() const {
             return stage_id >= 1 && stage_id <= 255 &&
-                total_enemics > 0 && total_enemics <= 15 &&
-                distribucio.pentagon + distribucio.quadrat + distribucio.molinillo == 100;
+                total_enemies > 0 && total_enemies <= 15 &&
+                distribucio.pentagon + distribucio.cuadrado + distribucio.molinillo == 100;
         }
 };
 
-// Configuració completa del sistema (carregada des de YAML)
-struct ConfigSistemaStages {
+// Configuración completa del sistema (carregada desde YAML)
+struct StageSystemConfig {
         MetadataStages metadata;
-        std::vector<ConfigStage> stages;  // Índex [0] = stage 1
+        std::vector<StageConfig> stages;  // Índex [0] = stage 1
 
-        // Obtenir configuració d'un stage específic
-        [[nodiscard]] const ConfigStage* obte_stage(uint8_t stage_id) const {
+        // Obtenir configuración de un stage específic
+        [[nodiscard]] const StageConfig* obte_stage(uint8_t stage_id) const {
             if (stage_id < 1 || stage_id > stages.size()) {
                 return nullptr;
             }
@@ -76,9 +76,9 @@ struct ConfigSistemaStages {
         }
 };
 
-// Constants per missatges de transició
+// Constants per messages de transición
 namespace Constants {
-// Pool de missatges per inici de level (selecció aleatòria)
+// Pool de messages per start de level (selecció aleatòria)
 inline constexpr std::array<const char*, 12> MISSATGES_LEVEL_START = {
     "ORNI ALERT!",
     "INCOMING ORNIS!",
diff --git a/source/game/stage_system/stage_loader.cpp b/source/game/stage_system/stage_loader.cpp
index d1046f3..3a5b8fa 100644
--- a/source/game/stage_system/stage_loader.cpp
+++ b/source/game/stage_system/stage_loader.cpp
@@ -1,4 +1,4 @@
-// stage_loader.cpp - Implementació del carregador de configuració YAML
+// stage_loader.cpp - Implementació del carregador de configuración YAML
 // © 2025 Orni Attack
 
 #include "stage_loader.hpp"
@@ -19,7 +19,7 @@
 
 namespace StageSystem {
 
-std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& path) {
+std::unique_ptr<StageSystemConfig> StageLoader::load(const std::string& path) {
     try {
         // Normalize path: "data/stages/stages.yaml" → "stages/stages.yaml"
         std::string normalized = path;
@@ -30,7 +30,7 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa
         // Load from resource system
         std::vector<uint8_t> data = Resource::Helper::loadFile(normalized);
         if (data.empty()) {
-            std::cerr << "[StageLoader] Error: no es pot carregar " << normalized << '\n';
+            std::cerr << "[StageLoader] Error: no es pot load " << normalized << '\n';
             return nullptr;
         }
 
@@ -40,7 +40,7 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa
 
         // Parse YAML
         fkyaml::node yaml = fkyaml::node::deserialize(stream);
-        auto config = std::make_unique<ConfigSistemaStages>();
+        auto config = std::make_unique<StageSystemConfig>();
 
         // Parse metadata
         if (!yaml.contains("metadata")) {
@@ -58,19 +58,19 @@ std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& pa
         }
 
         if (!yaml["stages"].is_sequence()) {
-            std::cerr << "[StageLoader] Error: 'stages' ha de ser una llista" << '\n';
+            std::cerr << "[StageLoader] Error: 'stages' ha de ser una list" << '\n';
             return nullptr;
         }
 
         for (const auto& stage_yaml : yaml["stages"]) {
-            ConfigStage stage;
+            StageConfig stage;
             if (!parse_stage(stage_yaml, stage)) {
                 return nullptr;
             }
             config->stages.push_back(stage);
         }
 
-        // Validar configuració
+        // Validar configuración
         if (!validar_config(*config)) {
             return nullptr;
         }
@@ -105,7 +105,7 @@ bool StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta)
     }
 }
 
-bool StageLoader::parse_stage(const fkyaml::node& yaml, ConfigStage& stage) {
+bool StageLoader::parse_stage(const fkyaml::node& yaml, StageConfig& stage) {
     try {
         if (!yaml.contains("stage_id") || !yaml.contains("total_enemies") ||
             !yaml.contains("spawn_config") || !yaml.contains("enemy_distribution") ||
@@ -115,7 +115,7 @@ bool StageLoader::parse_stage(const fkyaml::node& yaml, ConfigStage& stage) {
         }
 
         stage.stage_id = yaml["stage_id"].get_value<uint8_t>();
-        stage.total_enemics = yaml["total_enemies"].get_value<uint8_t>();
+        stage.total_enemies = yaml["total_enemies"].get_value<uint8_t>();
 
         if (!parse_spawn_config(yaml["spawn_config"], stage.config_spawn)) {
             return false;
@@ -129,7 +129,7 @@ bool StageLoader::parse_stage(const fkyaml::node& yaml, ConfigStage& stage) {
 
         if (!stage.es_valid()) {
             std::cerr << "[StageLoader] Error: stage " << static_cast<int>(stage.stage_id)
-                      << " no és vàlid" << '\n';
+                      << " no es vàlid" << '\n';
             return false;
         }
 
@@ -162,18 +162,18 @@ bool StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& conf
 
 bool StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist) {
     try {
-        if (!yaml.contains("pentagon") || !yaml.contains("quadrat") ||
+        if (!yaml.contains("pentagon") || !yaml.contains("cuadrado") ||
             !yaml.contains("molinillo")) {
             std::cerr << "[StageLoader] Error: enemy_distribution incompleta" << '\n';
             return false;
         }
 
         dist.pentagon = yaml["pentagon"].get_value<uint8_t>();
-        dist.quadrat = yaml["quadrat"].get_value<uint8_t>();
+        dist.cuadrado = yaml["cuadrado"].get_value<uint8_t>();
         dist.molinillo = yaml["molinillo"].get_value<uint8_t>();
 
         // Validar que suma 100
-        int sum = dist.pentagon + dist.quadrat + dist.molinillo;
+        int sum = dist.pentagon + dist.cuadrado + dist.molinillo;
         if (sum != 100) {
             std::cerr << "[StageLoader] Error: distribució no suma 100 (suma=" << sum << ")" << '\n';
             return false;
@@ -194,19 +194,19 @@ bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDifi
             return false;
         }
 
-        mult.velocitat = yaml["speed_multiplier"].get_value<float>();
-        mult.rotacio = yaml["rotation_multiplier"].get_value<float>();
+        mult.velocity = yaml["speed_multiplier"].get_value<float>();
+        mult.rotation = yaml["rotation_multiplier"].get_value<float>();
         mult.tracking_strength = yaml["tracking_strength"].get_value<float>();
 
         // Validar rangs raonables
-        if (mult.velocitat < 0.1F || mult.velocitat > 5.0F) {
-            std::cerr << "[StageLoader] Warning: speed_multiplier fora de rang (0.1-5.0)" << '\n';
+        if (mult.velocity < 0.1F || mult.velocity > 5.0F) {
+            std::cerr << "[StageLoader] Warning: speed_multiplier fuera de rang (0.1-5.0)" << '\n';
         }
-        if (mult.rotacio < 0.1F || mult.rotacio > 5.0F) {
-            std::cerr << "[StageLoader] Warning: rotation_multiplier fora de rang (0.1-5.0)" << '\n';
+        if (mult.rotation < 0.1F || mult.rotation > 5.0F) {
+            std::cerr << "[StageLoader] Warning: rotation_multiplier fuera de rang (0.1-5.0)" << '\n';
         }
         if (mult.tracking_strength < 0.0F || mult.tracking_strength > 2.0F) {
-            std::cerr << "[StageLoader] Warning: tracking_strength fora de rang (0.0-2.0)" << '\n';
+            std::cerr << "[StageLoader] Warning: tracking_strength fuera de rang (0.0-2.0)" << '\n';
         }
 
         return true;
@@ -231,15 +231,15 @@ ModeSpawn StageLoader::parse_spawn_mode(const std::string& mode_str) {
     return ModeSpawn::PROGRESSIVE;
 }
 
-bool StageLoader::validar_config(const ConfigSistemaStages& config) {
+bool StageLoader::validar_config(const StageSystemConfig& config) {
     if (config.stages.empty()) {
-        std::cerr << "[StageLoader] Error: cap stage carregat" << '\n';
+        std::cerr << "[StageLoader] Error: sin stage carregat" << '\n';
         return false;
     }
 
     if (config.stages.size() != config.metadata.total_stages) {
         std::cerr << "[StageLoader] Warning: nombre de stages (" << config.stages.size()
-                  << ") no coincideix amb metadata.total_stages ("
+                  << ") no coincideix con metadata.total_stages ("
                   << static_cast<int>(config.metadata.total_stages) << ")" << '\n';
     }
 
diff --git a/source/game/stage_system/stage_loader.hpp b/source/game/stage_system/stage_loader.hpp
index 61238a3..06d7c90 100644
--- a/source/game/stage_system/stage_loader.hpp
+++ b/source/game/stage_system/stage_loader.hpp
@@ -1,4 +1,4 @@
-// stage_loader.hpp - Carregador de configuració YAML
+// stage_loader.hpp - Carregador de configuración YAML
 // © 2025 Orni Attack
 
 #pragma once
@@ -13,21 +13,21 @@ namespace StageSystem {
 
 class StageLoader {
     public:
-        // Carregar configuració des de fitxer YAML
-        // Retorna nullptr si hi ha errors
-        static std::unique_ptr<ConfigSistemaStages> carregar(const std::string& path);
+        // Carregar configuración desde file YAML
+        // Retorna nullptr si hay errors
+        static std::unique_ptr<StageSystemConfig> load(const std::string& path);
 
     private:
         // Parsing helpers (implementats en .cpp)
         static bool parse_metadata(const fkyaml::node& yaml, MetadataStages& meta);
-        static bool parse_stage(const fkyaml::node& yaml, ConfigStage& stage);
+        static bool parse_stage(const fkyaml::node& yaml, StageConfig& stage);
         static bool parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config);
         static bool parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist);
         static bool parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult);
         static ModeSpawn parse_spawn_mode(const std::string& mode_str);
 
         // Validació
-        static bool validar_config(const ConfigSistemaStages& config);
+        static bool validar_config(const StageSystemConfig& config);
 };
 
 }  // namespace StageSystem
diff --git a/source/game/stage_system/stage_manager.cpp b/source/game/stage_system/stage_manager.cpp
index 6fb3d2f..d6bfa69 100644
--- a/source/game/stage_system/stage_manager.cpp
+++ b/source/game/stage_system/stage_manager.cpp
@@ -1,4 +1,4 @@
-// stage_manager.cpp - Implementació del gestor d'stages
+// stage_manager.cpp - Implementació del gestor de stages
 // © 2025 Orni Attack
 
 #include "stage_manager.hpp"
@@ -14,17 +14,17 @@
 
 namespace StageSystem {
 
-StageManager::StageManager(const ConfigSistemaStages* config)
+StageManager::StageManager(const StageSystemConfig* config)
     : config_(config),
       estat_(EstatStage::LEVEL_START),
       stage_actual_(1),
       timer_transicio_(0.0F) {
     if (config_ == nullptr) {
-        std::cerr << "[StageManager] Error: config és null" << '\n';
+        std::cerr << "[StageManager] Error: config es null" << '\n';
     }
 }
 
-void StageManager::inicialitzar() {
+void StageManager::init() {
     stage_actual_ = 1;
     carregar_stage(stage_actual_);
     canviar_estat(EstatStage::INIT_HUD);
@@ -33,7 +33,7 @@ void StageManager::inicialitzar() {
               << '\n';
 }
 
-void StageManager::actualitzar(float delta_time, bool pausar_spawn) {
+void StageManager::update(float delta_time, bool pause_spawn) {
     switch (estat_) {
         case EstatStage::INIT_HUD:
             processar_init_hud(delta_time);
@@ -44,7 +44,7 @@ void StageManager::actualitzar(float delta_time, bool pausar_spawn) {
             break;
 
         case EstatStage::PLAYING:
-            processar_playing(delta_time, pausar_spawn);
+            processar_playing(delta_time, pause_spawn);
             break;
 
         case EstatStage::LEVEL_COMPLETED:
@@ -65,7 +65,7 @@ bool StageManager::tot_completat() const {
         timer_transicio_ <= 0.0F;
 }
 
-const ConfigStage* StageManager::get_config_actual() const {
+const StageConfig* StageManager::get_config_actual() const {
     return config_->obte_stage(stage_actual_);
 }
 
@@ -86,14 +86,14 @@ void StageManager::canviar_estat(EstatStage nou_estat) {
         size_t index = static_cast<size_t>(std::rand()) % Constants::MISSATGES_LEVEL_START.size();
         missatge_level_start_actual_ = Constants::MISSATGES_LEVEL_START[index];
 
-        // [NOU] Iniciar música al entrar en LEVEL_START (després de INIT_HUD)
-        // Només si no està sonant ja (per evitar reiniciar en loops posteriors)
-        if (Audio::get()->getMusicState() != Audio::MusicState::PLAYING) {
+        // [NOU] Iniciar música al entrar en LEVEL_START (después de INIT_HUD)
+        // Solo si no está sonant ya (per evitar reset en loops posteriors)
+        if (Audio::getMusicState() != Audio::MusicState::PLAYING) {
             Audio::get()->playMusic("game.ogg");
         }
     }
 
-    std::cout << "[StageManager] Canvi d'estat: ";
+    std::cout << "[StageManager] Canvi de state: ";
     switch (nou_estat) {
         case EstatStage::INIT_HUD:
             std::cout << "INIT_HUD";
@@ -127,12 +127,12 @@ void StageManager::processar_level_start(float delta_time) {
     }
 }
 
-void StageManager::processar_playing(float delta_time, bool pausar_spawn) {
-    // Update spawn controller (pauses when pausar_spawn = true)
-    // Note: The actual enemy array update happens in EscenaJoc::actualitzar()
+void StageManager::processar_playing(float delta_time, bool pause_spawn) {
+    // Update spawn controller (pauses when pause_spawn = true)
+    // Note: The actual enemy array update happens in GameScene::update()
     // This is just for internal timekeeping
     (void)delta_time;    // Spawn controller is updated externally
-    (void)pausar_spawn;  // Passed to spawn_controller_.actualitzar() by EscenaJoc
+    (void)pause_spawn;  // Passed to spawn_controller_.update() by GameScene
 }
 
 void StageManager::processar_level_completed(float delta_time) {
@@ -145,7 +145,7 @@ void StageManager::processar_level_completed(float delta_time) {
         // Loop back to stage 1 after final stage
         if (stage_actual_ > config_->metadata.total_stages) {
             stage_actual_ = 1;
-            std::cout << "[StageManager] Totes les stages completades! Tornant a stage 1"
+            std::cout << "[StageManager] Todas las stages completades! Tornant a stage 1"
                       << '\n';
         }
 
@@ -156,7 +156,7 @@ void StageManager::processar_level_completed(float delta_time) {
 }
 
 void StageManager::carregar_stage(uint8_t stage_id) {
-    const ConfigStage* stage_config = config_->obte_stage(stage_id);
+    const StageConfig* stage_config = config_->obte_stage(stage_id);
     if (stage_config == nullptr) {
         std::cerr << "[StageManager] Error: no es pot trobar stage " << static_cast<int>(stage_id)
                   << '\n';
@@ -164,11 +164,11 @@ void StageManager::carregar_stage(uint8_t stage_id) {
     }
 
     // Configure spawn controller
-    spawn_controller_.configurar(stage_config);
-    spawn_controller_.iniciar();
+    spawn_controller_.configure(stage_config);
+    spawn_controller_.start();
 
     std::cout << "[StageManager] Carregat stage " << static_cast<int>(stage_id) << ": "
-              << static_cast<int>(stage_config->total_enemics) << " enemics" << '\n';
+              << static_cast<int>(stage_config->total_enemies) << " enemigos" << '\n';
 }
 
 }  // namespace StageSystem
diff --git a/source/game/stage_system/stage_manager.hpp b/source/game/stage_system/stage_manager.hpp
index 96371de..128a6e7 100644
--- a/source/game/stage_system/stage_manager.hpp
+++ b/source/game/stage_system/stage_manager.hpp
@@ -1,4 +1,4 @@
-// stage_manager.hpp - Gestor d'estat i progressió d'stages
+// stage_manager.hpp - Gestor de state i progressió de stages
 // © 2025 Orni Attack
 
 #pragma once
@@ -13,7 +13,7 @@ namespace StageSystem {
 
 // Estats del stage system
 enum class EstatStage {
-    INIT_HUD,        // Animació inicial del HUD (3s)
+    INIT_HUD,        // Animación inicial del HUD (3s)
     LEVEL_START,     // Pantalla "ENEMY INCOMING" (3s)
     PLAYING,         // Gameplay normal
     LEVEL_COMPLETED  // Pantalla "GOOD JOB COMMANDER!" (3s)
@@ -21,11 +21,11 @@ enum class EstatStage {
 
 class StageManager {
     public:
-        explicit StageManager(const ConfigSistemaStages* config);
+        explicit StageManager(const StageSystemConfig* config);
 
         // Lifecycle
-        void inicialitzar();  // Reset to stage 1
-        void actualitzar(float delta_time, bool pausar_spawn = false);
+        void init();  // Reset to stage 1
+        void update(float delta_time, bool pause_spawn = false);
 
         // Stage progression
         void stage_completat();                    // Call when all enemies destroyed
@@ -34,16 +34,16 @@ class StageManager {
         // Current state queries
         [[nodiscard]] EstatStage get_estat() const { return estat_; }
         [[nodiscard]] uint8_t get_stage_actual() const { return stage_actual_; }
-        [[nodiscard]] const ConfigStage* get_config_actual() const;
+        [[nodiscard]] const StageConfig* get_config_actual() const;
         [[nodiscard]] float get_timer_transicio() const { return timer_transicio_; }
         [[nodiscard]] const std::string& get_missatge_level_start() const { return missatge_level_start_actual_; }
 
         // Spawn control (delegate to SpawnController)
-        SpawnController& get_spawn_controller() { return spawn_controller_; }
-        [[nodiscard]] const SpawnController& get_spawn_controller() const { return spawn_controller_; }
+        SpawnController& getSpawnController() { return spawn_controller_; }
+        [[nodiscard]] const SpawnController& getSpawnController() const { return spawn_controller_; }
 
     private:
-        const ConfigSistemaStages* config_;  // Non-owning pointer
+        const StageSystemConfig* config_;  // Non-owning pointer
         SpawnController spawn_controller_;
 
         EstatStage estat_;
@@ -55,7 +55,7 @@ class StageManager {
         void canviar_estat(EstatStage nou_estat);
         void processar_init_hud(float delta_time);
         void processar_level_start(float delta_time);
-        void processar_playing(float delta_time, bool pausar_spawn);
+        void processar_playing(float delta_time, bool pause_spawn);
         void processar_level_completed(float delta_time);
         void carregar_stage(uint8_t stage_id);
 };
diff --git a/source/game/systems/collision_system.cpp b/source/game/systems/collision_system.cpp
new file mode 100644
index 0000000..fa1d4d7
--- /dev/null
+++ b/source/game/systems/collision_system.cpp
@@ -0,0 +1,150 @@
+// collision_system.cpp - Implementación del sistema de colisiones
+
+#include "game/systems/collision_system.hpp"
+
+#include <cstdint>
+
+#include "core/audio/audio.hpp"
+#include "core/physics/collision.hpp"
+#include "core/types.hpp"
+
+namespace Systems::Collision {
+
+void detectBulletEnemy(Context& ctx) {
+    constexpr float AMPLIFIER = Defaults::Game::COLLISION_BULLET_ENEMY_AMPLIFIER;
+    constexpr float VELOCITAT_EXPLOSIO = 80.0F;  // px/s (explosión suau)
+
+    for (auto& bullet : ctx.bullets) {
+        for (auto& enemy : ctx.enemies) {
+            if (!Physics::check_collision(bullet, enemy, AMPLIFIER)) {
+                continue;
+            }
+
+            // *** COLISIÓN bullet → enemy ***
+            const Vec2& POS_ENEMIC = enemy.getCenter();
+
+            // 1. Puntos según tipo
+            int points = 0;
+            switch (enemy.getType()) {
+                case EnemyType::PENTAGON:
+                    points = Defaults::Enemies::Scoring::PENTAGON_SCORE;
+                    break;
+                case EnemyType::QUADRAT:
+                    points = Defaults::Enemies::Scoring::QUADRAT_SCORE;
+                    break;
+                case EnemyType::MOLINILLO:
+                    points = Defaults::Enemies::Scoring::MOLINILLO_SCORE;
+                    break;
+            }
+
+            uint8_t owner_id = bullet.getOwnerId();
+            ctx.score_per_player[owner_id] += points;
+            ctx.floating_score_manager.crear(points, POS_ENEMIC);
+
+            // 2. Destruir enemy + crear explosión (debris hereda color del enemy)
+            SDL_Color enemy_color{};
+            switch (enemy.getType()) {
+                case EnemyType::PENTAGON:  enemy_color = Defaults::Palette::PENTAGON;  break;
+                case EnemyType::QUADRAT:   enemy_color = Defaults::Palette::QUADRAT;   break;
+                case EnemyType::MOLINILLO: enemy_color = Defaults::Palette::MOLINILLO; break;
+            }
+            enemy.destruir();
+            Vec2 vel_enemic = enemy.getVelocityVector();
+            ctx.debris_manager.explode(
+                enemy.getShape(),
+                POS_ENEMIC,
+                0.0F,                  // angle (la rotación es interna del enemy)
+                1.0F,                  // escala
+                VELOCITAT_EXPLOSIO,
+                enemy.getBrightness(),
+                vel_enemic,
+                enemy.getRotationDelta(),
+                0.0F,                  // sin herencia visual
+                Defaults::Sound::EXPLOSION,
+                enemy_color
+            );
+
+            // 3. Desactivar bullet (solo destruye 1 enemy)
+            bullet.desactivar();
+            break;
+        }
+    }
+}
+
+void detectShipEnemy(Context& ctx) {
+    constexpr float AMPLIFIER = Defaults::Game::COLLISION_SHIP_ENEMY_AMPLIFIER;
+
+    for (uint8_t i = 0; i < 2; i++) {
+        // Skip si ya tocado / muerto / invulnerable
+        if (ctx.hit_timer_per_player[i] > 0.0F ||
+            !ctx.ships[i].isAlive() ||
+            ctx.ships[i].isInvulnerable()) {
+            continue;
+        }
+
+        for (const auto& enemy : ctx.enemies) {
+            if (enemy.isInvulnerable()) {
+                continue;
+            }
+            if (Physics::check_collision(ctx.ships[i], enemy, AMPLIFIER)) {
+                ctx.on_player_hit(i);
+                break;  // Solo una colisión por player por frame
+            }
+        }
+    }
+}
+
+void detectBulletPlayer(Context& ctx) {
+    if (!Defaults::Game::FRIENDLY_FIRE_ENABLED) {
+        return;
+    }
+
+    constexpr float AMPLIFIER = Defaults::Game::COLLISION_BULLET_PLAYER_AMPLIFIER;
+
+    for (auto& bullet : ctx.bullets) {
+        if (!bullet.esta_activa() || bullet.getGraceTimer() > 0.0F) {
+            continue;
+        }
+        const uint8_t BULLET_OWNER = bullet.getOwnerId();
+
+        for (uint8_t player_id = 0; player_id < 2; player_id++) {
+            if (ctx.hit_timer_per_player[player_id] > 0.0F ||
+                !ctx.ships[player_id].isAlive() ||
+                ctx.ships[player_id].isInvulnerable()) {
+                continue;
+            }
+            const bool JUGADOR_ACTIU = (player_id == 0)
+                ? ctx.match_config.jugador1_actiu
+                : ctx.match_config.jugador2_actiu;
+            if (!JUGADOR_ACTIU) {
+                continue;
+            }
+
+            if (!Physics::check_collision(bullet, ctx.ships[player_id], AMPLIFIER)) {
+                continue;
+            }
+
+            // *** FRIENDLY FIRE HIT ***
+            if (BULLET_OWNER == player_id) {
+                // Self-hit: víctima pierde 1 vida.
+                ctx.on_player_hit(player_id);
+            } else {
+                // Teammate hit: víctima pierde 1, atacante gana 1.
+                ctx.on_player_hit(player_id);
+                ctx.lives_per_player[BULLET_OWNER]++;
+            }
+
+            Audio::get()->playSound(Defaults::Sound::FRIENDLY_FIRE_HIT, Audio::Group::GAME);
+            bullet.desactivar();
+            break;  // Una bullet solo impacta una vez por frame
+        }
+    }
+}
+
+void detectAll(Context& ctx) {
+    detectBulletEnemy(ctx);
+    detectShipEnemy(ctx);
+    detectBulletPlayer(ctx);
+}
+
+}  // namespace Systems::Collision
diff --git a/source/game/systems/collision_system.hpp b/source/game/systems/collision_system.hpp
new file mode 100644
index 0000000..244dd42
--- /dev/null
+++ b/source/game/systems/collision_system.hpp
@@ -0,0 +1,63 @@
+// collision_system.hpp - Detección de colisiones de gameplay
+// © 2025 Orni Attack
+//
+// Detecta colisiones bullet↔enemy, ship↔enemy y bullet↔player y aplica los
+// efectos directos sobre las entidades (destruir enemy, desactivar bullet,
+// crear debris/floating-score, ajustar score y lives). Las consecuencias de
+// gameplay que requieren transición de estado (muerte del jugador, game over)
+// se delegan a un callback `on_player_hit`.
+//
+// Esto es física de gameplay, NO física rígida — el PhysicsWorld ya resolvió
+// los impulsos físicos antes. Aquí solo decidimos quién muere/destruye a quién.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <functional>
+
+#include "core/defaults.hpp"
+#include "core/system/game_config.hpp"
+#include "game/effects/debris_manager.hpp"
+#include "game/effects/floating_score_manager.hpp"
+#include "game/entities/bullet.hpp"
+#include "game/entities/enemy.hpp"
+#include "game/entities/ship.hpp"
+
+namespace Systems::Collision {
+
+// Todo lo que las detecciones necesitan leer/modificar. Vive en GameScene;
+// se le pasa por referencia (no copia, no ownership).
+struct Context {
+        std::array<Ship, 2>& ships;
+        std::array<Enemy, Defaults::Entities::MAX_ORNIS>& enemies;
+        std::array<Bullet, Defaults::Entities::MAX_BALES * 2>& bullets;
+        std::array<float, 2>& hit_timer_per_player;
+        std::array<int, 2>& score_per_player;
+        std::array<int, 2>& lives_per_player;
+        Effects::DebrisManager& debris_manager;
+        Effects::FloatingScoreManager& floating_score_manager;
+        const GameConfig::MatchConfig& match_config;
+        // Trigger de muerte del jugador (GameScene::tocado).
+        std::function<void(uint8_t /*player_id*/)> on_player_hit;
+};
+
+// Detecta colisiones bullet → enemy. Si hit:
+//   - destruye el enemy (radius=0 en physics body)
+//   - crea debris + floating score
+//   - desactiva la bullet
+//   - suma puntos al shooter
+void detectBulletEnemy(Context& ctx);
+
+// Detecta colisiones ship → enemy. Si hit, llama on_player_hit(player_id).
+void detectShipEnemy(Context& ctx);
+
+// Detecta colisiones bullet → player (friendly fire / self-hit).
+// Self-hit: el shooter pierde 1 vida. Teammate-hit: la víctima pierde 1, el
+// atacante gana 1. En ambos casos, llama on_player_hit y desactiva bullet.
+void detectBulletPlayer(Context& ctx);
+
+// Las tres en orden lógico del frame.
+void detectAll(Context& ctx);
+
+}  // namespace Systems::Collision
diff --git a/source/game/systems/continue_system.cpp b/source/game/systems/continue_system.cpp
new file mode 100644
index 0000000..f9a6dd4
--- /dev/null
+++ b/source/game/systems/continue_system.cpp
@@ -0,0 +1,109 @@
+// continue_system.cpp - Implementación de la pantalla de continue
+
+#include "game/systems/continue_system.hpp"
+
+#include <cstdint>
+
+#include "core/audio/audio.hpp"
+#include "core/defaults.hpp"
+#include "core/input/input.hpp"
+#include "core/input/input_types.hpp"
+#include "game/scenes/game_scene.hpp"  // GameOverState (definición completa)
+
+namespace Systems::ContinueScreen {
+namespace {
+
+// Si el countdown ha bajado de 0, transiciona a GAME_OVER con su timer.
+void checkAndApplyTimeout(Context& ctx) {
+    if (ctx.counter < 0) {
+        ctx.state = GameOverState::GAME_OVER;
+        ctx.game_over_timer = Defaults::Game::GAME_OVER_DURATION;
+    }
+}
+
+void revivePlayer(Context& ctx, uint8_t player_id) {
+    ctx.score_per_player[player_id] = 0;
+    ctx.lives_per_player[player_id] = Defaults::Game::STARTING_LIVES;
+    ctx.hit_timer_per_player[player_id] = 0.0F;
+
+    if (player_id == 0) {
+        ctx.match_config.jugador1_actiu = true;
+    } else {
+        ctx.match_config.jugador2_actiu = true;
+    }
+
+    const Vec2 SPAWN = ctx.get_spawn_point(player_id);
+    ctx.ships[player_id].init(&SPAWN, /*activar_invulnerabilitat=*/true);
+}
+
+}  // namespace
+
+void update(Context& ctx, float delta_time) {
+    ctx.tick_timer -= delta_time;
+    if (ctx.tick_timer > 0.0F) {
+        return;
+    }
+    ctx.counter--;
+    ctx.tick_timer = Defaults::Game::CONTINUE_TICK_DURATION;
+
+    checkAndApplyTimeout(ctx);
+
+    // Solo pita el tick si seguimos en CONTINUE (no transitamos a GAME_OVER)
+    if (ctx.state == GameOverState::CONTINUE) {
+        Audio::get()->playSound(Defaults::Sound::CONTINUE, Audio::Group::GAME);
+    }
+}
+
+void processInput(Context& ctx) {
+    auto* input = Input::get();
+
+    const bool P1_START = input->checkActionPlayer1(InputAction::START, Input::DO_NOT_ALLOW_REPEAT);
+    const bool P2_START = input->checkActionPlayer2(InputAction::START, Input::DO_NOT_ALLOW_REPEAT);
+
+    if (P1_START || P2_START) {
+        // ¿Quedan continues?
+        if (!Defaults::Game::INFINITE_CONTINUES &&
+            ctx.continues_used >= Defaults::Game::MAX_CONTINUES) {
+            ctx.state = GameOverState::GAME_OVER;
+            ctx.game_over_timer = Defaults::Game::GAME_OVER_DURATION;
+            return;
+        }
+        if (!Defaults::Game::INFINITE_CONTINUES) {
+            ctx.continues_used++;
+        }
+
+        const uint8_t PRIMARY = P1_START ? 0 : 1;
+        revivePlayer(ctx, PRIMARY);
+        // Si ambos pulsan START, revivimos a los dos.
+        if (P1_START && P2_START) {
+            revivePlayer(ctx, 1);
+        }
+
+        // Reanudar partida.
+        ctx.state = GameOverState::NONE;
+        ctx.counter = 0;
+        ctx.tick_timer = 0.0F;
+
+        Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);
+        return;
+    }
+
+    // THRUST/SHOOT acelera el countdown manualmente.
+    const bool ACCEL = input->checkActionPlayer1(InputAction::THRUST, Input::DO_NOT_ALLOW_REPEAT) ||
+                       input->checkActionPlayer2(InputAction::THRUST, Input::DO_NOT_ALLOW_REPEAT) ||
+                       input->checkActionPlayer1(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT) ||
+                       input->checkActionPlayer2(InputAction::SHOOT, Input::DO_NOT_ALLOW_REPEAT);
+
+    if (ACCEL) {
+        ctx.counter--;
+        checkAndApplyTimeout(ctx);
+
+        if (ctx.state == GameOverState::CONTINUE) {
+            Audio::get()->playSound(Defaults::Sound::CONTINUE, Audio::Group::GAME);
+        }
+
+        ctx.tick_timer = Defaults::Game::CONTINUE_TICK_DURATION;
+    }
+}
+
+}  // namespace Systems::ContinueScreen
diff --git a/source/game/systems/continue_system.hpp b/source/game/systems/continue_system.hpp
new file mode 100644
index 0000000..266a9ec
--- /dev/null
+++ b/source/game/systems/continue_system.hpp
@@ -0,0 +1,49 @@
+// continue_system.hpp - Pantalla de continue y máquina de estados de game over
+// © 2025 Orni Attack
+//
+// Gestiona la transición CONTINUE → GAME_OVER, el countdown, los inputs de
+// los jugadores para continuar la partida y la revivificación. Vive como
+// estado en GameScene; este módulo solo opera sobre referencias a ese estado.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <functional>
+
+#include "core/system/game_config.hpp"
+#include "core/types.hpp"
+#include "game/entities/ship.hpp"
+
+// Forward declaration: GameOverState es un enum class definido en game_scene.hpp.
+// Para no traer toda la cabecera, lo declaramos aquí.
+enum class GameOverState : uint8_t;
+
+namespace Systems::ContinueScreen {
+
+// Todo lo que el ContinueSystem lee/modifica.
+struct Context {
+        GameOverState& state;
+        int& counter;
+        float& tick_timer;
+        int& continues_used;
+        float& game_over_timer;
+        std::array<int, 2>& lives_per_player;
+        std::array<int, 2>& score_per_player;
+        std::array<float, 2>& hit_timer_per_player;
+        std::array<Ship, 2>& ships;
+        GameConfig::MatchConfig& match_config;
+        // Helper inyectado por GameScene (obtenir_punt_spawn).
+        std::function<Vec2(uint8_t /*player_id*/)> get_spawn_point;
+};
+
+// Avanza el countdown automático (tick interno). Si el contador cae bajo 0,
+// transiciona a GAME_OVER y arranca el timer final.
+void update(Context& ctx, float delta_time);
+
+// Procesa input durante la pantalla CONTINUE:
+//   START → revive al jugador (1 o 2, según quién pulsó).
+//   THRUST/SHOOT → acelera el countdown.
+void processInput(Context& ctx);
+
+}  // namespace Systems::ContinueScreen
diff --git a/source/game/systems/init_hud_animator.cpp b/source/game/systems/init_hud_animator.cpp
new file mode 100644
index 0000000..fb4fe11
--- /dev/null
+++ b/source/game/systems/init_hud_animator.cpp
@@ -0,0 +1,100 @@
+// init_hud_animator.cpp - Implementación de la animación inicial del HUD
+
+#include "game/systems/init_hud_animator.hpp"
+
+#include <SDL3/SDL.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <string>
+
+#include "core/defaults.hpp"
+#include "core/math/easing.hpp"
+#include "core/rendering/line_renderer.hpp"
+
+namespace Systems::InitHud {
+
+auto computeRangeProgress(float global_progress,
+                          float ratio_init,
+                          float ratio_end) -> float {
+    if (ratio_init >= ratio_end) {
+        return (global_progress >= ratio_end) ? 1.0F : 0.0F;
+    }
+    if (global_progress < ratio_init) {
+        return 0.0F;
+    }
+    if (global_progress > ratio_end) {
+        return 1.0F;
+    }
+    return (global_progress - ratio_init) / (ratio_end - ratio_init);
+}
+
+auto computeShipPosition(float progress, const Vec2& final_position) -> Vec2 {
+    const float EASED = Easing::ease_out_quad(progress);
+    const SDL_FRect& ZONA = Defaults::Zones::PLAYAREA;
+    // Y inicial: 50 px bajo la zona de juego.
+    const float Y_INI = ZONA.y + ZONA.h + 50.0F;
+    const float Y_ANIM = Y_INI + ((final_position.y - Y_INI) * EASED);
+    return Vec2{.x = final_position.x, .y = Y_ANIM};
+}
+
+void drawBordersAnimated(Rendering::Renderer* renderer, float progress) {
+    const SDL_FRect& ZONA = Defaults::Zones::PLAYAREA;
+    const float EASED = Easing::ease_out_quad(progress);
+
+    const int X1 = static_cast<int>(ZONA.x);
+    const int Y1 = static_cast<int>(ZONA.y);
+    const int X2 = static_cast<int>(ZONA.x + ZONA.w);
+    const int Y2 = static_cast<int>(ZONA.y + ZONA.h);
+    const int CX = (X1 + X2) / 2;
+
+    constexpr float PHASE_1_END = 0.33F;
+    constexpr float PHASE_2_END = 0.66F;
+
+    // Fase 1: línea superior crece desde el centro hacia los lados.
+    if (EASED > 0.0F) {
+        const float P = std::min(EASED / PHASE_1_END, 1.0F);
+        const int X_LEFT = static_cast<int>(CX - ((CX - X1) * P));
+        const int X_RIGHT = static_cast<int>(CX + ((X2 - CX) * P));
+        Rendering::linea(renderer, CX, Y1, X_LEFT, Y1);
+        Rendering::linea(renderer, CX, Y1, X_RIGHT, Y1);
+    }
+
+    // Fase 2: laterales bajan.
+    if (EASED > PHASE_1_END) {
+        const float P = std::min((EASED - PHASE_1_END) / (PHASE_2_END - PHASE_1_END), 1.0F);
+        const int Y_BOTTOM = static_cast<int>(Y1 + ((Y2 - Y1) * P));
+        Rendering::linea(renderer, X1, Y1, X1, Y_BOTTOM);
+        Rendering::linea(renderer, X2, Y1, X2, Y_BOTTOM);
+    }
+
+    // Fase 3: línea inferior crece desde los lados hacia el centro.
+    if (EASED > PHASE_2_END) {
+        const float P = (EASED - PHASE_2_END) / (1.0F - PHASE_2_END);
+        const int X_LEFT = static_cast<int>(X1 + ((CX - X1) * P));
+        const int X_RIGHT = static_cast<int>(X2 - ((X2 - CX) * P));
+        Rendering::linea(renderer, X1, Y2, X_LEFT, Y2);
+        Rendering::linea(renderer, X2, Y2, X_RIGHT, Y2);
+    }
+}
+
+void drawScoreboardAnimated(Graphics::VectorText& text,
+                            const std::string& scoreboard_text,
+                            float progress) {
+    const float EASED = Easing::ease_out_quad(progress);
+
+    constexpr float SCALE = 0.85F;
+    constexpr float SPACING = 0.0F;
+    const SDL_FRect& SCOREBOARD = Defaults::Zones::SCOREBOARD;
+    const float CENTRE_X = SCOREBOARD.w / 2.0F;
+    const float Y_FINAL = SCOREBOARD.y + (SCOREBOARD.h / 2.0F);
+    // Posición inicial: fuera de la pantalla por debajo.
+    const auto Y_INI = static_cast<float>(Defaults::Game::HEIGHT);
+    const float Y_ANIM = Y_INI + ((Y_FINAL - Y_INI) * EASED);
+
+    text.renderCentered(scoreboard_text,
+                        Vec2{.x = CENTRE_X, .y = Y_ANIM},
+                        SCALE, SPACING);
+}
+
+}  // namespace Systems::InitHud
diff --git a/source/game/systems/init_hud_animator.hpp b/source/game/systems/init_hud_animator.hpp
new file mode 100644
index 0000000..681f584
--- /dev/null
+++ b/source/game/systems/init_hud_animator.hpp
@@ -0,0 +1,49 @@
+// init_hud_animator.hpp - Animación inicial del HUD del juego
+// © 2025 Orni Attack
+//
+// Cubre la animación INIT_HUD del comienzo de cada partida/stage:
+//   1. Crecimiento de los marcos del PLAYAREA con efecto pincel en 3 fases.
+//   2. Marcador subiendo desde abajo.
+//   3. Naves entrando desde la zona inferior hacia su spawn.
+//
+// Todas las funciones son puras (sin estado interno propio). GameScene aporta
+// el contexto que necesitan: posiciones finales, texto del scoreboard y el
+// renderer/VectorText. El timing global (progress 0..1) lo gestiona
+// StageManager.
+
+#pragma once
+
+#include <string>
+
+#include "core/graphics/vector_text.hpp"
+#include "core/rendering/render_context.hpp"
+#include "core/types.hpp"
+
+namespace Systems::InitHud {
+
+// Convierte un progreso global 0..1 al sub-progreso de un elemento que solo
+// se anima en la ventana [ratio_init, ratio_end].
+//   < ratio_init      → 0.0 (no empezó)
+//   > ratio_end       → 1.0 (terminó)
+//   en rango          → interpolación lineal 0..1
+[[nodiscard]] auto computeRangeProgress(float global_progress,
+                                        float ratio_init,
+                                        float ratio_end) -> float;
+
+// Calcula posición Y animada de una nave durante INIT_HUD. La nave sube
+// desde 50 px bajo el PLAYAREA hasta `final_position` con easing.
+[[nodiscard]] auto computeShipPosition(float progress, const Vec2& final_position) -> Vec2;
+
+// Dibuja los 4 lados del PLAYAREA con efecto pincel en 3 fases:
+//   0..33%  → línea superior crece desde el centro hacia los lados.
+//   33..66% → líneas verticales bajan por los laterales.
+//   66..100% → línea inferior crece desde los lados hacia el centro.
+void drawBordersAnimated(Rendering::Renderer* renderer, float progress);
+
+// Dibuja el scoreboard centrado, subiendo desde fuera de la pantalla
+// hasta su posición final con easing.
+void drawScoreboardAnimated(Graphics::VectorText& text,
+                            const std::string& scoreboard_text,
+                            float progress);
+
+}  // namespace Systems::InitHud
diff --git a/source/game/title/ship_animator.cpp b/source/game/title/ship_animator.cpp
index 4cdc770..ad15a55 100644
--- a/source/game/title/ship_animator.cpp
+++ b/source/game/title/ship_animator.cpp
@@ -1,5 +1,5 @@
-// ship_animator.cpp - Implementació del sistema d'animació de naus
-// © 2025 Port a C++20 amb SDL3
+// ship_animator.cpp - Implementació del sistema de animación de naves
+// © 2025 Port a C++20 con SDL3
 
 #include "ship_animator.hpp"
 
@@ -13,63 +13,62 @@
 
 namespace Title {
 
-ShipAnimator::ShipAnimator(SDL_Renderer* renderer)
+ShipAnimator::ShipAnimator(Rendering::Renderer* renderer)
     : renderer_(renderer) {
 }
 
-void ShipAnimator::inicialitzar() {
-    // Carregar formes de naus amb perspectiva pre-calculada
-    auto forma_p1 = Graphics::ShapeLoader::load("ship_perspective.shp");   // Perspectiva esquerra
-    auto forma_p2 = Graphics::ShapeLoader::load("ship2_perspective.shp");  // Perspectiva dreta
+void ShipAnimator::init() {
+    // Carregar formes de naves con perspectiva pre-calculada
+    auto forma_p1 = Graphics::ShapeLoader::load("ship_perspective.shp");   // Perspectiva izquierda
+    auto forma_p2 = Graphics::ShapeLoader::load("ship2_perspective.shp");  // Perspectiva derecha
 
-    // Configurar nau P1
-    naus_[0].jugador_id = 1;
-    naus_[0].forma = forma_p1;
-    configurar_nau_p1(naus_[0]);
+    // Configurar ship P1
+    ships_[0].player_id = 1;
+    ships_[0].shape = forma_p1;
+    configurar_nau_p1(ships_[0]);
 
-    // Configurar nau P2
-    naus_[1].jugador_id = 2;
-    naus_[1].forma = forma_p2;
-    configurar_nau_p2(naus_[1]);
+    // Configurar ship P2
+    ships_[1].player_id = 2;
+    ships_[1].shape = forma_p2;
+    configurar_nau_p2(ships_[1]);
 }
 
-void ShipAnimator::actualitzar(float delta_time) {
-    // Dispatcher segons estat de cada nau
-    for (auto& nau : naus_) {
-        if (!nau.visible) {
+void ShipAnimator::update(float delta_time) {
+    // Dispatcher segons state de cada ship
+    for (auto& ship : ships_) {
+        if (!ship.visible) {
             continue;
         }
 
-        switch (nau.estat) {
-            case EstatNau::ENTERING:
-                actualitzar_entering(nau, delta_time);
+        switch (ship.state) {
+            case ShipState::ENTERING:
+                actualitzar_entering(ship, delta_time);
                 break;
-            case EstatNau::FLOATING:
-                actualitzar_floating(nau, delta_time);
+            case ShipState::FLOATING:
+                actualitzar_floating(ship, delta_time);
                 break;
-            case EstatNau::EXITING:
-                actualitzar_exiting(nau, delta_time);
+            case ShipState::EXITING:
+                actualitzar_exiting(ship, delta_time);
                 break;
         }
     }
 }
 
-void ShipAnimator::dibuixar() const {
-    for (const auto& nau : naus_) {
-        if (!nau.visible) {
+void ShipAnimator::draw() const {
+    for (const auto& ship : ships_) {
+        if (!ship.visible) {
             continue;
         }
 
-        // Renderitzar nau (perspectiva ja incorporada a la forma)
+        // Renderizar ship (perspectiva ya incorporada a la shape)
         Rendering::render_shape(
             renderer_,
-            nau.forma,
-            nau.posicio_actual,
-            0.0F,  // angle (rotació 2D no utilitzada)
-            nau.escala_actual,
-            true,  // dibuixar
-            1.0F,  // progress (sempre visible)
-            1.0F   // brightness (brillantor màxima)
+            ship.shape,
+            ship.current_position,
+            0.0F,  // angle (rotación 2D no utilitzada)
+            ship.current_scale,
+            1.0F,  // progress (siempre visible)
+            1.0F   // brightness (brightness màxima)
         );
     }
 }
@@ -77,255 +76,255 @@ void ShipAnimator::dibuixar() const {
 void ShipAnimator::start_entry_animation() {
     using namespace Defaults::Title::Ships;
 
-    // Configurar nau P1 per a l'animació d'entrada
-    naus_[0].estat = EstatNau::ENTERING;
-    naus_[0].temps_estat = 0.0F;
-    naus_[0].posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
-    naus_[0].posicio_actual = naus_[0].posicio_inicial;
-    naus_[0].escala_actual = naus_[0].escala_inicial;
+    // Configurar ship P1 para l'animación de entrada
+    ships_[0].state = ShipState::ENTERING;
+    ships_[0].state_time = 0.0F;
+    ships_[0].initial_position = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
+    ships_[0].current_position = ships_[0].initial_position;
+    ships_[0].current_scale = ships_[0].initial_scale;
 
-    // Configurar nau P2 per a l'animació d'entrada
-    naus_[1].estat = EstatNau::ENTERING;
-    naus_[1].temps_estat = 0.0F;
-    naus_[1].posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
-    naus_[1].posicio_actual = naus_[1].posicio_inicial;
-    naus_[1].escala_actual = naus_[1].escala_inicial;
+    // Configurar ship P2 para l'animación de entrada
+    ships_[1].state = ShipState::ENTERING;
+    ships_[1].state_time = 0.0F;
+    ships_[1].initial_position = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
+    ships_[1].current_position = ships_[1].initial_position;
+    ships_[1].current_scale = ships_[1].initial_scale;
 }
 
 void ShipAnimator::trigger_exit_animation() {
-    // Configurar ambdues naus per a l'animació de sortida
-    for (auto& nau : naus_) {
-        // Canviar estat a EXITING
-        nau.estat = EstatNau::EXITING;
-        nau.temps_estat = 0.0F;
+    // Configurar ambdues naves para l'animación de salida
+    for (auto& ship : ships_) {
+        // Canviar state a EXITING
+        ship.state = ShipState::EXITING;
+        ship.state_time = 0.0F;
 
-        // Preservar posició actual (pot estar a mig camí si START es prem durant ENTERING)
-        nau.posicio_inicial = nau.posicio_actual;
+        // Preservar posición actual (pot estar a mig camí si START es prem durante ENTERING)
+        ship.initial_position = ship.current_position;
 
-        // La escala objectiu es preserva per a calcular la interpolació
-        // (escala_actual pot ser diferent si està en ENTERING)
+        // La scale objetivo es preserva para calcular la interpolació
+        // (current_scale pot ser diferent si está en ENTERING)
     }
 }
 
 void ShipAnimator::skip_to_floating_state() {
-    // Posar ambdues naus directament en estat FLOATING
-    for (auto& nau : naus_) {
-        nau.estat = EstatNau::FLOATING;
-        nau.temps_estat = 0.0F;
-        nau.fase_oscilacio = 0.0F;
+    // Posar ambdues naves directament en state FLOATING
+    for (auto& ship : ships_) {
+        ship.state = ShipState::FLOATING;
+        ship.state_time = 0.0F;
+        ship.oscillation_phase = 0.0F;
 
-        // Posar en posició objectiu (sense animació)
-        nau.posicio_actual = nau.posicio_objectiu;
-        nau.escala_actual = nau.escala_objectiu;
+        // Posar en posición objetivo (sin animación)
+        ship.current_position = ship.target_position;
+        ship.current_scale = ship.target_scale;
 
-        // NO establir visibilitat aquí - ja ho fa el caller
-        // (evita fer visibles ambdues naus quan només una ha premut START)
+        // NO establir visibilitat aquí - ya ho hace el caller
+        // (evita fer visibles ambdues naves cuando solo una ha premut START)
     }
 }
 
 bool ShipAnimator::is_visible() const {
-    // Retorna true si almenys una nau és visible
-    for (const auto& nau : naus_) {
-        if (nau.visible) {
+    // Retorna true si almenys una ship es visible
+    for (const auto& ship : ships_) {
+        if (ship.visible) {
             return true;
         }
     }
     return false;
 }
 
-void ShipAnimator::trigger_exit_animation_for_player(int jugador_id) {
-    // Trobar la nau del jugador especificat
-    for (auto& nau : naus_) {
-        if (nau.jugador_id == jugador_id) {
-            // Canviar estat a EXITING només per aquesta nau
-            nau.estat = EstatNau::EXITING;
-            nau.temps_estat = 0.0F;
+void ShipAnimator::trigger_exit_animation_for_player(int player_id) {
+    // Trobar la ship del player especificat
+    for (auto& ship : ships_) {
+        if (ship.player_id == player_id) {
+            // Canviar state a EXITING solo per esta ship
+            ship.state = ShipState::EXITING;
+            ship.state_time = 0.0F;
 
-            // Preservar posició actual (pot estar a mig camí si START es prem durant ENTERING)
-            nau.posicio_inicial = nau.posicio_actual;
+            // Preservar posición actual (pot estar a mig camí si START es prem durante ENTERING)
+            ship.initial_position = ship.current_position;
 
-            // La escala objectiu es preserva per a calcular la interpolació
-            // (escala_actual pot ser diferent si està en ENTERING)
-            break;  // Només una nau per jugador
+            // La scale objetivo es preserva para calcular la interpolació
+            // (current_scale pot ser diferent si está en ENTERING)
+            break;  // Solo una ship per player
         }
     }
 }
 
 void ShipAnimator::set_visible(bool visible) {
-    for (auto& nau : naus_) {
-        nau.visible = visible;
+    for (auto& ship : ships_) {
+        ship.visible = visible;
     }
 }
 
 bool ShipAnimator::is_animation_complete() const {
-    // Comprovar si totes les naus són invisibles (han completat l'animació de sortida)
-    for (const auto& nau : naus_) {
-        if (nau.visible) {
-            return false;  // Encara hi ha alguna nau visible
+    // Comprovar si todas las naves són invisibles (han completat l'animación de salida)
+    for (const auto& ship : ships_) {
+        if (ship.visible) {
+            return false;  // Aún hay alguna ship visible
         }
     }
-    return true;  // Totes les naus són invisibles
+    return true;  // Todas las naves són invisibles
 }
 
-// Mètodes d'animació (stubs)
-void ShipAnimator::actualitzar_entering(NauTitol& nau, float delta_time) {
+// Métodos de animación (stubs)
+void ShipAnimator::actualitzar_entering(TitleShip& ship, float delta_time) {
     using namespace Defaults::Title::Ships;
 
-    nau.temps_estat += delta_time;
+    ship.state_time += delta_time;
 
-    // Esperar al delay abans de començar l'animació
-    if (nau.temps_estat < nau.entry_delay) {
-        // Encara en delay: la nau es queda fora de pantalla (posició inicial)
-        nau.posicio_actual = nau.posicio_inicial;
-        nau.escala_actual = nau.escala_inicial;
+    // Esperar al delay antes de començar l'animación
+    if (ship.state_time < ship.entry_delay) {
+        // Aún en delay: la ship es queda fuera de pantalla (posición inicial)
+        ship.current_position = ship.initial_position;
+        ship.current_scale = ship.initial_scale;
         return;
     }
 
-    // Càlcul del progrés (restant el delay)
-    float elapsed = nau.temps_estat - nau.entry_delay;
+    // Cálculo del progrés (restant el delay)
+    float elapsed = ship.state_time - ship.entry_delay;
     float progress = std::min(1.0F, elapsed / ENTRY_DURATION);
 
     // Aplicar easing (ease_out_quad per arribada suau)
     float eased_progress = Easing::ease_out_quad(progress);
 
-    // Lerp posició (inicial → objectiu)
-    nau.posicio_actual.x = Easing::lerp(nau.posicio_inicial.x, nau.posicio_objectiu.x, eased_progress);
-    nau.posicio_actual.y = Easing::lerp(nau.posicio_inicial.y, nau.posicio_objectiu.y, eased_progress);
+    // Lerp posición (inicial → objetivo)
+    ship.current_position.x = Easing::lerp(ship.initial_position.x, ship.target_position.x, eased_progress);
+    ship.current_position.y = Easing::lerp(ship.initial_position.y, ship.target_position.y, eased_progress);
 
-    // Lerp escala (gran → normal)
-    nau.escala_actual = Easing::lerp(nau.escala_inicial, nau.escala_objectiu, eased_progress);
+    // Lerp scale (grande → normal)
+    ship.current_scale = Easing::lerp(ship.initial_scale, ship.target_scale, eased_progress);
 
-    // Transicionar a FLOATING quan completi
+    // Transicionar a FLOATING cuando completi
     if (elapsed >= ENTRY_DURATION) {
-        nau.estat = EstatNau::FLOATING;
-        nau.temps_estat = 0.0F;
-        nau.fase_oscilacio = 0.0F;  // Reiniciar fase d'oscil·lació
+        ship.state = ShipState::FLOATING;
+        ship.state_time = 0.0F;
+        ship.oscillation_phase = 0.0F;  // Reiniciar fase de oscil·lació
     }
 }
 
-void ShipAnimator::actualitzar_floating(NauTitol& nau, float delta_time) {
+void ShipAnimator::actualitzar_floating(TitleShip& ship, float delta_time) {
     using namespace Defaults::Title::Ships;
 
-    // Actualitzar temps i fase d'oscil·lació
-    nau.temps_estat += delta_time;
-    nau.fase_oscilacio += delta_time;
+    // Actualitzar time i fase de oscil·lació
+    ship.state_time += delta_time;
+    ship.oscillation_phase += delta_time;
 
-    // Oscil·lació sinusoïdal X/Y (paràmetres específics per nau)
-    float offset_x = nau.amplitude_x * std::sin(2.0F * Defaults::Math::PI * nau.frequency_x * nau.fase_oscilacio);
-    float offset_y = nau.amplitude_y * std::sin((2.0F * Defaults::Math::PI * nau.frequency_y * nau.fase_oscilacio) + FLOAT_PHASE_OFFSET);
+    // Oscil·lació sinusoïdal X/Y (parámetros específics per ship)
+    float offset_x = ship.amplitude_x * std::sin(2.0F * Defaults::Math::PI * ship.frequency_x * ship.oscillation_phase);
+    float offset_y = ship.amplitude_y * std::sin((2.0F * Defaults::Math::PI * ship.frequency_y * ship.oscillation_phase) + FLOAT_PHASE_OFFSET);
 
-    // Aplicar oscil·lació a la posició objectiu
-    nau.posicio_actual.x = nau.posicio_objectiu.x + offset_x;
-    nau.posicio_actual.y = nau.posicio_objectiu.y + offset_y;
+    // Aplicar oscil·lació a la posición objetivo
+    ship.current_position.x = ship.target_position.x + offset_x;
+    ship.current_position.y = ship.target_position.y + offset_y;
 
-    // Escala constant (sense "breathing" per ara)
-    nau.escala_actual = nau.escala_objectiu;
+    // Escala constant (sin "breathing" per ara)
+    ship.current_scale = ship.target_scale;
 }
 
-void ShipAnimator::actualitzar_exiting(NauTitol& nau, float delta_time) {
+void ShipAnimator::actualitzar_exiting(TitleShip& ship, float delta_time) {
     using namespace Defaults::Title::Ships;
 
-    nau.temps_estat += delta_time;
+    ship.state_time += delta_time;
 
     // Calcular progrés (0.0 → 1.0)
-    float progress = std::min(1.0F, nau.temps_estat / EXIT_DURATION);
+    float progress = std::min(1.0F, ship.state_time / EXIT_DURATION);
 
-    // Aplicar easing (ease_in_quad per acceleració cap al punt de fuga)
+    // Aplicar easing (ease_in_quad per aceleración hacia el point de fuga)
     float eased_progress = Easing::ease_in_quad(progress);
 
-    // Punt de fuga (centre del starfield)
-    constexpr Punt punt_fuga{.x = VANISHING_POINT_X, .y = VANISHING_POINT_Y};
+    // Vec2 de fuga (centro del starfield)
+    constexpr Vec2 punt_fuga{.x = VANISHING_POINT_X, .y = VANISHING_POINT_Y};
 
-    // Lerp posició cap al punt de fuga (preservar posició inicial actual)
-    // Nota: posicio_inicial conté la posició on estava quan es va activar EXITING
-    nau.posicio_actual.x = Easing::lerp(nau.posicio_inicial.x, punt_fuga.x, eased_progress);
-    nau.posicio_actual.y = Easing::lerp(nau.posicio_inicial.y, punt_fuga.y, eased_progress);
+    // Lerp posición hacia el point de fuga (preservar posición inicial actual)
+    // Nota: initial_position conté la posición on estava cuando es va activar EXITING
+    ship.current_position.x = Easing::lerp(ship.initial_position.x, punt_fuga.x, eased_progress);
+    ship.current_position.y = Easing::lerp(ship.initial_position.y, punt_fuga.y, eased_progress);
 
     // Escala redueix a 0 (simula Z → infinit)
-    nau.escala_actual = nau.escala_objectiu * (1.0F - eased_progress);
+    ship.current_scale = ship.target_scale * (1.0F - eased_progress);
 
-    // Marcar invisible quan l'animació completi
+    // Marcar invisible cuando l'animación completi
     if (progress >= 1.0F) {
-        nau.visible = false;
+        ship.visible = false;
     }
 }
 
-// Configuració
-void ShipAnimator::configurar_nau_p1(NauTitol& nau) {
+// Configuración
+void ShipAnimator::configurar_nau_p1(TitleShip& ship) {
     using namespace Defaults::Title::Ships;
 
     // Estat inicial: FLOATING (per test estàtic)
-    nau.estat = EstatNau::FLOATING;
-    nau.temps_estat = 0.0F;
+    ship.state = ShipState::FLOATING;
+    ship.state_time = 0.0F;
 
     // Posicions (clock 8, bottom-left)
-    nau.posicio_objectiu = {.x = P1_TARGET_X(), .y = P1_TARGET_Y()};
+    ship.target_position = {.x = P1_TARGET_X(), .y = P1_TARGET_Y()};
 
-    // Calcular posició inicial (fora de pantalla)
-    nau.posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
-    nau.posicio_actual = nau.posicio_inicial;  // Començar fora de pantalla
+    // Calcular posición inicial (fuera de pantalla)
+    ship.initial_position = calcular_posicio_fora_pantalla(CLOCK_8_ANGLE);
+    ship.current_position = ship.initial_position;  // Començar fuera de pantalla
 
     // Escales
-    nau.escala_objectiu = FLOATING_SCALE;
-    nau.escala_actual = FLOATING_SCALE;
-    nau.escala_inicial = ENTRY_SCALE_START;
+    ship.target_scale = FLOATING_SCALE;
+    ship.current_scale = FLOATING_SCALE;
+    ship.initial_scale = ENTRY_SCALE_START;
 
     // Flotació
-    nau.fase_oscilacio = 0.0F;
+    ship.oscillation_phase = 0.0F;
 
-    // Paràmetres d'entrada
-    nau.entry_delay = P1_ENTRY_DELAY;
+    // Parámetros de entrada
+    ship.entry_delay = P1_ENTRY_DELAY;
 
-    // Paràmetres d'oscil·lació específics P1
-    nau.amplitude_x = FLOAT_AMPLITUDE_X;
-    nau.amplitude_y = FLOAT_AMPLITUDE_Y;
-    nau.frequency_x = FLOAT_FREQUENCY_X_BASE * P1_FREQUENCY_MULTIPLIER;
-    nau.frequency_y = FLOAT_FREQUENCY_Y_BASE * P1_FREQUENCY_MULTIPLIER;
+    // Parámetros de oscil·lació específics P1
+    ship.amplitude_x = FLOAT_AMPLITUDE_X;
+    ship.amplitude_y = FLOAT_AMPLITUDE_Y;
+    ship.frequency_x = FLOAT_FREQUENCY_X_BASE * P1_FREQUENCY_MULTIPLIER;
+    ship.frequency_y = FLOAT_FREQUENCY_Y_BASE * P1_FREQUENCY_MULTIPLIER;
 
     // Visibilitat
-    nau.visible = true;
+    ship.visible = true;
 }
 
-void ShipAnimator::configurar_nau_p2(NauTitol& nau) {
+void ShipAnimator::configurar_nau_p2(TitleShip& ship) {
     using namespace Defaults::Title::Ships;
 
     // Estat inicial: FLOATING (per test estàtic)
-    nau.estat = EstatNau::FLOATING;
-    nau.temps_estat = 0.0F;
+    ship.state = ShipState::FLOATING;
+    ship.state_time = 0.0F;
 
     // Posicions (clock 4, bottom-right)
-    nau.posicio_objectiu = {.x = P2_TARGET_X(), .y = P2_TARGET_Y()};
+    ship.target_position = {.x = P2_TARGET_X(), .y = P2_TARGET_Y()};
 
-    // Calcular posició inicial (fora de pantalla)
-    nau.posicio_inicial = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
-    nau.posicio_actual = nau.posicio_inicial;  // Començar fora de pantalla
+    // Calcular posición inicial (fuera de pantalla)
+    ship.initial_position = calcular_posicio_fora_pantalla(CLOCK_4_ANGLE);
+    ship.current_position = ship.initial_position;  // Començar fuera de pantalla
 
     // Escales
-    nau.escala_objectiu = FLOATING_SCALE;
-    nau.escala_actual = FLOATING_SCALE;
-    nau.escala_inicial = ENTRY_SCALE_START;
+    ship.target_scale = FLOATING_SCALE;
+    ship.current_scale = FLOATING_SCALE;
+    ship.initial_scale = ENTRY_SCALE_START;
 
     // Flotació
-    nau.fase_oscilacio = 0.0F;
+    ship.oscillation_phase = 0.0F;
 
-    // Paràmetres d'entrada
-    nau.entry_delay = P2_ENTRY_DELAY;
+    // Parámetros de entrada
+    ship.entry_delay = P2_ENTRY_DELAY;
 
-    // Paràmetres d'oscil·lació específics P2
-    nau.amplitude_x = FLOAT_AMPLITUDE_X;
-    nau.amplitude_y = FLOAT_AMPLITUDE_Y;
-    nau.frequency_x = FLOAT_FREQUENCY_X_BASE * P2_FREQUENCY_MULTIPLIER;
-    nau.frequency_y = FLOAT_FREQUENCY_Y_BASE * P2_FREQUENCY_MULTIPLIER;
+    // Parámetros de oscil·lació específics P2
+    ship.amplitude_x = FLOAT_AMPLITUDE_X;
+    ship.amplitude_y = FLOAT_AMPLITUDE_Y;
+    ship.frequency_x = FLOAT_FREQUENCY_X_BASE * P2_FREQUENCY_MULTIPLIER;
+    ship.frequency_y = FLOAT_FREQUENCY_Y_BASE * P2_FREQUENCY_MULTIPLIER;
 
     // Visibilitat
-    nau.visible = true;
+    ship.visible = true;
 }
 
-Punt ShipAnimator::calcular_posicio_fora_pantalla(float angle_rellotge) const {
+Vec2 ShipAnimator::calcular_posicio_fora_pantalla(float angle_rellotge) const {
     using namespace Defaults::Title::Ships;
 
     // Convertir angle del rellotge a radians (per exemple: 240° per clock 8)
-    // Calcular posició en direcció radial des del centre, però més lluny
+    // Calcular posición en direcció radial des del centro, pero més lluny
     // ENTRY_OFFSET es calcula automàticament: (SHIP_MAX_RADIUS * ENTRY_SCALE_START) + ENTRY_OFFSET_MARGIN
     float extended_radius = CLOCK_RADIUS + ENTRY_OFFSET;
 
diff --git a/source/game/title/ship_animator.hpp b/source/game/title/ship_animator.hpp
index 281496a..751957b 100644
--- a/source/game/title/ship_animator.hpp
+++ b/source/game/title/ship_animator.hpp
@@ -1,8 +1,10 @@
-// ship_animator.hpp - Sistema d'animació de naus per a l'escena de títol
-// © 2025 Port a C++20 amb SDL3
+// ship_animator.hpp - Sistema de animación de naves para l'escena de título
+// © 2025 Port a C++20 con SDL3
 
 #pragma once
 
+#include "core/rendering/render_context.hpp"
+
 #include <SDL3/SDL.h>
 
 #include <array>
@@ -13,85 +15,85 @@
 
 namespace Title {
 
-// Estats de l'animació de la nau
-enum class EstatNau {
-    ENTERING,  // Entrant des de fora de pantalla
-    FLOATING,  // Flotant en posició estàtica
-    EXITING    // Volant cap al punt de fuga
+// Estats de l'animación de la ship
+enum class ShipState {
+    ENTERING,  // Entrant desde fuera de pantalla
+    FLOATING,  // Flotante en posición estàtica
+    EXITING    // Volant hacia el point de fuga
 };
 
-// Dades d'una nau individual al títol
-struct NauTitol {
+// Dades de una ship individual al título
+struct TitleShip {
         // Identificació
-        int jugador_id;  // 1 o 2
+        int player_id;  // 1 o 2
 
         // Estat
-        EstatNau estat;
-        float temps_estat;  // Temps acumulat en l'estat actual
+        ShipState state;
+        float state_time;  // Temps acumulat en l'state actual
 
         // Posicions
-        Punt posicio_inicial;   // Posició d'inici (fora de pantalla per ENTERING)
-        Punt posicio_objectiu;  // Posició objectiu (rellotge 8 o 4)
-        Punt posicio_actual;    // Posició interpolada actual
+        Vec2 initial_position;   // Posición de start (fuera de pantalla per ENTERING)
+        Vec2 target_position;  // Posición objetivo (rellotge 8 o 4)
+        Vec2 current_position;    // Posición interpolada actual
 
         // Escales (simulació eix Z)
-        float escala_inicial;   // Escala d'inici (més gran = més a prop)
-        float escala_objectiu;  // Escala objectiu (mida flotació)
-        float escala_actual;    // Escala interpolada actual
+        float initial_scale;   // Escala de start (més grande = més a prop)
+        float target_scale;  // Escala objetivo (mida flotació)
+        float current_scale;    // Escala interpolada actual
 
         // Flotació
-        float fase_oscilacio;  // Acumulador de fase per moviment sinusoïdal
+        float oscillation_phase;  // Acumulador de fase per movement sinusoïdal
 
-        // Paràmetres d'entrada
-        float entry_delay;  // Delay abans d'entrar (0.0 per P1, 0.5 per P2)
+        // Parámetros de entrada
+        float entry_delay;  // Delay antes de entrar (0.0 per P1, 0.5 per P2)
 
-        // Paràmetres d'oscil·lació per nau
+        // Parámetros de oscil·lació per ship
         float amplitude_x;
         float amplitude_y;
         float frequency_x;
         float frequency_y;
 
         // Forma
-        std::shared_ptr<Graphics::Shape> forma;
+        std::shared_ptr<Graphics::Shape> shape;
 
         // Visibilitat
         bool visible;
 };
 
-// Gestor d'animació de naus per a l'escena de títol
+// Gestor de animación de naves para l'escena de título
 class ShipAnimator {
     public:
-        explicit ShipAnimator(SDL_Renderer* renderer);
+        explicit ShipAnimator(Rendering::Renderer* renderer);
 
         // Cicle de vida
-        void inicialitzar();
-        void actualitzar(float delta_time);
-        void dibuixar() const;
+        void init();
+        void update(float delta_time);
+        void draw() const;
 
-        // Control d'estat (cridat per EscenaTitol)
+        // Control de state (cridat per TitleScene)
         void start_entry_animation();
-        void trigger_exit_animation();                           // Anima totes les naus
-        void trigger_exit_animation_for_player(int jugador_id);  // Anima només una nau (P1=1, P2=2)
-        void skip_to_floating_state();                           // Salta directament a FLOATING sense animació
+        void trigger_exit_animation();                           // Anima todas las naves
+        void trigger_exit_animation_for_player(int player_id);  // Anima solo una ship (P1=1, P2=2)
+        void skip_to_floating_state();                           // Salta directament a FLOATING sin animación
 
         // Control de visibilitat
         void set_visible(bool visible);
         [[nodiscard]] bool is_animation_complete() const;
-        [[nodiscard]] bool is_visible() const;  // Comprova si alguna nau és visible
+        [[nodiscard]] bool is_visible() const;  // Comprova si alguna ship es visible
 
     private:
-        SDL_Renderer* renderer_;
-        std::array<NauTitol, 2> naus_;  // Naus P1 i P2
+        Rendering::Renderer* renderer_;
+        std::array<TitleShip, 2> ships_;  // Naves P1 i P2
 
-        // Mètodes d'animació
-        void actualitzar_entering(NauTitol& nau, float delta_time);
-        void actualitzar_floating(NauTitol& nau, float delta_time);
-        void actualitzar_exiting(NauTitol& nau, float delta_time);
+        // Métodos de animación
+        void actualitzar_entering(TitleShip& ship, float delta_time);
+        void actualitzar_floating(TitleShip& ship, float delta_time);
+        void actualitzar_exiting(TitleShip& ship, float delta_time);
 
-        // Configuració
-        void configurar_nau_p1(NauTitol& nau);
-        void configurar_nau_p2(NauTitol& nau);
-        [[nodiscard]] Punt calcular_posicio_fora_pantalla(float angle_rellotge) const;
+        // Configuración
+        void configurar_nau_p1(TitleShip& ship);
+        void configurar_nau_p2(TitleShip& ship);
+        [[nodiscard]] Vec2 calcular_posicio_fora_pantalla(float angle_rellotge) const;
 };
 
 }  // namespace Title
diff --git a/source/main.cpp b/source/main.cpp
index 5e24d80..9dedad5 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -1,6 +1,6 @@
-// main.cpp - Punt d'entrada del joc Asteroides
-// © 1999 Visente i Sergi (versió Pascal)
-// © 2025 Port a C++20 amb SDL3
+// main.cpp - Vec2 de entrada del juego Asteroides
+// © 1999 Visente i Sergi (versión Pascal)
+// © 2025 Port a C++20 con SDL3
 
 #include <string>
 #include <vector>
@@ -11,9 +11,9 @@ int main(int argc, char* argv[]) {
     // Convertir arguments a std::vector<std::string>
     std::vector<std::string> args(argv, argv + argc);
 
-    // Crear director (inicialitza sistema, opcions, configuració)
+    // Crear director (inicialitza sistema, opciones, configuración)
     Director director(args);
 
-    // Executar bucle principal del joc
+    // Executar bucle principal del juego
     return director.run();
 }