afegit readme

- Check 11: llvm-include-order (0 errors - codi ja compleix)
- Check 12: misc-include-cleaner (detectar includes no usats i faltants)
  - Configurar IgnoreHeaders per SDL3 (genera falsos positius)
  - Fix: afegir <cstdint> a nau.hpp, enemic.hpp, bala.hpp
  - Fix: afegir <cmath> a nau.hpp, enemic.hpp (std::cos/sin)

Include order validat segons LLVM coding standards.
Headers més nets i compilació més ràpida.

.clang-tidy

@@ -0,0 +1,104 @@
+Checks:
+  # Estrategia: Habilitar checks uno por uno, aplicar fix, compilar, commit
+  # ✅ Check 1: readability-uppercase-literal-suffix (1.0f → 1.0F)
+  # ✅ Check 2: readability-math-missing-parentheses (claridad en ops matemáticas)
+  # ✅ Check 3: readability-identifier-naming (DESHABILITADO temporalmente - cascada de cambios)
+  # ✅ Check 4: readability-const-return-type (código ya cumple)
+  # ✅ Check 5: readability-else-after-return (código ya cumple)
+  # ✅ Check 6: readability-simplify-boolean-expr (código ya cumple)
+  # ✅ Check 7: readability-* (225 fixes aplicados)
+  - readability-*
+  - -readability-identifier-naming              # Excluido (cascada de cambios)
+  - -readability-identifier-length              # Excluido (nombres cortos son OK)
+  - -readability-magic-numbers                  # Excluido (muchos falsos positivos)
+  - -readability-convert-member-functions-to-static  # Excluido (rompe encapsulación)
+  - -readability-use-anyofallof                 # Excluido (C++20 ranges - no todos los compiladores)
+  - -readability-function-cognitive-complexity  # Excluido (complejidad ciclomática aceptable)
+  - -clang-analyzer-security.insecureAPI.rand   # Excluido (rand() es suficiente para juegos)
+  # ✅ Check 8: modernize-* (215 fixes aplicados)
+  - modernize-*
+  - -modernize-use-trailing-return-type         # Excluido (estilo controversial)
+  - -modernize-avoid-c-arrays                   # Excluido (arrays C son OK en algunos contextos)
+  # ✅ Check 9: performance-* (91 fixes aplicados)
+  - performance-*
+  - -performance-enum-size                      # Excluido (tamaño de enum no crítico)
+  # ✅ Check 10: bugprone-* (0 fixes - todos eran falsos positivos)
+  - bugprone-*
+  - -bugprone-easily-swappable-parameters       # Excluido (muchos falsos positivos)
+  - -bugprone-narrowing-conversions             # Excluido (conversiones intencionales)
+  - -bugprone-integer-division                  # Excluido (divisiones enteras OK en contexto)
+  - -bugprone-branch-clone                      # Excluido (fall-through en switch es intencional)
+  - -bugprone-switch-missing-default-case       # Excluido (no todos los switches necesitan default)
+  - -bugprone-implicit-widening-of-multiplication-result  # Excluido (valores pequeños, sin overflow)
+  - -bugprone-exception-escape                  # Excluido (excepciones en main terminan el programa - OK)
+  # ✅ Check 11: llvm-include-order (validar orden de includes - 0 errores)
+  - llvm-include-order
+  # ⏸️  Check 12: misc-include-cleaner (DESHABILITADO temporalmente - requiere refactorización masiva de includes)
+  - -misc-include-cleaner
+
+WarningsAsErrors: '*'
+# No usar HeaderFilterRegex - usamos .clang-tidy local en source/core/audio/ para excluir
+FormatStyle: file
+
+CheckOptions:
+  # Variables locales en snake_case
+  - { key: readability-identifier-naming.VariableCase, value: lower_case }
+
+  # Miembros privados en snake_case con sufijo _
+  - { key: readability-identifier-naming.PrivateMemberCase, value: lower_case }
+  - { key: readability-identifier-naming.PrivateMemberSuffix, value: _ }
+
+  # Miembros protegidos en snake_case con sufijo _
+  - { key: readability-identifier-naming.ProtectedMemberCase, value: lower_case }
+  - { key: readability-identifier-naming.ProtectedMemberSuffix, value: _ }
+
+  # Miembros públicos en snake_case (sin sufijo)
+  - { key: readability-identifier-naming.PublicMemberCase, value: lower_case }
+
+  # Namespaces en CamelCase
+  - { key: readability-identifier-naming.NamespaceCase, value: CamelCase }
+
+  # Variables estáticas privadas como miembros privados
+  - { key: readability-identifier-naming.StaticVariableCase, value: lower_case }
+  - { key: readability-identifier-naming.StaticVariableSuffix, value: _ }
+  
+  # Constantes estáticas sin sufijo
+  - { key: readability-identifier-naming.StaticConstantCase, value: UPPER_CASE }
+
+  # Constantes globales en UPPER_CASE
+  - { key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE }
+
+  # Variables constexpr globales en UPPER_CASE
+  - { key: readability-identifier-naming.ConstexprVariableCase, value: UPPER_CASE }
+
+  # Constantes locales en UPPER_CASE
+  - { key: readability-identifier-naming.LocalConstantCase, value: UPPER_CASE }
+
+  # Constexpr miembros en UPPER_CASE (sin sufijo)
+  - { key: readability-identifier-naming.ConstexprMemberCase, value: UPPER_CASE }
+
+  # Constexpr miembros privados/protegidos con sufijo _
+  - { key: readability-identifier-naming.ConstexprMethodCase, value: UPPER_CASE }
+
+  # Clases, structs y enums en CamelCase
+  - { key: readability-identifier-naming.ClassCase, value: CamelCase }
+  - { key: readability-identifier-naming.StructCase, value: CamelCase }
+  - { key: readability-identifier-naming.EnumCase, value: CamelCase }
+
+  # Valores de enums en UPPER_CASE
+  - { key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE }
+
+  # Métodos en camelBack (sin sufijos)
+  - { key: readability-identifier-naming.MethodCase, value: camelBack }
+  - { key: readability-identifier-naming.PrivateMethodCase, value: camelBack }
+  - { key: readability-identifier-naming.ProtectedMethodCase, value: camelBack }
+  - { key: readability-identifier-naming.PublicMethodCase, value: camelBack }
+
+  # Funciones en camelBack
+  - { key: readability-identifier-naming.FunctionCase, value: camelBack }
+
+  # Parámetros en lower_case
+  - { key: readability-identifier-naming.ParameterCase, value: lower_case }
+
+  # misc-include-cleaner: Ignorar SDL (genera falsos positivos)
+  - { key: misc-include-cleaner.IgnoreHeaders, value: 'SDL3/.*' }

.claude/settings.local.json

@@ -0,0 +1,19 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(dir \"C:\\mingw\\gitea\\orni_attack\\release\\dll\")",
+      "Bash(make:*)",
+      "Bash(echo:*)",
+      "Bash(objdump:*)",
+      "Bash(unzip:*)",
+      "Bash(\"/Volumes/diskito/diskito.app/Contents/MacOS/diskito\")",
+      "Bash(pkill:*)",
+      "Bash(hdiutil detach:*)",
+      "Bash(cat:*)",
+      "Bash(hdiutil mount:*)",
+      "Bash(open \"/Volumes/Orni Attack/Orni Attack.app\")"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.gitignore

@@ -17,6 +17,16 @@ asteroids
 *.exe
 *.out
 *.app
+tools/pack_resources/pack_resources
+tools/pack_resources/pack_resources.exe
+
+# Releases
+*.zip
+*.tar.gz
+*.dmg
+
+# Generated resources
+resources.pack
 
 # Compiled Object files
 *.o

CLAUDE.md

@@ -505,6 +505,284 @@ void dibuixar() {
 }
 ```
 
+## Title Screen Ship System (BETA 3.0)
+
+The title screen features two 3D ships floating on the starfield with perspective rendering, entry/exit animations, and subtle floating motion.
+
+### Architecture Overview
+
+**Files:**
+- `source/game/title/ship_animator.hpp/cpp` - Ship animation state machine
+- `source/core/rendering/shape_renderer.hpp/cpp` - 3D rotation + perspective projection
+- `source/core/defaults.hpp` - Title::Ships namespace with all constants
+- `source/game/escenes/escena_titol.hpp/cpp` - Integration with title scene
+
+**Design Philosophy:**
+- **Static 3D rotation**: Ships have fixed pitch/yaw/roll angles (not recalculated per frame)
+- **Simple Z-axis simulation**: Scale changes simulate depth, not full perspective recalculation
+- **State machine**: ENTERING → FLOATING → EXITING states
+- **Easing functions**: Smooth transitions with ease_out_quad (entry) and ease_in_quad (exit)
+- **Sinusoidal floating**: Organic motion using X/Y oscillation with phase offset
+
+### 3D Rendering System
+
+#### Rotation3D Struct (shape_renderer.hpp)
+
+```cpp
+struct Rotation3D {
+    float pitch;  // X-axis rotation (nose up/down)
+    float yaw;    // Y-axis rotation (turn left/right)
+    float roll;   // Z-axis rotation (bank left/right)
+
+    Rotation3D() : pitch(0.0f), yaw(0.0f), roll(0.0f) {}
+    Rotation3D(float p, float y, float r) : pitch(p), yaw(y), roll(r) {}
+
+    bool has_rotation() const {
+        return pitch != 0.0f || yaw != 0.0f || roll != 0.0f;
+    }
+};
+```
+
+#### 3D Transformation Pipeline (shape_renderer.cpp)
+
+```cpp
+static Punt apply_3d_rotation(float x, float y, const Rotation3D& rot) {
+    float z = 0.0f;  // All 2D points start at Z=0
+
+    // 1. Pitch (X-axis): Rotate around horizontal axis
+    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;
+
+    // 2. Yaw (Y-axis): Rotate around vertical axis
+    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;
+
+    // 3. Roll (Z-axis): Rotate around depth axis
+    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;
+
+    // 4. Perspective projection (Z-divide)
+    constexpr float perspective_factor = 500.0f;
+    float scale_factor = perspective_factor / (perspective_factor + z2);
+
+    return {x3 * scale_factor, y3 * scale_factor};
+}
+```
+
+**Rendering order**: 3D rotation → perspective → 2D scale → 2D rotation → translation
+
+**Backward compatibility**: Optional `rotation_3d` parameter (default nullptr) - existing code unaffected
+
+### Ship Animation State Machine
+
+#### States (ship_animator.hpp)
+
+```cpp
+enum class EstatNau {
+    ENTERING,  // Entering from off-screen
+    FLOATING,  // Floating at target position
+    EXITING    // Flying towards vanishing point
+};
+
+struct NauTitol {
+    int jugador_id;              // 1 or 2
+    EstatNau estat;              // Current state
+    float temps_estat;           // Time in current state
+
+    Punt posicio_inicial;        // Start position
+    Punt posicio_objectiu;       // Target position
+    Punt posicio_actual;         // Current interpolated position
+
+    float escala_inicial;        // Start scale
+    float escala_objectiu;       // Target scale
+    float escala_actual;         // Current interpolated scale
+
+    Rotation3D rotacio_3d;       // STATIC 3D rotation (never changes)
+    float fase_oscilacio;        // Oscillation phase accumulator
+
+    std::shared_ptr<Graphics::Shape> forma;
+    bool visible;
+};
+```
+
+#### State Transitions
+
+**ENTERING** (2.0s):
+- Ships appear from beyond screen edges (calculated radially from clock positions)
+- Lerp position: off-screen → target (clock 8 / clock 4)
+- Lerp scale: 1.0 → 0.6 (perspective effect)
+- Easing: `ease_out_quad` (smooth deceleration)
+- Transition: → FLOATING when complete
+
+**FLOATING** (indefinite):
+- Sinusoidal oscillation on X/Y axes
+- Different frequencies (0.5 Hz / 0.7 Hz) with phase offset (π/2)
+- Creates organic circular/elliptical motion
+- Scale constant at 0.6
+- Transition: → EXITING when START pressed
+
+**EXITING** (1.0s):
+- Ships fly towards vanishing point (center: 320, 240)
+- Lerp position: current → vanishing point
+- Lerp scale: current → 0.0 (simulates Z → infinity)
+- Easing: `ease_in_quad` (acceleration)
+- Edge case: If START pressed during ENTERING, ships fly from mid-animation position
+- Marks invisible when complete
+
+### Configuration (defaults.hpp)
+
+```cpp
+namespace Title {
+namespace Ships {
+    // Clock positions (polar coordinates from center 320, 240)
+    constexpr float CLOCK_8_ANGLE = 150.0f * Math::PI / 180.0f;  // Bottom-left
+    constexpr float CLOCK_4_ANGLE = 30.0f * Math::PI / 180.0f;   // Bottom-right
+    constexpr float CLOCK_RADIUS = 150.0f;
+
+    // Target positions (pre-calculated)
+    constexpr float P1_TARGET_X = 190.0f;  // Clock 8
+    constexpr float P1_TARGET_Y = 315.0f;
+    constexpr float P2_TARGET_X = 450.0f;  // Clock 4
+    constexpr float P2_TARGET_Y = 315.0f;
+
+    // 3D rotations (STATIC - tuned for subtle effect)
+    constexpr float P1_PITCH = 0.1f;   // ~6° nose-up
+    constexpr float P1_YAW = -0.15f;   // ~9° turn left
+    constexpr float P1_ROLL = -0.05f;  // ~3° bank left
+
+    constexpr float P2_PITCH = 0.1f;   // ~6° nose-up
+    constexpr float P2_YAW = 0.15f;    // ~9° turn right
+    constexpr float P2_ROLL = 0.05f;   // ~3° bank right
+
+    // Scales
+    constexpr float ENTRY_SCALE_START = 1.0f;
+    constexpr float FLOATING_SCALE = 0.6f;
+
+    // Animation durations
+    constexpr float ENTRY_DURATION = 2.0f;
+    constexpr float EXIT_DURATION = 1.0f;
+    constexpr float ENTRY_OFFSET = 200.0f;  // Distance beyond screen edge
+
+    // Floating oscillation
+    constexpr float FLOAT_AMPLITUDE_X = 6.0f;
+    constexpr float FLOAT_AMPLITUDE_Y = 4.0f;
+    constexpr float FLOAT_FREQUENCY_X = 0.5f;
+    constexpr float FLOAT_FREQUENCY_Y = 0.7f;
+    constexpr float FLOAT_PHASE_OFFSET = 1.57f;  // π/2 (90°)
+
+    // Vanishing point
+    constexpr float VANISHING_POINT_X = 320.0f;
+    constexpr float VANISHING_POINT_Y = 240.0f;
+}
+}
+```
+
+### Integration with EscenaTitol
+
+#### Constructor
+
+```cpp
+// Initialize ships after starfield
+ship_animator_ = std::make_unique<Title::ShipAnimator>(sdl_.obte_renderer());
+ship_animator_->inicialitzar();
+
+if (estat_actual_ == EstatTitol::MAIN) {
+    // Jump to MAIN: ships already in position (no entry animation)
+    ship_animator_->set_visible(true);
+} else {
+    // Normal flow: ships enter during STARFIELD_FADE_IN
+    ship_animator_->set_visible(true);
+    ship_animator_->start_entry_animation();
+}
+```
+
+#### Update Loop
+
+```cpp
+// Update ships in visible states
+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);
+}
+
+// Trigger exit when START pressed
+if (checkStartGameButtonPressed()) {
+    estat_actual_ = EstatTitol::PLAYER_JOIN_PHASE;
+    ship_animator_->trigger_exit_animation();  // Edge case: handles mid-ENTERING
+    Audio::get()->fadeOutMusic(MUSIC_FADE);
+}
+```
+
+#### Draw Loop
+
+```cpp
+// Draw order: starfield → ships → logo → text
+if (starfield_) starfield_->dibuixar();
+
+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();
+}
+
+// Logo and text drawn after ships (foreground)
+```
+
+### Timing & Visibility
+
+**Timeline:**
+1. **STARFIELD_FADE_IN** (3.0s): Ships enter from off-screen
+2. **STARFIELD** (4.0s): Ships floating
+3. **MAIN** (indefinite): Ships floating + logo + text visible
+4. **PLAYER_JOIN_PHASE** (2.5s): Ships exit (1.0s) + text blink
+5. **BLACK_SCREEN** (2.0s): Ships already invisible (exit completed at 1.0s)
+
+**Automatic visibility management:**
+- Ships marked `visible = false` when exit animation completes (actualitzar_exiting)
+- No manual hiding needed - state machine handles it
+
+### Tuning Notes
+
+**If ships look distorted:**
+- Reduce rotation angles (P1_PITCH, P1_YAW, P1_ROLL, P2_*)
+- Current values (0.1, 0.15, 0.05) are tuned for subtle 3D effect
+- Angles in radians: 0.1 rad ≈ 6°, 0.15 rad ≈ 9°
+
+**If ships are too large/small:**
+- Adjust FLOATING_SCALE (currently 0.6)
+- Adjust ENTRY_SCALE_START (currently 1.0)
+
+**If floating motion is too jerky/smooth:**
+- Adjust FLOAT_AMPLITUDE_X/Y (currently 6.0/4.0 pixels)
+- Adjust FLOAT_FREQUENCY_X/Y (currently 0.5/0.7 Hz)
+
+**If entry/exit animations are too fast/slow:**
+- Adjust ENTRY_DURATION (currently 2.0s)
+- Adjust EXIT_DURATION (currently 1.0s)
+
+### Implementation Phases (Completed)
+
+✅ **Phase 1**: 3D infrastructure (Rotation3D, render_shape extension)
+✅ **Phase 2**: Foundation (ship_animator files, constants)
+✅ **Phase 3**: Configuration & loading (shape loading, initialization)
+✅ **Phase 4**: Floating animation (sinusoidal oscillation)
+✅ **Phase 5**: Entry animation (off-screen → position with easing)
+✅ **Phase 6**: Exit animation (position → vanishing point)
+✅ **Phase 7**: EscenaTitol integration (constructor, update, draw)
+✅ **Phase 8**: Polish & tuning (angles, scales, edge cases)
+✅ **Phase 9**: Documentation (CLAUDE.md, code comments)
+
 ## Migration Progress
 
 ### ✅ Phase 0: Project Setup

CMakeLists.txt

@@ -1,11 +1,13 @@
 # CMakeLists.txt
 
 cmake_minimum_required(VERSION 3.10)
-project(orni VERSION 0.4.0)
+project(orni VERSION 0.7.2)
 
 # Info del proyecto
 set(PROJECT_LONG_NAME "Orni Attack")
-set(PROJECT_COPYRIGHT "© 1999 Visente i Sergi, 2025 Port")
+set(PROJECT_COPYRIGHT_ORIGINAL "© 1999 Visente i Sergi")
+set(PROJECT_COPYRIGHT_PORT "© 2025 JailDesigner")
+set(PROJECT_COPYRIGHT "${PROJECT_COPYRIGHT_ORIGINAL}, ${PROJECT_COPYRIGHT_PORT}")
 
 # Establecer estándar de C++
 set(CMAKE_CXX_STANDARD 20)
@@ -73,10 +75,21 @@ target_compile_options(${PROJECT_NAME} PRIVATE $<$<CONFIG:RELEASE>:-O2 -ffunctio
 target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:DEBUG>:_DEBUG>)
 target_compile_definitions(${PROJECT_NAME} PRIVATE $<$<CONFIG:RELEASE>:RELEASE_BUILD>)
 
+# Definir MACOS_BUNDLE si es un bundle de macOS
+if(APPLE AND MACOSX_BUNDLE)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUNDLE)
+endif()
+
 # Configuración específica para cada plataforma
 if(WIN32)
     target_compile_definitions(${PROJECT_NAME} PRIVATE WINDOWS_BUILD)
     target_link_libraries(${PROJECT_NAME} PRIVATE mingw32)
+    # Static linking for libgcc and libstdc++ (avoid DLL dependencies for distribution)
+    target_link_options(${PROJECT_NAME} PRIVATE
+        -static-libgcc
+        -static-libstdc++
+        -static
+    )
     # Añadir icono en Windows (se configurará desde el Makefile con windres)
 elseif(APPLE)
     target_compile_definitions(${PROJECT_NAME} PRIVATE MACOS_BUILD)
@@ -92,12 +105,16 @@ set_target_properties(${PROJECT_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAK
 # --- STATIC ANALYSIS TARGETS ---
 # Buscar herramientas de análisis estático
 find_program(CLANG_FORMAT_EXE NAMES clang-format)
+find_program(CLANG_TIDY_EXE NAMES clang-tidy)
 
 # Recopilar todos los archivos fuente para formateo
 file(GLOB_RECURSE ALL_SOURCE_FILES
     "${CMAKE_SOURCE_DIR}/source/*.cpp"
     "${CMAKE_SOURCE_DIR}/source/*.hpp"
 )
+# Excluir directorios con checks deshabilitados
+list(FILTER ALL_SOURCE_FILES EXCLUDE REGEX ".*/audio/.*")
+list(FILTER ALL_SOURCE_FILES EXCLUDE REGEX ".*/legacy/.*")
 
 # Targets de clang-format
 if(CLANG_FORMAT_EXE)
@@ -120,3 +137,43 @@ if(CLANG_FORMAT_EXE)
 else()
     message(STATUS "clang-format no encontrado - targets 'format' y 'format-check' no disponibles")
 endif()
+
+# Targets de clang-tidy
+if(CLANG_TIDY_EXE)
+    # En macOS, obtener la ruta del SDK para que clang-tidy encuentre los headers del sistema
+    set(CLANG_TIDY_EXTRA_ARGS "")
+    if(APPLE)
+        execute_process(
+            COMMAND xcrun --show-sdk-path
+            OUTPUT_VARIABLE MACOS_SDK_PATH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+        if(MACOS_SDK_PATH)
+            set(CLANG_TIDY_EXTRA_ARGS "--extra-arg=-isysroot${MACOS_SDK_PATH}")
+            message(STATUS "clang-tidy usará SDK de macOS: ${MACOS_SDK_PATH}")
+        endif()
+    endif()
+
+    add_custom_target(tidy
+        COMMAND ${CLANG_TIDY_EXE}
+            -p ${CMAKE_BINARY_DIR}
+            ${CLANG_TIDY_EXTRA_ARGS}
+            --fix
+            --fix-errors
+            ${ALL_SOURCE_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Running clang-tidy with auto-fix..."
+    )
+
+    add_custom_target(tidy-check
+        COMMAND ${CLANG_TIDY_EXE}
+            -p ${CMAKE_BINARY_DIR}
+            ${CLANG_TIDY_EXTRA_ARGS}
+            --warnings-as-errors='*'
+            ${ALL_SOURCE_FILES}
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        COMMENT "Checking clang-tidy..."
+    )
+else()
+    message(STATUS "clang-tidy no encontrado - targets 'tidy' y 'tidy-check' no disponibles")
+endif()

Makefile

@@ -9,8 +9,8 @@ DIR_BIN        := $(DIR_ROOT)
 # TARGET NAMES
 # ==============================================================================
 ifeq ($(OS),Windows_NT)
-    TARGET_NAME    := $(shell powershell -Command "$$line = Get-Content CMakeLists.txt | Where-Object {$$_ -match '^project'}; if ($$line -match 'project\s*\x28(\w+)') { $$matches[1] }")
+    TARGET_NAME    := $(shell powershell -Command "(Select-String -Path 'CMakeLists.txt' -Pattern 'project\s*\x28(\w+)').Matches.Groups[1].Value")
-    LONG_NAME      := $(shell powershell -Command "$$line = Get-Content CMakeLists.txt | Where-Object {$$_ -match 'PROJECT_LONG_NAME'}; if ($$line -match '\"(.+)\"') { $$matches[1] }")
+    LONG_NAME      := $(shell powershell -Command "(Select-String -Path 'CMakeLists.txt' -Pattern 'PROJECT_LONG_NAME\s+\x22(.+?)\x22').Matches.Groups[1].Value")
 else
     TARGET_NAME    := $(shell awk '/^project/ {gsub(/[)(]/, " "); print $$2}' CMakeLists.txt)
     LONG_NAME      := $(shell grep 'PROJECT_LONG_NAME' CMakeLists.txt | sed 's/.*"\(.*\)".*/\1/')
@@ -20,8 +20,21 @@ TARGET_FILE    := $(DIR_BIN)$(TARGET_NAME)
 RELEASE_FOLDER := $(TARGET_NAME)_release
 RELEASE_FILE   := $(RELEASE_FOLDER)/$(TARGET_NAME)
 
-# Release file names
+# ==============================================================================
+# VERSION
+# ==============================================================================
+ifeq ($(OS),Windows_NT)
+    VERSION := v$(shell powershell -Command "(Select-String -Path 'CMakeLists.txt' -Pattern 'project.*VERSION\s+([0-9.]+)').Matches.Groups[1].Value")
+else
+    VERSION := v$(shell grep "^project" CMakeLists.txt | tr -cd 0-9.)
+endif
+
+# Release file names (depend on VERSION, so must come after)
+ifeq ($(OS),Windows_NT)
+    RAW_VERSION := $(shell powershell -Command "\"$(VERSION)\" -replace '^v', ''")
+else
     RAW_VERSION := $(shell echo $(VERSION) | sed 's/^v//')
+endif
 WINDOWS_RELEASE := $(TARGET_NAME)-$(VERSION)-windows-x64.zip
 MACOS_ARM_RELEASE := $(TARGET_NAME)-$(VERSION)-macos-arm64.dmg
 MACOS_INTEL_RELEASE := $(TARGET_NAME)-$(VERSION)-macos-x64.dmg
@@ -29,15 +42,6 @@ LINUX_RELEASE := $(TARGET_NAME)-$(VERSION)-linux-x64.tar.gz
 RPI_RELEASE := $(TARGET_NAME)-$(VERSION)-rpi-arm64.tar.gz
 APP_NAME := $(LONG_NAME)
 
-# ==============================================================================
-# VERSION
-# ==============================================================================
-ifeq ($(OS),Windows_NT)
-    VERSION := v$(shell powershell -Command "$$line = Get-Content CMakeLists.txt | Where-Object {$$_ -match '^project'}; if ($$line -match 'VERSION\s+([0-9.]+)') { $$matches[1] }")
-else
-    VERSION := v$(shell grep "^project" CMakeLists.txt | tr -cd 0-9.)
-endif
-
 # ==============================================================================
 # SOURCE FILES
 # ==============================================================================
@@ -47,17 +51,38 @@ endif
 # ==============================================================================
 # PLATFORM-SPECIFIC UTILITIES
 # ==============================================================================
-ifeq ($(OS),Windows_NT)
+# Use Unix commands always (MinGW Make uses bash even on Windows)
-    RMFILE          := del /Q
-    RMDIR           := rmdir /S /Q
-    MKDIR           := mkdir
-else
 RMFILE          := rm -f
 RMDIR           := rm -rf
 MKDIR           := mkdir -p
+
+ifeq ($(OS),Windows_NT)
+    # Windows-specific: Force cmd.exe shell for PowerShell commands
+    SHELL := cmd.exe
+else
+    # Unix-specific
     UNAME_S         := $(shell uname -s)
 endif
 
+# ==============================================================================
+# PACKING TOOL
+# ==============================================================================
+PACK_TOOL := tools/pack_resources/pack_resources
+
+# ==============================================================================
+# DEFAULT GOAL
+# ==============================================================================
+.DEFAULT_GOAL := all
+
+.PHONY: pack_tool resources.pack
+
+pack_tool:
+	@make -C tools/pack_resources
+
+resources.pack: pack_tool
+	@echo "Creating resources.pack..."
+	@./$(PACK_TOOL) data resources.pack
+
 # ==============================================================================
 # TARGETS
 # ==============================================================================
@@ -67,8 +92,8 @@ endif
 # BUILD TARGETS (delegate to CMake)
 # ==============================================================================
 
-# Default target: build with CMake
+# Default target: build with CMake + resources
-all: $(TARGET_FILE)
+all: resources.pack $(TARGET_FILE)
 
 $(TARGET_FILE):
 	@cmake -B build -DCMAKE_BUILD_TYPE=Release
@@ -76,10 +101,10 @@ $(TARGET_FILE):
 	@echo "Build successful: $(TARGET_FILE)"
 
 # Debug build
-debug:
+debug: resources.pack
 	@cmake -B build -DCMAKE_BUILD_TYPE=Debug
 	@cmake --build build
-	@echo "Debug build successful: $(TARGET_FILE)_debug"
+	@echo "Debug build successful: $(TARGET_FILE)"
 
 # ==============================================================================
 # RELEASE PACKAGING TARGETS
@@ -87,7 +112,7 @@ debug:
 
 # macOS Release (Apple Silicon)
 .PHONY: macos_release
-macos_release:
+macos_release: pack_tool resources.pack
 	@echo "Creating macOS release - Version: $(VERSION)"
 
 	# Check/install create-dmg
@@ -104,8 +129,8 @@ macos_release:
 	@$(MKDIR) "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources"
 	@$(MKDIR) Frameworks
 
-	# Copy resources
+	# Copy resources.pack to Resources
-	@cp -r resources "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources/"
+	@cp resources.pack "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Resources/"
 	@ditto release/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework "$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Frameworks/SDL3.framework"
 	@ditto release/frameworks/SDL3.xcframework/macos-arm64_x86_64/SDL3.framework Frameworks/SDL3.framework
 
@@ -126,12 +151,18 @@ macos_release:
 	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
 	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
 
-	# Update Info.plist version
+	# Update Info.plist version and names
-	@echo "Updating Info.plist with version $(RAW_VERSION)..."
+	@echo "Updating Info.plist with version $(RAW_VERSION) and names..."
 	@sed -i '' '/<key>CFBundleShortVersionString<\/key>/{n;s|<string>.*</string>|<string>$(RAW_VERSION)</string>|;}' \
 		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
 	@sed -i '' '/<key>CFBundleVersion<\/key>/{n;s|<string>.*</string>|<string>$(RAW_VERSION)</string>|;}' \
 		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
+	@sed -i '' '/<key>CFBundleExecutable<\/key>/{n;s|<string>.*</string>|<string>$(TARGET_NAME)</string>|;}' \
+		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
+	@sed -i '' '/<key>CFBundleName<\/key>/{n;s|<string>.*</string>|<string>$(APP_NAME)</string>|;}' \
+		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
+	@sed -i '' '/<key>CFBundleDisplayName<\/key>/{n;s|<string>.*</string>|<string>$(APP_NAME)</string>|;}' \
+		"$(RELEASE_FOLDER)/$(APP_NAME).app/Contents/Info.plist"
 
 	# Compile for Apple Silicon using CMake
 	@cmake -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=arm64
@@ -150,6 +181,8 @@ macos_release:
 		--icon-size 96 \
 		--text-size 12 \
 		--icon "$(APP_NAME).app" 278 102 \
+		--icon "LICENSE" 441 102 \
+		--icon "README.md" 604 102 \
 		--app-drop-link 115 102 \
 		--hide-extension "$(APP_NAME).app" \
 		"$(MACOS_ARM_RELEASE)" \
@@ -162,8 +195,9 @@ macos_release:
 
 # Linux Release
 .PHONY: linux_release
-linux_release:
+linux_release: pack_tool resources.pack
 	@echo "Creating Linux release - Version: $(VERSION)"
+	@echo "Note: SDL3 must be installed on the target system (libsdl3-dev)"
 
 	# Clean previous
 	@$(RMDIR) "$(RELEASE_FOLDER)"
@@ -173,7 +207,7 @@ linux_release:
 	@$(MKDIR) "$(RELEASE_FOLDER)"
 
 	# Copy resources
-	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp resources.pack "$(RELEASE_FOLDER)/"
 	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
 	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
 
@@ -192,37 +226,25 @@ linux_release:
 
 # Windows Release (requires MinGW on Windows or cross-compiler on Linux)
 .PHONY: windows_release
-windows_release:
+windows_release: pack_tool resources.pack
-	@echo "Creating Windows release - Version: $(VERSION)"
+	@echo off
-	@echo "Note: This target should be run on Windows with MinGW or use windows_cross on Linux"
+	@echo Creating Windows release - Version: $(VERSION)
-
+	@powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
-	# Clean previous
+	@powershell if (Test-Path "$(WINDOWS_RELEASE)") {Remove-Item "$(WINDOWS_RELEASE)"}
-	@$(RMDIR) "$(RELEASE_FOLDER)"
+	@powershell if (-not (Test-Path "$(RELEASE_FOLDER)")) {New-Item "$(RELEASE_FOLDER)" -ItemType Directory}
-	@$(RMFILE) "$(WINDOWS_RELEASE)"
+	@powershell Copy-Item -Path "resources.pack" -Destination "$(RELEASE_FOLDER)"
-
+	@powershell Copy-Item "release\dll\SDL3.dll" -Destination "$(RELEASE_FOLDER)"
-	# Create folder
+	@powershell Copy-Item "release\dll\libwinpthread-1.dll" -Destination "$(RELEASE_FOLDER)"
-	@$(MKDIR) "$(RELEASE_FOLDER)"
+	@powershell if (Test-Path "LICENSE") {Copy-Item "LICENSE" -Destination "$(RELEASE_FOLDER)"}
-
+	@powershell if (Test-Path "README.md") {Copy-Item "README.md" -Destination "$(RELEASE_FOLDER)"}
-	# Copy resources
+	@windres release/$(TARGET_NAME).rc -O coff -o release/$(TARGET_NAME).res 2>nul || echo Warning: windres failed
-	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cmake -B build -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release
-	@cp release/dll/*.dll "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: DLLs not found"
-	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
-	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
-
-	# Compile resource file
-	@windres release/$(TARGET_NAME).rc -O coff -o release/$(TARGET_NAME).res 2>/dev/null || echo "Warning: windres failed"
-
-	# Compile with CMake
-	@cmake -B build -DCMAKE_BUILD_TYPE=Release
 	@cmake --build build
-	@cp $(TARGET_FILE).exe "$(RELEASE_FILE).exe" || cp $(TARGET_FILE) "$(RELEASE_FILE).exe"
+	@powershell if (Test-Path "$(TARGET_FILE).exe") {Copy-Item "$(TARGET_FILE).exe" -Destination "$(RELEASE_FILE).exe"} else {Copy-Item "$(TARGET_FILE)" -Destination "$(RELEASE_FILE).exe"}
-
+	@strip "$(RELEASE_FILE).exe" 2>nul || echo Warning: strip not available
-	# Package
+	@powershell Compress-Archive -Path "$(RELEASE_FOLDER)\*" -DestinationPath "$(WINDOWS_RELEASE)" -Force
-	@cd "$(RELEASE_FOLDER)" && zip -r ../$(WINDOWS_RELEASE) *
+	@echo Release created: $(WINDOWS_RELEASE)
-	@echo "✓ Windows release created: $(WINDOWS_RELEASE)"
+	@powershell if (Test-Path "$(RELEASE_FOLDER)") {Remove-Item "$(RELEASE_FOLDER)" -Recurse -Force}
-
-	# Cleanup
-	@$(RMDIR) "$(RELEASE_FOLDER)"
 
 # Raspberry Pi Release (cross-compilation from Linux/macOS)
 .PHONY: rpi_release
@@ -241,7 +263,7 @@ rpi_release:
 	@$(MKDIR) "$(RELEASE_FOLDER)"
 
 	# Copy resources
-	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp resources.pack "$(RELEASE_FOLDER)/"
 	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
 	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
 
@@ -277,8 +299,8 @@ windows_cross:
 	@$(MKDIR) "$(RELEASE_FOLDER)"
 
 	# Copy resources
-	@cp -r resources "$(RELEASE_FOLDER)/"
+	@cp resources.pack "$(RELEASE_FOLDER)/"
-	@cp release/dll/*.dll "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: DLLs not found in release/dll/"
+	@cp release/dll/SDL3.dll release/dll/libwinpthread-1.dll "$(RELEASE_FOLDER)/"
 	@cp LICENSE "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: LICENSE not found"
 	@cp README.md "$(RELEASE_FOLDER)/" 2>/dev/null || echo "Warning: README.md not found"
 
@@ -313,6 +335,8 @@ else
 	@$(RMFILE) $(TARGET_FILE) $(TARGET_FILE)_debug
 	@$(RMDIR) build $(RELEASE_FOLDER)
 	@$(RMFILE) *.dmg *.zip *.tar.gz 2>/dev/null || true
+	@$(RMFILE) resources.pack 2>/dev/null || true
+	@make -C tools/pack_resources clean 2>/dev/null || true
 endif
 	@echo "Clean complete"
 

README.md

@@ -1,20 +1,71 @@
-# Asteroids
+<div align="center">
+  <img src="https://php.sustancia.synology.me/images/orni_attack/orni_attack_1.png" width="600" alt="Orni Attack">
+</div>
+
+# Orni Attack
+
 Destrueix als cosinus mesisinus que ens ataquen montats en ORNIs!
-<img width="752" src="https://user-images.githubusercontent.com/110221325/184473983-a07c8594-f87c-4e6a-b723-b0a0f8d08e85.png">
+
+---
+
 ## Controls
- * `cursor amunt` accelerar
- * `cursor avall` frenar
- * `cursor dreta` rotar en el sentit de les agulles del rellotge
- * `cursor esquerra`rotar en l'altre sentit
- * `espai` disparar
- * `esc` eixir
 
-Nomes tens una bala a l'hora. Crec que els teus dispars encara no fan pupa als ORNIs. Pero si ells te toquen sí que rebentes.
+El joc permet l'ús del teclat per a controlar la nau i la finestra. Les tecles són les següents:
 
-## Com jugar hui en dia
+| Tecla | Acció |
+|-------|-------|
+| **↑** | Accelerar la nau |
+| **↓** | Frenar |
+| **←** | Rotar a l'esquerra |
+| **→** | Rotar a la dreta |
+| **Espai** | Disparar |
+| **ESC** | Eixir del joc |
+| **F1** | Disminuir la mida de la finestra |
+| **F2** | Augmentar la mida de la finestra |
+| **F3** | Alternar pantalla completa |
 
-Amb DosBox. Augmenta cicles, uns 30000 en el meu macbook.
+---
 
-## Com compilar hui en dia
+## Compilació i execució
 
-Turbo Pascal 7 desde DosBox. No m'ha fet falta activar res.
+### Compilar el joc
+
+```bash
+make           # Compilar
+make debug     # Compilació en mode debug
+make clean     # Netejar fitxers compilats
+./orni         # Executar
+```
+
+### Crear versions release
+
+```bash
+make macos_release     # macOS .app bundle + .dmg (Apple Silicon)
+make linux_release     # Linux .tar.gz
+make windows_release   # Windows .zip (requereix MinGW a Windows)
+make windows_cross     # Cross-compilació Windows des de Linux/macOS
+make rpi_release       # Raspberry Pi ARM64 cross-compilació
+```
+
+---
+
+## Requisits
+
+- **C++20** compatible compiler
+- **SDL3** library
+- **CMake** 3.15 o superior
+
+### Plataformes suportades
+
+- macOS (Apple Silicon i Intel)
+- Linux (x86_64)
+- Windows (MinGW)
+- Raspberry Pi (ARM64)
+
+---
+
+## Història
+
+Joc original creat en **Turbo Pascal 7 per a DOS** (1999), ara migrat a **C++20 amb SDL3**. Aquest port modern preserva la jugabilitat i l'estètica de l'original mentre aprofita les capacitats dels sistemes actuals.
+
+**Versió actual**: BETA 3.0

data/shapes/bullet.shp

@@ -6,14 +6,18 @@ name: bullet
 scale: 1.0
 center: 0, 0
 
-# Pentàgon petit radi=5 (1/4 del enemic)
+# Cercle (octàgon regular radi=3)
-# Pentàgon regular amb 72° entre punts
+# 8 punts equidistants (45° entre ells) per aproximar un cercle
+# Començant a angle=-90° (amunt), rotant sentit horari
 #
-# Conversió polar→cartesià (radi=5, SDL: Y creix cap avall):
+# Conversió polar→cartesià (radi=3, SDL: Y creix cap avall):
-#   angle=-90°: (0.00, -5.00)
+#   angle=-90°:  (0.00, -3.00)
-#   angle=-18°: (4.76, -1.55)
+#   angle=-45°:  (2.12, -2.12)
-#   angle=54°:  (2.94, 4.05)
+#   angle=0°:    (3.00, 0.00)
-#   angle=126°: (-2.94, 4.05)
+#   angle=45°:   (2.12, 2.12)
-#   angle=198°: (-4.76, -1.55)
+#   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,-5  4.76,-1.55  2.94,4.05  -2.94,4.05  -4.76,-1.55  0,-5
+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

data/shapes/font/char_3.shp

@@ -7,5 +7,5 @@ scale: 1.0
 center: 10, 20
 
 # Trazo continuo (barra superior + lateral derecho + barra media + lateral derecho + barra inferior)
-polyline: 2,10  18,10  18,20  14,20
+polyline: 2,10  18,10  18,20  8,20
-polyline: 14,20  18,20  18,30  2,30
+polyline: 8,20  18,20  18,30  2,30

data/shapes/ship.shp

@@ -1,4 +1,4 @@
-# ship.shp - Nau del jugador (triangle)
+# 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
 
@@ -6,15 +6,19 @@ name: ship
 scale: 1.0
 center: 0, 0
 
-# Triangle: punta amunt, base avall
+# 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)
+#   p1: (0, -12) → punta
-#   p2: (8.49, 8.49)
+#   p2: (8.49, 8.49) → base dreta
-#   p3: (-8.49, 8.49)
+#   p4: (0, 4) → base centre (cap endins)
+#   p3: (-8.49, 8.49) → base esquerra
 
-polyline: 0,-12  8.49,8.49  -8.49,8.49  0,-12
+polyline: 0,-12  8.49,8.49  0,4  -8.49,8.49  0,-12

data/shapes/ship2.shp

@@ -0,0 +1,30 @@
+# ship2.shp - Nau del jugador 2 (triangle amb circulito central)
+# © 1999 Visente i Sergi (versió Pascal)
+# © 2025 Port a C++20 amb SDL3
+
+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
+polyline: 0,-2.5  1.77,-1.77  2.5,0  1.77,1.77  0,2.5  -1.77,1.77  -2.5,0  -1.77,-1.77  0,-2.5

data/shapes/ship2_perspective.shp

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

data/shapes/ship3.shp

@@ -0,0 +1,27 @@
+# ship2.shp - Nau del jugador 2 (interceptor amb ales)
+# © 2025 Orni Attack - Jugador 2
+
+name: ship2
+scale: 1.0
+center: 0, 0
+
+# Interceptor amb ales laterals
+# Disseny més ample i agressiu que P1
+#
+# Geometria:
+#   - Punta més curta i ampla
+#   - Ales laterals pronunciades
+#   - Base més ampla per estabilitat visual
+#
+# Punts (cartesianes, Y negatiu = amunt):
+#   p1: (0, -10) → punta (més curta que P1)
+#   p2: (4, -6) → transició ala dreta
+#   p3: (10, 2) → punta ala dreta (més ampla)
+#   p4: (6, 8) → base ala dreta
+#   p5: (0, 6) → base centre (menys còncava)
+#   p6: (-6, 8) → base ala esquerra
+#   p7: (-10, 2) → punta ala esquerra
+#   p8: (-4, -6) → transició ala esquerra
+#   p1: (0, -10) → tanca
+
+polyline: 0,-10  4,-6  10,2  6,8  0,6  -6,8  -10,2  -4,-6  0,-10

data/shapes/ship_perspective.shp

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

data/stages/stages.yaml

@@ -0,0 +1,168 @@
+# stages.yaml - Configuració de les 10 etapes d'Orni Attack
+# © 2025 Orni Attack
+
+metadata:
+  version: "1.0"
+  total_stages: 10
+  description: "Progressive difficulty curve from novice to expert"
+
+stages:
+  # STAGE 1: Tutorial - Only pentagons, slow speed
+  - stage_id: 1
+    total_enemies: 5
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 2.0
+      spawn_interval: 3.0
+    enemy_distribution:
+      pentagon: 100
+      quadrat: 0
+      molinillo: 0
+    difficulty_multipliers:
+      speed_multiplier: 0.7
+      rotation_multiplier: 0.8
+      tracking_strength: 0.0
+
+  # STAGE 2: Introduction to tracking enemies
+  - stage_id: 2
+    total_enemies: 7
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 1.5
+      spawn_interval: 2.5
+    enemy_distribution:
+      pentagon: 70
+      quadrat: 30
+      molinillo: 0
+    difficulty_multipliers:
+      speed_multiplier: 0.85
+      rotation_multiplier: 0.9
+      tracking_strength: 0.3
+
+  # STAGE 3: All enemy types, normal speed
+  - stage_id: 3
+    total_enemies: 10
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 1.0
+      spawn_interval: 2.0
+    enemy_distribution:
+      pentagon: 50
+      quadrat: 30
+      molinillo: 20
+    difficulty_multipliers:
+      speed_multiplier: 1.0
+      rotation_multiplier: 1.0
+      tracking_strength: 0.5
+
+  # STAGE 4: Increased count, faster enemies
+  - stage_id: 4
+    total_enemies: 12
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.8
+      spawn_interval: 1.8
+    enemy_distribution:
+      pentagon: 40
+      quadrat: 35
+      molinillo: 25
+    difficulty_multipliers:
+      speed_multiplier: 1.1
+      rotation_multiplier: 1.15
+      tracking_strength: 0.6
+
+  # STAGE 5: Maximum count reached
+  - stage_id: 5
+    total_enemies: 15
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.5
+      spawn_interval: 1.5
+    enemy_distribution:
+      pentagon: 35
+      quadrat: 35
+      molinillo: 30
+    difficulty_multipliers:
+      speed_multiplier: 1.2
+      rotation_multiplier: 1.25
+      tracking_strength: 0.7
+
+  # STAGE 6: Molinillo becomes dominant
+  - stage_id: 6
+    total_enemies: 15
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.3
+      spawn_interval: 1.3
+    enemy_distribution:
+      pentagon: 30
+      quadrat: 30
+      molinillo: 40
+    difficulty_multipliers:
+      speed_multiplier: 1.3
+      rotation_multiplier: 1.4
+      tracking_strength: 0.8
+
+  # STAGE 7: High intensity, fast spawns
+  - stage_id: 7
+    total_enemies: 15
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.2
+      spawn_interval: 1.0
+    enemy_distribution:
+      pentagon: 25
+      quadrat: 30
+      molinillo: 45
+    difficulty_multipliers:
+      speed_multiplier: 1.4
+      rotation_multiplier: 1.5
+      tracking_strength: 0.9
+
+  # STAGE 8: Expert level, 50% molinillos
+  - stage_id: 8
+    total_enemies: 15
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.1
+      spawn_interval: 0.8
+    enemy_distribution:
+      pentagon: 20
+      quadrat: 30
+      molinillo: 50
+    difficulty_multipliers:
+      speed_multiplier: 1.5
+      rotation_multiplier: 1.6
+      tracking_strength: 1.0
+
+  # STAGE 9: Near-maximum difficulty
+  - stage_id: 9
+    total_enemies: 15
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.0
+      spawn_interval: 0.6
+    enemy_distribution:
+      pentagon: 15
+      quadrat: 25
+      molinillo: 60
+    difficulty_multipliers:
+      speed_multiplier: 1.6
+      rotation_multiplier: 1.7
+      tracking_strength: 1.1
+
+  # STAGE 10: Final challenge, 70% molinillos
+  - stage_id: 10
+    total_enemies: 15
+    spawn_config:
+      mode: "progressive"
+      initial_delay: 0.0
+      spawn_interval: 0.5
+    enemy_distribution:
+      pentagon: 10
+      quadrat: 20
+      molinillo: 70
+    difficulty_multipliers:
+      speed_multiplier: 1.8
+      rotation_multiplier: 2.0
+      tracking_strength: 1.2

source/core/audio/.clang-tidy

@@ -0,0 +1,5 @@
+# Deshabilitar clang-tidy para este directorio (código externo: jail_audio.hpp)
+# Los demás archivos de este directorio (audio.cpp, audio_cache.cpp) también se benefician
+# de no ser modificados porque dependen íntimamente de la API de jail_audio.hpp
+
+Checks: '-*'

source/core/audio/audio_cache.cpp

@@ -5,6 +5,8 @@
 
 #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_;
@@ -19,17 +21,28 @@ JA_Sound_t* AudioCache::getSound(const std::string& name) {
         return it->second;
     }
 
-    // Cache miss - cargar archivo
+    // Normalize path: "laser_shoot.wav" → "sounds/laser_shoot.wav"
-    std::string fullpath = resolveSoundPath(name);
+    std::string normalized = name;
-    JA_Sound_t* sound = JA_LoadSound(fullpath.c_str());
+    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 carregar " << fullpath
+        std::cerr << "[AudioCache] Error: no s'ha pogut decodificar " << normalized
                   << std::endl;
         return nullptr;
     }
 
-    std::cout << "[AudioCache] Sound loaded: " << name << std::endl;
+    std::cout << "[AudioCache] Sound loaded: " << normalized << std::endl;
     sounds_[name] = sound;
     return sound;
 }
@@ -42,17 +55,28 @@ JA_Music_t* AudioCache::getMusic(const std::string& name) {
         return it->second;
     }
 
-    // Cache miss - cargar archivo
+    // Normalize path: "title.ogg" → "music/title.ogg"
-    std::string fullpath = resolveMusicPath(name);
+    std::string normalized = name;
-    JA_Music_t* music = JA_LoadMusic(fullpath.c_str());
+    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 carregar " << fullpath
+        std::cerr << "[AudioCache] Error: no s'ha pogut decodificar " << normalized
                   << std::endl;
         return nullptr;
     }
 
-    std::cout << "[AudioCache] Music loaded: " << name << std::endl;
+    std::cout << "[AudioCache] Music loaded: " << normalized << std::endl;
     musics_[name] = music;
     return music;
 }

source/core/audio/jail_audio.hpp

@@ -60,7 +60,7 @@ 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_musicVolume{1.0F};
 inline float JA_soundVolume[JA_MAX_GROUPS];
 inline bool JA_musicEnabled{true};
 inline bool JA_soundEnabled{true};
@@ -69,7 +69,7 @@ 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'
+inline float fade_initial_volume{0.0F};  // Corregido de 'int' a 'float'
 
 // --- Forward Declarations ---
 inline void JA_StopMusic();
@@ -128,7 +128,7 @@ inline void JA_Init(const int freq, const SDL_AudioFormat format, const int num_
     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;
+    for (int i = 0; i < JA_MAX_GROUPS; ++i) JA_soundVolume[i] = 0.5F;
 }
 
 inline void JA_Quit() {
@@ -274,7 +274,7 @@ inline void JA_DeleteMusic(JA_Music_t* music) {
 }
 
 inline float JA_SetMusicVolume(float volume) {
-    JA_musicVolume = SDL_clamp(volume, 0.0f, 1.0f);
+    JA_musicVolume = SDL_clamp(volume, 0.0F, 1.0F);
     if (current_music && current_music->stream) {
         SDL_SetAudioStreamGain(current_music->stream, JA_musicVolume);
     }
@@ -443,7 +443,7 @@ inline JA_Channel_state JA_GetChannelState(const int channel) {
 
 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);
+    const float v = SDL_clamp(volume, 0.0F, 1.0F);
 
     if (group == -1) {
         for (int i = 0; i < JA_MAX_GROUPS; ++i) {

source/core/defaults.hpp

@@ -1,7 +1,9 @@
 #pragma once
 #include <SDL3/SDL.h>
 
+#include <cmath>
 #include <cstdint>
+#include <numbers>
 
 namespace Defaults {
 // Configuración de ventana
@@ -11,9 +13,10 @@ constexpr int HEIGHT = 480;
 constexpr int MIN_WIDTH = 320;  // Mínimo: mitad del original
 constexpr int MIN_HEIGHT = 240;
 // Zoom system
-constexpr float BASE_ZOOM = 1.0f;       // 640x480 baseline
+constexpr float BASE_ZOOM = 1.0F;       // 640x480 baseline
-constexpr float MIN_ZOOM = 0.5f;        // 320x240 minimum
+constexpr float MIN_ZOOM = 0.5F;        // 320x240 minimum
-constexpr float ZOOM_INCREMENT = 0.1f;  // 10% steps (F1/F2)
+constexpr float ZOOM_INCREMENT = 0.1F;  // 10% steps (F1/F2)
+constexpr bool FULLSCREEN = true;       // Pantalla completa activadapor defecto
 }  // namespace Window
 
 // Dimensions base del joc (coordenades lògiques)
@@ -22,44 +25,76 @@ constexpr int WIDTH = 640;
 constexpr int HEIGHT = 480;
 }  // namespace Game
 
-// Zones del joc (SDL_FRect amb càlculs automàtics)
+// Zones del joc (SDL_FRect amb càlculs automàtics basat en percentatges)
 namespace Zones {
 // --- CONFIGURACIÓ DE PORCENTATGES ---
-// Basats en valors originals 640x480
+// Totes les zones definides com a percentatges de Game::WIDTH (640) i Game::HEIGHT (480)
-// Ajusta estos valors per canviar proporcions
 
-constexpr float PLAYAREA_MARGIN_HORIZONTAL_PERCENT = 10.0f / Game::WIDTH;
+// Percentatges d'alçada (divisió vertical)
-constexpr float PLAYAREA_MARGIN_VERTICAL_PERCENT = 10.0f / Game::HEIGHT;
+constexpr float SCOREBOARD_TOP_HEIGHT_PERCENT = 0.02F;     // 10% superior
-constexpr float SCOREBOARD_HEIGHT_PERCENT = 48.0f / Game::HEIGHT;
+constexpr float MAIN_PLAYAREA_HEIGHT_PERCENT = 0.88F;      // 80% central
+constexpr float SCOREBOARD_BOTTOM_HEIGHT_PERCENT = 0.10F;  // 10% inferior
 
-// --- CÀLCULS AUTOMÀTICS ---
+// Padding horizontal per a PLAYAREA (dins de MAIN_PLAYAREA)
-// Estos valors es recalculen si canvien Game::WIDTH o Game::HEIGHT
+constexpr float PLAYAREA_PADDING_HORIZONTAL_PERCENT = 0.015F;  // 5% a cada costat
 
-constexpr float PLAYAREA_MARGIN_H =
+// --- CÀLCULS AUTOMÀTICS DE PÍXELS ---
-    Game::WIDTH * PLAYAREA_MARGIN_HORIZONTAL_PERCENT;
+// Càlculs automàtics a partir dels percentatges
-constexpr float PLAYAREA_MARGIN_V =
+
-    Game::HEIGHT * PLAYAREA_MARGIN_VERTICAL_PERCENT;
+// Alçades
-constexpr float SCOREBOARD_H = Game::HEIGHT * SCOREBOARD_HEIGHT_PERCENT;
+constexpr float SCOREBOARD_TOP_H = Game::HEIGHT * SCOREBOARD_TOP_HEIGHT_PERCENT;
+constexpr float MAIN_PLAYAREA_H = Game::HEIGHT * MAIN_PLAYAREA_HEIGHT_PERCENT;
+constexpr float SCOREBOARD_BOTTOM_H = Game::HEIGHT * SCOREBOARD_BOTTOM_HEIGHT_PERCENT;
+
+// Posicions Y
+constexpr float SCOREBOARD_TOP_Y = 0.0F;
+constexpr float MAIN_PLAYAREA_Y = SCOREBOARD_TOP_H;
+constexpr float SCOREBOARD_BOTTOM_Y = MAIN_PLAYAREA_Y + MAIN_PLAYAREA_H;
+
+// Padding horizontal de PLAYAREA
+constexpr float PLAYAREA_PADDING_H = Game::WIDTH * PLAYAREA_PADDING_HORIZONTAL_PERCENT;
 
 // --- ZONES FINALS (SDL_FRect) ---
 
-// Zona de joc principal
+// Marcador superior (reservat per a futur ús)
-// Ocupa: tot menys marges (dalt, esq, dret) i scoreboard (baix)
+// Ocupa: 10% superior (0-48px)
-constexpr SDL_FRect PLAYAREA = {
+constexpr SDL_FRect SCOREBOARD_TOP = {
-    PLAYAREA_MARGIN_H,                               // x = 10.0
+    0.0F,                             // x = 0.0
-    PLAYAREA_MARGIN_V,                               // y = 10.0
+    SCOREBOARD_TOP_Y,                 // y = 0.0
-    Game::WIDTH - 2.0f * PLAYAREA_MARGIN_H,          // width = 620.0
+    static_cast<float>(Game::WIDTH),  // w = 640.0
-    Game::HEIGHT - PLAYAREA_MARGIN_V - SCOREBOARD_H  // height = 406.0
+    SCOREBOARD_TOP_H                  // h = 48.0
 };
 
-// Zona de marcador
+// Àrea de joc principal (contenidor del 80% central, sense padding)
-// Ocupa: tot l'ample, 64px d'alçada en la part inferior
+// Ocupa: 10-90% (48-432px), ample complet
-constexpr SDL_FRect SCOREBOARD = {
+constexpr SDL_FRect MAIN_PLAYAREA = {
-    0.0f,                             // x = 0.0
+    0.0F,                             // x = 0.0
-    Game::HEIGHT - SCOREBOARD_H,      // y = 416.0
+    MAIN_PLAYAREA_Y,                  // y = 48.0
-    static_cast<float>(Game::WIDTH),  // width = 640.0
+    static_cast<float>(Game::WIDTH),  // w = 640.0
-    SCOREBOARD_H                      // height = 64.0
+    MAIN_PLAYAREA_H                   // h = 384.0
 };
+
+// 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
+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)
+};
+
+// Marcador inferior (marcador actual)
+// Ocupa: 10% inferior (432-480px)
+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
+};
+
+// Padding horizontal del marcador (per alinear zones esquerra/dreta amb PLAYAREA)
+constexpr float SCOREBOARD_PADDING_H = 0.0F;  // Game::WIDTH * 0.015f;
 }  // namespace Zones
 
 // Objetos del juego
@@ -68,51 +103,145 @@ constexpr int MAX_ORNIS = 15;
 constexpr int MAX_BALES = 3;
 constexpr int MAX_IPUNTS = 30;
 
-constexpr float SHIP_RADIUS = 12.0f;
+constexpr float SHIP_RADIUS = 12.0F;
-constexpr float ENEMY_RADIUS = 20.0f;
+constexpr float ENEMY_RADIUS = 20.0F;
-constexpr float BULLET_RADIUS = 5.0f;
+constexpr float BULLET_RADIUS = 3.0F;
 }  // namespace Entities
 
+// Ship (nave del jugador)
+namespace Ship {
+// Invulnerabilidad post-respawn
+constexpr float INVULNERABILITY_DURATION = 3.0F;  // Segundos de invulnerabilidad
+
+// Parpadeo visual durante invulnerabilidad
+constexpr float BLINK_VISIBLE_TIME = 0.1F;    // Tiempo visible (segundos)
+constexpr float BLINK_INVISIBLE_TIME = 0.1F;  // Tiempo invisible (segundos)
+// Frecuencia total: 0.2s/ciclo = 5 Hz (~15 parpadeos en 3s)
+}  // namespace Ship
+
 // Game rules (lives, respawn, game over)
 namespace Game {
 constexpr int STARTING_LIVES = 3;                          // Initial lives
-constexpr float DEATH_DURATION = 3.0f;                   // Seconds of death animation
+constexpr float DEATH_DURATION = 3.0F;                     // Seconds of death animation
-constexpr float GAME_OVER_DURATION = 5.0f;               // Seconds to display game over
+constexpr float GAME_OVER_DURATION = 5.0F;                 // Seconds to display game over
-constexpr float COLLISION_SHIP_ENEMY_AMPLIFIER = 0.80f;  // 80% hitbox (generous)
+constexpr float COLLISION_SHIP_ENEMY_AMPLIFIER = 0.80F;    // 80% hitbox (generous)
+constexpr float COLLISION_BULLET_ENEMY_AMPLIFIER = 1.15F;  // 115% hitbox (generous)
+
+// Friendly fire system
+constexpr bool FRIENDLY_FIRE_ENABLED = true;               // Activar friendly fire
+constexpr float COLLISION_BULLET_PLAYER_AMPLIFIER = 1.0F;  // Hitbox exacto (100%)
+constexpr float BULLET_GRACE_PERIOD = 0.2F;                // Inmunidad post-disparo (s)
+
+// Transición LEVEL_START (mensajes aleatorios PRE-level)
+constexpr float LEVEL_START_DURATION = 3.0F;      // Duración total
+constexpr float LEVEL_START_TYPING_RATIO = 0.3F;  // 30% escribiendo, 70% mostrando
+
+// Transición LEVEL_COMPLETED (mensaje "GOOD JOB COMMANDER!")
+constexpr float LEVEL_COMPLETED_DURATION = 3.0F;      // Duración total
+constexpr float LEVEL_COMPLETED_TYPING_RATIO = 0.0F;  // 0.0 = sin typewriter (directo)
+
+// Transición INIT_HUD (animación inicial del HUD)
+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)
+constexpr float INIT_HUD_RECT_RATIO_INIT = 0.30F;
+constexpr float INIT_HUD_RECT_RATIO_END = 0.85F;
+
+// SCORE (marcador de puntuación)
+constexpr float INIT_HUD_SCORE_RATIO_INIT = 0.60F;
+constexpr float INIT_HUD_SCORE_RATIO_END = 0.90F;
+
+// SHIP1 (nave jugador 1)
+constexpr float INIT_HUD_SHIP1_RATIO_INIT = 0.0F;
+constexpr float INIT_HUD_SHIP1_RATIO_END = 1.0F;
+
+// SHIP2 (nave jugador 2)
+constexpr float INIT_HUD_SHIP2_RATIO_INIT = 0.20F;
+constexpr float INIT_HUD_SHIP2_RATIO_END = 1.0F;
+
+// Posición inicial de la nave en INIT_HUD (75% de altura de zona de juego)
+constexpr float INIT_HUD_SHIP_START_Y_RATIO = 0.75F;  // 75% desde el top de PLAYAREA
+
+// Spawn positions (distribución horizontal para 2 jugadores)
+constexpr float P1_SPAWN_X_RATIO = 0.33F;  // 33% desde izquierda
+constexpr float P2_SPAWN_X_RATIO = 0.67F;  // 67% desde izquierda
+constexpr float SPAWN_Y_RATIO = 0.75F;     // 75% desde arriba
+
+// Continue system behavior
+constexpr int CONTINUE_COUNT_START = 9;         // Countdown starts at 9
+constexpr float CONTINUE_TICK_DURATION = 1.0F;  // Seconds per countdown tick
+constexpr int MAX_CONTINUES = 3;                // Maximum continues per game
+constexpr bool INFINITE_CONTINUES = false;      // If true, unlimited continues
+
+// Continue screen visual configuration
+namespace ContinueScreen {
+// "CONTINUE" text
+constexpr float CONTINUE_TEXT_SCALE = 2.0F;     // Text size
+constexpr float CONTINUE_TEXT_Y_RATIO = 0.30F;  // 35% from top of PLAYAREA
+
+// Countdown number (9, 8, 7...)
+constexpr float COUNTER_TEXT_SCALE = 4.0F;     // Text size (large)
+constexpr float COUNTER_TEXT_Y_RATIO = 0.50F;  // 50% from top of PLAYAREA
+
+// "CONTINUES LEFT: X" text
+constexpr float INFO_TEXT_SCALE = 0.7F;     // Text size (small)
+constexpr float INFO_TEXT_Y_RATIO = 0.75F;  // 65% from top of PLAYAREA
+}  // namespace ContinueScreen
+
+// Game Over screen visual configuration
+namespace GameOverScreen {
+constexpr float TEXT_SCALE = 2.0F;    // "GAME OVER" text size
+constexpr float TEXT_SPACING = 4.0F;  // Character spacing
+}  // namespace GameOverScreen
+
+// Stage message configuration (LEVEL_START, LEVEL_COMPLETED)
+constexpr float STAGE_MESSAGE_Y_RATIO = 0.25F;         // 25% from top of PLAYAREA
+constexpr float STAGE_MESSAGE_MAX_WIDTH_RATIO = 0.9F;  // 90% of PLAYAREA width
 }  // namespace Game
 
 // Física (valores actuales del juego, sincronizados con joc_asteroides.cpp)
 namespace Physics {
-constexpr float ROTATION_SPEED = 3.14f;  // rad/s (~180°/s)
+constexpr float ROTATION_SPEED = 3.14F;  // rad/s (~180°/s)
-constexpr float ACCELERATION = 400.0f;   // px/s²
+constexpr float ACCELERATION = 400.0F;   // px/s²
-constexpr float MAX_VELOCITY = 120.0f;   // px/s
+constexpr float MAX_VELOCITY = 120.0F;   // px/s
-constexpr float FRICTION = 20.0f;        // px/s²
+constexpr float FRICTION = 20.0F;        // px/s²
-constexpr float ENEMY_SPEED = 2.0f;      // unidades/frame
+constexpr float ENEMY_SPEED = 2.0F;      // unidades/frame
-constexpr float BULLET_SPEED = 6.0f;     // unidades/frame
+constexpr float BULLET_SPEED = 6.0F;     // unidades/frame
-constexpr float VELOCITY_SCALE = 20.0f;  // factor conversión frame→tiempo
+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;      // Velocitat inicial (px/s)
-constexpr float VARIACIO_VELOCITAT = 40.0f;  // ±variació aleatòria (px/s)
+constexpr float VARIACIO_VELOCITAT = 40.0F;  // ±variació aleatòria (px/s)
-constexpr float ACCELERACIO = -60.0f;        // Fricció/desacceleració (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_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_MAX = 0.3F;          // Rotació màxima (rad/s ~17.2°/s)
-constexpr float TEMPS_VIDA = 2.0f;           // Duració màxima (segons) - enemy/bullet debris
+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 TEMPS_VIDA_NAU = 3.0F;       // Ship debris lifetime (matches DEATH_DURATION)
-constexpr float SHRINK_RATE = 0.5f;          // Reducció de mida (factor/s)
+constexpr float SHRINK_RATE = 0.5F;          // Reducció de mida (factor/s)
+
+// Herència de velocitat 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
+// 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)
 }  // namespace Debris
 }  // namespace Physics
 
 // Matemáticas
 namespace Math {
-constexpr float PI = 3.14159265359f;
+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)
+constexpr float FREQUENCY = 6.0F;  // 1 Hz (1 ciclo/segundo)
 
 // Color de líneas (efecto fósforo verde CRT)
 constexpr uint8_t LINE_MIN_R = 100;  // Verde oscuro
@@ -136,15 +265,15 @@ constexpr uint8_t BACKGROUND_MAX_B = 0;
 // Brillantor (control de intensitat per cada tipus d'entitat)
 namespace Brightness {
 // Brillantor estàtica per entitats de joc (0.0-1.0)
-constexpr float NAU = 1.0f;     // Màxima visibilitat (jugador)
+constexpr float NAU = 1.0F;     // Màxima visibilitat (jugador)
-constexpr float ENEMIC = 0.7f;  // 30% més tènue (destaca menys)
+constexpr float ENEMIC = 0.7F;  // 30% més tènue (destaca menys)
-constexpr float BALA = 0.9f;    // Destacada però menys que nau
+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)
 // 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 centre)
-constexpr float STARFIELD_MAX = 0.8f;  // Estrelles properes (vora pantalla)
+constexpr float STARFIELD_MAX = 0.8F;  // Estrelles properes (vora pantalla)
 }  // namespace Brightness
 
 // Renderització (V-Sync i altres opcions de render)
@@ -163,6 +292,7 @@ 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
 }  // namespace Music
 
@@ -170,61 +300,233 @@ constexpr int FADE_DURATION_MS = 1000;          // Fade out duration
 namespace Sound {
 constexpr float VOLUME = 1.0F;                                               // Volumen efectos
 constexpr bool ENABLED = true;                                               // Sonidos habilitados
-constexpr const char* EXPLOSION = "explosion.wav";  // Explosión
+constexpr const char* CONTINUE = "effects/continue.wav";                     // Cuenta atras
-constexpr const char* LASER = "laser_shoot.wav";    // Disparo
+constexpr const char* EXPLOSION = "effects/explosion.wav";                   // Explosión
+constexpr const char* EXPLOSION2 = "effects/explosion2.wav";                 // Explosión alternativa
+constexpr const char* FRIENDLY_FIRE_HIT = "effects/friendly_fire.wav";       // Friendly fire hit
+constexpr const char* 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* GOOD_JOB_COMMANDER = "voices/good_job_commander.wav";  // Voz: "Good job, commander"
 }  // namespace Sound
 
+// Controls (mapeo de teclas para los jugadores)
+namespace Controls {
+namespace P1 {
+constexpr SDL_Scancode ROTATE_RIGHT = SDL_SCANCODE_RIGHT;
+constexpr SDL_Scancode ROTATE_LEFT = SDL_SCANCODE_LEFT;
+constexpr SDL_Scancode THRUST = SDL_SCANCODE_UP;
+constexpr SDL_Keycode SHOOT = SDLK_SPACE;
+}  // namespace P1
+
+namespace P2 {
+constexpr SDL_Scancode ROTATE_RIGHT = SDL_SCANCODE_D;
+constexpr SDL_Scancode ROTATE_LEFT = SDL_SCANCODE_A;
+constexpr SDL_Scancode THRUST = SDL_SCANCODE_W;
+constexpr SDL_Keycode SHOOT = SDLK_LSHIFT;
+}  // namespace P2
+}  // namespace Controls
+
 // Enemy type configuration (tipus d'enemics)
 namespace Enemies {
 // Pentagon (esquivador - zigzag evasion)
 namespace Pentagon {
-constexpr float VELOCITAT = 35.0f;         // px/s (slightly slower)
+constexpr float VELOCITAT = 35.0F;         // px/s (slightly slower)
-constexpr float CANVI_ANGLE_PROB = 0.20f;  // 20% per wall hit (frequent zigzag)
+constexpr float CANVI_ANGLE_PROB = 0.20F;  // 20% per wall hit (frequent zigzag)
-constexpr float CANVI_ANGLE_MAX = 1.0f;    // Max random angle change (rad)
+constexpr float CANVI_ANGLE_MAX = 1.0F;    // Max random angle change (rad)
-constexpr float DROTACIO_MIN = 0.5f;       // Min visual rotation (rad/s)
+constexpr float DROTACIO_MIN = 0.75F;      // Min visual rotation (rad/s) [+50%]
-constexpr float DROTACIO_MAX = 2.5f;       // Max visual rotation (rad/s)
+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 {
-constexpr float VELOCITAT = 40.0f;         // px/s (medium speed)
+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_STRENGTH = 0.5F;  // Interpolation toward player (0.0-1.0)
-constexpr float TRACKING_INTERVAL = 1.0f;  // Seconds between angle updates
+constexpr float TRACKING_INTERVAL = 1.0F;  // Seconds between angle updates
-constexpr float DROTACIO_MIN = 0.2f;       // Slow rotation
+constexpr float DROTACIO_MIN = 0.3F;       // Slow rotation [+50%]
-constexpr float DROTACIO_MAX = 1.0f;
+constexpr float DROTACIO_MAX = 1.5F;       // [+50%]
 constexpr const char* SHAPE_FILE = "enemy_square.shp";
 }  // namespace Quadrat
 
 // Molinillo (agressiu - fast straight lines, proximity spin-up)
 namespace Molinillo {
-constexpr float VELOCITAT = 50.0f;         // px/s (fastest)
+constexpr float VELOCITAT = 50.0F;                     // px/s (fastest)
-constexpr float CANVI_ANGLE_PROB = 0.05f;  // 5% per wall hit (rare direction change)
+constexpr float CANVI_ANGLE_PROB = 0.05F;              // 5% per wall hit (rare direction change)
-constexpr float CANVI_ANGLE_MAX = 0.3f;    // Small angle adjustments
+constexpr float CANVI_ANGLE_MAX = 0.3F;                // Small angle adjustments
-constexpr float DROTACIO_MIN = 2.0f;       // Base rotation (rad/s)
+constexpr float DROTACIO_MIN = 3.0F;                   // Base rotation (rad/s) [+50%]
-constexpr float DROTACIO_MAX = 4.0f;
+constexpr float DROTACIO_MAX = 6.0F;                   // [+50%]
-constexpr float DROTACIO_PROXIMITY_MULTIPLIER = 3.0f;  // Spin-up multiplier when near ship
+constexpr float DROTACIO_PROXIMITY_MULTIPLIER = 3.0F;  // Spin-up multiplier when near ship
-constexpr float PROXIMITY_DISTANCE = 100.0f;           // Distance threshold (px)
+constexpr float PROXIMITY_DISTANCE = 100.0F;           // Distance threshold (px)
 constexpr const char* SHAPE_FILE = "enemy_pinwheel.shp";
 }  // namespace Molinillo
 
 // Animation parameters (shared)
 namespace Animation {
 // Palpitation
-constexpr float PALPITACIO_TRIGGER_PROB = 0.01f;  // 1% chance per second
+constexpr float PALPITACIO_TRIGGER_PROB = 0.01F;  // 1% chance per second
-constexpr float PALPITACIO_DURACIO_MIN = 1.0f;    // Min duration (seconds)
+constexpr float PALPITACIO_DURACIO_MIN = 1.0F;    // Min duration (seconds)
-constexpr float PALPITACIO_DURACIO_MAX = 3.0f;    // Max duration (seconds)
+constexpr float PALPITACIO_DURACIO_MAX = 3.0F;    // Max duration (seconds)
-constexpr float PALPITACIO_AMPLITUD_MIN = 0.08f;  // Min scale variation
+constexpr float PALPITACIO_AMPLITUD_MIN = 0.08F;  // Min scale variation
-constexpr float PALPITACIO_AMPLITUD_MAX = 0.20f;  // Max scale variation
+constexpr float PALPITACIO_AMPLITUD_MAX = 0.20F;  // Max scale variation
-constexpr float PALPITACIO_FREQ_MIN = 1.5f;       // Min frequency (Hz)
+constexpr float PALPITACIO_FREQ_MIN = 1.5F;       // Min frequency (Hz)
-constexpr float PALPITACIO_FREQ_MAX = 3.0f;       // Max frequency (Hz)
+constexpr float PALPITACIO_FREQ_MAX = 3.0F;       // Max frequency (Hz)
 
 // Rotation acceleration
-constexpr float ROTACIO_ACCEL_TRIGGER_PROB = 0.005f;  // 0.5% chance per second
+constexpr float ROTACIO_ACCEL_TRIGGER_PROB = 0.02F;   // 2% chance per second [4x more frequent]
-constexpr float ROTACIO_ACCEL_DURACIO_MIN = 3.0f;     // Min transition time
+constexpr float ROTACIO_ACCEL_DURACIO_MIN = 3.0F;     // Min transition time
-constexpr float ROTACIO_ACCEL_DURACIO_MAX = 8.0f;     // Max transition time
+constexpr float ROTACIO_ACCEL_DURACIO_MAX = 8.0F;     // Max transition time
-constexpr float ROTACIO_ACCEL_MULTIPLIER_MIN = 0.5f;  // Min speed multiplier
+constexpr float ROTACIO_ACCEL_MULTIPLIER_MIN = 0.3F;  // Min speed multiplier [more dramatic]
-constexpr float ROTACIO_ACCEL_MULTIPLIER_MAX = 2.5f;  // Max speed multiplier
+constexpr float ROTACIO_ACCEL_MULTIPLIER_MAX = 4.0F;  // Max speed multiplier [more dramatic]
 }  // namespace Animation
+
+// Spawn safety and invulnerability system
+namespace Spawn {
+// Safe spawn distance from player
+constexpr float SAFETY_DISTANCE_MULTIPLIER = 3.0F;                                               // 3x ship radius
+constexpr float SAFETY_DISTANCE = Defaults::Entities::SHIP_RADIUS * SAFETY_DISTANCE_MULTIPLIER;  // 36.0f px
+constexpr int MAX_SPAWN_ATTEMPTS = 50;                                                           // Max attempts to find safe position
+
+// Invulnerability system
+constexpr float INVULNERABILITY_DURATION = 3.0F;          // Seconds
+constexpr float INVULNERABILITY_BRIGHTNESS_START = 0.3F;  // Dim
+constexpr float INVULNERABILITY_BRIGHTNESS_END = 0.7F;    // Normal (same as Defaults::Brightness::ENEMIC)
+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)
+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 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)
+namespace Title {
+namespace Ships {
+// ============================================================
+// PARÀMETRES BASE (ajustar aquí per experimentar)
+// ============================================================
+
+// 1. Escala global de les naus
+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
+
+// 4. Ángulos de posición (clock positions en coordenadas polares)
+// En coordenades de pantalla: 0° = dreta, 90° = baix, 180° = esquerra, 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)
+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)
+// ============================================================
+
+// 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
+
+// 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)
+inline float P1_TARGET_X() {
+    return CENTER_X + (CLOCK_RADIUS * std::cos(CLOCK_8_ANGLE));
+}
+inline float P1_TARGET_Y() {
+    return CENTER_Y + ((Game::HEIGHT / 2.0F) * TARGET_Y_RATIO);
+}
+inline float P2_TARGET_X() {
+    return CENTER_X + (CLOCK_RADIUS * std::cos(CLOCK_4_ANGLE));
+}
+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
+
+// Offset d'entrada (ajustat automàticament a l'escala)
+// Fórmula: (radi màxim de la nau * escala d'entrada) + marge
+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
+
+// ============================================================
+// ANIMACIONS (durades, oscil·lacions, delays)
+// ============================================================
+
+// Durades d'animació
+constexpr float ENTRY_DURATION = 2.0F;  // Entrada (segons)
+constexpr float EXIT_DURATION = 1.0F;   // Sortida (segons)
+
+// Flotació (oscil·lació reduïda i diferenciada per nau)
+constexpr float FLOAT_AMPLITUDE_X = 4.0F;  // Amplitud X (píxels)
+constexpr float FLOAT_AMPLITUDE_Y = 2.5F;  // Amplitud Y (píxels)
+
+// Freqüències base
+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)
+constexpr float P1_ENTRY_DELAY = 0.0F;  // P1 entra immediatament
+constexpr float P2_ENTRY_DELAY = 0.5F;  // P2 entra 0.5s despré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
+
+// Multiplicadors de freqüència per a cada nau (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)
+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
+
+// Separacions relatives (proporció respecte Game::HEIGHT = 480px)
+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
+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)
+constexpr float TEXT_SPACING = 2.0F;
+}  // namespace Layout
+}  // namespace Title
+
+// Floating score numbers (números flotants de puntuació)
+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 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)
+}  // namespace FloatingScore
+
 }  // namespace Defaults

source/core/entities/entitat.hpp

@@ -0,0 +1,49 @@
+// 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

source/core/graphics/shape.cpp

@@ -11,8 +11,8 @@
 namespace Graphics {
 
 Shape::Shape(const std::string& filepath)
-    : centre_({0.0f, 0.0f}),
+    : centre_({.x = 0.0F, .y = 0.0F}),
-      escala_defecte_(1.0f),
+      escala_defecte_(1.0F),
       nom_("unnamed") {
     carregar(filepath);
 }
@@ -21,7 +21,7 @@ bool Shape::carregar(const std::string& filepath) {
     // Llegir fitxer
     std::ifstream file(filepath);
     if (!file.is_open()) {
-        std::cerr << "[Shape] Error: no es pot obrir " << filepath << std::endl;
+        std::cerr << "[Shape] Error: no es pot obrir " << filepath << '\n';
         return false;
     }
 
@@ -44,8 +44,9 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
         line = trim(line);
 
         // Skip comments and blanks
-        if (line.empty() || line[0] == '#')
+        if (line.empty() || line[0] == '#') {
             continue;
+        }
 
         // Parse command
         if (starts_with(line, "name:")) {
@@ -54,8 +55,8 @@ 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" << std::endl;
+                std::cerr << "[Shape] Warning: escala invàlida, usant 1.0" << '\n';
-                escala_defecte_ = 1.0f;
+                escala_defecte_ = 1.0F;
             }
         } else if (starts_with(line, "center:")) {
             parse_center(extract_value(line));
@@ -65,7 +66,7 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
                 primitives_.push_back({PrimitiveType::POLYLINE, points});
             } else {
                 std::cerr << "[Shape] Warning: polyline amb menys de 2 punts ignorada"
-                          << std::endl;
+                          << '\n';
             }
         } else if (starts_with(line, "line:")) {
             auto points = parse_points(extract_value(line));
@@ -73,14 +74,14 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
                 primitives_.push_back({PrimitiveType::LINE, points});
             } else {
                 std::cerr << "[Shape] Warning: line ha de tenir exactament 2 punts"
-                          << std::endl;
+                          << '\n';
             }
         }
         // Comandes desconegudes ignorades silenciosament
     }
 
     if (primitives_.empty()) {
-        std::cerr << "[Shape] Error: cap primitiva carregada" << std::endl;
+        std::cerr << "[Shape] Error: cap primitiva carregada" << '\n';
         return false;
     }
 
@@ -91,8 +92,9 @@ bool Shape::parsejar_fitxer(const std::string& contingut) {
 std::string Shape::trim(const std::string& str) const {
     const char* whitespace = " \t\n\r";
     size_t start = str.find_first_not_of(whitespace);
-    if (start == std::string::npos)
+    if (start == std::string::npos) {
         return "";
+    }
 
     size_t end = str.find_last_not_of(whitespace);
     return str.substr(start, end - start + 1);
@@ -101,16 +103,18 @@ std::string Shape::trim(const std::string& str) const {
 // Helper: starts_with
 bool Shape::starts_with(const std::string& str,
     const std::string& prefix) const {
-    if (str.length() < prefix.length())
+    if (str.length() < prefix.length()) {
         return false;
-    return str.compare(0, prefix.length(), prefix) == 0;
+    }
+    return str.starts_with(prefix);
 }
 
 // Helper: extract value after ':'
 std::string Shape::extract_value(const std::string& line) const {
     size_t colon = line.find(':');
-    if (colon == std::string::npos)
+    if (colon == std::string::npos) {
         return "";
+    }
     return line.substr(colon + 1);
 }
 
@@ -123,8 +127,8 @@ void Shape::parse_center(const std::string& value) {
             centre_.x = std::stof(trim(val.substr(0, comma)));
             centre_.y = std::stof(trim(val.substr(comma + 1)));
         } catch (...) {
-            std::cerr << "[Shape] Warning: centre invàlid, usant (0,0)" << std::endl;
+            std::cerr << "[Shape] Warning: centre invàlid, usant (0,0)" << '\n';
-            centre_ = {0.0f, 0.0f};
+            centre_ = {.x = 0.0F, .y = 0.0F};
         }
     }
 }
@@ -144,7 +148,7 @@ std::vector<Punt> Shape::parse_points(const std::string& str) const {
                 points.push_back({x, y});
             } catch (...) {
                 std::cerr << "[Shape] Warning: punt invàlid ignorat: " << pair
-                          << std::endl;
+                          << '\n';
             }
         }
     }

source/core/graphics/shape.hpp

@@ -32,17 +32,20 @@ class Shape {
         // Carregar forma des de fitxer .shp
         bool carregar(const std::string& filepath);
 
+        // Parsejar forma des de buffer de memòria (per al sistema de recursos)
+        bool parsejar_fitxer(const std::string& contingut);
+
         // Getters
-        const std::vector<ShapePrimitive>& get_primitives() const {
+        [[nodiscard]] const std::vector<ShapePrimitive>& get_primitives() const {
             return primitives_;
         }
-        const Punt& get_centre() const { return centre_; }
+        [[nodiscard]] const Punt& get_centre() const { return centre_; }
-        float get_escala_defecte() const { return escala_defecte_; }
+        [[nodiscard]] float get_escala_defecte() const { return escala_defecte_; }
-        bool es_valida() const { return !primitives_.empty(); }
+        [[nodiscard]] bool es_valida() const { return !primitives_.empty(); }
 
         // Info de depuració
-        std::string get_nom() const { return nom_; }
+        [[nodiscard]] std::string get_nom() const { return nom_; }
-        size_t get_num_primitives() const { return primitives_.size(); }
+        [[nodiscard]] size_t get_num_primitives() const { return primitives_.size(); }
 
     private:
         std::vector<ShapePrimitive> primitives_;
@@ -50,15 +53,12 @@ class Shape {
         float escala_defecte_;  // Escala per defecte (normalment 1.0)
         std::string nom_;       // Nom de la forma (per depuració)
 
-        // Parsejador del fitxer
-        bool parsejar_fitxer(const std::string& contingut);
-
         // Helpers privats per parsejar
-        std::string trim(const std::string& str) const;
+        [[nodiscard]] std::string trim(const std::string& str) const;
-        bool starts_with(const std::string& str, const std::string& prefix) const;
+        [[nodiscard]] bool starts_with(const std::string& str, const std::string& prefix) const;
-        std::string extract_value(const std::string& line) const;
+        [[nodiscard]] std::string extract_value(const std::string& line) const;
         void parse_center(const std::string& value);
-        std::vector<Punt> parse_points(const std::string& str) const;
+        [[nodiscard]] std::vector<Punt> parse_points(const std::string& str) const;
 };
 
 }  // namespace Graphics

source/core/graphics/shape_loader.cpp

@@ -5,6 +5,8 @@
 
 #include <iostream>
 
+#include "core/resources/resource_helper.hpp"
+
 namespace Graphics {
 
 // Inicialització de variables estàtiques
@@ -15,32 +17,44 @@ std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
     // Check cache first
     auto it = cache_.find(filename);
     if (it != cache_.end()) {
-        std::cout << "[ShapeLoader] Cache hit: " << filename << std::endl;
+        std::cout << "[ShapeLoader] Cache hit: " << filename << '\n';
         return it->second;  // Cache hit
     }
 
-    // Resolve full path
+    // Normalize path: "ship.shp" → "shapes/ship.shp"
-    std::string fullpath = resolve_path(filename);
+    //                 "logo/letra_j.shp" → "shapes/logo/letra_j.shp"
+    std::string normalized = filename;
+    if (!normalized.starts_with("shapes/")) {
+        // Doesn't start with "shapes/", so add it
+        normalized = "shapes/" + normalized;
+    }
 
-    // Create and load shape
+    // 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
+                  << '\n';
+        return nullptr;
+    }
+
+    // Convert bytes to string and parse
+    std::string file_content(data.begin(), data.end());
     auto shape = std::make_shared<Shape>();
-    if (!shape->carregar(fullpath)) {
+    if (!shape->parsejar_fitxer(file_content)) {
-        std::cerr << "[ShapeLoader] Error: no s'ha pogut carregar " << filename
+        std::cerr << "[ShapeLoader] Error: no s'ha pogut parsejar " << normalized
-                  << std::endl;
+                  << '\n';
         return nullptr;
     }
 
     // Verify shape is valid
     if (!shape->es_valida()) {
-        std::cerr << "[ShapeLoader] Error: forma invàlida " << filename
+        std::cerr << "[ShapeLoader] Error: forma invàlida " << normalized << '\n';
-                  << std::endl;
         return nullptr;
     }
 
     // Cache and return
-    std::cout << "[ShapeLoader] Carregat: " << filename << " ("
+    std::cout << "[ShapeLoader] Carregat: " << normalized << " (" << shape->get_nom()
-              << shape->get_nom() << ", " << shape->get_num_primitives()
+              << ", " << shape->get_num_primitives() << " primitives)" << '\n';
-              << " primitives)" << std::endl;
 
     cache_[filename] = shape;
     return shape;
@@ -48,7 +62,7 @@ std::shared_ptr<Shape> ShapeLoader::load(const std::string& filename) {
 
 void ShapeLoader::clear_cache() {
     std::cout << "[ShapeLoader] Netejant caché (" << cache_.size() << " formes)"
-              << std::endl;
+              << '\n';
     cache_.clear();
 }
 
@@ -61,7 +75,7 @@ std::string ShapeLoader::resolve_path(const std::string& filename) {
     }
 
     // Si ja conté el prefix base_path, usar-lo directament
-    if (filename.find(base_path_) == 0) {
+    if (filename.starts_with(base_path_)) {
         return filename;
     }
 

source/core/graphics/starfield.cpp

@@ -8,6 +8,7 @@
 #include <iostream>
 
 #include "core/defaults.hpp"
+#include "core/graphics/shape_loader.hpp"
 #include "core/rendering/shape_renderer.hpp"
 
 namespace Graphics {
@@ -21,28 +22,28 @@ Starfield::Starfield(SDL_Renderer* renderer,
       punt_fuga_(punt_fuga),
       area_(area),
       densitat_(densitat) {
-    // Carregar forma d'estrella
+    // Carregar forma d'estrella amb ShapeLoader
-    shape_estrella_ = std::make_shared<Shape>("data/shapes/star.shp");
+    shape_estrella_ = ShapeLoader::load("star.shp");
 
-    if (!shape_estrella_->es_valida()) {
+    if (!shape_estrella_ || !shape_estrella_->es_valida()) {
-        std::cerr << "ERROR: No s'ha pogut carregar data/shapes/star.shp" << std::endl;
+        std::cerr << "ERROR: No s'ha pogut carregar star.shp" << '\n';
         return;
     }
 
     // Configurar 3 capes amb diferents velocitats i escales
     // Capa 0: Fons llunyà (lenta, petita)
-    capes_.push_back({20.0f, 0.3f, 0.8f, densitat / 3});
+    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});
+    capes_.push_back({40.0F, 0.5F, 1.2F, densitat / 3});
 
     // Capa 2: Primer pla (ràpida, gran)
-    capes_.push_back({80.0f, 0.8f, 2.0f, densitat / 3});
+    capes_.push_back({80.0F, 0.8F, 2.0F, densitat / 3});
 
     // Calcular radi màxim (distància del centre 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);
+    radi_max_ = std::sqrt((dx * dx) + (dy * dy));
 
     // Inicialitzar estrelles amb posicions distribuïdes (pre-omplir pantalla)
     for (int capa_idx = 0; capa_idx < 3; capa_idx++) {
@@ -52,15 +53,15 @@ Starfield::Starfield(SDL_Renderer* renderer,
             estrella.capa = capa_idx;
 
             // Angle aleatori
-            estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0f * Defaults::Math::PI;
+            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
             estrella.distancia_centre = static_cast<float>(rand()) / RAND_MAX;
 
             // Calcular posició des de la distància
             float radi = estrella.distancia_centre * radi_max_;
-            estrella.posicio.x = punt_fuga_.x + radi * std::cos(estrella.angle);
+            estrella.posicio.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
-            estrella.posicio.y = punt_fuga_.y + radi * std::sin(estrella.angle);
+            estrella.posicio.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
 
             estrelles_.push_back(estrella);
         }
@@ -68,17 +69,17 @@ Starfield::Starfield(SDL_Renderer* renderer,
 }
 
 // Inicialitzar una estrella (nova o regenerada)
-void Starfield::inicialitzar_estrella(Estrella& estrella) {
+void Starfield::inicialitzar_estrella(Estrella& estrella) const {
     // Angle aleatori des del punt de fuga cap a fora
-    estrella.angle = (static_cast<float>(rand()) / RAND_MAX) * 2.0f * Defaults::Math::PI;
+    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
-    estrella.distancia_centre = 0.05f;
+    estrella.distancia_centre = 0.05F;
 
     // Posició inicial: molt prop del punt de fuga
     float radi = estrella.distancia_centre * radi_max_;
-    estrella.posicio.x = punt_fuga_.x + radi * std::cos(estrella.angle);
+    estrella.posicio.x = punt_fuga_.x + (radi * std::cos(estrella.angle));
-    estrella.posicio.y = punt_fuga_.y + radi * std::sin(estrella.angle);
+    estrella.posicio.y = punt_fuga_.y + (radi * std::sin(estrella.angle));
 }
 
 // Verificar si una estrella està fora de l'àrea
@@ -96,7 +97,7 @@ float Starfield::calcular_escala(const Estrella& estrella) const {
     // Interpolació lineal basada en distància del centre
     // distancia_centre: 0.0 (centre) → 1.0 (vora)
     return capa.escala_min +
-        (capa.escala_max - capa.escala_min) * estrella.distancia_centre;
+        ((capa.escala_max - capa.escala_min) * estrella.distancia_centre);
 }
 
 // Calcular brightness dinàmica segons distància del centre
@@ -104,11 +105,11 @@ 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)
     float brightness_base = Defaults::Brightness::STARFIELD_MIN +
-        (Defaults::Brightness::STARFIELD_MAX - Defaults::Brightness::STARFIELD_MIN) *
+        ((Defaults::Brightness::STARFIELD_MAX - Defaults::Brightness::STARFIELD_MIN) *
-        estrella.distancia_centre;
+            estrella.distancia_centre);
 
     // Aplicar multiplicador i limitar a 1.0
-    return std::min(1.0f, brightness_base * multiplicador_brightness_);
+    return std::min(1.0F, brightness_base * multiplicador_brightness_);
 }
 
 // Actualitzar posicions de les estrelles
@@ -128,7 +129,7 @@ void Starfield::actualitzar(float delta_time) {
         // Actualitzar distància del centre
         float dx_centre = estrella.posicio.x - punt_fuga_.x;
         float dy_centre = estrella.posicio.y - punt_fuga_.y;
-        float dist_px = std::sqrt(dx_centre * dx_centre + dy_centre * dy_centre);
+        float dist_px = std::sqrt((dx_centre * dx_centre) + (dy_centre * dy_centre));
         estrella.distancia_centre = dist_px / radi_max_;
 
         // Si ha sortit de l'àrea, regenerar-la
@@ -140,7 +141,7 @@ void Starfield::actualitzar(float delta_time) {
 
 // Establir multiplicador de brightness
 void Starfield::set_brightness(float multiplier) {
-    multiplicador_brightness_ = std::max(0.0f, multiplier);  // Evitar valors negatius
+    multiplicador_brightness_ = std::max(0.0F, multiplier);  // Evitar valors negatius
 }
 
 // Dibuixar totes les estrelles
@@ -159,10 +160,10 @@ void Starfield::dibuixar() {
             renderer_,
             shape_estrella_,
             estrella.posicio,
-            0.0f,       // angle (les estrelles no giren)
+            0.0F,       // angle (les estrelles no giren)
             escala,     // escala dinàmica
             true,       // dibuixar
-            1.0f,       // progress (sempre visible)
+            1.0F,       // progress (sempre visible)
             brightness  // brightness dinàmica
         );
     }

source/core/graphics/starfield.hpp

@@ -54,16 +54,16 @@ class Starfield {
         };
 
         // Inicialitzar una estrella (nova o regenerada)
-        void inicialitzar_estrella(Estrella& estrella);
+        void inicialitzar_estrella(Estrella& estrella) const;
 
         // Verificar si una estrella està fora de l'àrea
-        bool fora_area(const Estrella& estrella) const;
+        [[nodiscard]] bool fora_area(const Estrella& estrella) const;
 
         // Calcular escala dinàmica segons distància del centre
-        float calcular_escala(const Estrella& estrella) const;
+        [[nodiscard]] float calcular_escala(const Estrella& estrella) const;
 
         // Calcular brightness dinàmica segons distància del centre
-        float calcular_brightness(const Estrella& estrella) const;
+        [[nodiscard]] float calcular_brightness(const Estrella& estrella) const;
 
         // Dades
         std::vector<Estrella> estrelles_;
@@ -76,7 +76,7 @@ class Starfield {
         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 multiplicador_brightness_{1.0F};  // Multiplicador de brillantor (1.0 = default)
 };
 
 }  // namespace Graphics

source/core/graphics/vector_text.cpp

@@ -1,5 +1,6 @@
 // vector_text.cpp - Implementació del sistema de text vectorial
 // © 2025 Port a C++20 amb SDL3
+// Test pre-commit hook
 
 #include "core/graphics/vector_text.hpp"
 
@@ -11,8 +12,8 @@
 namespace Graphics {
 
 // Constants per a mides base dels caràcters
-constexpr float char_width = 20.0f;   // Amplada base del caràcter
+constexpr float char_width = 20.0F;   // Amplada base del caràcter
-constexpr float char_height = 40.0f;  // Altura base del caràcter
+constexpr float char_height = 40.0F;  // Altura base del caràcter
 
 VectorText::VectorText(SDL_Renderer* renderer)
     : renderer_(renderer) {
@@ -29,7 +30,7 @@ void VectorText::load_charset() {
             chars_[c] = shape;
         } else {
             std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
-                      << std::endl;
+                      << '\n';
         }
     }
 
@@ -42,7 +43,7 @@ void VectorText::load_charset() {
             chars_[c] = shape;
         } else {
             std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
-                      << std::endl;
+                      << '\n';
         }
     }
 
@@ -57,7 +58,7 @@ void VectorText::load_charset() {
             chars_[c] = shape;
         } else {
             std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
-                      << std::endl;
+                      << '\n';
         }
     }
 
@@ -72,12 +73,12 @@ void VectorText::load_charset() {
             chars_[c] = shape;
         } else {
             std::cerr << "[VectorText] Warning: no s'ha pogut carregar " << filename
-                      << std::endl;
+                      << '\n';
         }
     }
 
     std::cout << "[VectorText] Carregats " << chars_.size() << " caràcters"
-              << std::endl;
+              << '\n';
 }
 
 std::string VectorText::get_shape_filename(char c) const {
@@ -178,11 +179,11 @@ std::string VectorText::get_shape_filename(char c) const {
 }
 
 bool VectorText::is_supported(char c) const {
-    return chars_.find(c) != chars_.end();
+    return chars_.contains(c);
 }
 
-void VectorText::render(const std::string& text, const Punt& posicio, float escala, float spacing) {
+void VectorText::render(const std::string& text, const Punt& posicio, float escala, float spacing, float brightness) const {
-    if (!renderer_) {
+    if (renderer_ == nullptr) {
         return;
     }
 
@@ -195,13 +196,13 @@ void VectorText::render(const std::string& text, const Punt& posicio, float esca
     // Altura de un carácter escalado (necesario para ajustar Y)
     const float char_height_scaled = char_height * escala;
 
-    // Posición actual del centro del carácter (ajustada desde esquina superior
+    // Posición X del borde izquierdo del carácter actual
-    // izquierda)
+    // (se ajustará +char_width/2 para obtener el centro al renderizar)
     float current_x = posicio.x;
 
     // Iterar sobre cada byte del string (con detecció UTF-8)
     for (size_t i = 0; i < text.length(); i++) {
-        unsigned char c = static_cast<unsigned char>(text[i]);
+        auto c = static_cast<unsigned char>(text[i]);
 
         // Detectar copyright UTF-8 (0xC2 0xA9)
         if (c == 0xC2 && i + 1 < text.length() &&
@@ -220,40 +221,62 @@ 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 Y para que posicio represente esquina superior izquierda
+            // Ajustar X e Y para que posicio represente esquina superior izquierda
-            // (render_shape espera el centro, así que sumamos la mitad de la altura)
+            // (render_shape espera el centro, así que sumamos la mitad de ancho y altura)
-            Punt char_pos = {current_x, posicio.y + char_height_scaled / 2.0f};
+            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);
+            Rendering::render_shape(renderer_, it->second, char_pos, 0.0F, escala, true, 1.0F, brightness);
 
             // Avanzar posición
             current_x += char_width_scaled + spacing_scaled;
         } else {
             // Carácter no soportado: saltar (o renderizar '?' en el futuro)
             std::cerr << "[VectorText] Warning: caràcter no suportat '" << c << "'"
-                      << std::endl;
+                      << '\n';
             current_x += char_width_scaled + spacing_scaled;
         }
     }
 }
 
+void VectorText::render_centered(const std::string& text, const Punt& centre_punt, float escala, 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);
+
+    // Calcular posició de l'esquina superior esquerra
+    // restant la meitat de les dimensions del punt central
+    Punt 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);
+}
+
 float VectorText::get_text_width(const std::string& text, float escala, float spacing) const {
     if (text.empty()) {
-        return 0.0f;
+        return 0.0F;
     }
 
     const float char_width_scaled = char_width * escala;
     const float spacing_scaled = spacing * escala;
 
-    // Ancho total = (número de caracteres × char_width) + (espacios entre
+    // Contar caracteres visuals (no bytes) - manejar UTF-8
-    // caracteres)
+    size_t visual_chars = 0;
-    float width = text.length() * char_width_scaled;
+    for (size_t i = 0; i < text.length(); i++) {
+        auto c = static_cast<unsigned char>(text[i]);
 
-    // Añadir spacing entre caracteres (n-1 espacios para n caracteres)
+        // Detectar copyright UTF-8 (0xC2 0xA9) - igual que render()
-    if (text.length() > 1) {
+        if (c == 0xC2 && i + 1 < text.length() &&
-        width += (text.length() - 1) * spacing_scaled;
+            static_cast<unsigned char>(text[i + 1]) == 0xA9) {
+            visual_chars++;  // Un caràcter visual (©)
+            i++;             // Saltar el següent byte
+        } else {
+            visual_chars++;  // Caràcter normal
+        }
     }
 
-    return width;
+    // Ancho total = todos los caracteres VISUALES + spacing entre ellos
+    return (visual_chars * char_width_scaled) + ((visual_chars - 1) * spacing_scaled);
 }
 
 float VectorText::get_text_height(float escala) const {

source/core/graphics/vector_text.hpp

@@ -24,23 +24,32 @@ class VectorText {
         // - 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)
-        void render(const std::string& text, const Punt& posicio, float escala = 1.0f, float spacing = 2.0f);
+        // - 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;
+
+        // 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;
 
         // Calcular ancho total de un string (útil para centrado)
-        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 escala = 1.0F, float spacing = 2.0F) const;
 
         // Calcular altura del texto (útil para centrado vertical)
-        float get_text_height(float escala = 1.0f) const;
+        [[nodiscard]] float get_text_height(float escala = 1.0F) const;
 
         // Verificar si un carácter está soportado
-        bool is_supported(char c) const;
+        [[nodiscard]] bool is_supported(char c) const;
 
     private:
         SDL_Renderer* renderer_;
         std::unordered_map<char, std::shared_ptr<Shape>> chars_;
 
         void load_charset();
-        std::string get_shape_filename(char c) const;
+        [[nodiscard]] std::string get_shape_filename(char c) const;
 };
 
 }  // namespace Graphics

source/core/input/input.cpp

@@ -0,0 +1,606 @@
+#include "core/input/input.hpp"
+
+#include <SDL3/SDL.h>  // Para SDL_GetGamepadAxis, SDL_GamepadAxis, SDL_GamepadButton, SDL_GetError, SDL_JoystickID, SDL_AddGamepadMappingsFromFile, SDL_Event, SDL_EventType, SDL_GetGamepadButton, SDL_GetKeyboardState, SDL_INIT_GAMEPAD, SDL_InitSubSystem, SDL_LogError, SDL_OpenGamepad, SDL_PollEvent, SDL_WasInit, Sint16, SDL_Gamepad, SDL_LogCategory, SDL_Scancode
+
+#include <iostream>       // Para basic_ostream, operator<<, cout, cerr
+#include <memory>         // Para shared_ptr, __shared_ptr_access, allocator, operator==, make_shared
+#include <ranges>         // Para __find_if_fn, find_if
+#include <unordered_map>  // Para unordered_map, _Node_iterator, operator==, _Node_iterator_base, _Node_const_iterator
+#include <utility>        // Para pair, move
+
+#include "game/options.hpp"  // Para Options::controls
+
+// Singleton
+Input* Input::instance = nullptr;
+
+// Inicializa la instancia única del singleton
+void Input::init(const std::string& game_controller_db_path) {
+    Input::instance = new Input(game_controller_db_path);
+}
+
+// Libera la instancia
+void Input::destroy() { delete Input::instance; }
+
+// Obtiene la instancia
+auto Input::get() -> Input* { return Input::instance; }
+
+// Constructor
+Input::Input(std::string game_controller_db_path)
+    : gamepad_mappings_file_(std::move(game_controller_db_path)) {
+    // Inicializar bindings del teclado (valores por defecto)
+    // Estos serán sobrescritos por applyPlayer1BindingsFromOptions()
+    keyboard_.bindings = {
+        // Movimiento del jugador
+        {Action::LEFT, KeyState{.scancode = SDL_SCANCODE_LEFT}},
+        {Action::RIGHT, KeyState{.scancode = SDL_SCANCODE_RIGHT}},
+        {Action::THRUST, KeyState{.scancode = SDL_SCANCODE_UP}},
+        {Action::SHOOT, KeyState{.scancode = SDL_SCANCODE_SPACE}},
+
+        // Inputs de sistema (globales)
+        {Action::WINDOW_DEC_ZOOM, KeyState{.scancode = SDL_SCANCODE_F1}},
+        {Action::WINDOW_INC_ZOOM, KeyState{.scancode = SDL_SCANCODE_F2}},
+        {Action::TOGGLE_FULLSCREEN, KeyState{.scancode = SDL_SCANCODE_F3}},
+        {Action::TOGGLE_VSYNC, KeyState{.scancode = SDL_SCANCODE_F4}},
+        {Action::EXIT, KeyState{.scancode = SDL_SCANCODE_ESCAPE}}};
+
+    initSDLGamePad();  // Inicializa el subsistema SDL_INIT_GAMEPAD
+}
+
+// Asigna inputs a teclas
+void Input::bindKey(Action action, SDL_Scancode code) {
+    keyboard_.bindings[action].scancode = code;
+}
+
+// Aplica las teclas configuradas desde Options
+void Input::applyKeyboardBindingsFromOptions() {
+    bindKey(Action::LEFT, Options::keyboard_controls.key_left);
+    bindKey(Action::RIGHT, Options::keyboard_controls.key_right);
+    bindKey(Action::THRUST, Options::keyboard_controls.key_thrust);
+}
+
+// Aplica configuración de botones del gamepad desde Options al primer gamepad conectado
+void Input::applyGamepadBindingsFromOptions() {
+    // Si no hay gamepads conectados, no hay nada que hacer
+    if (gamepads_.empty()) {
+        return;
+    }
+
+    // Obtener el primer gamepad conectado
+    const auto& gamepad = gamepads_[0];
+
+    // Aplicar bindings desde Options
+    // Los valores pueden ser:
+    // - 0-20+: Botones SDL_GamepadButton (DPAD, face buttons, shoulders)
+    // - 100: L2 trigger
+    // - 101: R2 trigger
+    // - 200+: Ejes del stick analógico
+    gamepad->bindings[Action::LEFT].button = Options::gamepad_controls.button_left;
+    gamepad->bindings[Action::RIGHT].button = Options::gamepad_controls.button_right;
+    gamepad->bindings[Action::THRUST].button = Options::gamepad_controls.button_thrust;
+}
+
+// Asigna inputs a botones del mando
+void Input::bindGameControllerButton(const std::shared_ptr<Gamepad>& gamepad, Action action, SDL_GamepadButton button) {
+    if (gamepad != nullptr) {
+        gamepad->bindings[action].button = button;
+    }
+}
+
+// Asigna inputs a botones del mando
+void Input::bindGameControllerButton(const std::shared_ptr<Gamepad>& gamepad, Action action_target, Action action_source) {
+    if (gamepad != nullptr) {
+        gamepad->bindings[action_target].button = gamepad->bindings[action_source].button;
+    }
+}
+
+// Comprueba si alguna acción está activa
+auto Input::checkAction(Action action, bool repeat, bool check_keyboard, const std::shared_ptr<Gamepad>& gamepad) -> bool {
+    bool success_keyboard = false;
+    bool success_controller = false;
+
+    if (check_keyboard) {
+        if (repeat) {  // El usuario quiere saber si está pulsada (estado mantenido)
+            success_keyboard = keyboard_.bindings[action].is_held;
+        } else {  // El usuario quiere saber si ACABA de ser pulsada (evento de un solo fotograma)
+            success_keyboard = keyboard_.bindings[action].just_pressed;
+        }
+    }
+
+    // Si gamepad es nullptr pero hay mandos conectados, usar el primero
+    std::shared_ptr<Gamepad> active_gamepad = gamepad;
+    if (active_gamepad == nullptr && !gamepads_.empty()) {
+        active_gamepad = gamepads_[0];
+    }
+
+    if (active_gamepad != nullptr) {
+        success_controller = checkAxisInput(action, active_gamepad, repeat);
+
+        if (!success_controller) {
+            success_controller = checkTriggerInput(action, active_gamepad, repeat);
+        }
+
+        if (!success_controller) {
+            if (repeat) {  // El usuario quiere saber si está pulsada (estado mantenido)
+                success_controller = active_gamepad->bindings[action].is_held;
+            } else {  // El usuario quiere saber si ACABA de ser pulsada (evento de un solo fotograma)
+                success_controller = active_gamepad->bindings[action].just_pressed;
+            }
+        }
+    }
+
+    return (success_keyboard || success_controller);
+}
+
+// Comprueba si hay almenos una acción activa
+auto Input::checkAnyInput(bool check_keyboard, const std::shared_ptr<Gamepad>& gamepad) -> bool {
+    // Obtenemos el número total de acciones posibles para iterar sobre ellas.
+
+    // --- Comprobación del Teclado ---
+    if (check_keyboard) {
+        for (const auto& pair : keyboard_.bindings) {
+            // Simplemente leemos el estado pre-calculado por Input::update().
+            // Ya no se llama a SDL_GetKeyboardState ni se modifica el estado '.active'.
+            if (pair.second.just_pressed) {
+                return true;  // Se encontró una acción recién pulsada.
+            }
+        }
+    }
+
+    // Si gamepad es nullptr pero hay mandos conectados, usar el primero
+    std::shared_ptr<Gamepad> active_gamepad = gamepad;
+    if (active_gamepad == nullptr && !gamepads_.empty()) {
+        active_gamepad = gamepads_[0];
+    }
+
+    // --- Comprobación del Mando ---
+    // Comprobamos si hay mandos y si el índice solicitado es válido.
+    if (active_gamepad != nullptr) {
+        // Iteramos sobre todas las acciones, no sobre el número de mandos.
+        for (const auto& pair : active_gamepad->bindings) {
+            // Leemos el estado pre-calculado para el mando y la acción específicos.
+            if (pair.second.just_pressed) {
+                return true;  // Se encontró una acción recién pulsada en el mando.
+            }
+        }
+    }
+
+    // Si llegamos hasta aquí, no se detectó ninguna nueva pulsación.
+    return false;
+}
+
+// Comprueba si hay algún botón pulsado
+auto Input::checkAnyButton(bool repeat) -> bool {
+    // Solo comprueba los botones definidos previamente
+    for (auto bi : BUTTON_INPUTS) {
+        // Comprueba el teclado
+        if (checkAction(bi, repeat, CHECK_KEYBOARD)) {
+            return true;
+        }
+
+        // Comprueba los mandos
+        for (const auto& gamepad : gamepads_) {
+            if (checkAction(bi, repeat, DO_NOT_CHECK_KEYBOARD, gamepad)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+// Comprueba si algún jugador (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)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// Comprueba si hay algun mando conectado
+auto Input::gameControllerFound() const -> bool { return !gamepads_.empty(); }
+
+// Obten el nombre de un mando de juego
+auto Input::getControllerName(const std::shared_ptr<Gamepad>& gamepad) -> std::string {
+    return gamepad == nullptr ? std::string() : gamepad->name;
+}
+
+// Obtiene la lista de nombres de mandos
+auto Input::getControllerNames() const -> std::vector<std::string> {
+    std::vector<std::string> names;
+    for (const auto& gamepad : gamepads_) {
+        names.push_back(gamepad->name);
+    }
+    return names;
+}
+
+// Obten el número de mandos conectados
+auto Input::getNumGamepads() const -> int { return gamepads_.size(); }
+
+// Obtiene el gamepad a partir de un event.id
+auto Input::getGamepad(SDL_JoystickID id) const -> std::shared_ptr<Input::Gamepad> {
+    for (const auto& gamepad : gamepads_) {
+        if (gamepad->instance_id == id) {
+            return gamepad;
+        }
+    }
+    return nullptr;
+}
+
+auto Input::getGamepadByName(const std::string& name) const -> std::shared_ptr<Input::Gamepad> {
+    for (const auto& gamepad : gamepads_) {
+        if (gamepad && gamepad->name == name) {
+            return gamepad;
+        }
+    }
+    return nullptr;
+}
+
+// Obtiene el SDL_GamepadButton asignado a un action
+auto Input::getControllerBinding(const std::shared_ptr<Gamepad>& gamepad, Action action) -> SDL_GamepadButton {
+    return static_cast<SDL_GamepadButton>(gamepad->bindings[action].button);
+}
+
+// Comprueba el eje del mando
+auto Input::checkAxisInput(Action action, const std::shared_ptr<Gamepad>& gamepad, bool repeat) -> bool {
+    // Obtener el binding configurado para esta acción
+    auto& binding = gamepad->bindings[action];
+
+    // Solo revisar ejes si el binding está configurado como eje (valores 200+)
+    // 200 = Left stick izquierda, 201 = Left stick derecha
+    if (binding.button < 200) {
+        // El binding no es un eje, no revisar axis
+        return false;
+    }
+
+    // Determinar qué eje y dirección revisar según el binding
+    bool axis_active_now = false;
+
+    if (binding.button == 200) {
+        // Left stick izquierda
+        axis_active_now = SDL_GetGamepadAxis(gamepad->pad, SDL_GAMEPAD_AXIS_LEFTX) < -AXIS_THRESHOLD;
+    } else if (binding.button == 201) {
+        // Left stick derecha
+        axis_active_now = SDL_GetGamepadAxis(gamepad->pad, SDL_GAMEPAD_AXIS_LEFTX) > AXIS_THRESHOLD;
+    } else {
+        // Binding de eje no soportado
+        return false;
+    }
+
+    if (repeat) {
+        // Si se permite repetir, simplemente devolvemos el estado actual
+        return axis_active_now;
+    }  // Si no se permite repetir, aplicamos la lógica de transición
+    if (axis_active_now && !binding.axis_active) {
+        // Transición de inactivo a activo
+        binding.axis_active = true;
+        return true;
+    }
+    if (!axis_active_now && binding.axis_active) {
+        // Transición de activo a inactivo
+        binding.axis_active = false;
+    }
+    // Mantener el estado actual
+    return false;
+}
+
+// Comprueba los triggers del mando como botones digitales
+auto Input::checkTriggerInput(Action action, const std::shared_ptr<Gamepad>& gamepad, bool repeat) -> bool {
+    // Solo manejamos botones específicos que pueden ser triggers
+    if (gamepad->bindings[action].button != static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID)) {
+        // Solo procesamos L2 y R2 como triggers
+        int button = gamepad->bindings[action].button;
+
+        // Verificar si el botón mapeado corresponde a un trigger virtual
+        // (Para esto necesitamos valores especiales que representen L2/R2 como botones)
+        bool trigger_active_now = false;
+
+        // Usamos constantes especiales para L2 y R2 como botones
+        if (button == TRIGGER_L2_AS_BUTTON) {  // L2 como botón
+            Sint16 trigger_value = SDL_GetGamepadAxis(gamepad->pad, SDL_GAMEPAD_AXIS_LEFT_TRIGGER);
+            trigger_active_now = trigger_value > TRIGGER_THRESHOLD;
+        } else if (button == TRIGGER_R2_AS_BUTTON) {  // R2 como botón
+            Sint16 trigger_value = SDL_GetGamepadAxis(gamepad->pad, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER);
+            trigger_active_now = trigger_value > TRIGGER_THRESHOLD;
+        } else {
+            return false;  // No es un trigger
+        }
+
+        // Referencia al binding correspondiente
+        auto& binding = gamepad->bindings[action];
+
+        if (repeat) {
+            // Si se permite repetir, simplemente devolvemos el estado actual
+            return trigger_active_now;
+        }
+
+        // Si no se permite repetir, aplicamos la lógica de transición
+        if (trigger_active_now && !binding.trigger_active) {
+            // Transición de inactivo a activo
+            binding.trigger_active = true;
+            return true;
+        }
+        if (!trigger_active_now && binding.trigger_active) {
+            // Transición de activo a inactivo
+            binding.trigger_active = false;
+        }
+
+        // Mantener el estado actual
+        return false;
+    }
+
+    return false;
+}
+
+void Input::addGamepadMappingsFromFile() {
+    if (SDL_AddGamepadMappingsFromFile(gamepad_mappings_file_.c_str()) < 0) {
+        std::cout << "Error, could not load " << gamepad_mappings_file_.c_str() << " file: " << SDL_GetError() << '\n';
+    }
+}
+
+void Input::discoverGamepads() {
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+        handleEvent(event);  // Comprueba mandos conectados
+    }
+}
+
+void Input::initSDLGamePad() {
+    if (SDL_WasInit(SDL_INIT_GAMEPAD) != 1) {
+        if (!SDL_InitSubSystem(SDL_INIT_GAMEPAD)) {
+            SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GAMEPAD could not initialize! SDL Error: %s", SDL_GetError());
+        } else {
+            addGamepadMappingsFromFile();
+            discoverGamepads();
+            std::cout << "\n** INPUT SYSTEM **\n";
+            std::cout << "Input System initialized successfully\n";
+        }
+    }
+}
+
+void Input::resetInputStates() {
+    // Resetear todos los KeyBindings.active a false
+    for (auto& key : keyboard_.bindings) {
+        key.second.is_held = false;
+        key.second.just_pressed = false;
+    }
+    // Resetear todos los ControllerBindings.active a false
+    for (const auto& gamepad : gamepads_) {
+        for (auto& binding : gamepad->bindings) {
+            binding.second.is_held = false;
+            binding.second.just_pressed = false;
+            binding.second.trigger_active = false;
+        }
+    }
+}
+
+void Input::update() {
+    // --- TECLADO ---
+    const bool* key_states = SDL_GetKeyboardState(nullptr);
+
+    // Actualizar bindings globales (F1-F4, ESC)
+    for (auto& binding : keyboard_.bindings) {
+        bool key_is_down_now = key_states[binding.second.scancode];
+
+        // El estado .is_held del fotograma anterior nos sirve para saber si es un pulso nuevo
+        binding.second.just_pressed = key_is_down_now && !binding.second.is_held;
+        binding.second.is_held = key_is_down_now;
+    }
+
+    // Actualizar bindings de jugador 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
+    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;
+        binding.second.is_held = key_is_down_now;
+    }
+
+    // --- MANDOS ---
+    for (const auto& gamepad : gamepads_) {
+        for (auto& binding : gamepad->bindings) {
+            bool button_is_down_now = static_cast<int>(SDL_GetGamepadButton(gamepad->pad, static_cast<SDL_GamepadButton>(binding.second.button))) != 0;
+
+            // El estado .is_held del fotograma anterior nos sirve para saber si es un pulso nuevo
+            binding.second.just_pressed = button_is_down_now && !binding.second.is_held;
+            binding.second.is_held = button_is_down_now;
+        }
+    }
+}
+
+auto Input::handleEvent(const SDL_Event& event) -> std::string {
+    switch (event.type) {
+        case SDL_EVENT_GAMEPAD_ADDED:
+            return addGamepad(event.gdevice.which);
+        case SDL_EVENT_GAMEPAD_REMOVED:
+            return removeGamepad(event.gdevice.which);
+    }
+    return {};
+}
+
+auto Input::addGamepad(int device_index) -> std::string {
+    SDL_Gamepad* pad = SDL_OpenGamepad(device_index);
+    if (pad == nullptr) {
+        std::cerr << "Error al abrir el gamepad: " << SDL_GetError() << '\n';
+        return {};
+    }
+
+    auto gamepad = std::make_shared<Gamepad>(pad);
+    auto name = gamepad->name;
+    std::cout << "Gamepad connected (" << name << ")" << '\n';
+    gamepads_.push_back(std::move(gamepad));
+    return name + " CONNECTED";
+}
+
+auto Input::removeGamepad(SDL_JoystickID id) -> std::string {
+    auto it = std::ranges::find_if(gamepads_, [id](const std::shared_ptr<Gamepad>& gamepad) {
+        return gamepad->instance_id == id;
+    });
+
+    if (it != gamepads_.end()) {
+        std::string name = (*it)->name;
+        std::cout << "Gamepad disconnected (" << name << ")" << '\n';
+        gamepads_.erase(it);
+        return name + " DISCONNECTED";
+    }
+    std::cerr << "No se encontró el gamepad con ID " << id << '\n';
+    return {};
+}
+
+void Input::printConnectedGamepads() const {
+    if (gamepads_.empty()) {
+        std::cout << "No hay gamepads conectados." << '\n';
+        return;
+    }
+
+    std::cout << "Gamepads conectados:\n";
+    for (const auto& gamepad : gamepads_) {
+        std::string name = gamepad->name.empty() ? "Desconocido" : gamepad->name;
+        std::cout << "  - ID: " << gamepad->instance_id
+                  << ", Nombre: " << name << ")" << '\n';
+    }
+}
+
+auto Input::findAvailableGamepadByName(const std::string& gamepad_name) -> std::shared_ptr<Input::Gamepad> {
+    // Si no hay gamepads disponibles, devolver gamepad por defecto
+    if (gamepads_.empty()) {
+        return nullptr;
+    }
+
+    // Buscar por nombre
+    for (const auto& gamepad : gamepads_) {
+        if (gamepad && gamepad->name == gamepad_name) {
+            return gamepad;
+        }
+    }
+
+    // Si no se encuentra por nombre, devolver el primer gamepad válido
+    for (const auto& gamepad : gamepads_) {
+        if (gamepad) {
+            return gamepad;
+        }
+    }
+
+    // Si llegamos aquí, no hay gamepads válidos
+    return nullptr;
+}
+
+// ========== MÉTODOS ESPECÍFICOS POR JUGADOR (ORNI) ==========
+
+// Aplica configuración de controles del jugador 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;
+    player1_keyboard_bindings_[Action::RIGHT].scancode = Options::player1.keyboard.key_right;
+    player1_keyboard_bindings_[Action::THRUST].scancode = Options::player1.keyboard.key_thrust;
+    player1_keyboard_bindings_[Action::SHOOT].scancode = Options::player1.keyboard.key_shoot;
+    player1_keyboard_bindings_[Action::START].scancode = Options::player1.keyboard.key_start;
+
+    // 2. Encontrar gamepad por nombre (o usar primer gamepad como fallback)
+    std::shared_ptr<Gamepad> gamepad = nullptr;
+    if (Options::player1.gamepad_name.empty()) {
+        // Fallback: usar primer gamepad disponible
+        gamepad = (!gamepads_.empty()) ? gamepads_[0] : nullptr;
+    } else {
+        // Buscar por nombre
+        gamepad = findAvailableGamepadByName(Options::player1.gamepad_name);
+    }
+
+    if (!gamepad) {
+        player1_gamepad_ = nullptr;
+        return;
+    }
+
+    // 3. Aplicar bindings de gamepad
+    gamepad->bindings[Action::LEFT].button = Options::player1.gamepad.button_left;
+    gamepad->bindings[Action::RIGHT].button = Options::player1.gamepad.button_right;
+    gamepad->bindings[Action::THRUST].button = Options::player1.gamepad.button_thrust;
+    gamepad->bindings[Action::SHOOT].button = Options::player1.gamepad.button_shoot;
+
+    // 4. Cachear referencia
+    player1_gamepad_ = gamepad;
+}
+
+// Aplica configuración de controles del jugador 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;
+    player2_keyboard_bindings_[Action::RIGHT].scancode = Options::player2.keyboard.key_right;
+    player2_keyboard_bindings_[Action::THRUST].scancode = Options::player2.keyboard.key_thrust;
+    player2_keyboard_bindings_[Action::SHOOT].scancode = Options::player2.keyboard.key_shoot;
+    player2_keyboard_bindings_[Action::START].scancode = Options::player2.keyboard.key_start;
+
+    // 2. Encontrar gamepad por nombre (o usar segundo gamepad como fallback)
+    std::shared_ptr<Gamepad> gamepad = nullptr;
+    if (Options::player2.gamepad_name.empty()) {
+        // Fallback: usar segundo gamepad disponible
+        gamepad = (gamepads_.size() > 1) ? gamepads_[1] : nullptr;
+    } else {
+        // Buscar por nombre
+        gamepad = findAvailableGamepadByName(Options::player2.gamepad_name);
+    }
+
+    if (!gamepad) {
+        player2_gamepad_ = nullptr;
+        return;
+    }
+
+    // 3. Aplicar bindings de gamepad
+    gamepad->bindings[Action::LEFT].button = Options::player2.gamepad.button_left;
+    gamepad->bindings[Action::RIGHT].button = Options::player2.gamepad.button_right;
+    gamepad->bindings[Action::THRUST].button = Options::player2.gamepad.button_thrust;
+    gamepad->bindings[Action::SHOOT].button = Options::player2.gamepad.button_shoot;
+
+    // 4. Cachear referencia
+    player2_gamepad_ = gamepad;
+}
+
+// Consulta de input para jugador 1
+auto Input::checkActionPlayer1(Action action, bool repeat) -> bool {
+    // Comprobar teclado con el mapa específico de P1
+    bool keyboard_active = false;
+
+    if (player1_keyboard_bindings_.contains(action)) {
+        if (repeat) {
+            keyboard_active = player1_keyboard_bindings_[action].is_held;
+        } else {
+            keyboard_active = player1_keyboard_bindings_[action].just_pressed;
+        }
+    }
+
+    // Comprobar gamepad de P1
+    bool gamepad_active = false;
+    if (player1_gamepad_) {
+        gamepad_active = checkAction(action, repeat, DO_NOT_CHECK_KEYBOARD, player1_gamepad_);
+    }
+
+    return keyboard_active || gamepad_active;
+}
+
+// Consulta de input para jugador 2
+auto Input::checkActionPlayer2(Action action, bool repeat) -> bool {
+    // Comprobar teclado con el mapa específico de P2
+    bool keyboard_active = false;
+
+    if (player2_keyboard_bindings_.contains(action)) {
+        if (repeat) {
+            keyboard_active = player2_keyboard_bindings_[action].is_held;
+        } else {
+            keyboard_active = player2_keyboard_bindings_[action].just_pressed;
+        }
+    }
+
+    // Comprobar gamepad de P2
+    bool gamepad_active = false;
+    if (player2_gamepad_) {
+        gamepad_active = checkAction(action, repeat, DO_NOT_CHECK_KEYBOARD, player2_gamepad_);
+    }
+
+    return keyboard_active || gamepad_active;
+}

source/core/input/input.hpp

@@ -0,0 +1,162 @@
+#pragma once
+
+#include <SDL3/SDL.h>  // Para SDL_Scancode, SDL_GamepadButton, SDL_JoystickID, SDL_CloseGamepad, SDL_Gamepad, SDL_GetGamepadJoystick, SDL_GetGamepadName, SDL_GetGamepadPath, SDL_GetJoystickID, Sint16, Uint8, SDL_Event
+
+#include <array>          // Para array
+#include <memory>         // Para shared_ptr
+#include <span>           // Para span
+#include <string>         // Para string, basic_string
+#include <unordered_map>  // Para unordered_map
+#include <utility>        // Para pair
+#include <vector>         // Para vector
+
+#include "core/input/input_types.hpp"  // for InputAction
+
+// --- Clase Input: gestiona la entrada de teclado y mandos (singleton) ---
+class Input {
+    public:
+        // --- Constantes ---
+        static constexpr bool ALLOW_REPEAT = true;            // Permite repetición
+        static constexpr bool DO_NOT_ALLOW_REPEAT = false;    // No permite repetición
+        static constexpr bool CHECK_KEYBOARD = true;          // Comprueba teclado
+        static constexpr bool DO_NOT_CHECK_KEYBOARD = false;  // No comprueba teclado
+        static constexpr int TRIGGER_L2_AS_BUTTON = 100;      // L2 como botón
+        static constexpr int TRIGGER_R2_AS_BUTTON = 101;      // R2 como botón
+
+        // --- Tipos ---
+        using Action = InputAction;  // Alias para mantener compatibilidad
+
+        // --- Estructuras ---
+        struct KeyState {
+                Uint8 scancode{0};         // Scancode asociado
+                bool is_held{false};       // Está pulsada ahora mismo
+                bool just_pressed{false};  // Se acaba de pulsar en este fotograma
+        };
+
+        struct ButtonState {
+                int button{static_cast<int>(SDL_GAMEPAD_BUTTON_INVALID)};  // GameControllerButton asociado
+                bool is_held{false};                                       // Está pulsada ahora mismo
+                bool just_pressed{false};                                  // Se acaba de pulsar en este fotograma
+                bool axis_active{false};                                   // Estado del eje
+                bool trigger_active{false};                                // Estado del trigger como botón digital
+        };
+
+        struct Keyboard {
+                std::unordered_map<Action, KeyState> bindings;  // Mapa de acciones a estados de tecla
+        };
+
+        struct Gamepad {
+                SDL_Gamepad* pad{nullptr};                         // Puntero al gamepad SDL
+                SDL_JoystickID instance_id{0};                     // ID de instancia del joystick
+                std::string name;                                  // Nombre del gamepad
+                std::string path;                                  // Ruta del dispositivo
+                std::unordered_map<Action, ButtonState> bindings;  // Mapa de acciones a estados de botón
+
+                explicit Gamepad(SDL_Gamepad* gamepad)
+                    : pad(gamepad),
+                      instance_id(SDL_GetJoystickID(SDL_GetGamepadJoystick(gamepad))),
+                      name(std::string(SDL_GetGamepadName(gamepad))),
+                      path(std::string(SDL_GetGamepadPath(pad))),
+                      bindings{
+                          // Movimiento y acciones del jugador
+                          {Action::LEFT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_LEFT)}},
+                          {Action::RIGHT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_DPAD_RIGHT)}},
+                          {Action::THRUST, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_WEST)}},
+                          {Action::SHOOT, ButtonState{.button = static_cast<int>(SDL_GAMEPAD_BUTTON_SOUTH)}}} {}
+
+                ~Gamepad() {
+                    if (pad != nullptr) {
+                        SDL_CloseGamepad(pad);
+                    }
+                }
+
+                // Reasigna un botón a una acción
+                void rebindAction(Action action, SDL_GamepadButton new_button) {
+                    bindings[action].button = static_cast<int>(new_button);
+                }
+        };
+
+        // --- Tipos ---
+        using Gamepads = std::vector<std::shared_ptr<Gamepad>>;  // Vector de gamepads
+
+        // --- Singleton ---
+        static void init(const std::string& game_controller_db_path);
+        static void destroy();
+        static auto get() -> Input*;
+
+        // --- Actualización del sistema ---
+        void update();  // Actualiza estados de entrada
+
+        // --- Configuración de controles ---
+        void bindKey(Action action, SDL_Scancode code);
+        void applyKeyboardBindingsFromOptions();
+        void applyGamepadBindingsFromOptions();
+
+        // Configuración por jugador (Orni - dos jugadores)
+        void applyPlayer1BindingsFromOptions();
+        void applyPlayer2BindingsFromOptions();
+
+        static void bindGameControllerButton(const std::shared_ptr<Gamepad>& gamepad, Action action, SDL_GamepadButton button);
+        static void bindGameControllerButton(const std::shared_ptr<Gamepad>& gamepad, Action action_target, Action action_source);
+
+        // --- Consulta de entrada ---
+        auto checkAction(Action action, bool repeat = true, bool check_keyboard = true, const std::shared_ptr<Gamepad>& gamepad = nullptr) -> bool;
+        auto checkAnyInput(bool check_keyboard = true, const std::shared_ptr<Gamepad>& gamepad = nullptr) -> bool;
+        auto checkAnyButton(bool repeat = DO_NOT_ALLOW_REPEAT) -> bool;
+        void resetInputStates();
+
+        // Consulta por jugador (Orni - dos jugadores)
+        auto checkActionPlayer1(Action action, bool repeat = true) -> bool;
+        auto checkActionPlayer2(Action action, bool repeat = true) -> bool;
+
+        // Check if any player pressed any action from a list
+        auto checkAnyPlayerAction(const std::span<const InputAction>& actions, bool repeat = DO_NOT_ALLOW_REPEAT) -> bool;
+
+        // --- Gestión de gamepads ---
+        [[nodiscard]] auto gameControllerFound() const -> bool;
+        [[nodiscard]] auto getNumGamepads() const -> int;
+        [[nodiscard]] auto getGamepad(SDL_JoystickID id) const -> std::shared_ptr<Gamepad>;
+        [[nodiscard]] auto getGamepadByName(const std::string& name) const -> std::shared_ptr<Input::Gamepad>;
+        [[nodiscard]] auto getGamepads() const -> const Gamepads& { return gamepads_; }
+        auto findAvailableGamepadByName(const std::string& gamepad_name) -> std::shared_ptr<Gamepad>;
+        static auto getControllerName(const std::shared_ptr<Gamepad>& gamepad) -> std::string;
+        [[nodiscard]] auto getControllerNames() const -> std::vector<std::string>;
+        [[nodiscard]] static auto getControllerBinding(const std::shared_ptr<Gamepad>& gamepad, Action action) -> SDL_GamepadButton;
+        void printConnectedGamepads() const;
+
+        // --- Eventos ---
+        auto handleEvent(const SDL_Event& event) -> std::string;
+
+    private:
+        // --- Constantes ---
+        static constexpr Sint16 AXIS_THRESHOLD = 30000;                          // Umbral para ejes analógicos
+        static constexpr Sint16 TRIGGER_THRESHOLD = 16384;                       // Umbral para triggers (50% del rango)
+        static constexpr std::array<Action, 1> BUTTON_INPUTS = {Action::SHOOT};  // Inputs que usan botones
+
+        // --- Métodos ---
+        explicit Input(std::string game_controller_db_path);
+        ~Input() = default;
+
+        void initSDLGamePad();
+        static auto checkAxisInput(Action action, const std::shared_ptr<Gamepad>& gamepad, bool repeat) -> bool;
+        static auto checkTriggerInput(Action action, const std::shared_ptr<Gamepad>& gamepad, bool repeat) -> bool;
+        auto addGamepad(int device_index) -> std::string;
+        auto removeGamepad(SDL_JoystickID id) -> std::string;
+        void addGamepadMappingsFromFile();
+        void discoverGamepads();
+
+        // --- Variables miembro ---
+        static Input* instance;  // Instancia única del singleton
+
+        Gamepads gamepads_;                  // Lista de gamepads conectados
+        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)
+        std::shared_ptr<Gamepad> player1_gamepad_;
+        std::shared_ptr<Gamepad> player2_gamepad_;
+
+        // Mapas de bindings separados por jugador (Orni - dos jugadores)
+        std::unordered_map<Action, KeyState> player1_keyboard_bindings_;
+        std::unordered_map<Action, KeyState> player2_keyboard_bindings_;
+};

source/core/input/input_types.cpp

@@ -0,0 +1,60 @@
+#include "input_types.hpp"
+
+#include <utility>  // Para pair
+
+// Definición de los mapas
+const std::unordered_map<InputAction, std::string> ACTION_TO_STRING = {
+    {InputAction::LEFT, "LEFT"},
+    {InputAction::RIGHT, "RIGHT"},
+    {InputAction::THRUST, "THRUST"},
+    {InputAction::SHOOT, "SHOOT"},
+    {InputAction::WINDOW_INC_ZOOM, "WINDOW_INC_ZOOM"},
+    {InputAction::WINDOW_DEC_ZOOM, "WINDOW_DEC_ZOOM"},
+    {InputAction::TOGGLE_FULLSCREEN, "TOGGLE_FULLSCREEN"},
+    {InputAction::TOGGLE_VSYNC, "TOGGLE_VSYNC"},
+    {InputAction::EXIT, "EXIT"},
+    {InputAction::NONE, "NONE"}};
+
+const std::unordered_map<std::string, InputAction> STRING_TO_ACTION = {
+    {"LEFT", InputAction::LEFT},
+    {"RIGHT", InputAction::RIGHT},
+    {"THRUST", InputAction::THRUST},
+    {"SHOOT", InputAction::SHOOT},
+    {"WINDOW_INC_ZOOM", InputAction::WINDOW_INC_ZOOM},
+    {"WINDOW_DEC_ZOOM", InputAction::WINDOW_DEC_ZOOM},
+    {"TOGGLE_FULLSCREEN", InputAction::TOGGLE_FULLSCREEN},
+    {"TOGGLE_VSYNC", InputAction::TOGGLE_VSYNC},
+    {"EXIT", InputAction::EXIT},
+    {"NONE", InputAction::NONE}};
+
+const std::unordered_map<SDL_GamepadButton, std::string> BUTTON_TO_STRING = {
+    {SDL_GAMEPAD_BUTTON_WEST, "WEST"},
+    {SDL_GAMEPAD_BUTTON_NORTH, "NORTH"},
+    {SDL_GAMEPAD_BUTTON_EAST, "EAST"},
+    {SDL_GAMEPAD_BUTTON_SOUTH, "SOUTH"},
+    {SDL_GAMEPAD_BUTTON_START, "START"},
+    {SDL_GAMEPAD_BUTTON_BACK, "BACK"},
+    {SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, "LEFT_SHOULDER"},
+    {SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, "RIGHT_SHOULDER"},
+    {SDL_GAMEPAD_BUTTON_DPAD_UP, "DPAD_UP"},
+    {SDL_GAMEPAD_BUTTON_DPAD_DOWN, "DPAD_DOWN"},
+    {SDL_GAMEPAD_BUTTON_DPAD_LEFT, "DPAD_LEFT"},
+    {SDL_GAMEPAD_BUTTON_DPAD_RIGHT, "DPAD_RIGHT"},
+    {static_cast<SDL_GamepadButton>(100), "L2_AS_BUTTON"},
+    {static_cast<SDL_GamepadButton>(101), "R2_AS_BUTTON"}};
+
+const std::unordered_map<std::string, SDL_GamepadButton> STRING_TO_BUTTON = {
+    {"WEST", SDL_GAMEPAD_BUTTON_WEST},
+    {"NORTH", SDL_GAMEPAD_BUTTON_NORTH},
+    {"EAST", SDL_GAMEPAD_BUTTON_EAST},
+    {"SOUTH", SDL_GAMEPAD_BUTTON_SOUTH},
+    {"START", SDL_GAMEPAD_BUTTON_START},
+    {"BACK", SDL_GAMEPAD_BUTTON_BACK},
+    {"LEFT_SHOULDER", SDL_GAMEPAD_BUTTON_LEFT_SHOULDER},
+    {"RIGHT_SHOULDER", SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER},
+    {"DPAD_UP", SDL_GAMEPAD_BUTTON_DPAD_UP},
+    {"DPAD_DOWN", SDL_GAMEPAD_BUTTON_DPAD_DOWN},
+    {"DPAD_LEFT", SDL_GAMEPAD_BUTTON_DPAD_LEFT},
+    {"DPAD_RIGHT", SDL_GAMEPAD_BUTTON_DPAD_RIGHT},
+    {"L2_AS_BUTTON", static_cast<SDL_GamepadButton>(100)},
+    {"R2_AS_BUTTON", static_cast<SDL_GamepadButton>(101)}};

source/core/input/input_types.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#include <array>
+#include <string>
+#include <unordered_map>
+
+// --- Enums ---
+enum class InputAction : int {  // Acciones de entrada posibles en el juego
+    // Inputs de juego (movimiento y acción)
+    LEFT,    // Rotar izquierda
+    RIGHT,   // Rotar derecha
+    THRUST,  // Acelerar
+    SHOOT,   // Disparar
+    START,   // Empezar partida
+
+    // Inputs de sistema (globales)
+    WINDOW_INC_ZOOM,    // F2
+    WINDOW_DEC_ZOOM,    // F1
+    TOGGLE_FULLSCREEN,  // F3
+    TOGGLE_VSYNC,       // F4
+    EXIT,               // ESC
+
+    // Input obligatorio
+    NONE,
+    SIZE,
+};
+
+// --- Variables ---
+extern const std::unordered_map<InputAction, std::string> ACTION_TO_STRING;        // Mapeo de acción a string
+extern const std::unordered_map<std::string, InputAction> STRING_TO_ACTION;        // Mapeo de string a acción
+extern const std::unordered_map<SDL_GamepadButton, std::string> BUTTON_TO_STRING;  // Mapeo de botón a string
+extern const std::unordered_map<std::string, SDL_GamepadButton> STRING_TO_BUTTON;  // Mapeo de string a botón
+
+// --- Constantes ---
+// Physical arcade buttons (excludes directional controls LEFT/RIGHT)
+static constexpr std::array<InputAction, 3> ARCADE_BUTTONS = {
+    InputAction::SHOOT,
+    InputAction::THRUST,
+    InputAction::START};

source/core/input/mouse.cpp

@@ -1,29 +1,44 @@
 #include "core/input/mouse.hpp"
 
+#include <iostream>
+
 namespace Mouse {
 Uint32 cursor_hide_time = 3000;   // Tiempo en milisegundos para ocultar el cursor
 Uint32 last_mouse_move_time = 0;  // Última vez que el ratón se movió
-bool cursor_visible = true;       // Estado del cursor
+bool cursor_visible = false;      // Estado del cursor (inicia ocult)
 
 // Modo forzado: Usado cuando SDLManager entra en pantalla completa.
 // Cuando está activado, el cursor permanece oculto independientemente del movimiento del ratón.
 // SDLManager controla esto mediante llamadas a setForceHidden().
 bool force_hidden = false;
 
+// Temps d'inicialització 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
+              << " -> 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';
+}
+
 void setForceHidden(bool force) {
     force_hidden = force;
 
     if (force) {
         // Entrando en modo oculto forzado: ocultar cursor inmediatamente
-        if (cursor_visible) {
         SDL_HideCursor();
         cursor_visible = false;
-        }
     } else {
-        // Saliendo de modo oculto forzado: mostrar cursor y resetear temporizador
+        // Saliendo de modo oculto forzado: NO mostrar cursor automáticamente
-        SDL_ShowCursor();
+        // El cursor permanece oculto hasta que haya movimiento de ratón (handleEvent)
-        cursor_visible = true;
         last_mouse_move_time = SDL_GetTicks();  // Resetear temporizador
+        // cursor_visible permanece false - handleEvent lo cambiará al detectar movimiento
     }
 }
 
@@ -39,8 +54,18 @@ void handleEvent(const SDL_Event& event) {
 
     // MODO NORMAL: Mostrar cursor al mover el ratón
     if (event.type == SDL_EVENT_MOUSE_MOTION) {
-        last_mouse_move_time = SDL_GetTicks();
+        Uint32 current_time = SDL_GetTicks();
+
+        // Ignorar esdeveniments fantasma de SDL durant 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';
+            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';
             SDL_ShowCursor();
             cursor_visible = true;
         }
@@ -56,6 +81,8 @@ void updateCursorVisibility() {
     // MODO NORMAL: Auto-ocultar basado en timeout
     Uint32 current_time = SDL_GetTicks();
     if (cursor_visible && (current_time - last_mouse_move_time > cursor_hide_time)) {
+        std::cout << "[Mouse::updateCursorVisibility] Ocultant cursor per timeout. current=" << current_time
+                  << " last=" << last_mouse_move_time << " diff=" << (current_time - last_mouse_move_time) << '\n';
         SDL_HideCursor();
         cursor_visible = false;
     }

source/core/input/mouse.hpp

@@ -7,6 +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 handleEvent(const SDL_Event& event);
 void updateCursorVisibility();
 

source/core/math/easing.hpp

@@ -0,0 +1,44 @@
+// easing.hpp - Funcions d'interpolació i easing
+// © 2025 Orni Attack
+
+#pragma once
+
+namespace Easing {
+
+// Ease-out quadratic: empieza rápido, desacelera suavemente
+// t = progreso normalizado [0.0 - 1.0]
+// retorna valor 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]
+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]
+inline float ease_in_out_quad(float t) {
+    return (t < 0.5F)
+        ? 2.0F * t * t
+        : 1.0F - ((-2.0F * t + 2.0F) * (-2.0F * t + 2.0F) / 2.0F);
+}
+
+// Ease-out cubic: desaceleración más suave que quadratic
+// t = progreso normalizado [0.0 - 1.0]
+// retorna valor interpolado [0.0 - 1.0]
+inline float ease_out_cubic(float t) {
+    float t1 = 1.0F - t;
+    return 1.0F - (t1 * t1 * t1);
+}
+
+// Interpolación lineal básica (para referencia)
+inline float lerp(float start, float end, float t) {
+    return start + ((end - start) * t);
+}
+
+}  // namespace Easing

source/core/physics/collision.hpp

@@ -0,0 +1,32 @@
+// collision.hpp - Utilitats de detecció de col·lisions
+// © 2025 Orni Attack - Sistema de física
+
+#pragma once
+
+#include "core/entities/entitat.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) {
+    // Comprovar si ambdós són col·lisionables
+    if (!a.es_collidable() || !b.es_collidable()) {
+        return false;
+    }
+
+    // Calcular radi combinat (amb amplificador per hitbox generós)
+    float suma_radis = (a.get_collision_radius() + b.get_collision_radius()) * 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();
+    float dx = pos_a.x - pos_b.x;
+    float dy = pos_a.y - pos_b.y;
+    float dist_sq = (dx * dx) + (dy * dy);
+
+    return dist_sq <= suma_radis_sq;
+}
+
+}  // namespace Physics

source/core/rendering/color_oscillator.cpp

@@ -10,16 +10,16 @@
 namespace Rendering {
 
 ColorOscillator::ColorOscillator()
-    : accumulated_time_(0.0f) {
+    : accumulated_time_(0.0F) {
     // Inicialitzar amb el color mínim
-    current_line_color_ = {Defaults::Color::LINE_MIN_R,
+    current_line_color_ = {.r = Defaults::Color::LINE_MIN_R,
-        Defaults::Color::LINE_MIN_G,
+        .g = Defaults::Color::LINE_MIN_G,
-        Defaults::Color::LINE_MIN_B,
+        .b = Defaults::Color::LINE_MIN_B,
-        255};
+        .a = 255};
-    current_background_color_ = {Defaults::Color::BACKGROUND_MIN_R,
+    current_background_color_ = {.r = Defaults::Color::BACKGROUND_MIN_R,
-        Defaults::Color::BACKGROUND_MIN_G,
+        .g = Defaults::Color::BACKGROUND_MIN_G,
-        Defaults::Color::BACKGROUND_MIN_B,
+        .b = Defaults::Color::BACKGROUND_MIN_B,
-        255};
+        .a = 255};
 }
 
 void ColorOscillator::update(float delta_time) {
@@ -54,14 +54,14 @@ void ColorOscillator::update(float delta_time) {
 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;
+    float radians = time * frequency * 2.0F * Defaults::Math::PI;
-    return (std::sin(radians) + 1.0f) / 2.0f;
+    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),
+    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.g + ((max.g - min.g) * factor)),
-        static_cast<uint8_t>(min.b + (max.b - min.b) * factor),
+        static_cast<uint8_t>(min.b + ((max.b - min.b) * factor)),
         255};
 }
 

source/core/rendering/color_oscillator.hpp

@@ -12,8 +12,8 @@ class ColorOscillator {
 
         void update(float delta_time);
 
-        SDL_Color getCurrentLineColor() const { return current_line_color_; }
+        [[nodiscard]] SDL_Color getCurrentLineColor() const { return current_line_color_; }
-        SDL_Color getCurrentBackgroundColor() const {
+        [[nodiscard]] SDL_Color getCurrentBackgroundColor() const {
             return current_background_color_;
         }
 

source/core/rendering/coordinate_transform.cpp

@@ -6,6 +6,6 @@
 namespace Rendering {
 
 // Factor d'escala global (inicialitzat a 1.0 per defecte)
-float g_current_scale_factor = 1.0f;
+float g_current_scale_factor = 1.0F;
 
 }  // namespace Rendering

source/core/rendering/line_renderer.cpp

@@ -20,10 +20,12 @@ bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar
 
     // Helper function: retorna el signe d'un nombre
     auto sign = [](int x) -> int {
-        if (x < 0)
+        if (x < 0) {
             return -1;
-        if (x > 0)
+        }
+        if (x > 0) {
             return 1;
+        }
         return 0;
     };
 
@@ -40,7 +42,7 @@ bool linea(SDL_Renderer* renderer, int x1, int y1, int x2, int y2, bool dibuixar
     bool colisio = false;
 
     // Dibuixar amb SDL3 (més eficient que Bresenham píxel a píxel)
-    if (dibuixar && renderer) {
+    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);

source/core/rendering/line_renderer.hpp

@@ -9,7 +9,7 @@ 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);
+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ó)
 void setLineColor(SDL_Color color);

source/core/rendering/primitives.cpp

@@ -14,7 +14,7 @@
 
 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);
+    return std::sqrt((p.x * p.x) + (p.y * p.y));
 }
 
 void diferencia(const Punt& o, const Punt& d, Punt& p) {
@@ -35,15 +35,15 @@ float angle_punt(const Punt& p) {
     if (p.y != 0) {
         return std::atan(p.x / p.y);
     }
-    return 0.0f;
+    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 interval = 2.0F * Defaults::Math::PI / n;
-    float act = 0.0f;
+    float act = 0.0F;
 
     for (uint8_t i = 0; i < n; i++) {
         pol.ipuntx[i].r = r;
@@ -52,15 +52,15 @@ void crear_poligon_regular(Poligon& pol, uint8_t n, float r) {
     }
 
     // Inicialitzar propietats del polígon
-    pol.centre.x = 320.0f;
+    pol.centre.x = 320.0F;
-    pol.centre.y = 200.0f;
+    pol.centre.y = 200.0F;
-    pol.angle = 0.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.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.drotacio = 0.078539816F * 20.0F;
-    pol.rotacio = 0.0f;
+    pol.rotacio = 0.0F;
     pol.esta = true;
 }

source/core/rendering/sdl_manager.cpp

@@ -17,7 +17,7 @@
 SDLManager::SDLManager()
     : finestra_(nullptr),
       renderer_(nullptr),
-      fps_accumulator_(0.0f),
+      fps_accumulator_(0.0F),
       fps_frame_count_(0),
       fps_display_(0),
       current_width_(Defaults::Window::WIDTH),
@@ -28,10 +28,10 @@ SDLManager::SDLManager()
       zoom_factor_(Defaults::Window::BASE_ZOOM),
       windowed_width_(Defaults::Window::WIDTH),
       windowed_height_(Defaults::Window::HEIGHT),
-      max_zoom_(1.0f) {
+      max_zoom_(1.0F) {
     // Inicialitzar SDL3
     if (!SDL_Init(SDL_INIT_VIDEO)) {
-        std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
+        std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << '\n';
         return;
     }
 
@@ -47,8 +47,8 @@ SDLManager::SDLManager()
             SDL_WINDOW_RESIZABLE  // Permetre resize manual també
         );
 
-    if (!finestra_) {
+    if (finestra_ == nullptr) {
-        std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
         SDL_Quit();
         return;
     }
@@ -59,8 +59,8 @@ SDLManager::SDLManager()
     // Crear renderer amb acceleració
     renderer_ = SDL_CreateRenderer(finestra_, nullptr);
 
-    if (!renderer_) {
+    if (renderer_ == nullptr) {
-        std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
         SDL_DestroyWindow(finestra_);
         SDL_Quit();
         return;
@@ -74,14 +74,14 @@ SDLManager::SDLManager()
 
     std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
               << " (logic: " << Defaults::Game::WIDTH << "x"
-              << Defaults::Game::HEIGHT << ")" << std::endl;
+              << Defaults::Game::HEIGHT << ")" << '\n';
 }
 
 // Constructor amb configuració
 SDLManager::SDLManager(int width, int height, bool fullscreen)
     : finestra_(nullptr),
       renderer_(nullptr),
-      fps_accumulator_(0.0f),
+      fps_accumulator_(0.0F),
       fps_frame_count_(0),
       fps_display_(0),
       current_width_(width),
@@ -92,10 +92,10 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
       zoom_factor_(static_cast<float>(width) / Defaults::Window::WIDTH),
       windowed_width_(width),
       windowed_height_(height),
-      max_zoom_(1.0f) {
+      max_zoom_(1.0F) {
     // Inicialitzar SDL3
     if (!SDL_Init(SDL_INIT_VIDEO)) {
-        std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << std::endl;
+        std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << '\n';
         return;
     }
 
@@ -114,8 +114,8 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
     // Crear finestra
     finestra_ = SDL_CreateWindow(window_title.c_str(), current_width_, current_height_, flags);
 
-    if (!finestra_) {
+    if (finestra_ == nullptr) {
-        std::cerr << "Error creant finestra: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
         SDL_Quit();
         return;
     }
@@ -128,8 +128,8 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
     // Crear renderer amb acceleració
     renderer_ = SDL_CreateRenderer(finestra_, nullptr);
 
-    if (!renderer_) {
+    if (renderer_ == nullptr) {
-        std::cerr << "Error creant renderer: " << SDL_GetError() << std::endl;
+        std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
         SDL_DestroyWindow(finestra_);
         SDL_Quit();
         return;
@@ -141,50 +141,53 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
     // Configurar viewport scaling
     updateLogicalPresentation();
 
+    // Inicialitzar sistema de cursor
+    // En fullscreen: forzar ocultació permanent
+    if (is_fullscreen_) {
+        Mouse::setForceHidden(true);
+    }
+
     std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
               << " (logic: " << Defaults::Game::WIDTH << "x"
               << Defaults::Game::HEIGHT << ")";
     if (is_fullscreen_) {
         std::cout << " [FULLSCREEN]";
     }
-    std::cout << std::endl;
+    std::cout << '\n';
-
-    // Inicialitzar mòdul Mouse amb l'estat actual de fullscreen
-    Mouse::setForceHidden(is_fullscreen_);
 }
 
 SDLManager::~SDLManager() {
-    if (renderer_) {
+    if (renderer_ != nullptr) {
         SDL_DestroyRenderer(renderer_);
         renderer_ = nullptr;
     }
 
-    if (finestra_) {
+    if (finestra_ != nullptr) {
         SDL_DestroyWindow(finestra_);
         finestra_ = nullptr;
     }
 
     SDL_Quit();
-    std::cout << "SDL3 netejat correctament" << std::endl;
+    std::cout << "SDL3 netejat correctament" << '\n';
 }
 
 void SDLManager::calculateMaxWindowSize() {
     SDL_DisplayID display = SDL_GetPrimaryDisplay();
     const SDL_DisplayMode* mode = SDL_GetCurrentDisplayMode(display);
 
-    if (mode) {
+    if (mode != nullptr) {
         // Deixar marge de 100px per a 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_ << ")"
-                  << std::endl;
+                  << '\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_ << std::endl;
+                  << max_width_ << "x" << max_height_ << '\n';
     }
 
     // Calculate max zoom immediately after determining max size
@@ -206,7 +209,7 @@ void SDLManager::calculateMaxZoom() {
     max_zoom_ = std::max(max_zoom_, Defaults::Window::MIN_ZOOM);
 
     std::cout << "Max zoom: " << max_zoom_ << "x (display: "
-              << max_width_ << "x" << max_height_ << ")" << std::endl;
+              << max_width_ << "x" << max_height_ << ")" << '\n';
 }
 
 void SDLManager::applyZoom(float new_zoom) {
@@ -218,7 +221,7 @@ void SDLManager::applyZoom(float new_zoom) {
     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) {
+    if (std::abs(new_zoom - zoom_factor_) < 0.01F) {
         return;
     }
 
@@ -246,7 +249,7 @@ void SDLManager::applyZoom(float new_zoom) {
     Options::window.zoom_factor = zoom_factor_;
 
     std::cout << "Zoom: " << zoom_factor_ << "x ("
-              << new_width << "x" << new_height << ")" << std::endl;
+              << new_width << "x" << new_height << ")" << '\n';
 }
 
 void SDLManager::updateLogicalPresentation() {
@@ -276,37 +279,40 @@ void SDLManager::updateViewport() {
 
     std::cout << "Viewport: " << scaled_width << "x" << scaled_height
               << " @ (" << offset_x << "," << offset_y << ") [scale=" << scale << "]"
-              << std::endl;
+              << '\n';
 }
 
-void SDLManager::updateRenderingContext() {
+void SDLManager::updateRenderingContext() const {
     // Actualitzar el factor d'escala global per a totes les funcions de renderitzat
     Rendering::g_current_scale_factor = zoom_factor_;
 }
 
 void SDLManager::increaseWindowSize() {
-    if (is_fullscreen_)
+    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" << std::endl;
+    std::cout << "F2: Zoom aumentat a " << zoom_factor_ << "x" << '\n';
 }
 
 void SDLManager::decreaseWindowSize() {
-    if (is_fullscreen_)
+    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" << std::endl;
+    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, old_y;
+    int old_x;
+    int old_y;
     SDL_GetWindowPosition(finestra_, &old_x, &old_y);
 
     int old_width = current_width_;
@@ -346,7 +352,7 @@ void SDLManager::toggleFullscreen() {
         SDL_SetWindowFullscreen(finestra_, true);
 
         std::cout << "F3: Fullscreen activat (guardada: "
-                  << windowed_width_ << "x" << windowed_height_ << ")" << std::endl;
+                  << windowed_width_ << "x" << windowed_height_ << ")" << '\n';
     } else {
         // EXITING FULLSCREEN
         is_fullscreen_ = false;
@@ -356,7 +362,7 @@ void SDLManager::toggleFullscreen() {
         applyWindowSize(windowed_width_, windowed_height_);
 
         std::cout << "F3: Fullscreen desactivat (restaurada: "
-                  << windowed_width_ << "x" << windowed_height_ << ")" << std::endl;
+                  << windowed_width_ << "x" << windowed_height_ << ")" << '\n';
     }
 
     Options::window.fullscreen = is_fullscreen_;
@@ -386,15 +392,16 @@ bool SDLManager::handleWindowEvent(const SDL_Event& event) {
 
         std::cout << "Finestra redimensionada: " << current_width_
                   << "x" << current_height_ << " (zoom ≈" << zoom_factor_ << "x)"
-                  << std::endl;
+                  << '\n';
         return true;
     }
     return false;
 }
 
 void SDLManager::neteja(uint8_t r, uint8_t g, uint8_t b) {
-    if (!renderer_)
+    if (renderer_ == nullptr) {
         return;
+    }
 
     // [MODIFICAT] Usar color oscil·lat del fons en lloc dels paràmetres
     (void)r;
@@ -406,8 +413,9 @@ void SDLManager::neteja(uint8_t r, uint8_t g, uint8_t b) {
 }
 
 void SDLManager::presenta() {
-    if (!renderer_)
+    if (renderer_ == nullptr) {
         return;
+    }
 
     SDL_RenderPresent(renderer_);
 }
@@ -427,19 +435,21 @@ void SDLManager::updateFPS(float delta_time) {
     fps_frame_count_++;
 
     // Actualitzar display cada 0.5 segons
-    if (fps_accumulator_ >= 0.5f) {
+    if (fps_accumulator_ >= 0.5F) {
         fps_display_ = static_cast<int>(fps_frame_count_ / fps_accumulator_);
         fps_frame_count_ = 0;
-        fps_accumulator_ = 0.0f;
+        fps_accumulator_ = 0.0F;
 
         // Actualitzar títol de la finestra
-        std::string title = std::format("{} v{} ({}) - {} FPS",
+        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_);
+            fps_display_,
+            vsync_state);
 
-        if (finestra_) {
+        if (finestra_ != nullptr) {
             SDL_SetWindowTitle(finestra_, title.c_str());
         }
     }
@@ -447,7 +457,7 @@ void SDLManager::updateFPS(float delta_time) {
 
 // [NUEVO] Actualitzar títol de la finestra
 void SDLManager::setWindowTitle(const std::string& title) {
-    if (finestra_) {
+    if (finestra_ != nullptr) {
         SDL_SetWindowTitle(finestra_, title.c_str());
     }
 }
@@ -458,10 +468,14 @@ void SDLManager::toggleVSync() {
     Options::rendering.vsync = (Options::rendering.vsync == 1) ? 0 : 1;
 
     // Aplicar a SDL
-    if (renderer_) {
+    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ó
     Options::saveToFile();
 }

source/core/rendering/sdl_manager.hpp

@@ -14,8 +14,7 @@
 class SDLManager {
     public:
         SDLManager();                                        // Constructor per defecte (usa Defaults::)
-        SDLManager(int width, int height,
+        SDLManager(int width, int height, bool fullscreen);  // Constructor amb configuració
-            bool fullscreen);  // Constructor amb configuració
         ~SDLManager();
 
         // No permetre còpia ni assignació
@@ -27,8 +26,7 @@ class SDLManager {
         void decreaseWindowSize();                       // F1: -100px
         void toggleFullscreen();                         // F3
         void toggleVSync();                              // F4
-        bool
+        bool handleWindowEvent(const SDL_Event& event);  // Per a SDL_EVENT_WINDOW_RESIZED
-        handleWindowEvent(const SDL_Event& event);  // Per a SDL_EVENT_WINDOW_RESIZED
 
         // Funcions principals (renderitzat)
         void neteja(uint8_t r = 0, uint8_t g = 0, uint8_t b = 0);
@@ -42,13 +40,13 @@ class SDLManager {
 
         // Getters
         SDL_Renderer* obte_renderer() { return renderer_; }
-        float getScaleFactor() const { return zoom_factor_; }
+        [[nodiscard]] float getScaleFactor() const { 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)
-        void updateRenderingContext();
+        void updateRenderingContext() const;
 
     private:
         SDL_Window* finestra_;

source/core/rendering/shape_renderer.cpp

@@ -10,28 +10,66 @@
 
 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
+
+    // Pitch (rotació 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
+    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
+    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
+    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) {
+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
     float centered_x = point.x - shape_centre.x;
     float centered_y = point.y - shape_centre.y;
 
-    // 2. Aplicar escala al punt centrat
+    // 2. Aplicar rotació 3D (si es proporciona)
+    if ((rotation_3d != nullptr) && rotation_3d->has_rotation()) {
+        Punt 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 rotació
+    // 4. Aplicar rotació 2D (Z-axis, tradicional)
     // IMPORTANT: En el sistema original, angle=0 apunta AMUNT (no dreta)
     // Per això usem (angle - PI/2) per compensar
     // Però aquí angle ja ve en el sistema correcte del joc
     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_x = (scaled_x * cos_a) - (scaled_y * sin_a);
-    float rotated_y = scaled_x * sin_a + scaled_y * cos_a;
+    float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);
 
-    // 4. Aplicar trasllació a posició mundial
+    // 5. Aplicar trasllació a posició mundial
-    return {rotated_x + posicio.x, rotated_y + posicio.y};
+    return {.x = rotated_x + posicio.x, .y = rotated_y + posicio.y};
 }
 
 void render_shape(SDL_Renderer* renderer,
@@ -41,14 +79,15 @@ void render_shape(SDL_Renderer* renderer,
     float escala,
     bool dibuixar,
     float progress,
-    float brightness) {
+    float brightness,
+    const Rotation3D* rotation_3d) {
     // Verificar que la forma és vàlida
     if (!shape || !shape->es_valida()) {
         return;
     }
 
     // Si progress < 1.0, no dibuixar (tot o res)
-    if (progress < 1.0f) {
+    if (progress < 1.0F) {
         return;
     }
 
@@ -60,16 +99,16 @@ void render_shape(SDL_Renderer* renderer,
         if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
             // POLYLINE: connectar punts consecutius
             for (size_t i = 0; i < primitive.points.size() - 1; i++) {
-                Punt p1 = transform_point(primitive.points[i], shape_centre, posicio, angle, escala);
+                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);
+                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);
+                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);
+                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);
             }

source/core/rendering/shape_renderer.hpp

@@ -12,6 +12,26 @@
 
 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)
+
+        Rotation3D()
+            : pitch(0.0F),
+              yaw(0.0F),
+              roll(0.0F) {}
+        Rotation3D(float p, float y, float r)
+            : pitch(p),
+              yaw(y),
+              roll(r) {}
+
+        [[nodiscard]] bool has_rotation() const {
+            return pitch != 0.0F || yaw != 0.0F || roll != 0.0F;
+        }
+};
+
 // Renderitzar forma amb transformacions
 // - renderer: SDL renderer
 // - shape: forma vectorial a dibuixar
@@ -25,9 +45,10 @@ void render_shape(SDL_Renderer* renderer,
     const std::shared_ptr<Graphics::Shape>& shape,
     const Punt& posicio,
     float angle,
-    float escala = 1.0f,
+    float escala = 1.0F,
     bool dibuixar = true,
-    float progress = 1.0f,
+    float progress = 1.0F,
-    float brightness = 1.0f);
+    float brightness = 1.0F,
+    const Rotation3D* rotation_3d = nullptr);
 
 }  // namespace Rendering

source/core/resources/resource_helper.cpp

@@ -0,0 +1,81 @@
+// resource_helper.cpp - Implementació de funcions d'ajuda
+// © 2025 Port a C++20 amb SDL3
+
+#include "resource_helper.hpp"
+
+#include <algorithm>
+#include <iostream>
+
+#include "resource_loader.hpp"
+
+namespace Resource::Helper {
+
+// Inicialitzar el sistema de recursos
+bool initializeResourceSystem(const std::string& pack_file, bool fallback) {
+    return Loader::get().initialize(pack_file, fallback);
+}
+
+// Carregar un fitxer
+std::vector<uint8_t> loadFile(const std::string& filepath) {
+    // Normalitzar la ruta
+    std::string normalized = normalizePath(filepath);
+
+    // Carregar del sistema de recursos
+    return Loader::get().loadResource(normalized);
+}
+
+// Comprovar si existeix un fitxer
+bool fileExists(const std::string& filepath) {
+    std::string normalized = normalizePath(filepath);
+    return Loader::get().resourceExists(normalized);
+}
+
+// Obtenir ruta normalitzada per al paquet
+// Elimina prefixos "data/", rutes absolutes, etc.
+std::string getPackPath(const std::string& asset_path) {
+    std::string path = asset_path;
+
+    // Eliminar rutes absolutes (detectar / o C:\ al principi)
+    if (!path.empty() && path[0] == '/') {
+        // Buscar "data/" i agafar el que ve després
+        size_t data_pos = path.find("/data/");
+        if (data_pos != std::string::npos) {
+            path = path.substr(data_pos + 6);  // Saltar "/data/"
+        }
+    }
+
+    // Eliminar "./" i "../" del principi
+    while (path.starts_with("./")) {
+        path = path.substr(2);
+    }
+    while (path.starts_with("../")) {
+        path = path.substr(3);
+    }
+
+    // Eliminar "data/" del principi
+    if (path.starts_with("data/")) {
+        path = path.substr(5);
+    }
+
+    // Eliminar "Resources/" (macOS bundles)
+    if (path.starts_with("Resources/")) {
+        path = path.substr(10);
+    }
+
+    // Convertir barres invertides a normals
+    std::ranges::replace(path, '\\', '/');
+
+    return path;
+}
+
+// Normalitzar ruta (alias de getPackPath)
+std::string normalizePath(const std::string& path) {
+    return getPackPath(path);
+}
+
+// Comprovar si hi ha paquet carregat
+bool isPackLoaded() {
+    return Loader::get().isPackLoaded();
+}
+
+}  // namespace Resource::Helper

source/core/resources/resource_helper.hpp

@@ -0,0 +1,27 @@
+// resource_helper.hpp - Funcions d'ajuda per gestió de recursos
+// © 2025 Port a C++20 amb SDL3
+// API simplificada i normalització de rutes
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace Resource::Helper {
+
+// Inicialització del sistema
+bool initializeResourceSystem(const std::string& pack_file, bool fallback);
+
+// Càrrega de fitxers
+std::vector<uint8_t> loadFile(const std::string& filepath);
+bool fileExists(const std::string& filepath);
+
+// Normalització de rutes
+std::string getPackPath(const std::string& asset_path);
+std::string normalizePath(const std::string& path);
+
+// Estat
+bool isPackLoaded();
+
+}  // namespace Resource::Helper

source/core/resources/resource_loader.cpp

@@ -0,0 +1,143 @@
+// resource_loader.cpp - Implementació del carregador de recursos
+// © 2025 Port a C++20 amb SDL3
+
+#include "resource_loader.hpp"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+namespace Resource {
+
+// Singleton
+Loader& Loader::get() {
+    static Loader instance;
+    return instance;
+}
+
+// Inicialitzar el sistema de recursos
+bool Loader::initialize(const std::string& pack_file, bool enable_fallback) {
+    fallback_enabled_ = enable_fallback;
+
+    // Intentar carregar 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";
+            return false;
+        }
+
+        std::cout << "[ResourceLoader] Paquet no trobat, usant fallback al sistema de fitxers\n";
+        pack_.reset();  // No hi ha paquet
+        return true;
+    }
+
+    std::cout << "[ResourceLoader] Paquet carregat: " << pack_file << "\n";
+    return true;
+}
+
+// Carregar un recurs
+std::vector<uint8_t> Loader::loadResource(const std::string& filename) {
+    // Intentar carregar del paquet primer
+    if (pack_) {
+        if (pack_->hasResource(filename)) {
+            auto data = pack_->getResource(filename);
+            if (!data.empty()) {
+                return data;
+            }
+            std::cerr << "[ResourceLoader] Advertència: recurs buit al paquet: " << filename
+                      << "\n";
+        }
+
+        // Si no està al paquet i no hi ha fallback, falla
+        if (!fallback_enabled_) {
+            std::cerr << "[ResourceLoader] ERROR: Recurs no trobat al paquet i fallback desactivat: "
+                      << filename << "\n";
+            return {};
+        }
+    }
+
+    // Fallback al sistema de fitxers
+    if (fallback_enabled_) {
+        return loadFromFilesystem(filename);
+    }
+
+    return {};
+}
+
+// Comprovar si existeix un recurs
+bool Loader::resourceExists(const std::string& filename) {
+    // Comprovar al paquet
+    if (pack_ && pack_->hasResource(filename)) {
+        return true;
+    }
+
+    // Comprovar al sistema de fitxers 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);
+    }
+
+    return false;
+}
+
+// Validar el paquet
+bool Loader::validatePack() {
+    if (!pack_) {
+        std::cerr << "[ResourceLoader] Advertència: no hi ha paquet carregat per validar\n";
+        return false;
+    }
+
+    return pack_->validatePack();
+}
+
+// Comprovar si hi ha paquet carregat
+bool Loader::isPackLoaded() const {
+    return pack_ != nullptr;
+}
+
+// Establir la ruta base
+void Loader::setBasePath(const std::string& path) {
+    base_path_ = path;
+    std::cout << "[ResourceLoader] Ruta base establerta: " << base_path_ << "\n";
+}
+
+// Obtenir la ruta base
+std::string Loader::getBasePath() const {
+    return base_path_;
+}
+
+// Carregar des del sistema de fitxers (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/"
+    std::string fullpath;
+
+    if (base_path_.empty()) {
+        fullpath = "data/" + filename;
+    } else {
+        fullpath = base_path_ + "/data/" + filename;
+    }
+
+    std::ifstream file(fullpath, std::ios::binary | std::ios::ate);
+    if (!file) {
+        std::cerr << "[ResourceLoader] Error: no es pot obrir " << fullpath << "\n";
+        return {};
+    }
+
+    std::streamsize file_size = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> data(file_size);
+    if (!file.read(reinterpret_cast<char*>(data.data()), file_size)) {
+        std::cerr << "[ResourceLoader] Error: no es pot llegir " << fullpath << "\n";
+        return {};
+    }
+
+    std::cout << "[ResourceLoader] Carregat des del sistema de fitxers: " << fullpath << "\n";
+    return data;
+}
+
+}  // namespace Resource

source/core/resources/resource_loader.hpp

@@ -0,0 +1,53 @@
+// 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
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "resource_pack.hpp"
+
+namespace Resource {
+
+// Singleton per gestionar la càrrega de recursos
+class Loader {
+    public:
+        // Singleton
+        static Loader& get();
+
+        // Inicialització
+        bool initialize(const std::string& pack_file, bool enable_fallback);
+
+        // Càrrega de recursos
+        std::vector<uint8_t> loadResource(const std::string& filename);
+        bool resourceExists(const std::string& filename);
+
+        // Validació
+        bool validatePack();
+        [[nodiscard]] bool isPackLoaded() const;
+
+        // Estat
+        void setBasePath(const std::string& path);
+        [[nodiscard]] std::string getBasePath() const;
+
+        // No es pot copiar ni moure
+        Loader(const Loader&) = delete;
+        Loader& operator=(const Loader&) = delete;
+
+    private:
+        Loader() = default;
+        ~Loader() = default;
+
+        // Dades
+        std::unique_ptr<Pack> pack_;
+        bool fallback_enabled_ = false;
+        std::string base_path_;
+
+        // Funcions auxiliars
+        std::vector<uint8_t> loadFromFilesystem(const std::string& filename);
+};
+
+}  // namespace Resource

source/core/resources/resource_pack.cpp

@@ -0,0 +1,309 @@
+// resource_pack.cpp - Implementació del sistema d'empaquetament
+// © 2025 Port a C++20 amb SDL3
+
+#include "resource_pack.hpp"
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+namespace Resource {
+
+// Calcular checksum CRC32 simplificat
+uint32_t Pack::calculateChecksum(const std::vector<uint8_t>& data) const {
+    uint32_t checksum = 0x12345678;
+    for (unsigned char byte : data) {
+        checksum = ((checksum << 5) + checksum) + byte;
+    }
+    return checksum;
+}
+
+// Encriptació XOR (simètrica)
+void Pack::encryptData(std::vector<uint8_t>& data, const std::string& key) {
+    if (key.empty()) {
+        return;
+    }
+    for (size_t i = 0; i < data.size(); ++i) {
+        data[i] ^= key[i % key.length()];
+    }
+}
+
+void Pack::decryptData(std::vector<uint8_t>& data, const std::string& key) {
+    // XOR és simètric
+    encryptData(data, key);
+}
+
+// Llegir fitxer 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) {
+        std::cerr << "[ResourcePack] Error: no es pot obrir " << filepath << '\n';
+        return {};
+    }
+
+    std::streamsize file_size = file.tellg();
+    file.seekg(0, std::ios::beg);
+
+    std::vector<uint8_t> data(file_size);
+    if (!file.read(reinterpret_cast<char*>(data.data()), file_size)) {
+        std::cerr << "[ResourcePack] Error: no es pot llegir " << filepath << '\n';
+        return {};
+    }
+
+    return data;
+}
+
+// Afegir un fitxer individual al paquet
+bool Pack::addFile(const std::string& filepath, const std::string& pack_name) {
+    auto file_data = readFile(filepath);
+    if (file_data.empty()) {
+        return false;
+    }
+
+    ResourceEntry entry{
+        .filename = pack_name,
+        .offset = data_.size(),
+        .size = file_data.size(),
+        .checksum = calculateChecksum(file_data)};
+
+    // Afegir 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()
+              << " bytes)\n";
+    return true;
+}
+
+// Afegir tots els fitxers d'un directori recursivament
+bool Pack::addDirectory(const std::string& dir_path,
+    const std::string& base_path) {
+    namespace fs = std::filesystem;
+
+    if (!fs::exists(dir_path) || !fs::is_directory(dir_path)) {
+        std::cerr << "[ResourcePack] Error: directori no trobat: " << dir_path << '\n';
+        return false;
+    }
+
+    std::string current_base = base_path.empty() ? "" : base_path + "/";
+
+    for (const auto& entry : fs::recursive_directory_iterator(dir_path)) {
+        if (!entry.is_regular_file()) {
+            continue;
+        }
+
+        std::string full_path = entry.path().string();
+        std::string relative_path = entry.path().lexically_relative(dir_path).string();
+
+        // Convertir barres invertides a normals (Windows)
+        std::ranges::replace(relative_path, '\\', '/');
+
+        // Saltar fitxers 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 ||
+            relative_path.find(".git") != std::string::npos) {
+            std::cout << "[ResourcePack] Saltant: " << relative_path << '\n';
+            continue;
+        }
+
+        std::string pack_name = current_base + relative_path;
+        addFile(full_path, pack_name);
+    }
+
+    return true;
+}
+
+// Guardar paquet a disc
+bool Pack::savePack(const std::string& pack_file) {
+    std::ofstream file(pack_file, std::ios::binary);
+    if (!file) {
+        std::cerr << "[ResourcePack] Error: no es pot crear " << pack_file << '\n';
+        return false;
+    }
+
+    // Escriure capçalera
+    file.write(MAGIC_HEADER, 4);
+    file.write(reinterpret_cast<const char*>(&VERSION), sizeof(VERSION));
+
+    // Escriure nombre de recursos
+    auto resource_count = static_cast<uint32_t>(resources_.size());
+    file.write(reinterpret_cast<const char*>(&resource_count), sizeof(resource_count));
+
+    // Escriure metadades de recursos
+    for (const auto& [name, entry] : resources_) {
+        // Nom del fitxer
+        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);
+
+        // Offset, mida, checksum
+        file.write(reinterpret_cast<const char*>(&entry.offset), sizeof(entry.offset));
+        file.write(reinterpret_cast<const char*>(&entry.size), sizeof(entry.size));
+        file.write(reinterpret_cast<const char*>(&entry.checksum), sizeof(entry.checksum));
+    }
+
+    // Encriptar dades
+    std::vector<uint8_t> encrypted_data = data_;
+    encryptData(encrypted_data, DEFAULT_ENCRYPT_KEY);
+
+    // Escriure mida de dades i 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());
+
+    std::cout << "[ResourcePack] Guardat: " << pack_file << " (" << resources_.size()
+              << " recursos, " << data_size << " bytes)\n";
+
+    return true;
+}
+
+// Carregar paquet des de disc
+bool Pack::loadPack(const std::string& pack_file) {
+    std::ifstream file(pack_file, std::ios::binary);
+    if (!file) {
+        std::cerr << "[ResourcePack] Error: no es pot obrir " << pack_file << '\n';
+        return false;
+    }
+
+    // Llegir capçalera
+    char magic[4];
+    file.read(magic, 4);
+    if (std::string(magic, 4) != MAGIC_HEADER) {
+        std::cerr << "[ResourcePack] Error: capçalera invàlida (esperava " << MAGIC_HEADER
+                  << ")\n";
+        return false;
+    }
+
+    uint32_t version;
+    file.read(reinterpret_cast<char*>(&version), sizeof(version));
+    if (version != VERSION) {
+        std::cerr << "[ResourcePack] Error: versió incompatible (esperava " << VERSION
+                  << ", trobat " << version << ")\n";
+        return false;
+    }
+
+    // Llegir nombre de recursos
+    uint32_t resource_count;
+    file.read(reinterpret_cast<char*>(&resource_count), sizeof(resource_count));
+
+    // Llegir metadades de recursos
+    resources_.clear();
+    for (uint32_t i = 0; i < resource_count; ++i) {
+        // Nom del fitxer
+        uint32_t name_len;
+        file.read(reinterpret_cast<char*>(&name_len), sizeof(name_len));
+
+        std::string filename(name_len, '\0');
+        file.read(filename.data(), name_len);
+
+        // Offset, mida, checksum
+        ResourceEntry entry;
+        entry.filename = filename;
+        file.read(reinterpret_cast<char*>(&entry.offset), sizeof(entry.offset));
+        file.read(reinterpret_cast<char*>(&entry.size), sizeof(entry.size));
+        file.read(reinterpret_cast<char*>(&entry.checksum), sizeof(entry.checksum));
+
+        resources_[filename] = entry;
+    }
+
+    // Llegir dades encriptades
+    uint64_t data_size;
+    file.read(reinterpret_cast<char*>(&data_size), sizeof(data_size));
+
+    data_.resize(data_size);
+    file.read(reinterpret_cast<char*>(data_.data()), data_size);
+
+    // Desencriptar
+    decryptData(data_, DEFAULT_ENCRYPT_KEY);
+
+    std::cout << "[ResourcePack] Carregat: " << pack_file << " (" << resources_.size()
+              << " recursos)\n";
+
+    return true;
+}
+
+// Obtenir un recurs del paquet
+std::vector<uint8_t> Pack::getResource(const std::string& filename) {
+    auto it = resources_.find(filename);
+    if (it == resources_.end()) {
+        std::cerr << "[ResourcePack] Error: recurs no trobat: " << filename << '\n';
+        return {};
+    }
+
+    const auto& entry = it->second;
+
+    // Extreure dades
+    if (entry.offset + entry.size > data_.size()) {
+        std::cerr << "[ResourcePack] Error: offset/mida invàlid per " << filename << '\n';
+        return {};
+    }
+
+    std::vector<uint8_t> resource_data(data_.begin() + entry.offset,
+        data_.begin() + entry.offset + entry.size);
+
+    // Verificar checksum
+    uint32_t computed_checksum = calculateChecksum(resource_data);
+    if (computed_checksum != entry.checksum) {
+        std::cerr << "[ResourcePack] ADVERTÈNCIA: checksum invàlid per " << filename
+                  << " (esperat " << entry.checksum << ", calculat " << computed_checksum
+                  << ")\n";
+        // No falla, però adverteix
+    }
+
+    return resource_data;
+}
+
+// Comprovar si existeix un recurs
+bool Pack::hasResource(const std::string& filename) const {
+    return resources_.contains(filename);
+}
+
+// Obtenir llista de tots els recursos
+std::vector<std::string> Pack::getResourceList() const {
+    std::vector<std::string> list;
+    list.reserve(resources_.size());
+
+    for (const auto& [name, entry] : resources_) {
+        list.push_back(name);
+    }
+
+    std::ranges::sort(list);
+    return list;
+}
+
+// Validar integritat del paquet
+bool Pack::validatePack() const {
+    bool valid = true;
+
+    for (const auto& [name, entry] : resources_) {
+        // Verificar offset i mida
+        if (entry.offset + entry.size > data_.size()) {
+            std::cerr << "[ResourcePack] Error de validació: " << name
+                      << " té offset/mida invàlid\n";
+            valid = false;
+            continue;
+        }
+
+        // Extreure i verificar checksum
+        std::vector<uint8_t> resource_data(data_.begin() + entry.offset,
+            data_.begin() + entry.offset + entry.size);
+
+        uint32_t computed_checksum = calculateChecksum(resource_data);
+        if (computed_checksum != entry.checksum) {
+            std::cerr << "[ResourcePack] Error de validació: " << name
+                      << " té checksum invàlid\n";
+            valid = false;
+        }
+    }
+
+    if (valid) {
+        std::cout << "[ResourcePack] Validació OK (" << resources_.size() << " recursos)\n";
+    }
+
+    return valid;
+}
+
+}  // namespace Resource

source/core/resources/resource_pack.hpp

@@ -0,0 +1,67 @@
+// 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
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace Resource {
+
+// Capçalera del fitxer de paquet
+struct PackHeader {
+        char magic[4];     // "ORNI"
+        uint32_t version;  // Versió 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
+        uint64_t size;         // Mida en bytes
+        uint32_t checksum;     // Checksum CRC32 per verificació
+};
+
+// Classe principal per gestionar paquets de recursos
+class Pack {
+    public:
+        Pack() = default;
+        ~Pack() = default;
+
+        // Afegir fitxers 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
+        bool savePack(const std::string& pack_file);
+        bool loadPack(const std::string& pack_file);
+
+        // Accés a recursos
+        std::vector<uint8_t> getResource(const std::string& filename);
+        [[nodiscard]] bool hasResource(const std::string& filename) const;
+        [[nodiscard]] std::vector<std::string> getResourceList() const;
+
+        // Validació
+        [[nodiscard]] bool validatePack() const;
+
+    private:
+        // Constants
+        static constexpr const char* MAGIC_HEADER = "ORNI";
+        static constexpr uint32_t VERSION = 1;
+        static constexpr const char* DEFAULT_ENCRYPT_KEY = "ORNI_RESOURCES_2025";
+
+        // Dades del paquet
+        std::unordered_map<std::string, ResourceEntry> resources_;
+        std::vector<uint8_t> data_;
+
+        // Funcions 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);
+        void decryptData(std::vector<uint8_t>& data, const std::string& key);
+};
+
+}  // namespace Resource

source/core/system/context_escenes.hpp

@@ -0,0 +1,81 @@
+// 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

source/core/system/director.cpp

@@ -7,15 +7,20 @@
 #include <cstdlib>
 #include <iostream>
 
+#include "context_escenes.hpp"
 #include "core/audio/audio.hpp"
 #include "core/audio/audio_cache.hpp"
 #include "core/defaults.hpp"
+#include "core/input/input.hpp"
+#include "core/input/mouse.hpp"
 #include "core/rendering/sdl_manager.hpp"
+#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/options.hpp"
-#include "gestor_escenes.hpp"
 #include "project.h"
 
 #ifndef _WIN32
@@ -23,6 +28,10 @@
 #include <unistd.h>
 #endif
 
+// Using declarations per simplificar el codi
+using GestorEscenes::ContextEscenes;
+using Escena = ContextEscenes::Escena;
+
 // Constructor
 Director::Director(std::vector<std::string> const& args) {
     std::cout << "Orni Attack - Inici\n";
@@ -33,6 +42,44 @@ Director::Director(std::vector<std::string> const& args) {
     // Comprovar arguments del programa
     executable_path_ = checkProgramArguments(args);
 
+    // Inicialitzar sistema de rutes
+    Utils::initializePathSystem(args[0].c_str());
+
+    // Obtenir ruta base dels recursos
+    std::string resource_base = Utils::getResourceBasePath();
+
+    // Inicialitzar sistema de recursos
+#ifdef RELEASE_BUILD
+    // Mode release: paquet obligatori, sense 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::exit(1);
+    }
+
+    // Validar integritat del paquet
+    if (!Resource::Loader::get().validatePack()) {
+        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/
+    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";
+    } else {
+        std::cout << "Sistema de recursos inicialitzat (mode dev, fallback a data/)\n";
+    }
+
+    // Establir ruta base per al fallback
+    Resource::Loader::get().setBasePath(resource_base);
+#endif
+
     // Crear carpetes del sistema
     createSystemFolder("jailgames");
     createSystemFolder(std::string("jailgames/") + Project::NAME);
@@ -43,12 +90,21 @@ Director::Director(std::vector<std::string> const& args) {
     // Carregar o crear configuració
     Options::loadFromFile();
 
+    // Inicialitzar sistema d'input
+    Input::init("data/gamecontrollerdb.txt");
+
+    // Aplicar configuració de controls dels jugadors
+    Input::get()->applyPlayer1BindingsFromOptions();
+    Input::get()->applyPlayer2BindingsFromOptions();
+
     if (Options::console) {
         std::cout << "Configuració carregada\n";
         std::cout << "  Finestra: " << Options::window.width << "×"
                   << Options::window.height << '\n';
         std::cout << "  Física: rotation=" << Options::physics.rotation_speed
                   << " rad/s\n";
+        std::cout << "  Input: " << Input::get()->getNumGamepads()
+                  << " gamepad(s) detectat(s)\n";
     }
 
     std::cout << '\n';
@@ -58,6 +114,9 @@ Director::~Director() {
     // Guardar opcions
     Options::saveToFile();
 
+    // Cleanup input
+    Input::destroy();
+
     // Cleanup audio
     Audio::destroy();
 
@@ -159,33 +218,54 @@ auto Director::run() -> int {
     // Crear gestor SDL amb configuració 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
+    if (!Options::window.fullscreen) {
+        Mouse::forceHide();
+    }
+
     // Inicialitzar sistema d'audio
     Audio::init();
+    Audio::get()->setMusicVolume(1.0);
+    Audio::get()->setSoundVolume(0.4);
 
     // Precachejar música per evitar lag al començar
     AudioCache::getMusic("title.ogg");
+    AudioCache::getMusic("game.ogg");
     if (Options::console) {
         std::cout << "Música precachejada: "
                   << AudioCache::getMusicCacheSize() << " fitxers\n";
     }
 
+    // Crear context d'escenes
+    ContextEscenes context;
+#ifdef _DEBUG
+    context.canviar_escena(Escena::TITOL);
+#else
+    context.canviar_escena(Escena::LOGO);
+#endif
+
     // Bucle principal de gestió d'escenes
-    while (GestorEscenes::actual != GestorEscenes::Escena::EIXIR) {
+    while (context.escena_desti() != Escena::EIXIR) {
-        switch (GestorEscenes::actual) {
+        // Sincronitzar GestorEscenes::actual amb context
-            case GestorEscenes::Escena::LOGO: {
+        // (altres sistemes encara poden llegir GestorEscenes::actual)
-                EscenaLogo logo(sdl);
+        GestorEscenes::actual = context.escena_desti();
+
+        switch (context.escena_desti()) {
+            case Escena::LOGO: {
+                EscenaLogo logo(sdl, context);
                 logo.executar();
                 break;
             }
 
-            case GestorEscenes::Escena::TITOL: {
+            case Escena::TITOL: {
-                EscenaTitol titol(sdl);
+                EscenaTitol titol(sdl, context);
                 titol.executar();
                 break;
             }
 
-            case GestorEscenes::Escena::JOC: {
+            case Escena::JOC: {
-                EscenaJoc joc(sdl);
+                EscenaJoc joc(sdl, context);
                 joc.executar();
                 break;
             }
@@ -195,5 +275,8 @@ auto Director::run() -> int {
         }
     }
 
+    // Sincronitzar final amb GestorEscenes::actual
+    GestorEscenes::actual = Escena::EIXIR;
+
     return 0;
 }

source/core/system/game_config.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdint>
+
+namespace GameConfig {
+
+// Mode de joc
+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
+
+        // Mètodes auxiliars
+
+        // Retorna true si només hi ha un jugador actiu
+        [[nodiscard]] bool es_un_jugador() const {
+            return (jugador1_actiu && !jugador2_actiu) ||
+                (!jugador1_actiu && jugador2_actiu);
+        }
+
+        // Retorna true si hi ha dos jugadors actius
+        [[nodiscard]] bool son_dos_jugadors() const {
+            return jugador1_actiu && jugador2_actiu;
+        }
+
+        // Retorna true si no hi ha cap jugador actiu
+        [[nodiscard]] bool cap_jugador() const {
+            return !jugador1_actiu && !jugador2_actiu;
+        }
+
+        // Compte de jugadors actius (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
+        [[nodiscard]] uint8_t id_unic_jugador() const {
+            if (jugador1_actiu && !jugador2_actiu) {
+                return 0;
+            }
+            if (!jugador1_actiu && jugador2_actiu) {
+                return 1;
+            }
+            return 0;  // Fallback (cal comprovar es_un_jugador() primer)
+        }
+};
+
+}  // namespace GameConfig

source/core/system/gestor_escenes.hpp

@@ -1,17 +0,0 @@
-// gestor_escenes.hpp - Sistema de gestió d'escenes
-// Basat en el patró del projecte "pollo"
-// © 2025 Port a C++20
-
-#pragma once
-
-namespace GestorEscenes {
-enum class Escena {
-    LOGO,   // Pantalla d'inici (2 segons negre)
-    TITOL,  // Pantalla de títol amb menú
-    JOC,    // Joc principal
-    EIXIR   // Sortir del programa
-};
-
-// Variable global inline per gestionar l'escena actual
-inline Escena actual = Escena::LOGO;
-}  // namespace GestorEscenes

source/core/system/global_events.cpp

@@ -3,45 +3,67 @@
 
 #include "global_events.hpp"
 
+#include <iostream>
+
+#include "context_escenes.hpp"
+#include "core/input/input.hpp"
 #include "core/input/mouse.hpp"
 #include "core/rendering/sdl_manager.hpp"
-#include "gestor_escenes.hpp"
+
+// Using declarations per simplificar el codi
+using GestorEscenes::ContextEscenes;
+using Escena = ContextEscenes::Escena;
 
 namespace GlobalEvents {
 
-bool handle(const SDL_Event& event, SDLManager& sdl) {
+bool handle(const SDL_Event& event, SDLManager& sdl, ContextEscenes& context) {
-    // Tecles globals de finestra (F1/F2/F3)
+    // 1. Permitir que Input procese el evento (para hotplug de gamepads)
+    auto event_msg = Input::get()->handleEvent(event);
+    if (!event_msg.empty()) {
+        std::cout << "[Input] " << event_msg << '\n';
+    }
+
+    // 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;
+        return true;
+    }
+
+    // 3. Gestió del ratolí (auto-ocultar)
+    Mouse::handleEvent(event);
+
+    // 4. Procesar acciones globales directamente desde eventos SDL
+    // (NO usar Input::checkAction() para evitar desfase de timing)
     if (event.type == SDL_EVENT_KEY_DOWN) {
-        switch (event.key.key) {
+        switch (event.key.scancode) {
-            case SDLK_F1:
+            case SDL_SCANCODE_F1:
                 sdl.decreaseWindowSize();
                 return true;
-            case SDLK_F2:
+
+            case SDL_SCANCODE_F2:
                 sdl.increaseWindowSize();
                 return true;
-            case SDLK_F3:
+
+            case SDL_SCANCODE_F3:
                 sdl.toggleFullscreen();
                 return true;
-            case SDLK_F4:
+
+            case SDL_SCANCODE_F4:
                 sdl.toggleVSync();
                 return true;
-            case SDLK_ESCAPE:
+
-                GestorEscenes::actual = GestorEscenes::Escena::EIXIR;
+            case SDL_SCANCODE_ESCAPE:
+                context.canviar_escena(Escena::EIXIR);
+                GestorEscenes::actual = Escena::EIXIR;
                 return true;
+
             default:
+                // Tecla no global
                 break;
         }
     }
 
-    // Tancar finestra
-    if (event.type == SDL_EVENT_QUIT) {
-        GestorEscenes::actual = GestorEscenes::Escena::EIXIR;
-        return true;
-    }
-
-    // Gestió del ratolí (auto-ocultar)
-    Mouse::handleEvent(event);
-
     return false;  // Event no processat
 }
 

source/core/system/global_events.hpp

@@ -6,11 +6,14 @@
 
 #include <SDL3/SDL.h>
 
-// Forward declaration
+// Forward declarations
 class SDLManager;
+namespace GestorEscenes {
+class ContextEscenes;
+}
 
 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);
+bool handle(const SDL_Event& event, SDLManager& sdl, GestorEscenes::ContextEscenes& context);
 }  // namespace GlobalEvents

source/core/utils/path_utils.cpp

@@ -0,0 +1,90 @@
+// path_utils.cpp - Implementació de utilitats de rutes
+// © 2025 Port a C++20 amb SDL3
+
+#include "path_utils.hpp"
+
+#include <algorithm>
+#include <filesystem>
+#include <iostream>
+
+namespace Utils {
+
+// Variables globals per guardar argv[0]
+static std::string executable_path_;
+static std::string executable_directory_;
+
+// Inicialitzar el sistema de rutes amb argv[0]
+void initializePathSystem(const char* argv0) {
+    if (argv0 == nullptr) {
+        std::cerr << "[PathUtils] ADVERTÈNCIA: argv[0] és nullptr\n";
+        executable_path_ = "";
+        executable_directory_ = ".";
+        return;
+    }
+
+    executable_path_ = argv0;
+
+    // Extreure el directori
+    std::filesystem::path path(argv0);
+    executable_directory_ = path.parent_path().string();
+
+    if (executable_directory_.empty()) {
+        executable_directory_ = ".";
+    }
+
+    std::cout << "[PathUtils] Executable: " << executable_path_ << "\n";
+    std::cout << "[PathUtils] Directori: " << executable_directory_ << "\n";
+}
+
+// Obtenir el directori de l'executable
+std::string getExecutableDirectory() {
+    if (executable_directory_.empty()) {
+        std::cerr << "[PathUtils] ADVERTÈNCIA: Sistema de rutes no inicialitzat\n";
+        return ".";
+    }
+    return executable_directory_;
+}
+
+// Detectar si estem dins un bundle de macOS
+bool isMacOSBundle() {
+#ifdef MACOS_BUNDLE
+    return true;
+#else
+    // Detecció en temps d'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;
+#endif
+}
+
+// Obtenir la ruta base dels recursos
+std::string getResourceBasePath() {
+    std::string exe_dir = getExecutableDirectory();
+
+    if (isMacOSBundle()) {
+        // Bundle de macOS: recursos a ../Resources des de MacOS/
+        std::cout << "[PathUtils] Detectat bundle de macOS\n";
+        return exe_dir + "/../Resources";
+    }  // Executable normal: recursos al mateix directori
+    return exe_dir;
+}
+
+// Normalitzar ruta (convertir barres, etc.)
+std::string normalizePath(const std::string& path) {
+    std::string normalized = path;
+
+    // Convertir barres invertides a normals
+    std::ranges::replace(normalized, '\\', '/');
+
+    // Simplificar rutes amb filesystem
+    try {
+        std::filesystem::path fs_path(normalized);
+        normalized = fs_path.lexically_normal().string();
+    } catch (const std::exception& e) {
+        std::cerr << "[PathUtils] Error normalitzant ruta: " << e.what() << "\n";
+    }
+
+    return normalized;
+}
+
+}  // namespace Utils

source/core/utils/path_utils.hpp

@@ -0,0 +1,24 @@
+// path_utils.hpp - Utilitats de gestió de rutes
+// © 2025 Port a C++20 amb SDL3
+// Detecció de directoris i bundles multiplataforma
+
+#pragma once
+
+#include <string>
+
+namespace Utils {
+
+// Inicialització amb argv[0]
+void initializePathSystem(const char* argv0);
+
+// Obtenció de rutes
+std::string getExecutableDirectory();
+std::string getResourceBasePath();
+
+// Detecció de plataforma
+bool isMacOSBundle();
+
+// Normalització
+std::string normalizePath(const std::string& path);
+
+}  // namespace Utils

source/external/.clang-tidy

@@ -0,0 +1,4 @@
+# source/external/.clang-tidy
+Checks: '-*'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''

source/game/constants.hpp

@@ -43,7 +43,7 @@ inline void obtenir_limits_zona(float& min_x, float& max_x, float& min_y, float&
 // Obtenir límits segurs (compensant radi de l'entitat)
 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
+    constexpr float MARGE_SEGURETAT = 10.0F;  // Safety margin
 
     min_x = zona.x + radi + MARGE_SEGURETAT;
     max_x = zona.x + zona.w - radi - MARGE_SEGURETAT;
@@ -54,7 +54,7 @@ inline void obtenir_limits_zona_segurs(float radi, float& min_x, float& max_x, f
 // Obtenir centre de l'àrea de joc
 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;
+    centre_x = zona.x + (zona.w / 2.0F);
-    centre_y = zona.y + zona.h / 2.0f;
+    centre_y = zona.y + (zona.h / 2.0F);
 }
 }  // namespace Constants

source/game/effects/debris.hpp

@@ -19,7 +19,8 @@ struct Debris {
 
         // Rotació
         float angle_rotacio;         // Angle de rotació acumulat (radians)
-        float velocitat_rot;  // Velocitat de rotació en rad/s
+        float velocitat_rot;         // Velocitat de rotació de TRAYECTORIA (rad/s)
+        float velocitat_rot_visual;  // Velocitat de rotació VISUAL del segment (rad/s)
 
         // Estat de vida
         float temps_vida;  // Temps transcorregut (segons)
@@ -28,6 +29,9 @@ struct Debris {
 
         // Shrinking (reducció de distància entre punts)
         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)
 };
 
 }  // namespace Effects

source/game/effects/debris_manager.cpp

@@ -3,6 +3,7 @@
 
 #include "debris_manager.hpp"
 
+#include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <iostream>
@@ -28,11 +29,11 @@ static Punt transform_point(const Punt& point, const Punt& shape_centre, const P
     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_x = (scaled_x * cos_a) - (scaled_y * sin_a);
-    float rotated_y = scaled_x * sin_a + scaled_y * cos_a;
+    float rotated_y = (scaled_x * sin_a) + (scaled_y * cos_a);
 
     // 4. Aplicar trasllació a posició mundial
-    return {rotated_x + posicio.x, rotated_y + posicio.y};
+    return {.x = rotated_x + posicio.x, .y = rotated_y + posicio.y};
 }
 
 DebrisManager::DebrisManager(SDL_Renderer* renderer)
@@ -47,13 +48,18 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
     const Punt& centre,
     float angle,
     float escala,
-    float velocitat_base) {
+    float velocitat_base,
+    float brightness,
+    const Punt& velocitat_objecte,
+    float velocitat_angular,
+    float factor_herencia_visual,
+    const std::string& sound) {
     if (!shape || !shape->es_valida()) {
         return;
     }
 
     // Reproducir sonido de explosión
-    Audio::get()->playSound(Defaults::Sound::EXPLOSION, Audio::Group::GAME);
+    Audio::get()->playSound(sound, Audio::Group::GAME);
 
     // Obtenir centre de la forma per a transformacions
     const Punt& shape_centre = shape->get_centre();
@@ -66,12 +72,12 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
         if (primitive.type == Graphics::PrimitiveType::POLYLINE) {
             // Polyline: extreure segments consecutius
             for (size_t i = 0; i < primitive.points.size() - 1; i++) {
-                segments.push_back({primitive.points[i], primitive.points[i + 1]});
+                segments.emplace_back(primitive.points[i], primitive.points[i + 1]);
             }
         } else {  // PrimitiveType::LINE
             // Line: un únic segment
             if (primitive.points.size() >= 2) {
-                segments.push_back({primitive.points[0], primitive.points[1]});
+                segments.emplace_back(primitive.points[0], primitive.points[1]);
             }
         }
 
@@ -85,7 +91,7 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
 
             // 2. Trobar slot lliure
             Debris* debris = trobar_slot_lliure();
-            if (!debris) {
+            if (debris == nullptr) {
                 std::cerr << "[DebrisManager] Warning: no debris slots disponibles\n";
                 return;  // Pool ple
             }
@@ -94,39 +100,105 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
             debris->p1 = world_p1;
             debris->p2 = world_p2;
 
-            // 4. Calcular direcció perpendicular
+            // 4. Calcular direcció d'explosió (radial, des del centre cap a fora)
-            Punt direccio = calcular_direccio_perpendicular(world_p1, world_p2);
+            Punt direccio = calcular_direccio_explosio(world_p1, world_p2, centre);
 
-            // 5. Velocitat inicial (base ± variació aleatòria)
+            // 5. Velocitat inicial (base ± variació aleatòria + velocitat heretada)
             float speed =
                 velocitat_base +
-                ((std::rand() / static_cast<float>(RAND_MAX)) * 2.0f - 1.0f) *
+                (((std::rand() / static_cast<float>(RAND_MAX)) * 2.0F - 1.0F) *
-                    Defaults::Physics::Debris::VARIACIO_VELOCITAT;
+                    Defaults::Physics::Debris::VARIACIO_VELOCITAT);
 
-            debris->velocitat.x = direccio.x * speed;
+            // Heredar velocitat de l'objecte original (suma vectorial)
-            debris->velocitat.y = direccio.y * speed;
+            debris->velocitat.x = (direccio.x * speed) + velocitat_objecte.x;
+            debris->velocitat.y = (direccio.y * speed) + velocitat_objecte.y;
             debris->acceleracio = Defaults::Physics::Debris::ACCELERACIO;
 
-            // 6. Rotació lenta aleatòria
+            // 6. Herència de velocitat angular amb cap + conversió d'excés
-            debris->velocitat_rot =
+
+            // 6a. Rotació de TRAYECTORIA amb cap + conversió tangencial
+            if (std::abs(velocitat_angular) > 0.01F) {
+                // FASE 1: Aplicar herència i variació (igual que abans)
+                float factor_herencia =
+                    Defaults::Physics::Debris::FACTOR_HERENCIA_MIN +
+                    ((std::rand() / static_cast<float>(RAND_MAX)) *
+                        (Defaults::Physics::Debris::FACTOR_HERENCIA_MAX -
+                            Defaults::Physics::Debris::FACTOR_HERENCIA_MIN));
+
+                float velocitat_ang_heretada = velocitat_angular * factor_herencia;
+
+                float variacio =
+                    ((std::rand() / static_cast<float>(RAND_MAX)) * 0.2F) - 0.1F;
+                velocitat_ang_heretada *= (1.0F + variacio);
+
+                // FASE 2: Aplicar cap 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
+                    float excess = abs_ang - CAP;
+
+                    // Radi de la forma (enemics = 20 px)
+                    float radius = 20.0F;
+
+                    // Velocitat tangencial = ω_excés × radi
+                    float v_tangential = excess * radius;
+
+                    // Direcció tangencial: perpendicular a la radial (90° CCW)
+                    // Si direccio = (dx, dy), tangent = (-dy, dx)
+                    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;
+
+                    // Aplicar cap a velocitat angular (preservar signe)
+                    debris->velocitat_rot = sign_ang * CAP;
+                } else {
+                    // Per sota del cap: 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)
+            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
+                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)
+                debris->velocitat_rot_visual =
                     Defaults::Physics::Debris::ROTACIO_MIN +
-                (std::rand() / static_cast<float>(RAND_MAX)) *
+                    ((std::rand() / static_cast<float>(RAND_MAX)) *
                         (Defaults::Physics::Debris::ROTACIO_MAX -
-                        Defaults::Physics::Debris::ROTACIO_MIN);
+                            Defaults::Physics::Debris::ROTACIO_MIN));
 
                 // 50% probabilitat de rotació en sentit contrari
                 if (std::rand() % 2 == 0) {
-                debris->velocitat_rot = -debris->velocitat_rot;
+                    debris->velocitat_rot_visual = -debris->velocitat_rot_visual;
+                }
             }
 
-            debris->angle_rotacio = 0.0f;
+            debris->angle_rotacio = 0.0F;
 
             // 7. Configurar vida i shrinking
-            debris->temps_vida = 0.0f;
+            debris->temps_vida = 0.0F;
             debris->temps_max = Defaults::Physics::Debris::TEMPS_VIDA;
             debris->factor_shrink = Defaults::Physics::Debris::SHRINK_RATE;
 
-            // 8. Activar
+            // 8. Heredar brightness
+            debris->brightness = brightness;
+
+            // 9. Activar
             debris->actiu = true;
         }
     }
@@ -134,8 +206,9 @@ void DebrisManager::explotar(const std::shared_ptr<Graphics::Shape>& shape,
 
 void DebrisManager::actualitzar(float delta_time) {
     for (auto& debris : debris_pool_) {
-        if (!debris.actiu)
+        if (!debris.actiu) {
             continue;
+        }
 
         // 1. Actualitzar temps de vida
         debris.temps_vida += delta_time;
@@ -148,66 +221,101 @@ void DebrisManager::actualitzar(float delta_time) {
 
         // 2. Actualitzar velocitat (desacceleració)
         // Aplicar fricció en la direcció del moviment
-        float speed = std::sqrt(debris.velocitat.x * debris.velocitat.x +
+        float speed = std::sqrt((debris.velocitat.x * debris.velocitat.x) +
-            debris.velocitat.y * debris.velocitat.y);
+            (debris.velocitat.y * debris.velocitat.y));
 
-        if (speed > 1.0f) {
+        if (speed > 1.0F) {
             // Calcular direcció normalitzada
             float dir_x = debris.velocitat.x / speed;
             float dir_y = debris.velocitat.y / speed;
 
             // Aplicar acceleració negativa (fricció)
-            float nova_speed = speed + debris.acceleracio * delta_time;
+            float nova_speed = speed + (debris.acceleracio * delta_time);
-            if (nova_speed < 0.0f)
+            nova_speed = std::max(nova_speed, 0.0F);
-                nova_speed = 0.0f;
 
             debris.velocitat.x = dir_x * nova_speed;
             debris.velocitat.y = dir_y * nova_speed;
         } else {
             // Velocitat molt baixa, aturar
-            debris.velocitat.x = 0.0f;
+            debris.velocitat.x = 0.0F;
-            debris.velocitat.y = 0.0f;
+            debris.velocitat.y = 0.0F;
+        }
+
+        // 2b. Rotar vector de velocitat (trayectoria curva)
+        if (std::abs(debris.velocitat_rot) > 0.01F) {
+            // Calcular angle de rotació aquest 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;
+
+            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);
+        }
+
+        // 2c. Aplicar fricció angular (desacceleració gradual)
+        if (std::abs(debris.velocitat_rot) > 0.01F) {
+            float sign = (debris.velocitat_rot > 0) ? 1.0F : -1.0F;
+            float reduccion =
+                Defaults::Physics::Debris::FRICCIO_ANGULAR * delta_time;
+            debris.velocitat_rot -= sign * reduccion;
+
+            // Evitar canvi de signe (no pot passar de CW a CCW)
+            if ((debris.velocitat_rot > 0) != (sign > 0)) {
+                debris.velocitat_rot = 0.0F;
+            }
         }
 
         // 3. Calcular centre del segment
-        Punt centre = {(debris.p1.x + debris.p2.x) / 2.0f,
+        Punt centre = {.x = (debris.p1.x + debris.p2.x) / 2.0F,
-            (debris.p1.y + debris.p2.y) / 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;
 
-        // 5. Actualitzar rotació
+        // 5. Actualitzar rotació VISUAL
-        debris.angle_rotacio += debris.velocitat_rot * delta_time;
+        debris.angle_rotacio += debris.velocitat_rot_visual * delta_time;
 
         // 6. Aplicar shrinking (reducció de distància entre punts)
         float shrink_factor =
-            1.0f - (debris.factor_shrink * debris.temps_vida / debris.temps_max);
+            1.0F - (debris.factor_shrink * debris.temps_vida / debris.temps_max);
-        shrink_factor = std::max(0.0f, shrink_factor);  // No negatiu
+        shrink_factor = std::max(0.0F, shrink_factor);  // No negatiu
 
         // Calcular distància original entre punts
         float dx = debris.p2.x - debris.p1.x;
         float dy = debris.p2.y - debris.p1.y;
 
         // 7. Reconstruir segment amb nova mida i rotació
-        float half_length = std::sqrt(dx * dx + dy * dy) * shrink_factor / 2.0f;
+        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.x = centre.x - (half_length * std::cos(new_angle));
-        debris.p1.y = centre.y - half_length * std::sin(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.x = centre.x + (half_length * std::cos(new_angle));
-        debris.p2.y = centre.y + half_length * std::sin(new_angle);
+        debris.p2.y = centre.y + (half_length * std::sin(new_angle));
     }
 }
 
 void DebrisManager::dibuixar() const {
     for (const auto& debris : debris_pool_) {
-        if (!debris.actiu)
+        if (!debris.actiu) {
             continue;
+        }
 
-        // Dibuixar segment de línia
+        // Dibuixar segment de línia amb brightness heretat
-        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);
+        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);
     }
 }
 
@@ -220,46 +328,41 @@ Debris* DebrisManager::trobar_slot_lliure() {
     return nullptr;  // Pool ple
 }
 
-Punt DebrisManager::calcular_direccio_perpendicular(const Punt& p1,
+Punt DebrisManager::calcular_direccio_explosio(const Punt& p1,
-    const Punt& p2) const {
+    const Punt& p2,
-    // 1. Calcular vector de la línia (p1 → p2)
+    const Punt& centre_objecte) const {
-    float dx = p2.x - p1.x;
+    // 1. Calcular centre del segment
-    float dy = p2.y - p1.y;
+    float centro_seg_x = (p1.x + p2.x) / 2.0F;
+    float centro_seg_y = (p1.y + p2.y) / 2.0F;
 
-    // 2. Normalitzar (obtenir vector unitari)
+    // 2. Calcular vector des del centre de l'objecte cap al centre del segment
-    float length = std::sqrt(dx * dx + dy * dy);
+    // Això garanteix que la direcció sempre apunte cap a fora (direcció radial)
-    if (length < 0.001f) {
+    float dx = centro_seg_x - centre_objecte.x;
-        // Línia degenerada, retornar direcció aleatòria
+    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
         float angle_rand =
-            (std::rand() / static_cast<float>(RAND_MAX)) * 2.0f * Defaults::Math::PI;
+            (std::rand() / static_cast<float>(RAND_MAX)) * 2.0F * Defaults::Math::PI;
-        return {std::cos(angle_rand), std::sin(angle_rand)};
+        return {.x = std::cos(angle_rand), .y = std::sin(angle_rand)};
     }
 
     dx /= length;
     dy /= length;
 
-    // 3. Rotar 90° (perpendicular)
+    // 4. Afegir variació aleatòria petita (±15°) per varietat visual
-    // Rotació 90° sentit antihorari: (x,y) → (-y, x)
-    float perp_x = -dy;
-    float perp_y = dx;
-
-    // 4. Afegir variació aleatòria petita (±15°)
     float angle_variacio =
-        ((std::rand() % 30) - 15) * Defaults::Math::PI / 180.0f;
+        ((std::rand() % 30) - 15) * Defaults::Math::PI / 180.0F;
 
     float cos_v = std::cos(angle_variacio);
     float sin_v = std::sin(angle_variacio);
 
-    float final_x = perp_x * cos_v - perp_y * sin_v;
+    float final_x = (dx * cos_v) - (dy * sin_v);
-    float final_y = perp_x * sin_v + perp_y * cos_v;
+    float final_y = (dx * sin_v) + (dy * cos_v);
 
-    // 5. Afegir ± direcció aleatòria (50% probabilitat d'invertir)
+    return {.x = final_x, .y = final_y};
-    if (std::rand() % 2 == 0) {
-        final_x = -final_x;
-        final_y = -final_y;
-    }
-
-    return {final_x, final_y};
 }
 
 void DebrisManager::reiniciar() {
@@ -271,9 +374,10 @@ void DebrisManager::reiniciar() {
 int DebrisManager::get_num_actius() const {
     int count = 0;
     for (const auto& debris : debris_pool_) {
-        if (debris.actiu)
+        if (debris.actiu) {
             count++;
         }
+    }
     return count;
 }
 

source/game/effects/debris_manager.hpp

@@ -25,11 +25,20 @@ class DebrisManager {
         // - 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,
             float angle,
             float escala,
-            float velocitat_base);
+            float velocitat_base,
+            float brightness = 1.0F,
+            const Punt& 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);
 
         // Actualitzar tots els fragments actius
         void actualitzar(float delta_time);
@@ -41,7 +50,7 @@ class DebrisManager {
         void reiniciar();
 
         // Obtenir número de fragments actius
-        int get_num_actius() const;
+        [[nodiscard]] int get_num_actius() const;
 
     private:
         SDL_Renderer* renderer_;
@@ -50,14 +59,14 @@ class DebrisManager {
         // 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
         // Arrodonit a 100 per seguretat
-        static constexpr int MAX_DEBRIS = 100;
+        static constexpr int MAX_DEBRIS = 150;
         std::array<Debris, MAX_DEBRIS> debris_pool_;
 
         // Trobar primer slot inactiu
         Debris* trobar_slot_lliure();
 
-        // Calcular direcció perpendicular a un segment
+        // Calcular direcció d'explosió (radial, des del centre cap al segment)
-        Punt calcular_direccio_perpendicular(const Punt& p1, const Punt& p2) const;
+        [[nodiscard]] Punt calcular_direccio_explosio(const Punt& p1, const Punt& p2, const Punt& centre_objecte) const;
 };
 
 }  // namespace Effects

source/game/effects/gestor_puntuacio_flotant.cpp

@@ -0,0 +1,99 @@
+// 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

source/game/effects/gestor_puntuacio_flotant.hpp

@@ -0,0 +1,53 @@
+// 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

source/game/effects/puntuacio_flotant.hpp

@@ -0,0 +1,33 @@
+// 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

source/game/entities/bala.cpp

@@ -4,39 +4,46 @@
 
 #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)
-    : renderer_(renderer),
+    : Entitat(renderer),
-      centre_({0.0f, 0.0f}),
+      velocitat_(0.0F),
-      angle_(0.0f),
-      velocitat_(0.0f),
       esta_(false),
-      brightness_(Defaults::Brightness::BALA) {
+      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" << std::endl;
+        std::cerr << "[Bala] Error: no s'ha pogut carregar bullet.shp" << '\n';
     }
 }
 
 void Bala::inicialitzar() {
     // Inicialment inactiva
     esta_ = false;
-    centre_ = {0.0f, 0.0f};
+    centre_ = {.x = 0.0F, .y = 0.0F};
-    angle_ = 0.0f;
+    angle_ = 0.0F;
-    velocitat_ = 0.0f;
+    velocitat_ = 0.0F;
+    grace_timer_ = 0.0F;
 }
 
-void Bala::disparar(const Punt& posicio, float angle) {
+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
 
@@ -50,9 +57,15 @@ void Bala::disparar(const Punt& posicio, float angle) {
     // 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;
+    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);
@@ -60,6 +73,12 @@ void Bala::disparar(const Punt& posicio, float angle) {
 
 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);
     }
 }
@@ -67,8 +86,8 @@ void Bala::actualitzar(float delta_time) {
 void Bala::dibuixar() const {
     if (esta_ && forma_) {
         // [NUEVO] Usar render_shape en lloc de rota_pol
-        // Les bales no roten visualment (angle sempre 0.0f)
+        // Les bales roten segons l'angle de trajectòria
-        Rendering::render_shape(renderer_, forma_, centre_, 0.0f, 1.0f, true, 1.0f, brightness_);
+        Rendering::render_shape(renderer_, forma_, centre_, angle_, 1.0F, true, 1.0F, brightness_);
     }
 }
 
@@ -82,8 +101,8 @@ void Bala::mou(float 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 dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(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;
@@ -91,7 +110,10 @@ void Bala::mou(float delta_time) {
 
     // 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, max_x, min_y, max_y;
+    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,

source/game/entities/bala.hpp

@@ -5,39 +5,46 @@
 #pragma once
 #include <SDL3/SDL.h>
 
-#include <memory>
+#include <cstdint>
 
-#include "core/graphics/shape.hpp"
+#include "core/defaults.hpp"
+#include "core/entities/entitat.hpp"
 #include "core/types.hpp"
 
-class Bala {
+class Bala : public Entities::Entitat {
     public:
         Bala()
-            : renderer_(nullptr) {}
+            : Entitat(nullptr) {}
         Bala(SDL_Renderer* renderer);
 
-        void inicialitzar();
+        void inicialitzar() override;
-        void disparar(const Punt& posicio, float angle);
+        void disparar(const Punt& posicio, float angle, uint8_t owner_id);
-        void actualitzar(float delta_time);
+        void actualitzar(float delta_time) override;
-        void dibuixar() const;
+        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)
-        bool esta_activa() const { return esta_; }
+        [[nodiscard]] bool esta_activa() const { return esta_; }
-        const Punt& get_centre() const { return centre_; }
+        [[nodiscard]] uint8_t get_owner_id() const { return owner_id_; }
+        [[nodiscard]] float get_grace_timer() const { return grace_timer_; }
         void desactivar() { esta_ = false; }
 
     private:
-        SDL_Renderer* renderer_;
+        // Membres específics de Bala (heretats: renderer_, forma_, centre_, angle_, brightness_)
-
-        // [NUEVO] Forma vectorial (compartida entre totes les bales)
-        std::shared_ptr<Graphics::Shape> forma_;
-
-        // [NUEVO] Estat de la instància (separat de la geometria)
-        Punt centre_;
-        float angle_;
         float velocitat_;
         bool esta_;
-        float brightness_;  // Factor de brillantor (0.0-1.0)
+        uint8_t owner_id_;   // 0=P1, 1=P2
+        float grace_timer_;  // Grace period timer (0.0 = vulnerable)
 
         void mou(float delta_time);
 };

source/game/entities/enemic.cpp

@@ -4,38 +4,44 @@
 
 #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)
-    : renderer_(renderer),
+    : Entitat(renderer),
-      centre_({0.0f, 0.0f}),
+      velocitat_(0.0F),
-      angle_(0.0f),
+      drotacio_(0.0F),
-      velocitat_(0.0f),
+      rotacio_(0.0F),
-      drotacio_(0.0f),
-      rotacio_(0.0f),
       esta_(false),
-      brightness_(Defaults::Brightness::ENEMIC),
       tipus_(TipusEnemic::PENTAGON),
-      tracking_timer_(0.0f),
+      tracking_timer_(0.0F),
-      ship_position_(nullptr) {
+      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) {
+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, drotacio_max;
+    float drotacio_min;
+    float drotacio_max;
 
     switch (tipus_) {
         case TipusEnemic::PENTAGON:
@@ -50,7 +56,7 @@ void Enemic::inicialitzar(TipusEnemic tipus) {
             velocitat_ = Defaults::Enemies::Quadrat::VELOCITAT;
             drotacio_min = Defaults::Enemies::Quadrat::DROTACIO_MIN;
             drotacio_max = Defaults::Enemies::Quadrat::DROTACIO_MAX;
-            tracking_timer_ = 0.0f;
+            tracking_timer_ = 0.0F;
             break;
 
         case TipusEnemic::MOLINILLO:
@@ -59,40 +65,86 @@ void Enemic::inicialitzar(TipusEnemic tipus) {
             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 << std::endl;
+        std::cerr << "[Enemic] Error: no s'ha pogut carregar " << shape_file << '\n';
     }
 
-    // Posició aleatòria dins de l'àrea de joc
+    // [MODIFIED] Posició aleatòria amb comprovació de seguretat
-    float min_x, max_x, min_y, max_y;
+    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;
+    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;
+    drotacio_ = drotacio_min + ((static_cast<float>(std::rand()) / RAND_MAX) * drotacio_range);
-    rotacio_ = 0.0f;
+    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
+    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;
@@ -100,6 +152,22 @@ void Enemic::inicialitzar(TipusEnemic tipus) {
 
 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);
 
@@ -113,9 +181,11 @@ void Enemic::actualitzar(float delta_time) {
 
 void Enemic::dibuixar() const {
     if (esta_ && forma_) {
-        // [NUEVO] Usar render_shape amb escala animada
+        // Calculate animated scale (includes invulnerability LERP)
         float escala = calcular_escala_actual();
-        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, escala, true, 1.0f, brightness_);
+
+        // brightness_ is already updated in actualitzar()
+        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, escala, true, 1.0F, brightness_);
     }
 }
 
@@ -131,6 +201,10 @@ void Enemic::mou(float delta_time) {
         case TipusEnemic::MOLINILLO:
             comportament_molinillo(delta_time);
             break;
+        default:
+            // Fallback: comportament bàsic (Pentagon)
+            comportament_pentagon(delta_time);
+            break;
     }
 }
 
@@ -141,14 +215,17 @@ void Enemic::comportament_pentagon(float 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 dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(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, max_x, min_y, max_y;
+    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,
@@ -186,36 +263,43 @@ void Enemic::comportament_quadrat(float delta_time) {
 
     // Periodically update angle toward ship
     if (tracking_timer_ >= Defaults::Enemies::Quadrat::TRACKING_INTERVAL) {
-        tracking_timer_ = 0.0f;
+        tracking_timer_ = 0.0F;
 
-        if (ship_position_) {
+        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;
+            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) {
-            while (angle_diff < -Constants::PI) angle_diff += 2.0f * Constants::PI;
+                angle_diff -= 2.0F * Constants::PI;
+            }
+            while (angle_diff < -Constants::PI) {
+                angle_diff += 2.0F * Constants::PI;
+            }
 
-            // Apply tracking strength
+            // Apply tracking strength (uses member variable, defaults to 0.5)
-            angle_ += angle_diff * Defaults::Enemies::Quadrat::TRACKING_STRENGTH;
+            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 dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(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, max_x, min_y, max_y;
+    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,
@@ -240,10 +324,10 @@ 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_) {
+    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);
+        float distance = std::sqrt((dx * dx) + (dy * dy));
 
         if (distance < Defaults::Enemies::Molinillo::PROXIMITY_DISTANCE) {
             // Temporarily boost rotation speed when near ship
@@ -257,14 +341,17 @@ void Enemic::comportament_molinillo(float delta_time) {
 
     // Fast straight-line movement
     float velocitat_efectiva = velocitat_ * delta_time;
-    float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
+    float dy = velocitat_efectiva * std::sin(angle_ - (Constants::PI / 2.0F));
-    float dx = velocitat_efectiva * std::cos(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, max_x, min_y, max_y;
+    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,
@@ -301,13 +388,13 @@ void Enemic::actualitzar_animacio(float 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;
+        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) {
+        if (animacio_.palpitacio_temps_restant <= 0.0F) {
             animacio_.palpitacio_activa = false;
         }
     } else {
@@ -318,45 +405,45 @@ void Enemic::actualitzar_palpitacio(float delta_time) {
         if (rand_val < trigger_prob) {
             // Activate palpitation
             animacio_.palpitacio_activa = true;
-            animacio_.palpitacio_fase = 0.0f;
+            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;
+                ((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;
+                ((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;
+                ((static_cast<float>(std::rand()) / RAND_MAX) * dur_range);
         }
     }
 }
 
 void Enemic::actualitzar_rotacio_accelerada(float delta_time) {
-    if (animacio_.drotacio_t < 1.0f) {
+    if (animacio_.drotacio_t < 1.0F) {
         // Transitioning to new target
         animacio_.drotacio_t += delta_time / animacio_.drotacio_duracio;
 
-        if (animacio_.drotacio_t >= 1.0f) {
+        if (animacio_.drotacio_t >= 1.0F) {
-            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);
+            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;
+            drotacio_ = initial + ((target - initial) * smooth_t);
         }
     } else {
         // Random trigger for new acceleration
@@ -365,13 +452,13 @@ void Enemic::actualitzar_rotacio_accelerada(float delta_time) {
 
         if (rand_val < trigger_prob) {
             // Start new transition
-            animacio_.drotacio_t = 0.0f;
+            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;
+                ((static_cast<float>(std::rand()) / RAND_MAX) * mult_range);
 
             animacio_.drotacio_objetivo = animacio_.drotacio_base * multiplier;
 
@@ -379,18 +466,86 @@ void Enemic::actualitzar_rotacio_accelerada(float delta_time) {
             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;
+                ((static_cast<float>(std::rand()) / RAND_MAX) * dur_range);
         }
     }
 }
 
 float Enemic::calcular_escala_actual() const {
-    float escala = 1.0f;
+    float escala = 1.0F;
 
-    if (animacio_.palpitacio_activa) {
+    // [NEW] Invulnerability LERP prioritza sobre palpitació
-        // Add pulsating scale variation
+    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;
+}

source/game/entities/enemic.hpp

@@ -5,10 +5,13 @@
 #pragma once
 #include <SDL3/SDL.h>
 
-#include <memory>
+#include <cmath>
+#include <cstdint>
 
-#include "core/graphics/shape.hpp"
+#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 {
@@ -21,51 +24,75 @@ enum class TipusEnemic : uint8_t {
 struct AnimacioEnemic {
         // Palpitation (breathing effect)
         bool palpitacio_activa = false;
-        float palpitacio_fase = 0.0f;           // Phase in cycle (0.0-2π)
+        float palpitacio_fase = 0.0F;           // Phase in cycle (0.0-2π)
-        float palpitacio_frequencia = 2.0f;     // Hz (cycles per second)
+        float palpitacio_frequencia = 2.0F;     // Hz (cycles per second)
-        float palpitacio_amplitud = 0.15f;      // Scale variation (±15%)
+        float palpitacio_amplitud = 0.15F;      // Scale variation (±15%)
-        float palpitacio_temps_restant = 0.0f;  // Time remaining (seconds)
+        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_base = 0.0F;      // Base rotation speed (rad/s)
-        float drotacio_objetivo = 0.0f;  // Target 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_t = 0.0F;         // Interpolation progress (0.0-1.0)
-        float drotacio_duracio = 0.0f;   // Duration of transition (seconds)
+        float drotacio_duracio = 0.0F;   // Duration of transition (seconds)
 };
 
-class Enemic {
+class Enemic : public Entities::Entitat {
     public:
         Enemic()
-            : renderer_(nullptr) {}
+            : Entitat(nullptr) {}
         Enemic(SDL_Renderer* renderer);
 
-        void inicialitzar(TipusEnemic tipus = TipusEnemic::PENTAGON);
+        void inicialitzar() override { inicialitzar(TipusEnemic::PENTAGON, nullptr); }
-        void actualitzar(float delta_time);
+        void inicialitzar(TipusEnemic tipus, const Punt* ship_pos = nullptr);
-        void dibuixar() const;
+        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)
-        bool esta_actiu() const { return esta_; }
-        const Punt& get_centre() const { return centre_; }
-        const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
         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:
-        SDL_Renderer* renderer_;
+        // Membres específics d'Enemic (heretats: renderer_, forma_, centre_, angle_, brightness_)
-
-        // [NUEVO] Forma vectorial (compartida entre tots els enemics)
-        std::shared_ptr<Graphics::Shape> forma_;
-
-        // [NUEVO] Estat de la instància (separat de la geometria)
-        Punt centre_;
-        float angle_;  // Angle de moviment
         float velocitat_;
         float drotacio_;  // Delta rotació visual (rad/s)
         float rotacio_;   // Rotació visual acumulada
         bool esta_;
-        float brightness_;  // Factor de brillantor (0.0-1.0)
 
         // [NEW] Enemy type and configuration
         TipusEnemic tipus_;
@@ -76,6 +103,10 @@ class Enemic {
         // [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);
@@ -87,5 +118,6 @@ class Enemic {
         void comportament_pentagon(float delta_time);
         void comportament_quadrat(float delta_time);
         void comportament_molinillo(float delta_time);
-        float calcular_escala_actual() const;  // Returns scale with palpitation applied
+        [[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);
 };

source/game/entities/nau.cpp

@@ -6,30 +6,37 @@
 
 #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)
+Nau::Nau(SDL_Renderer* renderer, const char* shape_file)
-    : renderer_(renderer),
+    : Entitat(renderer),
-      centre_({0.0f, 0.0f}),
+      velocitat_(0.0F),
-      angle_(0.0f),
-      velocitat_(0.0f),
       esta_tocada_(false),
-      brightness_(Defaults::Brightness::NAU) {
+      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("ship.shp");
+    forma_ = Graphics::ShapeLoader::load(shape_file);
 
     if (!forma_ || !forma_->es_valida()) {
-        std::cerr << "[Nau] Error: no s'ha pogut carregar ship.shp" << std::endl;
+        std::cerr << "[Nau] Error: no s'ha pogut carregar " << shape_file << '\n';
     }
 }
 
-void Nau::inicialitzar(const Punt* spawn_point) {
+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
@@ -38,48 +45,73 @@ void Nau::inicialitzar(const Punt* spawn_point) {
     // fitxer Només inicialitzem l'estat de la instància
 
     // Use custom spawn point if provided, otherwise use center
-    if (spawn_point) {
+    if (spawn_point != nullptr) {
         centre_.x = spawn_point->x;
         centre_.y = spawn_point->y;
     } else {
         // Default: center of play area
-        float centre_x, centre_y;
+        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;
+    angle_ = 0.0F;
-    velocitat_ = 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) {
+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_)
+    if (esta_tocada_) {
         return;
+    }
 
-    // Obtenir estat actual del teclat (no events, sinó estat continu)
+    auto* input = Input::get();
-    const bool* keyboard_state = SDL_GetKeyboardState(nullptr);
 
-    // Rotació
+    // Processar input segons el jugador
-    if (keyboard_state[SDL_SCANCODE_RIGHT]) {
+    if (player_id == 0) {
+        // Jugador 1
+        if (input->checkActionPlayer1(InputAction::RIGHT, Input::ALLOW_REPEAT)) {
             angle_ += Defaults::Physics::ROTATION_SPEED * delta_time;
         }
 
-    if (keyboard_state[SDL_SCANCODE_LEFT]) {
+        if (input->checkActionPlayer1(InputAction::LEFT, Input::ALLOW_REPEAT)) {
             angle_ -= Defaults::Physics::ROTATION_SPEED * delta_time;
         }
 
-    // Acceleració
+        if (input->checkActionPlayer1(InputAction::THRUST, Input::ALLOW_REPEAT)) {
-    if (keyboard_state[SDL_SCANCODE_UP]) {
             if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
                 velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-            if (velocitat_ > Defaults::Physics::MAX_VELOCITY) {
+                velocitat_ = std::min(velocitat_, Defaults::Physics::MAX_VELOCITY);
-                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);
             }
         }
     }
@@ -87,8 +119,15 @@ void Nau::processar_input(float delta_time) {
 
 void Nau::actualitzar(float delta_time) {
     // Només actualitzar si la nau està viva
-    if (esta_tocada_)
+    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);
@@ -96,11 +135,26 @@ void Nau::actualitzar(float delta_time) {
 
 void Nau::dibuixar() const {
     // Només dibuixar si la nau està viva
-    if (esta_tocada_)
+    if (esta_tocada_) {
         return;
+    }
 
-    if (!forma_)
+    // 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
@@ -110,10 +164,10 @@ void Nau::dibuixar() const {
     // [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 velocitat_visual = velocitat_ / 33.33F;
-    float escala = 1.0f + (velocitat_visual / 12.0f);
+    float escala = 1.0F + (velocitat_visual / 12.0F);
 
-    Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true, 1.0f, brightness_);
+    Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true, 1.0F, brightness_);
 }
 
 void Nau::aplicar_fisica(float delta_time) {
@@ -124,15 +178,18 @@ void Nau::aplicar_fisica(float delta_time) {
     // 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) +
+        ((velocitat_ * delta_time) * std::sin(angle_ - (Constants::PI / 2.0F))) +
         centre_.y;
     float dx =
-        (velocitat_ * delta_time) * std::cos(angle_ - Constants::PI / 2.0f) +
+        ((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, max_x, min_y, max_y;
+    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,
@@ -149,10 +206,8 @@ void Nau::aplicar_fisica(float delta_time) {
     }
 
     // Fricció - desacceleració gradual (time-based)
-    if (velocitat_ > 0.1f) {
+    if (velocitat_ > 0.1F) {
         velocitat_ -= Defaults::Physics::FRICTION * delta_time;
-        if (velocitat_ < 0.0f) {
+        velocitat_ = std::max(velocitat_, 0.0F);
-            velocitat_ = 0.0f;
-        }
     }
 }

source/game/entities/nau.hpp

@@ -5,44 +5,58 @@
 #pragma once
 #include <SDL3/SDL.h>
 
-#include <memory>
+#include <cmath>
+#include <cstdint>
 
-#include "core/graphics/shape.hpp"
+#include "core/defaults.hpp"
+#include "core/entities/entitat.hpp"
 #include "core/types.hpp"
+#include "game/constants.hpp"
 
-class Nau {
+class Nau : public Entities::Entitat {
     public:
         Nau()
-            : renderer_(nullptr) {}
+            : Entitat(nullptr) {}
-        Nau(SDL_Renderer* renderer);
+        Nau(SDL_Renderer* renderer, const char* shape_file = "ship.shp");
 
-        void inicialitzar(const Punt* spawn_point = nullptr);
+        void inicialitzar() override { inicialitzar(nullptr, false); }
-        void processar_input(float delta_time);
+        void inicialitzar(const Punt* spawn_point, bool activar_invulnerabilitat = false);
-        void actualitzar(float delta_time);
+        void processar_input(float delta_time, uint8_t player_id);
-        void dibuixar() const;
+        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)
-        const Punt& get_centre() const { return centre_; }
+        [[nodiscard]] bool esta_viva() const { return !esta_tocada_; }
-        float get_angle() const { return angle_; }
+        [[nodiscard]] bool esta_tocada() const { return esta_tocada_; }
-        bool esta_viva() const { return !esta_tocada_; }
+        [[nodiscard]] bool es_invulnerable() const { return invulnerable_timer_ > 0.0F; }
-        const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
+        [[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:
-        SDL_Renderer* renderer_;
+        // Membres específics de Nau (heretats: renderer_, forma_, centre_, angle_, brightness_)
-
-        // [NUEVO] Forma vectorial (compartida, només 1 instància de Nau però preparat
-        // per reutilització)
-        std::shared_ptr<Graphics::Shape> forma_;
-
-        // [NUEVO] Estat de la instància (separat de la geometria)
-        Punt centre_;
-        float angle_;      // Angle d'orientació
         float velocitat_;  // Velocitat (px/s)
         bool esta_tocada_;
-        float brightness_;  // Factor de brillantor (0.0-1.0)
+        float invulnerable_timer_;  // 0.0f = vulnerable, >0.0f = invulnerable
 
         void aplicar_fisica(float delta_time);
 };

source/game/escenes/escena_joc.hpp

@@ -5,60 +5,110 @@
 #ifndef ESCENA_JOC_HPP
 #define ESCENA_JOC_HPP
 
-#include <SDL3/SDL.h>
-
 #include <array>
 #include <cstdint>
+#include <memory>
+#include <string>
 
-#include "../constants.hpp"
-#include "../effects/debris_manager.hpp"
-#include "../entities/bala.hpp"
-#include "../entities/enemic.hpp"
-#include "../entities/nau.hpp"
 #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);
+        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();
-        void processar_input(const SDL_Event& event);
 
     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
-        Nau nau_;
+        std::array<Nau, 2> naus_;  // [0]=P1, [1]=P2
         std::array<Enemic, Constants::MAX_ORNIS> orni_;
-        std::array<Bala, Constants::MAX_BALES> bales_;
+        std::array<Bala, Constants::MAX_BALES * 2> bales_;  // 6 balas: P1=[0,1,2], P2=[3,4,5]
         Poligon chatarra_cosmica_;
-        float itocado_;  // Death timer (seconds)
+        std::array<float, 2> itocado_per_jugador_;  // Death timers per player (seconds)
 
         // Lives and game over system
-        int num_vides_;          // Current lives count
+        std::array<int, 2> vides_per_jugador_;  // [0]=P1, [1]=P2
-        bool game_over_;         // Game over state flag
+        EstatGameOver estat_game_over_;         // Game over state machine (NONE, CONTINUE, GAME_OVER)
-        float game_over_timer_;  // Countdown timer for auto-return (seconds)
+        int continue_counter_;                  // Continue countdown (9→0)
-        Punt punt_spawn_;        // Configurable spawn point
+        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();
+        void tocado(uint8_t player_id);
         void detectar_col·lisions_bales_enemics();                       // Col·lisions bala-enemic
-        void detectar_col·lisio_nau_enemics();      // Ship-enemy collision detection
+        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

source/game/escenes/escena_logo.cpp

@@ -11,59 +11,76 @@
 
 #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/gestor_escenes.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)
+    if (num_letras == 0) {
-        return 1.0f;
+        return 1.0F;
+    }
 
     // Calcular temps per lletra
-    float duration_per_letra = 1.0f / static_cast<float>(num_letras);
+    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
+        return 0.0F;  // Encara no ha començat
-    } else if (global_progress >= end) {
+    }
-        return 1.0f;  // Completament apareguda
+    if (global_progress >= end) {
-    } else {
+        return 1.0F;  // Completament apareguda
+    }
     return (global_progress - start) / (end - start);
 }
-}
 
-EscenaLogo::EscenaLogo(SDLManager& sdl)
+EscenaLogo::EscenaLogo(SDLManager& sdl, ContextEscenes& context)
     : sdl_(sdl),
+      context_(context),
       estat_actual_(EstatAnimacio::PRE_ANIMATION),
-      temps_estat_actual_(0.0f),
+      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) {
+      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 == GestorEscenes::Escena::LOGO) {
+    while (GestorEscenes::actual == Escena::LOGO) {
         // Calcular delta_time real
         Uint64 current_time = SDL_GetTicks();
-        float delta_time = (current_time - last_time) / 1000.0f;
+        float delta_time = (current_time - last_time) / 1000.0F;
         last_time = current_time;
 
         // Limitar delta_time per evitar grans salts
-        if (delta_time > 0.05f) {
+        delta_time = std::min(delta_time, 0.05F);
-            delta_time = 0.05f;
-        }
 
         // Actualitzar comptador de FPS
         sdl_.updateFPS(delta_time);
@@ -71,6 +88,9 @@ void EscenaLogo::executar() {
         // 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
@@ -79,7 +99,7 @@ void EscenaLogo::executar() {
             }
 
             // Events globals (F1/F2/F3/ESC/QUIT)
-            if (GlobalEvents::handle(event, sdl_)) {
+            if (GlobalEvents::handle(event, sdl_, context_)) {
                 continue;
             }
 
@@ -119,12 +139,12 @@ void EscenaLogo::inicialitzar_lletres() {
         "logo/letra_s.shp"};
 
     // Pas 1: Carregar totes les formes i calcular amplades
-    float ancho_total = 0.0f;
+    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 << std::endl;
+            std::cerr << "[EscenaLogo] Error carregant " << fitxer << '\n';
             continue;
         }
 
@@ -147,7 +167,7 @@ void EscenaLogo::inicialitzar_lletres() {
         float offset_centre = (forma->get_centre().x - min_x) * ESCALA_FINAL;
 
         lletres_.push_back({forma,
-            {0.0f, 0.0f},  // Posició es calcularà després
+            {.x = 0.0F, .y = 0.0F},  // Posició es calcularà després
             ancho,
             offset_centre});
 
@@ -158,11 +178,11 @@ void EscenaLogo::inicialitzar_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_ANCHO = 640.0F;
-    constexpr float PANTALLA_ALTO = 480.0f;
+    constexpr float PANTALLA_ALTO = 480.0F;
 
-    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0f;
+    float x_inicial = (PANTALLA_ANCHO - ancho_total) / 2.0F;
-    float y_centre = PANTALLA_ALTO / 2.0f;
+    float y_centre = PANTALLA_ALTO / 2.0F;
 
     // Pas 4: Assignar posicions a cada lletra
     float x_actual = x_inicial;
@@ -184,12 +204,12 @@ void EscenaLogo::inicialitzar_lletres() {
 
 void EscenaLogo::canviar_estat(EstatAnimacio nou_estat) {
     estat_actual_ = nou_estat;
-    temps_estat_actual_ = 0.0f;  // Reset temps
+    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;
+        temps_des_ultima_explosio_ = 0.0F;
 
         // Generar ordre aleatori d'explosions
         ordre_explosio_.clear();
@@ -199,9 +219,7 @@ void EscenaLogo::canviar_estat(EstatAnimacio nou_estat) {
         std::random_device rd;
         std::mt19937 g(rd());
         std::shuffle(ordre_explosio_.begin(), ordre_explosio_.end(), g);
-    }
+    } else if (nou_estat == EstatAnimacio::POST_EXPLOSION) {
-    else if (nou_estat == EstatAnimacio::POST_EXPLOSION)
-    {
         Audio::get()->playMusic("title.ogg");
     }
 
@@ -227,16 +245,18 @@ void EscenaLogo::actualitzar_explosions(float delta_time) {
             debris_manager_->explotar(
                 lletra.forma,           // Forma a explotar
                 lletra.posicio,         // Posició
-                0.0f,               // Angle (sense rotació)
+                0.0F,                   // Angle (sense rotació)
                 ESCALA_FINAL,           // Escala (lletres a escala final)
-                VELOCITAT_EXPLOSIO  // Velocitat base
+                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;
+            temps_des_ultima_explosio_ = 0.0F;
         } else {
             // Totes les lletres han explotat, transició a POST_EXPLOSION
             canviar_estat(EstatAnimacio::POST_EXPLOSION);
@@ -256,7 +276,7 @@ void EscenaLogo::actualitzar(float delta_time) {
 
         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);
+            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]) {
@@ -267,8 +287,8 @@ void EscenaLogo::actualitzar(float delta_time) {
                         THRESHOLD_LETRA);
 
                     // Reproduir so quan la lletra comença a aparèixer (progress > 0)
-                    if (letra_progress > 0.0f) {
+                    if (letra_progress > 0.0F) {
-                        Audio::get()->playSound("logo.wav", Audio::Group::INTERFACE);
+                        Audio::get()->playSound(Defaults::Sound::LOGO, Audio::Group::GAME);
                         so_reproduit_[i] = true;
                     }
                 }
@@ -292,12 +312,19 @@ void EscenaLogo::actualitzar(float delta_time) {
 
         case EstatAnimacio::POST_EXPLOSION:
             if (temps_estat_actual_ >= DURACIO_POST_EXPLOSION) {
-                // Iniciar música de títol abans de la transició
+                // Transició a pantalla de títol
-                GestorEscenes::actual = GestorEscenes::Escena::TITOL;
+                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);
 }
@@ -317,10 +344,10 @@ void EscenaLogo::dibuixar() {
         estat_actual_ == EstatAnimacio::POST_ANIMATION) {
         float global_progress =
             (estat_actual_ == EstatAnimacio::ANIMATION)
-            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0f)
+            ? std::min(temps_estat_actual_ / DURACIO_ZOOM, 1.0F)
-            : 1.0f;  // POST: mantenir al 100%
+            : 1.0F;  // POST: mantenir al 100%
 
-        const Punt ORIGEN_ZOOM = {ORIGEN_ZOOM_X, ORIGEN_ZOOM_Y};
+        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];
@@ -331,29 +358,29 @@ void EscenaLogo::dibuixar() {
                 global_progress,
                 THRESHOLD_LETRA);
 
-            if (letra_progress <= 0.0f) {
+            if (letra_progress <= 0.0F) {
                 continue;
             }
 
             Punt pos_actual;
             pos_actual.x =
-                ORIGEN_ZOOM.x + (lletra.posicio.x - ORIGEN_ZOOM.x) * letra_progress;
+                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;
+                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 ease_factor = 1.0F - ((1.0F - t) * (1.0F - t));
             float escala_actual =
-                ESCALA_INICIAL + (ESCALA_FINAL - ESCALA_INICIAL) * ease_factor;
+                ESCALA_INICIAL + ((ESCALA_FINAL - ESCALA_INICIAL) * ease_factor);
 
             Rendering::render_shape(
                 sdl_.obte_renderer(),
                 lletra.forma,
                 pos_actual,
-                0.0f,
+                0.0F,
                 escala_actual,
                 true,
-                1.0f);
+                1.0F);
         }
     }
 
@@ -367,17 +394,17 @@ void EscenaLogo::dibuixar() {
 
         // Dibuixar només lletres que NO han explotat
         for (size_t i = 0; i < lletres_.size(); i++) {
-            if (explotades.find(i) == explotades.end()) {
+            if (!explotades.contains(i)) {
                 const auto& lletra = lletres_[i];
 
                 Rendering::render_shape(
                     sdl_.obte_renderer(),
                     lletra.forma,
                     lletra.posicio,
-                    0.0f,
+                    0.0F,
                     ESCALA_FINAL,
                     true,
-                    1.0f);
+                    1.0F);
             }
         }
     }
@@ -390,10 +417,10 @@ void EscenaLogo::dibuixar() {
     sdl_.presenta();
 }
 
+auto EscenaLogo::checkSkipButtonPressed() -> bool {
+    return Input::get()->checkAnyPlayerAction(ARCADE_BUTTONS);
+}
+
 void EscenaLogo::processar_events(const SDL_Event& event) {
-    // Qualsevol tecla o clic de ratolí salta a la pantalla de títol
+    // No procesar eventos genéricos aquí - la lógica se movió a actualitzar()
-    if (event.type == SDL_EVENT_KEY_DOWN ||
-        event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
-        GestorEscenes::actual = GestorEscenes::Escena::TITOL;
-    }
 }

source/game/escenes/escena_logo.hpp

@@ -6,18 +6,22 @@
 
 #include <SDL3/SDL.h>
 
+#include <array>
 #include <memory>
 #include <vector>
 
-#include "game/effects/debris_manager.hpp"
 #include "core/defaults.hpp"
 #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/types.hpp"
+#include "game/effects/debris_manager.hpp"
 
 class EscenaLogo {
     public:
-        explicit EscenaLogo(SDLManager& sdl);
+        explicit EscenaLogo(SDLManager& sdl, GestorEscenes::ContextEscenes& context);
+        ~EscenaLogo();    // Destructor per aturar sons
         void executar();  // Bucle principal de l'escena
 
     private:
@@ -31,6 +35,7 @@ class EscenaLogo {
         };
 
         SDLManager& sdl_;
+        GestorEscenes::ContextEscenes& context_;
         EstatAnimacio estat_actual_;  // Estat actual de la màquina
         float
             temps_estat_actual_;  // Temps en l'estat actual (reset en cada transició)
@@ -57,20 +62,20 @@ class EscenaLogo {
         std::array<bool, 9> so_reproduit_;  // Track si cada lletra ja ha reproduit el so
 
         // Constants d'animació
-        static constexpr float DURACIO_PRE = 1.5f;             // Duració PRE_ANIMATION (pantalla negra)
+        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_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_ANIMATION = 3.0F;  // Duració POST_ANIMATION (logo complet)
-        static constexpr float DURACIO_POST_EXPLOSION = 3.0f;  // Duració POST_EXPLOSION (espera final)
+        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 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;    // Velocitat base fragments (px/s)
-        static constexpr float ESCALA_INICIAL = 0.1f;          // Escala inicial (10%)
+        static constexpr float ESCALA_INICIAL = 0.1F;          // Escala inicial (10%)
-        static constexpr float ESCALA_FINAL = 0.8f;            // Escala final (80%)
+        static constexpr float ESCALA_FINAL = 0.8F;            // Escala final (80%)
-        static constexpr float ESPAI_ENTRE_LLETRES = 10.0f;    // Espaiat entre lletres
+        static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;    // Espaiat entre lletres
 
         // Constants d'animació seqüencial
-        static constexpr float THRESHOLD_LETRA = 0.6f;                         // Umbral per activar següent lletra (0.0-1.0)
+        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_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_Y = Defaults::Game::HEIGHT * 0.4F;  // Punt inicial Y del zoom
 
         // Mètodes privats
         void inicialitzar_lletres();
@@ -78,8 +83,9 @@ class EscenaLogo {
         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);
-        bool totes_lletres_completes() const;
+        [[nodiscard]] bool totes_lletres_completes() const;
 };

source/game/escenes/escena_titol.cpp

@@ -3,35 +3,57 @@
 
 #include "escena_titol.hpp"
 
+#include <algorithm>
 #include <cfloat>
 #include <cmath>
 #include <iostream>
+#include <numbers>
 #include <string>
 
 #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/gestor_escenes.hpp"
+#include "core/system/context_escenes.hpp"
 #include "core/system/global_events.hpp"
 #include "project.h"
 
-namespace {
+// Using declarations per simplificar el codi
-// Brightness del starfield (1.0 = default, >1.0 més brillant, <1.0 menys brillant)
+using GestorEscenes::ContextEscenes;
-constexpr float BRIGHTNESS_STARFIELD = 1.2f;
+using Escena = ContextEscenes::Escena;
-}  // namespace
+using Opcio = ContextEscenes::Opcio;
 
-EscenaTitol::EscenaTitol(SDLManager& sdl)
+EscenaTitol::EscenaTitol(SDLManager& sdl, ContextEscenes& context)
     : sdl_(sdl),
+      context_(context),
       text_(sdl.obte_renderer()),
-      estat_actual_(EstatTitol::INIT),
+      estat_actual_(EstatTitol::STARFIELD_FADE_IN),
-      temps_acumulat_(0.0f) {
+      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";
 
+    // 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;
+
+    // Processar opció del context
+    auto opcio = context_.consumir_opcio();
+
+    if (opcio == Opcio::JUMP_TO_TITLE_MAIN) {
+        std::cout << "Escena Titol: Opció JUMP_TO_TITLE_MAIN activada\n";
+        estat_actual_ = EstatTitol::MAIN;
+        temps_estat_main_ = 0.0F;
+    }
+
     // Crear starfield de fons
     Punt centre_pantalla{
-        Defaults::Game::WIDTH / 2.0f,
+        .x = Defaults::Game::WIDTH / 2.0F,
-        Defaults::Game::HEIGHT / 2.0f};
+        .y = Defaults::Game::HEIGHT / 2.0F};
 
     SDL_FRect area_completa{
         0,
@@ -46,8 +68,27 @@ EscenaTitol::EscenaTitol(SDLManager& sdl)
         150  // densitat: 150 estrelles (50 per capa)
     );
 
-    // Configurar brightness del starfield
+    // Brightness depèn de l'opció
+    if (estat_actual_ == EstatTitol::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
+        starfield_->set_brightness(0.0F);
+    }
+
+    // Inicialitzar animador de naus 3D
+    ship_animator_ = std::make_unique<Title::ShipAnimator>(sdl_.obte_renderer());
+    ship_animator_->inicialitzar();
+
+    if (estat_actual_ == EstatTitol::MAIN) {
+        // Jump to MAIN: empezar entrada inmediatamente
+        ship_animator_->set_visible(true);
+        ship_animator_->start_entry_animation();
+    } else {
+        // Flux normal: NO empezar entrada todavía (esperaran a MAIN)
+        ship_animator_->set_visible(false);
+    }
 
     // Inicialitzar lletres del títol "ORNI ATTACK!"
     inicialitzar_titol();
@@ -74,12 +115,12 @@ void EscenaTitol::inicialitzar_titol() {
         "title/letra_i.shp"};
 
     // Pas 1: Carregar formes i calcular amplades per "ORNI"
-    float ancho_total_orni = 0.0f;
+    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 << std::endl;
+            std::cerr << "[EscenaTitol] Error carregant " << fitxer << '\n';
             continue;
         }
 
@@ -101,12 +142,12 @@ void EscenaTitol::inicialitzar_titol() {
         float ancho_sin_escalar = max_x - min_x;
         float altura_sin_escalar = max_y - min_y;
 
-        // Escalar ancho, altura i offset amb ESCALA_TITULO
+        // Escalar ancho, altura i offset amb LOGO_SCALE
-        float ancho = ancho_sin_escalar * ESCALA_TITULO;
+        float ancho = ancho_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
-        float altura = altura_sin_escalar * ESCALA_TITULO;
+        float altura = altura_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
-        float offset_centre = (forma->get_centre().x - min_x) * ESCALA_TITULO;
+        float offset_centre = (forma->get_centre().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
 
-        lletres_orni_.push_back({forma, {0.0f, 0.0f}, ancho, altura, offset_centre});
+        lletres_orni_.push_back({forma, {.x = 0.0F, .y = 0.0F}, ancho, altura, offset_centre});
 
         ancho_total_orni += ancho;
     }
@@ -115,12 +156,12 @@ void EscenaTitol::inicialitzar_titol() {
     ancho_total_orni += ESPAI_ENTRE_LLETRES * (lletres_orni_.size() - 1);
 
     // Calcular posició inicial (centrat horitzontal) per "ORNI"
-    float x_inicial_orni = (Defaults::Game::WIDTH - ancho_total_orni) / 2.0f;
+    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 = Y_ORNI;
+        lletra.posicio.y = Defaults::Game::HEIGHT * Defaults::Title::Layout::LOGO_POS;
         x_actual += lletra.ancho + ESPAI_ENTRE_LLETRES;
     }
 
@@ -129,8 +170,10 @@ void EscenaTitol::inicialitzar_titol() {
 
     // === Calcular posició Y dinàmica per "ATTACK!" ===
     // Totes les lletres ORNI tenen la mateixa altura, utilitzem la primera
-    float altura_orni = lletres_orni_.empty() ? 50.0f : lletres_orni_[0].altura;
+    float altura_orni = lletres_orni_.empty() ? 50.0F : lletres_orni_[0].altura;
-    y_attack_dinamica_ = Y_ORNI + altura_orni + SEPARACION_LINEAS;
+    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
               << " px, Y_ATTACK dinàmica: " << y_attack_dinamica_ << " px\n";
@@ -146,12 +189,12 @@ void EscenaTitol::inicialitzar_titol() {
         "title/letra_exclamacion.shp"};
 
     // Pas 1: Carregar formes i calcular amplades per "ATTACK!"
-    float ancho_total_attack = 0.0f;
+    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 << std::endl;
+            std::cerr << "[EscenaTitol] Error carregant " << fitxer << '\n';
             continue;
         }
 
@@ -173,12 +216,12 @@ void EscenaTitol::inicialitzar_titol() {
         float ancho_sin_escalar = max_x - min_x;
         float altura_sin_escalar = max_y - min_y;
 
-        // Escalar ancho, altura i offset amb ESCALA_TITULO
+        // Escalar ancho, altura i offset amb LOGO_SCALE
-        float ancho = ancho_sin_escalar * ESCALA_TITULO;
+        float ancho = ancho_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
-        float altura = altura_sin_escalar * ESCALA_TITULO;
+        float altura = altura_sin_escalar * Defaults::Title::Layout::LOGO_SCALE;
-        float offset_centre = (forma->get_centre().x - min_x) * ESCALA_TITULO;
+        float offset_centre = (forma->get_centre().x - min_x) * Defaults::Title::Layout::LOGO_SCALE;
 
-        lletres_attack_.push_back({forma, {0.0f, 0.0f}, ancho, altura, offset_centre});
+        lletres_attack_.push_back({forma, {.x = 0.0F, .y = 0.0F}, ancho, altura, offset_centre});
 
         ancho_total_attack += ancho;
     }
@@ -187,7 +230,7 @@ void EscenaTitol::inicialitzar_titol() {
     ancho_total_attack += ESPAI_ENTRE_LLETRES * (lletres_attack_.size() - 1);
 
     // Calcular posició inicial (centrat horitzontal) per "ATTACK!"
-    float x_inicial_attack = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0f;
+    float x_inicial_attack = (Defaults::Game::WIDTH - ancho_total_attack) / 2.0F;
     x_actual = x_inicial_attack;
 
     for (auto& lletra : lletres_attack_) {
@@ -198,22 +241,33 @@ void EscenaTitol::inicialitzar_titol() {
 
     std::cout << "[EscenaTitol] Línia 2 (ATTACK!): " << lletres_attack_.size()
               << " lletres, ancho total: " << ancho_total_attack << " px\n";
+
+    // Guardar posicions originals per l'animació orbital
+    posicions_originals_orni_.clear();
+    for (const auto& lletra : lletres_orni_) {
+        posicions_originals_orni_.push_back(lletra.posicio);
+    }
+
+    posicions_originals_attack_.clear();
+    for (const auto& lletra : lletres_attack_) {
+        posicions_originals_attack_.push_back(lletra.posicio);
+    }
+
+    std::cout << "[EscenaTitol] Animació: Posicions originals guardades\n";
 }
 
 void EscenaTitol::executar() {
     SDL_Event event;
     Uint64 last_time = SDL_GetTicks();
 
-    while (GestorEscenes::actual == GestorEscenes::Escena::TITOL) {
+    while (GestorEscenes::actual == Escena::TITOL) {
         // Calcular delta_time real
         Uint64 current_time = SDL_GetTicks();
-        float delta_time = (current_time - last_time) / 1000.0f;
+        float delta_time = (current_time - last_time) / 1000.0F;
         last_time = current_time;
 
         // Limitar delta_time per evitar grans salts
-        if (delta_time > 0.05f) {
+        delta_time = std::min(delta_time, 0.05F);
-            delta_time = 0.05f;
-        }
 
         // Actualitzar comptador de FPS
         sdl_.updateFPS(delta_time);
@@ -221,6 +275,9 @@ void EscenaTitol::executar() {
         // 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
@@ -229,7 +286,7 @@ void EscenaTitol::executar() {
             }
 
             // Events globals (F1/F2/F3/F4/ESC/QUIT)
-            if (GlobalEvents::handle(event, sdl_)) {
+            if (GlobalEvents::handle(event, sdl_, context_)) {
                 continue;
             }
 
@@ -268,42 +325,299 @@ void EscenaTitol::actualitzar(float delta_time) {
         starfield_->actualitzar(delta_time);
     }
 
+    // Actualitzar naus (quan 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);
+    }
+
     switch (estat_actual_) {
-        case EstatTitol::INIT:
+        case EstatTitol::STARFIELD_FADE_IN: {
+            temps_acumulat_ += delta_time;
+
+            // Calcular progrés del fade (0.0 → 1.0)
+            float progress = std::min(1.0F, temps_acumulat_ / DURACIO_FADE_IN);
+
+            // Lerp brightness de 0.0 a BRIGHTNESS_STARFIELD
+            float brightness_actual = progress * BRIGHTNESS_STARFIELD;
+            starfield_->set_brightness(brightness_actual);
+
+            // Transició a STARFIELD quan 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
+            }
+            break;
+        }
+
+        case EstatTitol::STARFIELD:
             temps_acumulat_ += delta_time;
             if (temps_acumulat_ >= DURACIO_INIT) {
                 estat_actual_ = EstatTitol::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
+
+                // Naus esperaran ENTRANCE_DELAY abans d'entrar (no iniciar aquí)
             }
             break;
 
-        case EstatTitol::MAIN:
+        case EstatTitol::MAIN: {
-            // No hi ha lògica d'actualització en l'estat MAIN
+            temps_estat_main_ += delta_time;
-            break;
 
-        case EstatTitol::TRANSITION:
+            // Iniciar animació d'entrada de naus després del delay
+            if (temps_estat_main_ >= Defaults::Title::Ships::ENTRANCE_DELAY) {
+                if (ship_animator_ && !ship_animator_->is_visible()) {
+                    ship_animator_->set_visible(true);
+                    ship_animator_->start_entry_animation();
+                }
+            }
+
+            // Fase 1: Estàtic (0-10s)
+            if (temps_estat_main_ < DELAY_INICI_ANIMACIO) {
+                factor_lerp_ = 0.0F;
+                animacio_activa_ = false;
+            }
+            // Fase 2: Lerp (10-12s)
+            else if (temps_estat_main_ < DELAY_INICI_ANIMACIO + DURACIO_LERP) {
+                float temps_lerp = temps_estat_main_ - DELAY_INICI_ANIMACIO;
+                factor_lerp_ = temps_lerp / DURACIO_LERP;  // 0.0 → 1.0 linealment
+                animacio_activa_ = true;
+            }
+            // Fase 3: Animació completa (12s+)
+            else {
+                factor_lerp_ = 1.0F;
+                animacio_activa_ = true;
+            }
+
+            // Actualitzar animació del logo
+            actualitzar_animacio_logo(delta_time);
+            break;
+        }
+
+        case EstatTitol::PLAYER_JOIN_PHASE:
             temps_acumulat_ += delta_time;
+
+            // Continuar animació orbital durant la transició
+            actualitzar_animacio_logo(delta_time);
+
+            // [NOU] Continuar comprovant si l'altre jugador vol unir-se durant la transició ("late join")
+            {
+                bool p1_actiu_abans = config_partida_.jugador1_actiu;
+                bool p2_actiu_abans = config_partida_.jugador2_actiu;
+
+                if (checkStartGameButtonPressed()) {
+                    // Updates config_partida_ if pressed, logs are in the method
+                    context_.set_config_partida(config_partida_);
+
+                    // Trigger animació de sortida per la nau que acaba d'unir-se
+                    if (ship_animator_) {
+                        if (config_partida_.jugador1_actiu && !p1_actiu_abans) {
+                            ship_animator_->trigger_exit_animation_for_player(1);
+                            std::cout << "[EscenaTitol] P1 late join - ship exiting\n";
+                        }
+                        if (config_partida_.jugador2_actiu && !p2_actiu_abans) {
+                            ship_animator_->trigger_exit_animation_for_player(2);
+                            std::cout << "[EscenaTitol] P2 late join - ship exiting\n";
+                        }
+                    }
+
+                    // Reproducir so de START quan el segon jugador s'uneix
+                    Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);
+
+                    // Reiniciar el timer per allargar el temps de transició
+                    temps_acumulat_ = 0.0F;
+
+                    std::cout << "[EscenaTitol] Segon jugador s'ha unit - so i timer reiniciats\n";
+                }
+            }
+
             if (temps_acumulat_ >= DURACIO_TRANSITION) {
-                // Transició a JOC (la música ja s'ha parat en el fade)
+                // Transició a pantalla negra
-                GestorEscenes::actual = GestorEscenes::Escena::JOC;
+                estat_actual_ = EstatTitol::BLACK_SCREEN;
+                temps_acumulat_ = 0.0F;
+                std::cout << "[EscenaTitol] Passant a BLACK_SCREEN\n";
             }
             break;
+
+        case EstatTitol::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";
+            }
+            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 (checkSkipButtonPressed()) {
+            // Saltar a MAIN
+            estat_actual_ = EstatTitol::MAIN;
+            starfield_->set_brightness(BRIGHTNESS_STARFIELD);
+            temps_estat_main_ = 0.0F;
+
+            // Naus esperaran ENTRANCE_DELAY abans d'entrar (no iniciar 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;
+
+        if (checkStartGameButtonPressed()) {
+            // Si START es prem durant el delay (naus encara invisibles), saltar-les 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")
+                      << ", P2: "
+                      << (config_partida_.jugador2_actiu ? "ACTIU" : "INACTIU")
+                      << '\n';
+
+            context_.canviar_escena(Escena::JOC);
+            estat_actual_ = EstatTitol::PLAYER_JOIN_PHASE;
+            temps_acumulat_ = 0.0F;
+
+            // Trigger animació de sortida NOMÉS per les naus que han premut START
+            if (ship_animator_) {
+                if (config_partida_.jugador1_actiu && !p1_actiu_abans) {
+                    ship_animator_->trigger_exit_animation_for_player(1);
+                    std::cout << "[EscenaTitol] P1 ship exiting\n";
+                }
+                if (config_partida_.jugador2_actiu && !p2_actiu_abans) {
+                    ship_animator_->trigger_exit_animation_for_player(2);
+                    std::cout << "[EscenaTitol] P2 ship exiting\n";
+                }
+            }
+
+            Audio::get()->fadeOutMusic(MUSIC_FADE);
+            Audio::get()->playSound(Defaults::Sound::START, Audio::Group::GAME);
+        }
+    }
+}
+
+void EscenaTitol::actualitzar_animacio_logo(float delta_time) {
+    // Només calcular i aplicar offsets si l'animació està activa
+    if (animacio_activa_) {
+        // Acumular temps escalat
+        temps_animacio_ += delta_time * factor_lerp_;
+
+        // Usar amplituds i freqüències completes
+        float amplitude_x_actual = ORBIT_AMPLITUDE_X;
+        float amplitude_y_actual = ORBIT_AMPLITUDE_Y;
+        float frequency_x_actual = ORBIT_FREQUENCY_X;
+        float frequency_y_actual = ORBIT_FREQUENCY_Y;
+
+        // Calcular offset orbital
+        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"
+        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));
+        }
+
+        // Aplicar offset a totes les 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));
+        }
     }
 }
 
 void EscenaTitol::dibuixar() {
-    // Dibuixar starfield de fons (sempre, en tots els estats)
+    // Dibuixar starfield de fons (en tots els estats excepte BLACK_SCREEN)
-    if (starfield_) {
+    if (starfield_ && estat_actual_ != EstatTitol::BLACK_SCREEN) {
         starfield_->dibuixar();
     }
 
-    // En l'estat INIT, només mostrar starfield (sense text)
+    // Dibuixar naus (després starfield, abans logo)
-    if (estat_actual_ == EstatTitol::INIT) {
+    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();
+    }
+
+    // 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) {
         return;
     }
 
-    // Estat MAIN i TRANSITION: Dibuixar títol i text (sobre el starfield)
+    // Estat MAIN i PLAYER_JOIN_PHASE: Dibuixar títol i text (sobre el starfield)
-    if (estat_actual_ == EstatTitol::MAIN || estat_actual_ == EstatTitol::TRANSITION) {
+    // BLACK_SCREEN: no dibuixar res (fons negre ja està netejat)
-        // === Dibuixar lletres del títol "ORNI ATTACK!" ===
+    if (estat_actual_ == EstatTitol::MAIN || estat_actual_ == EstatTitol::PLAYER_JOIN_PHASE) {
+        // === Calcular i renderitzar ombra (només si animació activa) ===
+        if (animacio_activa_) {
+            float temps_shadow = temps_animacio_ - SHADOW_DELAY;
+            temps_shadow = std::max(temps_shadow, 0.0F);  // Evitar temps negatiu
+
+            // Usar amplituds i freqüències completes per l'ombra
+            float amplitude_x_shadow = ORBIT_AMPLITUDE_X;
+            float amplitude_y_shadow = ORBIT_AMPLITUDE_Y;
+            float frequency_x_shadow = ORBIT_FREQUENCY_X;
+            float frequency_y_shadow = ORBIT_FREQUENCY_Y;
+
+            // Calcular offset de l'ombra
+            float shadow_offset_x = (amplitude_x_shadow * std::sin(2.0F * Defaults::Math::PI * frequency_x_shadow * temps_shadow)) + SHADOW_OFFSET_X;
+            float shadow_offset_y = (amplitude_y_shadow * std::sin((2.0F * Defaults::Math::PI * frequency_y_shadow * temps_shadow) + ORBIT_PHASE_OFFSET)) + SHADOW_OFFSET_Y;
+
+            // === RENDERITZAR OMBRA PRIMER (darrera del logo principal) ===
+
+            // Ombra "ORNI"
+            for (size_t i = 0; i < lletres_orni_.size(); ++i) {
+                Punt 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,
+                    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)
+                );
+            }
+
+            // Ombra "ATTACK!"
+            for (size_t i = 0; i < lletres_attack_.size(); ++i) {
+                Punt 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,
+                    pos_shadow,
+                    0.0F,
+                    Defaults::Title::Layout::LOGO_SCALE,
+                    true,
+                    1.0F,  // progress = 1.0 (totalment visible)
+                    SHADOW_BRIGHTNESS);
+            }
+        }
+
+        // === RENDERITZAR LOGO PRINCIPAL (damunt) ===
 
         // Dibuixar "ORNI" (línia 1)
         for (const auto& lletra : lletres_orni_) {
@@ -311,10 +625,10 @@ void EscenaTitol::dibuixar() {
                 sdl_.obte_renderer(),
                 lletra.forma,
                 lletra.posicio,
-                0.0f,           // sense rotació
+                0.0F,
-                ESCALA_TITULO,  // escala 80%
+                Defaults::Title::Layout::LOGO_SCALE,
-                true,           // dibuixar
+                true,
-                1.0f            // progrés complet (totalment visible)
+                1.0F  // Brillantor completa
             );
         }
 
@@ -324,79 +638,97 @@ void EscenaTitol::dibuixar() {
                 sdl_.obte_renderer(),
                 lletra.forma,
                 lletra.posicio,
-                0.0f,           // sense rotació
+                0.0F,
-                ESCALA_TITULO,  // escala 80%
+                Defaults::Title::Layout::LOGO_SCALE,
-                true,           // dibuixar
+                true,
-                1.0f            // progrés complet (totalment visible)
+                1.0F  // Brillantor completa
             );
         }
 
-        // === Text "PRESS BUTTON TO PLAY" ===
+        // === Text "PRESS START TO PLAY" ===
         // En estat MAIN: sempre visible
         // En estat TRANSITION: parpellejant (blink amb sinusoide)
 
-        const float spacing = 2.0f;  // Espai entre caràcters (usat també per copyright)
+        const float spacing = Defaults::Title::Layout::TEXT_SPACING;
 
         bool mostrar_text = true;
-        if (estat_actual_ == EstatTitol::TRANSITION) {
+        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 * 3.14159f;  // 2π × freq × temps
+            float fase = temps_acumulat_ * BLINK_FREQUENCY * 2.0F * std::numbers::pi_v<float>;  // 2π × freq × temps
-            mostrar_text = (std::sin(fase) > 0.0f);
+            mostrar_text = (std::sin(fase) > 0.0F);
         }
 
         if (mostrar_text) {
-            const std::string main_text = "PRESS BUTTON TO PLAY";
+            const std::string main_text = "PRESS START TO PLAY";
-            const float escala_main = 1.0f;
+            const float escala_main = Defaults::Title::Layout::PRESS_START_SCALE;
 
-            float text_width = text_.get_text_width(main_text, escala_main, spacing);
+            float centre_x = Defaults::Game::WIDTH / 2.0F;
+            float centre_y = Defaults::Game::HEIGHT * Defaults::Title::Layout::PRESS_START_POS;
 
-            float x_center = (Defaults::Game::WIDTH - text_width) / 2.0f;
+            text_.render_centered(main_text, {.x = centre_x, .y = centre_y}, escala_main, spacing);
-            float altura_attack = lletres_attack_.empty() ? 50.0f : lletres_attack_[0].altura;
-            float y_center = y_attack_dinamica_ + altura_attack + 70.0f;
-
-            text_.render(main_text, Punt{x_center, y_center}, escala_main, spacing);
         }
 
-        // === Copyright a la part inferior (centrat horitzontalment) ===
+        // === Copyright a la part inferior (centrat horitzontalment, dues línies) ===
-        // Convert to uppercase since VectorText only supports A-Z
+        const float escala_copy = Defaults::Title::Layout::COPYRIGHT_SCALE;
-        std::string copyright = Project::COPYRIGHT;
+        const float copy_height = text_.get_text_height(escala_copy);
-        for (char& c : copyright) {
+        const float line_spacing = Defaults::Game::HEIGHT * Defaults::Title::Layout::COPYRIGHT_LINE_SPACING;
+
+        // Línea 1: Original (© 1999 Visente i Sergi)
+        std::string copyright_original = Project::COPYRIGHT_ORIGINAL;
+        for (char& c : copyright_original) {
             if (c >= 'a' && c <= 'z') {
-                c = c - 32;  // Convert to uppercase
+                c = c - 32;  // Uppercase
             }
         }
-        const float escala_copy = 0.6f;
 
-        float copy_width = text_.get_text_width(copyright, escala_copy, spacing);
+        // Línea 2: Port (© 2025 jaildesigner)
-        float copy_height = text_.get_text_height(escala_copy);
+        std::string copyright_port = Project::COPYRIGHT_PORT;
-
+        for (char& c : copyright_port) {
-        float x_copy = (Defaults::Game::WIDTH - copy_width) / 2.0f;
+            if (c >= 'a' && c <= 'z') {
-        float y_copy = Defaults::Game::HEIGHT - copy_height - 20.0f;  // 20px des del fons
+                c = c - 32;  // Uppercase
-
-        text_.render(copyright, Punt{x_copy, y_copy}, escala_copy, spacing);
             }
         }
 
+        // Calcular posicions (anclatge des del top + separació)
+        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
+        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);
+    }
+}
+
+auto EscenaTitol::checkSkipButtonPressed() -> bool {
+    return Input::get()->checkAnyPlayerAction(ARCADE_BUTTONS);
+}
+
+auto EscenaTitol::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;
+                any_pressed = true;
+                std::cout << "[EscenaTitol] P1 pressed START\n";
+            }
+        }
+        if (input->checkActionPlayer2(action, Input::DO_NOT_ALLOW_REPEAT)) {
+            if (!config_partida_.jugador2_actiu) {
+                config_partida_.jugador2_actiu = true;
+                any_pressed = true;
+                std::cout << "[EscenaTitol] P2 pressed START\n";
+            }
+        }
+    }
+
+    return any_pressed;
+}
+
 void EscenaTitol::processar_events(const SDL_Event& event) {
-    // Qualsevol tecla o clic de ratolí
+    // No procesar eventos genéricos aquí - la lógica se movió a actualitzar()
-    if (event.type == SDL_EVENT_KEY_DOWN ||
-        event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
-        switch (estat_actual_) {
-            case EstatTitol::INIT:
-                // Saltar a MAIN
-                estat_actual_ = EstatTitol::MAIN;
-                break;
-
-            case EstatTitol::MAIN:
-                // Iniciar transició amb fade-out de música
-                estat_actual_ = EstatTitol::TRANSITION;
-                temps_acumulat_ = 0.0f;  // Reset del comptador
-                Audio::get()->fadeOutMusic(MUSIC_FADE);  // Fade de 300ms
-                break;
-
-            case EstatTitol::TRANSITION:
-                // Ignorar inputs durant la transició
-                break;
-        }
-    }
 }

source/game/escenes/escena_titol.hpp

@@ -6,6 +6,7 @@
 
 #include <SDL3/SDL.h>
 
+#include <array>
 #include <memory>
 #include <vector>
 
@@ -13,21 +14,31 @@
 #include "core/graphics/shape.hpp"
 #include "core/graphics/starfield.hpp"
 #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/game_config.hpp"
 #include "core/types.hpp"
+#include "game/title/ship_animator.hpp"
+
+// Botones para INICIAR PARTIDA desde MAIN (solo START)
+static constexpr std::array<InputAction, 1> START_GAME_BUTTONS = {
+    InputAction::START};
 
 class EscenaTitol {
     public:
-        explicit EscenaTitol(SDLManager& sdl);
+        explicit EscenaTitol(SDLManager& sdl, GestorEscenes::ContextEscenes& context);
         ~EscenaTitol();   // Destructor per aturar música
         void executar();  // Bucle principal de l'escena
 
     private:
         // Màquina d'estats per la pantalla de títol
         enum class EstatTitol {
-            INIT,       // Pantalla negra inicial (2 segons)
+            STARFIELD_FADE_IN,  // Fade-in del starfield (3.0s)
-            MAIN,       // Pantalla de títol amb text
+            STARFIELD,          // Pantalla amb camp d'estrelles (4.0s)
-            TRANSITION  // Transició amb fade-out de música i text parpellejant
+            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)
         };
 
         // Estructura per emmagatzemar informació de cada lletra del títol
@@ -40,8 +51,11 @@ class EscenaTitol {
         };
 
         SDLManager& sdl_;
+        GestorEscenes::ContextEscenes& context_;
+        GameConfig::ConfigPartida config_partida_;            // Configuració de jugadors actius
         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
 
@@ -50,19 +64,49 @@ class EscenaTitol {
         std::vector<LetraLogo> lletres_attack_;  // Lletres de "ATTACK!" (línia 2)
         float y_attack_dinamica_;                // Posició 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 d'arrencada de l'animació
+        float temps_estat_main_;  // Temps acumulat en estat MAIN
+        bool animacio_activa_;    // Flag: true quan animació està activa
+        float factor_lerp_;       // Factor de lerp actual (0.0 → 1.0)
+
         // Constants
-        static constexpr float DURACIO_INIT = 4.0f;          // Duració de l'estat INIT (2 segons)
+        static constexpr float BRIGHTNESS_STARFIELD = 1.2F;  // Brightness del starfield (>1.0 = més brillant)
-        static constexpr float DURACIO_TRANSITION = 1.5f;    // Duració de la transició (1.5 segons)
+        static constexpr float DURACIO_FADE_IN = 3.0F;       // Duració del fade-in del starfield (1.5 segons)
-        static constexpr float ESCALA_TITULO = 0.6f;         // Escala per les lletres del títol (50%)
+        static constexpr float DURACIO_INIT = 4.0F;          // Duració de l'estat INIT (2 segons)
-        static constexpr float ESPAI_ENTRE_LLETRES = 10.0f;  // Espai entre lletres
+        static constexpr float DURACIO_TRANSITION = 2.5F;    // Duració de la transició (1.5 segons)
-        static constexpr float Y_ORNI = 150.0f;              // Posició Y de "ORNI"
+        static constexpr float ESPAI_ENTRE_LLETRES = 10.0F;  // Espai entre lletres
-        static constexpr float SEPARACION_LINEAS = 10.0f;    // Separació entre "ORNI" i "ATTACK!" (0.0f = pegades)
+        static constexpr float BLINK_FREQUENCY = 3.0F;       // Freqüència de parpelleig (3 Hz)
-        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 = 1000;              // Duracio del fade de la musica del titol al començar a jugar
+        static constexpr int MUSIC_FADE = 1500;              // Duracio del fade de la musica del titol al començar a jugar
+
+        // Constants d'animació 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_PHASE_OFFSET = 1.57F;  // Desfasament entre X i Y (90° per circular)
+
+        // Constants d'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_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
+        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);
+        auto checkSkipButtonPressed() -> bool;
+        auto checkStartGameButtonPressed() -> bool;
         void inicialitzar_titol();  // Carrega i posiciona les lletres del títol
 };

source/game/options.cpp

@@ -3,6 +3,7 @@
 #include <fstream>
 #include <iostream>
 #include <string>
+#include <unordered_map>
 
 #include "core/defaults.hpp"
 #include "external/fkyaml_node.hpp"
@@ -10,6 +11,173 @@
 
 namespace Options {
 
+// ========== FUNCIONS AUXILIARS PER CONVERSIÓ DE CONTROLES ==========
+
+// Mapa de SDL_Scancode a string
+static const std::unordered_map<SDL_Scancode, std::string> SCANCODE_TO_STRING = {
+    {SDL_SCANCODE_A, "A"},
+    {SDL_SCANCODE_B, "B"},
+    {SDL_SCANCODE_C, "C"},
+    {SDL_SCANCODE_D, "D"},
+    {SDL_SCANCODE_E, "E"},
+    {SDL_SCANCODE_F, "F"},
+    {SDL_SCANCODE_G, "G"},
+    {SDL_SCANCODE_H, "H"},
+    {SDL_SCANCODE_I, "I"},
+    {SDL_SCANCODE_J, "J"},
+    {SDL_SCANCODE_K, "K"},
+    {SDL_SCANCODE_L, "L"},
+    {SDL_SCANCODE_M, "M"},
+    {SDL_SCANCODE_N, "N"},
+    {SDL_SCANCODE_O, "O"},
+    {SDL_SCANCODE_P, "P"},
+    {SDL_SCANCODE_Q, "Q"},
+    {SDL_SCANCODE_R, "R"},
+    {SDL_SCANCODE_S, "S"},
+    {SDL_SCANCODE_T, "T"},
+    {SDL_SCANCODE_U, "U"},
+    {SDL_SCANCODE_V, "V"},
+    {SDL_SCANCODE_W, "W"},
+    {SDL_SCANCODE_X, "X"},
+    {SDL_SCANCODE_Y, "Y"},
+    {SDL_SCANCODE_Z, "Z"},
+    {SDL_SCANCODE_1, "1"},
+    {SDL_SCANCODE_2, "2"},
+    {SDL_SCANCODE_3, "3"},
+    {SDL_SCANCODE_4, "4"},
+    {SDL_SCANCODE_5, "5"},
+    {SDL_SCANCODE_6, "6"},
+    {SDL_SCANCODE_7, "7"},
+    {SDL_SCANCODE_8, "8"},
+    {SDL_SCANCODE_9, "9"},
+    {SDL_SCANCODE_0, "0"},
+    {SDL_SCANCODE_RETURN, "RETURN"},
+    {SDL_SCANCODE_ESCAPE, "ESCAPE"},
+    {SDL_SCANCODE_BACKSPACE, "BACKSPACE"},
+    {SDL_SCANCODE_TAB, "TAB"},
+    {SDL_SCANCODE_SPACE, "SPACE"},
+    {SDL_SCANCODE_UP, "UP"},
+    {SDL_SCANCODE_DOWN, "DOWN"},
+    {SDL_SCANCODE_LEFT, "LEFT"},
+    {SDL_SCANCODE_RIGHT, "RIGHT"},
+    {SDL_SCANCODE_LSHIFT, "LSHIFT"},
+    {SDL_SCANCODE_RSHIFT, "RSHIFT"},
+    {SDL_SCANCODE_LCTRL, "LCTRL"},
+    {SDL_SCANCODE_RCTRL, "RCTRL"},
+    {SDL_SCANCODE_LALT, "LALT"},
+    {SDL_SCANCODE_RALT, "RALT"}};
+
+// Mapa invers: string a SDL_Scancode
+static const std::unordered_map<std::string, SDL_Scancode> STRING_TO_SCANCODE = {
+    {"A", SDL_SCANCODE_A},
+    {"B", SDL_SCANCODE_B},
+    {"C", SDL_SCANCODE_C},
+    {"D", SDL_SCANCODE_D},
+    {"E", SDL_SCANCODE_E},
+    {"F", SDL_SCANCODE_F},
+    {"G", SDL_SCANCODE_G},
+    {"H", SDL_SCANCODE_H},
+    {"I", SDL_SCANCODE_I},
+    {"J", SDL_SCANCODE_J},
+    {"K", SDL_SCANCODE_K},
+    {"L", SDL_SCANCODE_L},
+    {"M", SDL_SCANCODE_M},
+    {"N", SDL_SCANCODE_N},
+    {"O", SDL_SCANCODE_O},
+    {"P", SDL_SCANCODE_P},
+    {"Q", SDL_SCANCODE_Q},
+    {"R", SDL_SCANCODE_R},
+    {"S", SDL_SCANCODE_S},
+    {"T", SDL_SCANCODE_T},
+    {"U", SDL_SCANCODE_U},
+    {"V", SDL_SCANCODE_V},
+    {"W", SDL_SCANCODE_W},
+    {"X", SDL_SCANCODE_X},
+    {"Y", SDL_SCANCODE_Y},
+    {"Z", SDL_SCANCODE_Z},
+    {"1", SDL_SCANCODE_1},
+    {"2", SDL_SCANCODE_2},
+    {"3", SDL_SCANCODE_3},
+    {"4", SDL_SCANCODE_4},
+    {"5", SDL_SCANCODE_5},
+    {"6", SDL_SCANCODE_6},
+    {"7", SDL_SCANCODE_7},
+    {"8", SDL_SCANCODE_8},
+    {"9", SDL_SCANCODE_9},
+    {"0", SDL_SCANCODE_0},
+    {"RETURN", SDL_SCANCODE_RETURN},
+    {"ESCAPE", SDL_SCANCODE_ESCAPE},
+    {"BACKSPACE", SDL_SCANCODE_BACKSPACE},
+    {"TAB", SDL_SCANCODE_TAB},
+    {"SPACE", SDL_SCANCODE_SPACE},
+    {"UP", SDL_SCANCODE_UP},
+    {"DOWN", SDL_SCANCODE_DOWN},
+    {"LEFT", SDL_SCANCODE_LEFT},
+    {"RIGHT", SDL_SCANCODE_RIGHT},
+    {"LSHIFT", SDL_SCANCODE_LSHIFT},
+    {"RSHIFT", SDL_SCANCODE_RSHIFT},
+    {"LCTRL", SDL_SCANCODE_LCTRL},
+    {"RCTRL", SDL_SCANCODE_RCTRL},
+    {"LALT", SDL_SCANCODE_LALT},
+    {"RALT", SDL_SCANCODE_RALT}};
+
+// Mapa de botó de gamepad (int) a string
+static const std::unordered_map<int, std::string> BUTTON_TO_STRING = {
+    {SDL_GAMEPAD_BUTTON_SOUTH, "SOUTH"},  // A (Xbox), Cross (PS)
+    {SDL_GAMEPAD_BUTTON_EAST, "EAST"},    // B (Xbox), Circle (PS)
+    {SDL_GAMEPAD_BUTTON_WEST, "WEST"},    // X (Xbox), Square (PS)
+    {SDL_GAMEPAD_BUTTON_NORTH, "NORTH"},  // Y (Xbox), Triangle (PS)
+    {SDL_GAMEPAD_BUTTON_BACK, "BACK"},
+    {SDL_GAMEPAD_BUTTON_START, "START"},
+    {SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, "LEFT_SHOULDER"},
+    {SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, "RIGHT_SHOULDER"},
+    {SDL_GAMEPAD_BUTTON_DPAD_UP, "DPAD_UP"},
+    {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
+};
+
+// Mapa invers: string a botó de gamepad
+static const std::unordered_map<std::string, int> STRING_TO_BUTTON = {
+    {"SOUTH", SDL_GAMEPAD_BUTTON_SOUTH},
+    {"EAST", SDL_GAMEPAD_BUTTON_EAST},
+    {"WEST", SDL_GAMEPAD_BUTTON_WEST},
+    {"NORTH", SDL_GAMEPAD_BUTTON_NORTH},
+    {"BACK", SDL_GAMEPAD_BUTTON_BACK},
+    {"START", SDL_GAMEPAD_BUTTON_START},
+    {"LEFT_SHOULDER", SDL_GAMEPAD_BUTTON_LEFT_SHOULDER},
+    {"RIGHT_SHOULDER", SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER},
+    {"DPAD_UP", SDL_GAMEPAD_BUTTON_DPAD_UP},
+    {"DPAD_DOWN", SDL_GAMEPAD_BUTTON_DPAD_DOWN},
+    {"DPAD_LEFT", SDL_GAMEPAD_BUTTON_DPAD_LEFT},
+    {"DPAD_RIGHT", SDL_GAMEPAD_BUTTON_DPAD_RIGHT},
+    {"L2_AS_BUTTON", 100},
+    {"R2_AS_BUTTON", 101}};
+
+static auto scancodeToString(SDL_Scancode code) -> std::string {
+    auto it = SCANCODE_TO_STRING.find(code);
+    return (it != SCANCODE_TO_STRING.end()) ? it->second : "UNKNOWN";
+}
+
+static auto stringToScancode(const std::string& str) -> SDL_Scancode {
+    auto it = STRING_TO_SCANCODE.find(str);
+    return (it != STRING_TO_SCANCODE.end()) ? it->second : SDL_SCANCODE_UNKNOWN;
+}
+
+static auto buttonToString(int button) -> std::string {
+    auto it = BUTTON_TO_STRING.find(button);
+    return (it != BUTTON_TO_STRING.end()) ? it->second : "UNKNOWN";
+}
+
+static auto stringToButton(const std::string& str) -> int {
+    auto it = STRING_TO_BUTTON.find(str);
+    return (it != STRING_TO_BUTTON.end()) ? it->second : SDL_GAMEPAD_BUTTON_INVALID;
+}
+
+// ========== FI FUNCIONS AUXILIARS ==========
+
 // Inicialitzar opcions amb valors per defecte de Defaults::
 void init() {
 #ifdef _DEBUG
@@ -21,7 +189,7 @@ void init() {
     // Window
     window.width = Defaults::Window::WIDTH;
     window.height = Defaults::Window::HEIGHT;
-    window.fullscreen = false;
+    window.fullscreen = Defaults::Window::FULLSCREEN;
     window.zoom_factor = Defaults::Window::BASE_ZOOM;
 
     // Physics
@@ -93,7 +261,7 @@ static void loadWindowConfigFromYaml(const fkyaml::node& yaml) {
         if (win.contains("zoom_factor")) {
             try {
                 auto val = win["zoom_factor"].get_value<float>();
-                window.zoom_factor = (val >= Defaults::Window::MIN_ZOOM && val <= 10.0f)
+                window.zoom_factor = (val >= Defaults::Window::MIN_ZOOM && val <= 10.0F)
                     ? val
                     : Defaults::Window::BASE_ZOOM;
             } catch (...) {
@@ -227,8 +395,8 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
 
         if (aud.contains("volume")) {
             try {
-                float val = aud["volume"].get_value<float>();
+                auto val = aud["volume"].get_value<float>();
-                audio.volume = (val >= 0.0f && val <= 1.0f) ? val : Defaults::Audio::VOLUME;
+                audio.volume = (val >= 0.0F && val <= 1.0F) ? val : Defaults::Audio::VOLUME;
             } catch (...) {
                 audio.volume = Defaults::Audio::VOLUME;
             }
@@ -247,8 +415,8 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
 
             if (mus.contains("volume")) {
                 try {
-                    float val = mus["volume"].get_value<float>();
+                    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::Music::VOLUME;
                 } catch (...) {
                     audio.music.volume = Defaults::Music::VOLUME;
                 }
@@ -268,8 +436,8 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
 
             if (snd.contains("volume")) {
                 try {
-                    float val = snd["volume"].get_value<float>();
+                    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::Sound::VOLUME;
                 } catch (...) {
                     audio.sound.volume = Defaults::Sound::VOLUME;
                 }
@@ -278,6 +446,102 @@ static void loadAudioConfigFromYaml(const fkyaml::node& yaml) {
     }
 }
 
+// Carregar controls del jugador 1 des de YAML
+static void loadPlayer1ControlsFromYaml(const fkyaml::node& yaml) {
+    if (!yaml.contains("player1")) {
+        return;
+    }
+
+    const auto& p1 = yaml["player1"];
+
+    // Carregar controls de teclat
+    if (p1.contains("keyboard")) {
+        const auto& kb = p1["keyboard"];
+        if (kb.contains("key_left")) {
+            player1.keyboard.key_left = stringToScancode(kb["key_left"].get_value<std::string>());
+        }
+        if (kb.contains("key_right")) {
+            player1.keyboard.key_right = stringToScancode(kb["key_right"].get_value<std::string>());
+        }
+        if (kb.contains("key_thrust")) {
+            player1.keyboard.key_thrust = stringToScancode(kb["key_thrust"].get_value<std::string>());
+        }
+        if (kb.contains("key_shoot")) {
+            player1.keyboard.key_shoot = stringToScancode(kb["key_shoot"].get_value<std::string>());
+        }
+    }
+
+    // Carregar controls de gamepad
+    if (p1.contains("gamepad")) {
+        const auto& gp = p1["gamepad"];
+        if (gp.contains("button_left")) {
+            player1.gamepad.button_left = stringToButton(gp["button_left"].get_value<std::string>());
+        }
+        if (gp.contains("button_right")) {
+            player1.gamepad.button_right = stringToButton(gp["button_right"].get_value<std::string>());
+        }
+        if (gp.contains("button_thrust")) {
+            player1.gamepad.button_thrust = stringToButton(gp["button_thrust"].get_value<std::string>());
+        }
+        if (gp.contains("button_shoot")) {
+            player1.gamepad.button_shoot = stringToButton(gp["button_shoot"].get_value<std::string>());
+        }
+    }
+
+    // Carregar nom del gamepad
+    if (p1.contains("gamepad_name")) {
+        player1.gamepad_name = p1["gamepad_name"].get_value<std::string>();
+    }
+}
+
+// Carregar controls del jugador 2 des de YAML
+static void loadPlayer2ControlsFromYaml(const fkyaml::node& yaml) {
+    if (!yaml.contains("player2")) {
+        return;
+    }
+
+    const auto& p2 = yaml["player2"];
+
+    // Carregar controls de teclat
+    if (p2.contains("keyboard")) {
+        const auto& kb = p2["keyboard"];
+        if (kb.contains("key_left")) {
+            player2.keyboard.key_left = stringToScancode(kb["key_left"].get_value<std::string>());
+        }
+        if (kb.contains("key_right")) {
+            player2.keyboard.key_right = stringToScancode(kb["key_right"].get_value<std::string>());
+        }
+        if (kb.contains("key_thrust")) {
+            player2.keyboard.key_thrust = stringToScancode(kb["key_thrust"].get_value<std::string>());
+        }
+        if (kb.contains("key_shoot")) {
+            player2.keyboard.key_shoot = stringToScancode(kb["key_shoot"].get_value<std::string>());
+        }
+    }
+
+    // Carregar controls de gamepad
+    if (p2.contains("gamepad")) {
+        const auto& gp = p2["gamepad"];
+        if (gp.contains("button_left")) {
+            player2.gamepad.button_left = stringToButton(gp["button_left"].get_value<std::string>());
+        }
+        if (gp.contains("button_right")) {
+            player2.gamepad.button_right = stringToButton(gp["button_right"].get_value<std::string>());
+        }
+        if (gp.contains("button_thrust")) {
+            player2.gamepad.button_thrust = stringToButton(gp["button_thrust"].get_value<std::string>());
+        }
+        if (gp.contains("button_shoot")) {
+            player2.gamepad.button_shoot = stringToButton(gp["button_shoot"].get_value<std::string>());
+        }
+    }
+
+    // Carregar nom del gamepad
+    if (p2.contains("gamepad_name")) {
+        player2.gamepad_name = p2["gamepad_name"].get_value<std::string>();
+    }
+}
+
 // Carregar configuració des del fitxer YAML
 auto loadFromFile() -> bool {
     const std::string CONFIG_VERSION = std::string(Project::VERSION);
@@ -325,6 +589,8 @@ auto loadFromFile() -> bool {
         loadGameplayConfigFromYaml(yaml);
         loadRenderingConfigFromYaml(yaml);
         loadAudioConfigFromYaml(yaml);
+        loadPlayer1ControlsFromYaml(yaml);
+        loadPlayer2ControlsFromYaml(yaml);
 
         if (console) {
             std::cout << "Config carregada correctament des de: " << config_file_path
@@ -345,6 +611,40 @@ auto loadFromFile() -> bool {
     }
 }
 
+// Guardar controls del jugador 1 a YAML
+static void savePlayer1ControlsToYaml(std::ofstream& file) {
+    file << "# CONTROLS JUGADOR 1\n";
+    file << "player1:\n";
+    file << "  keyboard:\n";
+    file << "    key_left: " << scancodeToString(player1.keyboard.key_left) << "\n";
+    file << "    key_right: " << scancodeToString(player1.keyboard.key_right) << "\n";
+    file << "    key_thrust: " << scancodeToString(player1.keyboard.key_thrust) << "\n";
+    file << "    key_shoot: " << scancodeToString(player1.keyboard.key_shoot) << "\n";
+    file << "  gamepad:\n";
+    file << "    button_left: " << buttonToString(player1.gamepad.button_left) << "\n";
+    file << "    button_right: " << buttonToString(player1.gamepad.button_right) << "\n";
+    file << "    button_thrust: " << buttonToString(player1.gamepad.button_thrust) << "\n";
+    file << "    button_shoot: " << buttonToString(player1.gamepad.button_shoot) << "\n";
+    file << "  gamepad_name: \"" << player1.gamepad_name << "\"   # Buit = primer disponible\n\n";
+}
+
+// Guardar controls del jugador 2 a YAML
+static void savePlayer2ControlsToYaml(std::ofstream& file) {
+    file << "# CONTROLS JUGADOR 2\n";
+    file << "player2:\n";
+    file << "  keyboard:\n";
+    file << "    key_left: " << scancodeToString(player2.keyboard.key_left) << "\n";
+    file << "    key_right: " << scancodeToString(player2.keyboard.key_right) << "\n";
+    file << "    key_thrust: " << scancodeToString(player2.keyboard.key_thrust) << "\n";
+    file << "    key_shoot: " << scancodeToString(player2.keyboard.key_shoot) << "\n";
+    file << "  gamepad:\n";
+    file << "    button_left: " << buttonToString(player2.gamepad.button_left) << "\n";
+    file << "    button_right: " << buttonToString(player2.gamepad.button_right) << "\n";
+    file << "    button_thrust: " << buttonToString(player2.gamepad.button_thrust) << "\n";
+    file << "    button_shoot: " << buttonToString(player2.gamepad.button_shoot) << "\n";
+    file << "  gamepad_name: \"" << player2.gamepad_name << "\"   # Buit = segon disponible\n\n";
+}
+
 // Guardar configuració al fitxer YAML
 auto saveToFile() -> bool {
     std::ofstream file(config_file_path);
@@ -399,7 +699,11 @@ auto saveToFile() -> bool {
     file << "    volume: " << audio.music.volume << "   # 0.0 to 1.0\n";
     file << "  sound:\n";
     file << "    enabled: " << (audio.sound.enabled ? "true" : "false") << "\n";
-    file << "    volume: " << audio.sound.volume << "   # 0.0 to 1.0\n";
+    file << "    volume: " << audio.sound.volume << "   # 0.0 to 1.0\n\n";
+
+    // Guardar controls de jugadors
+    savePlayer1ControlsToYaml(file);
+    savePlayer2ControlsToYaml(file);
 
     file.close();
 

source/game/options.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <SDL3/SDL.h>  // Para SDL_Scancode
+
 #include <string>
 
 namespace Options {
@@ -10,16 +12,16 @@ struct Window {
         int width{640};
         int height{480};
         bool fullscreen{false};
-        float zoom_factor{1.0f};  // Zoom level (0.5x to max_zoom)
+        float zoom_factor{1.0F};  // Zoom level (0.5x to max_zoom)
 };
 
 struct Physics {
-        float rotation_speed{3.14f};  // rad/s
+        float rotation_speed{3.14F};  // rad/s
-        float acceleration{400.0f};   // px/s²
+        float acceleration{400.0F};   // px/s²
-        float max_velocity{120.0f};   // px/s
+        float max_velocity{120.0F};   // px/s
-        float friction{20.0f};        // px/s²
+        float friction{20.0F};        // px/s²
-        float enemy_speed{2.0f};      // unitats/frame
+        float enemy_speed{2.0F};      // unitats/frame
-        float bullet_speed{6.0f};     // unitats/frame
+        float bullet_speed{6.0F};     // unitats/frame
 };
 
 struct Gameplay {
@@ -33,19 +35,42 @@ struct Rendering {
 
 struct Music {
         bool enabled{true};
-        float volume{0.8f};
+        float volume{0.8F};
 };
 
 struct Sound {
         bool enabled{true};
-        float volume{1.0f};
+        float volume{1.0F};
 };
 
 struct Audio {
         Music music{};
         Sound sound{};
         bool enabled{true};
-        float volume{1.0f};
+        float volume{1.0F};
+};
+
+// Controles de jugadors
+
+struct KeyboardControls {
+        SDL_Scancode key_left{SDL_SCANCODE_LEFT};
+        SDL_Scancode key_right{SDL_SCANCODE_RIGHT};
+        SDL_Scancode key_thrust{SDL_SCANCODE_UP};
+        SDL_Scancode key_shoot{SDL_SCANCODE_SPACE};
+        SDL_Scancode key_start{SDL_SCANCODE_1};
+};
+
+struct GamepadControls {
+        int button_left{SDL_GAMEPAD_BUTTON_DPAD_LEFT};
+        int button_right{SDL_GAMEPAD_BUTTON_DPAD_RIGHT};
+        int button_thrust{SDL_GAMEPAD_BUTTON_WEST};  // X button
+        int button_shoot{SDL_GAMEPAD_BUTTON_SOUTH};  // A button
+};
+
+struct PlayerControls {
+        KeyboardControls keyboard{};
+        GamepadControls gamepad{};
+        std::string gamepad_name;  // Buit = auto-assignar per índex
 };
 
 // Variables globals (inline per evitar ODR violations)
@@ -58,6 +83,31 @@ inline Gameplay gameplay{};
 inline Rendering rendering{};
 inline Audio audio{};
 
+// Controles per jugador
+inline PlayerControls player1{
+    .keyboard =
+        {.key_left = SDL_SCANCODE_LEFT,
+            .key_right = SDL_SCANCODE_RIGHT,
+            .key_thrust = SDL_SCANCODE_UP,
+            .key_shoot = SDL_SCANCODE_SPACE,
+            .key_start = SDL_SCANCODE_1},
+    .gamepad_name = ""  // Primer gamepad disponible
+};
+
+inline PlayerControls player2{
+    .keyboard =
+        {.key_left = SDL_SCANCODE_A,
+            .key_right = SDL_SCANCODE_D,
+            .key_thrust = SDL_SCANCODE_W,
+            .key_shoot = SDL_SCANCODE_LSHIFT,
+            .key_start = SDL_SCANCODE_2},
+    .gamepad_name = ""  // Segon gamepad disponible
+};
+
+// Per compatibilitat amb pollo (no utilitzat en orni, però necessari per Input)
+inline KeyboardControls keyboard_controls{};
+inline GamepadControls gamepad_controls{};
+
 inline std::string config_file_path{};  // Establert per setConfigFile()
 
 // Funcions públiques

source/game/stage_system/spawn_controller.cpp

@@ -0,0 +1,177 @@
+// spawn_controller.cpp - Implementació del controlador de spawn
+// © 2025 Orni Attack
+
+#include "spawn_controller.hpp"
+
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <utility>
+
+#include "core/types.hpp"
+#include "game/entities/enemic.hpp"
+#include "stage_config.hpp"
+
+namespace StageSystem {
+
+SpawnController::SpawnController()
+    : config_(nullptr),
+      temps_transcorregut_(0.0F),
+      index_spawn_actual_(0),
+      ship_position_(nullptr) {}
+
+void SpawnController::configurar(const ConfigStage* config) {
+    config_ = config;
+}
+
+void SpawnController::iniciar() {
+    if (config_ == nullptr) {
+        std::cerr << "[SpawnController] Error: config_ és null" << '\n';
+        return;
+    }
+
+    reset();
+    generar_spawn_events();
+
+    std::cout << "[SpawnController] Stage " << static_cast<int>(config_->stage_id)
+              << ": generats " << spawn_queue_.size() << " spawn events" << '\n';
+}
+
+void SpawnController::reset() {
+    spawn_queue_.clear();
+    temps_transcorregut_ = 0.0F;
+    index_spawn_actual_ = 0;
+}
+
+void SpawnController::actualitzar(float delta_time, std::array<Enemic, 15>& orni_array, bool pausar) {
+    if ((config_ == nullptr) || spawn_queue_.empty()) {
+        return;
+    }
+
+    // Increment timer only when not paused
+    if (!pausar) {
+        temps_transcorregut_ += delta_time;
+    }
+
+    // Process spawn events
+    while (index_spawn_actual_ < spawn_queue_.size()) {
+        SpawnEvent& event = spawn_queue_[index_spawn_actual_];
+
+        if (event.spawnejat) {
+            index_spawn_actual_++;
+            continue;
+        }
+
+        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_);
+                    event.spawnejat = true;
+                    index_spawn_actual_++;
+                    break;
+                }
+            }
+
+            // If no slot available, try next frame
+            if (!event.spawnejat) {
+                break;
+            }
+        } else {
+            // Not yet time for this spawn
+            break;
+        }
+    }
+}
+
+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 {
+    if (!tots_enemics_spawnejats()) {
+        return false;
+    }
+
+    for (const auto& enemic : orni_array) {
+        if (enemic.esta_actiu()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+uint8_t SpawnController::get_enemics_vius(const std::array<Enemic, 15>& orni_array) const {
+    uint8_t count = 0;
+    for (const auto& enemic : orni_array) {
+        if (enemic.esta_actiu()) {
+            count++;
+        }
+    }
+    return count;
+}
+
+uint8_t SpawnController::get_enemics_spawnejats() const {
+    return static_cast<uint8_t>(index_spawn_actual_);
+}
+
+void SpawnController::generar_spawn_events() {
+    if (config_ == nullptr) {
+        return;
+    }
+
+    for (uint8_t i = 0; i < config_->total_enemics; i++) {
+        float spawn_time = config_->config_spawn.delay_inicial +
+            (i * config_->config_spawn.interval_spawn);
+
+        TipusEnemic tipus = seleccionar_tipus_aleatori();
+
+        spawn_queue_.push_back({spawn_time, tipus, false});
+    }
+}
+
+TipusEnemic SpawnController::seleccionar_tipus_aleatori() const {
+    if (config_ == nullptr) {
+        return TipusEnemic::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;
+    }
+    if (rand_val < config_->distribucio.pentagon + config_->distribucio.quadrat) {
+        return TipusEnemic::QUADRAT;
+    }
+    return TipusEnemic::MOLINILLO;
+}
+
+void SpawnController::spawn_enemic(Enemic& enemic, TipusEnemic tipus, const Punt* ship_pos) {
+    // Initialize enemy (with safe spawn if ship_pos provided)
+    enemic.inicialitzar(tipus, ship_pos);
+
+    // Apply difficulty multipliers
+    aplicar_multiplicadors(enemic);
+}
+
+void SpawnController::aplicar_multiplicadors(Enemic& enemic) const {
+    if (config_ == nullptr) {
+        return;
+    }
+
+    // Apply velocity multiplier
+    float base_vel = enemic.get_base_velocity();
+    enemic.set_velocity(base_vel * config_->multiplicadors.velocitat);
+
+    // Apply rotation multiplier
+    float base_rot = enemic.get_base_rotation();
+    enemic.set_rotation(base_rot * config_->multiplicadors.rotacio);
+
+    // Apply tracking strength (only affects QUADRAT)
+    enemic.set_tracking_strength(config_->multiplicadors.tracking_strength);
+}
+
+}  // namespace StageSystem

source/game/stage_system/spawn_controller.hpp

@@ -0,0 +1,58 @@
+// spawn_controller.hpp - Controlador de spawn d'enemics
+// © 2025 Orni Attack
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <vector>
+
+#include "core/types.hpp"
+#include "game/entities/enemic.hpp"
+#include "stage_config.hpp"
+
+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?
+};
+
+class SpawnController {
+    public:
+        SpawnController();
+
+        // Configuration
+        void configurar(const ConfigStage* config);  // Set stage config
+        void iniciar();                              // Generate spawn schedule
+        void reset();                                // Clear all pending spawns
+
+        // Update
+        void actualitzar(float delta_time, std::array<Enemic, 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]] 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; }
+
+    private:
+        const ConfigStage* 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
+};
+
+}  // namespace StageSystem

source/game/stage_system/stage_config.hpp

@@ -0,0 +1,99 @@
+// stage_config.hpp - Estructures de dades per configuració d'stages
+// © 2025 Orni Attack
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace StageSystem {
+
+// Tipus 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ó)
+};
+
+// Configuració de spawn
+struct ConfigSpawn {
+        ModeSpawn mode;
+        float delay_inicial;   // Segons abans del primer spawn
+        float interval_spawn;  // Segons entre spawns consecutius
+};
+
+// Distribució de tipus d'enemics (percentatges)
+struct DistribucioEnemics {
+        uint8_t pentagon;   // 0-100
+        uint8_t quadrat;    // 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)
+};
+
+// Metadades del fitxer YAML
+struct MetadataStages {
+        std::string version;
+        uint8_t total_stages;
+        std::string descripcio;
+};
+
+// Configuració completa d'un stage
+struct ConfigStage {
+        uint8_t stage_id;       // 1-10
+        uint8_t total_enemics;  // 5-15
+        ConfigSpawn config_spawn;
+        DistribucioEnemics distribucio;
+        MultiplicadorsDificultat multiplicadors;
+
+        // 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;
+        }
+};
+
+// Configuració completa del sistema (carregada des de YAML)
+struct ConfigSistemaStages {
+        MetadataStages metadata;
+        std::vector<ConfigStage> stages;  // Índex [0] = stage 1
+
+        // Obtenir configuració d'un stage específic
+        [[nodiscard]] const ConfigStage* obte_stage(uint8_t stage_id) const {
+            if (stage_id < 1 || stage_id > stages.size()) {
+                return nullptr;
+            }
+            return &stages[stage_id - 1];
+        }
+};
+
+// Constants per missatges de transició
+namespace Constants {
+// Pool de missatges per inici de level (selecció aleatòria)
+inline constexpr std::array<const char*, 12> MISSATGES_LEVEL_START = {
+    "ORNI ALERT!",
+    "INCOMING ORNIS!",
+    "ROLLING THREAT!",
+    "ENEMY WAVE!",
+    "WAVE OF ORNIS DETECTED!",
+    "NEXT SWARM APPROACHING!",
+    "BRACE FOR THE NEXT WAVE!",
+    "ANOTHER ATTACK INCOMING!",
+    "SENSORS DETECT HOSTILE ORNIS...",
+    "UNIDENTIFIED ROLLING OBJECTS INBOUND!",
+    "ENEMY FORCES MOBILIZING!",
+    "PREPARE FOR IMPACT!"};
+
+constexpr const char* MISSATGE_LEVEL_COMPLETED = "GOOD JOB COMMANDER!";
+}  // namespace Constants
+
+}  // namespace StageSystem

source/game/stage_system/stage_loader.cpp

@@ -0,0 +1,259 @@
+// stage_loader.cpp - Implementació del carregador de configuració YAML
+// © 2025 Orni Attack
+
+#include "stage_loader.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "core/resources/resource_helper.hpp"
+#include "external/fkyaml_node.hpp"
+#include "stage_config.hpp"
+
+namespace StageSystem {
+
+std::unique_ptr<ConfigSistemaStages> StageLoader::carregar(const std::string& path) {
+    try {
+        // Normalize path: "data/stages/stages.yaml" → "stages/stages.yaml"
+        std::string normalized = path;
+        if (normalized.starts_with("data/")) {
+            normalized = normalized.substr(5);
+        }
+
+        // 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';
+            return nullptr;
+        }
+
+        // Convert to string
+        std::string yaml_content(data.begin(), data.end());
+        std::stringstream stream(yaml_content);
+
+        // Parse YAML
+        fkyaml::node yaml = fkyaml::node::deserialize(stream);
+        auto config = std::make_unique<ConfigSistemaStages>();
+
+        // Parse metadata
+        if (!yaml.contains("metadata")) {
+            std::cerr << "[StageLoader] Error: falta camp 'metadata'" << '\n';
+            return nullptr;
+        }
+        if (!parse_metadata(yaml["metadata"], config->metadata)) {
+            return nullptr;
+        }
+
+        // Parse stages
+        if (!yaml.contains("stages")) {
+            std::cerr << "[StageLoader] Error: falta camp 'stages'" << '\n';
+            return nullptr;
+        }
+
+        if (!yaml["stages"].is_sequence()) {
+            std::cerr << "[StageLoader] Error: 'stages' ha de ser una llista" << '\n';
+            return nullptr;
+        }
+
+        for (const auto& stage_yaml : yaml["stages"]) {
+            ConfigStage stage;
+            if (!parse_stage(stage_yaml, stage)) {
+                return nullptr;
+            }
+            config->stages.push_back(stage);
+        }
+
+        // Validar configuració
+        if (!validar_config(*config)) {
+            return nullptr;
+        }
+
+        std::cout << "[StageLoader] Carregats " << config->stages.size()
+                  << " stages correctament" << '\n';
+        return config;
+
+    } catch (const std::exception& e) {
+        std::cerr << "[StageLoader] Excepció: " << e.what() << '\n';
+        return nullptr;
+    }
+}
+
+bool StageLoader::parse_metadata(const fkyaml::node& yaml, MetadataStages& meta) {
+    try {
+        if (!yaml.contains("version") || !yaml.contains("total_stages")) {
+            std::cerr << "[StageLoader] Error: metadata incompleta" << '\n';
+            return false;
+        }
+
+        meta.version = yaml["version"].get_value<std::string>();
+        meta.total_stages = yaml["total_stages"].get_value<uint8_t>();
+        meta.descripcio = yaml.contains("description")
+            ? yaml["description"].get_value<std::string>()
+            : "";
+
+        return true;
+    } catch (const std::exception& e) {
+        std::cerr << "[StageLoader] Error parsing metadata: " << e.what() << '\n';
+        return false;
+    }
+}
+
+bool StageLoader::parse_stage(const fkyaml::node& yaml, ConfigStage& stage) {
+    try {
+        if (!yaml.contains("stage_id") || !yaml.contains("total_enemies") ||
+            !yaml.contains("spawn_config") || !yaml.contains("enemy_distribution") ||
+            !yaml.contains("difficulty_multipliers")) {
+            std::cerr << "[StageLoader] Error: stage incompleta" << '\n';
+            return false;
+        }
+
+        stage.stage_id = yaml["stage_id"].get_value<uint8_t>();
+        stage.total_enemics = yaml["total_enemies"].get_value<uint8_t>();
+
+        if (!parse_spawn_config(yaml["spawn_config"], stage.config_spawn)) {
+            return false;
+        }
+        if (!parse_distribution(yaml["enemy_distribution"], stage.distribucio)) {
+            return false;
+        }
+        if (!parse_multipliers(yaml["difficulty_multipliers"], stage.multiplicadors)) {
+            return false;
+        }
+
+        if (!stage.es_valid()) {
+            std::cerr << "[StageLoader] Error: stage " << static_cast<int>(stage.stage_id)
+                      << " no és vàlid" << '\n';
+            return false;
+        }
+
+        return true;
+    } catch (const std::exception& e) {
+        std::cerr << "[StageLoader] Error parsing stage: " << e.what() << '\n';
+        return false;
+    }
+}
+
+bool StageLoader::parse_spawn_config(const fkyaml::node& yaml, ConfigSpawn& config) {
+    try {
+        if (!yaml.contains("mode") || !yaml.contains("initial_delay") ||
+            !yaml.contains("spawn_interval")) {
+            std::cerr << "[StageLoader] Error: spawn_config incompleta" << '\n';
+            return false;
+        }
+
+        auto mode_str = yaml["mode"].get_value<std::string>();
+        config.mode = parse_spawn_mode(mode_str);
+        config.delay_inicial = yaml["initial_delay"].get_value<float>();
+        config.interval_spawn = yaml["spawn_interval"].get_value<float>();
+
+        return true;
+    } catch (const std::exception& e) {
+        std::cerr << "[StageLoader] Error parsing spawn_config: " << e.what() << '\n';
+        return false;
+    }
+}
+
+bool StageLoader::parse_distribution(const fkyaml::node& yaml, DistribucioEnemics& dist) {
+    try {
+        if (!yaml.contains("pentagon") || !yaml.contains("quadrat") ||
+            !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.molinillo = yaml["molinillo"].get_value<uint8_t>();
+
+        // Validar que suma 100
+        int sum = dist.pentagon + dist.quadrat + dist.molinillo;
+        if (sum != 100) {
+            std::cerr << "[StageLoader] Error: distribució no suma 100 (suma=" << sum << ")" << '\n';
+            return false;
+        }
+
+        return true;
+    } catch (const std::exception& e) {
+        std::cerr << "[StageLoader] Error parsing distribution: " << e.what() << '\n';
+        return false;
+    }
+}
+
+bool StageLoader::parse_multipliers(const fkyaml::node& yaml, MultiplicadorsDificultat& mult) {
+    try {
+        if (!yaml.contains("speed_multiplier") || !yaml.contains("rotation_multiplier") ||
+            !yaml.contains("tracking_strength")) {
+            std::cerr << "[StageLoader] Error: difficulty_multipliers incompleta" << '\n';
+            return false;
+        }
+
+        mult.velocitat = yaml["speed_multiplier"].get_value<float>();
+        mult.rotacio = 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.rotacio < 0.1F || mult.rotacio > 5.0F) {
+            std::cerr << "[StageLoader] Warning: rotation_multiplier fora 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';
+        }
+
+        return true;
+    } catch (const std::exception& e) {
+        std::cerr << "[StageLoader] Error parsing multipliers: " << e.what() << '\n';
+        return false;
+    }
+}
+
+ModeSpawn StageLoader::parse_spawn_mode(const std::string& mode_str) {
+    if (mode_str == "progressive") {
+        return ModeSpawn::PROGRESSIVE;
+    }
+    if (mode_str == "immediate") {
+        return ModeSpawn::IMMEDIATE;
+    }
+    if (mode_str == "wave") {
+        return ModeSpawn::WAVE;
+    }
+    std::cerr << "[StageLoader] Warning: mode de spawn desconegut '" << mode_str
+              << "', usant PROGRESSIVE" << '\n';
+    return ModeSpawn::PROGRESSIVE;
+}
+
+bool StageLoader::validar_config(const ConfigSistemaStages& config) {
+    if (config.stages.empty()) {
+        std::cerr << "[StageLoader] Error: cap 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 ("
+                  << static_cast<int>(config.metadata.total_stages) << ")" << '\n';
+    }
+
+    // Validar stage_id consecutius
+    for (size_t i = 0; i < config.stages.size(); i++) {
+        if (config.stages[i].stage_id != i + 1) {
+            std::cerr << "[StageLoader] Error: stage_id no consecutius (esperat "
+                      << i + 1 << ", trobat " << static_cast<int>(config.stages[i].stage_id)
+                      << ")" << '\n';
+            return false;
+        }
+    }
+
+    return true;
+}
+
+}  // namespace StageSystem

source/game/stage_system/stage_loader.hpp

@@ -0,0 +1,33 @@
+// stage_loader.hpp - Carregador de configuració YAML
+// © 2025 Orni Attack
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "external/fkyaml_node.hpp"
+#include "stage_config.hpp"
+
+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);
+
+    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_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);
+};
+
+}  // namespace StageSystem

source/game/stage_system/stage_manager.cpp

@@ -0,0 +1,174 @@
+// stage_manager.cpp - Implementació del gestor d'stages
+// © 2025 Orni Attack
+
+#include "stage_manager.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+
+#include "core/audio/audio.hpp"
+#include "core/defaults.hpp"
+#include "stage_config.hpp"
+
+namespace StageSystem {
+
+StageManager::StageManager(const ConfigSistemaStages* 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';
+    }
+}
+
+void StageManager::inicialitzar() {
+    stage_actual_ = 1;
+    carregar_stage(stage_actual_);
+    canviar_estat(EstatStage::INIT_HUD);
+
+    std::cout << "[StageManager] Inicialitzat a stage " << static_cast<int>(stage_actual_)
+              << '\n';
+}
+
+void StageManager::actualitzar(float delta_time, bool pausar_spawn) {
+    switch (estat_) {
+        case EstatStage::INIT_HUD:
+            processar_init_hud(delta_time);
+            break;
+
+        case EstatStage::LEVEL_START:
+            processar_level_start(delta_time);
+            break;
+
+        case EstatStage::PLAYING:
+            processar_playing(delta_time, pausar_spawn);
+            break;
+
+        case EstatStage::LEVEL_COMPLETED:
+            processar_level_completed(delta_time);
+            break;
+    }
+}
+
+void StageManager::stage_completat() {
+    std::cout << "[StageManager] Stage " << static_cast<int>(stage_actual_) << " completat!"
+              << '\n';
+    canviar_estat(EstatStage::LEVEL_COMPLETED);
+}
+
+bool StageManager::tot_completat() const {
+    return stage_actual_ >= config_->metadata.total_stages &&
+        estat_ == EstatStage::LEVEL_COMPLETED &&
+        timer_transicio_ <= 0.0F;
+}
+
+const ConfigStage* StageManager::get_config_actual() const {
+    return config_->obte_stage(stage_actual_);
+}
+
+void StageManager::canviar_estat(EstatStage nou_estat) {
+    estat_ = nou_estat;
+
+    // Set timer based on state type
+    if (nou_estat == EstatStage::INIT_HUD) {
+        timer_transicio_ = Defaults::Game::INIT_HUD_DURATION;
+    } else if (nou_estat == EstatStage::LEVEL_START) {
+        timer_transicio_ = Defaults::Game::LEVEL_START_DURATION;
+    } else if (nou_estat == EstatStage::LEVEL_COMPLETED) {
+        timer_transicio_ = Defaults::Game::LEVEL_COMPLETED_DURATION;
+    }
+
+    // Select random message when entering LEVEL_START
+    if (nou_estat == EstatStage::LEVEL_START) {
+        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) {
+            Audio::get()->playMusic("game.ogg");
+        }
+    }
+
+    std::cout << "[StageManager] Canvi d'estat: ";
+    switch (nou_estat) {
+        case EstatStage::INIT_HUD:
+            std::cout << "INIT_HUD";
+            break;
+        case EstatStage::LEVEL_START:
+            std::cout << "LEVEL_START";
+            break;
+        case EstatStage::PLAYING:
+            std::cout << "PLAYING";
+            break;
+        case EstatStage::LEVEL_COMPLETED:
+            std::cout << "LEVEL_COMPLETED";
+            break;
+    }
+    std::cout << '\n';
+}
+
+void StageManager::processar_init_hud(float delta_time) {
+    timer_transicio_ -= delta_time;
+
+    if (timer_transicio_ <= 0.0F) {
+        canviar_estat(EstatStage::LEVEL_START);
+    }
+}
+
+void StageManager::processar_level_start(float delta_time) {
+    timer_transicio_ -= delta_time;
+
+    if (timer_transicio_ <= 0.0F) {
+        canviar_estat(EstatStage::PLAYING);
+    }
+}
+
+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()
+    // 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 StageManager::processar_level_completed(float delta_time) {
+    timer_transicio_ -= delta_time;
+
+    if (timer_transicio_ <= 0.0F) {
+        // Advance to next stage
+        stage_actual_++;
+
+        // 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"
+                      << '\n';
+        }
+
+        // Load next stage
+        carregar_stage(stage_actual_);
+        canviar_estat(EstatStage::LEVEL_START);
+    }
+}
+
+void StageManager::carregar_stage(uint8_t stage_id) {
+    const ConfigStage* 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';
+        return;
+    }
+
+    // Configure spawn controller
+    spawn_controller_.configurar(stage_config);
+    spawn_controller_.iniciar();
+
+    std::cout << "[StageManager] Carregat stage " << static_cast<int>(stage_id) << ": "
+              << static_cast<int>(stage_config->total_enemics) << " enemics" << '\n';
+}
+
+}  // namespace StageSystem